doc: consistent indenting for unordered list items

BUILDING.md

@@ -243,8 +243,8 @@ transition before the year-end deadline.
 * `gcc` and `g++` >= 6.3 or newer, or
 * GNU Make 3.81 or newer
 * Python (see note above)
-  * Python 2.7
-  * Python 3.5, 3.6, and 3.7 are experimental.
+ * Python 2.7
+ * Python 3.5, 3.6, and 3.7 are experimental.
 
 Installation via Linux package manager can be achieved with:
 
@@ -259,8 +259,8 @@ FreeBSD and OpenBSD users may also need to install `libexecinfo`.
 
 * Xcode Command Line Tools >= 8 for macOS
 * Python (see note above)
-  * Python 2.7
-  * Python 3.5, 3.6, and 3.7 are experimental.
+ * Python 2.7
+ * Python 3.5, 3.6, and 3.7 are experimental.
 
 macOS users can install the `Xcode Command Line Tools` by running
 `xcode-select --install`. Alternatively, if you already have the full Xcode

doc/api/addons.md

@@ -17,34 +17,34 @@ for more information on N-API.
 When not using N-API, implementing Addons is complicated,
 involving knowledge of several components and APIs:
 
- - V8: the C++ library Node.js currently 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
-  tree), which is also available [online][v8-docs].
-
- - [libuv][]: The C library that implements the Node.js event loop, its worker
-  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
-  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.
-
- - Internal Node.js libraries. Node.js itself exports a number of C++ APIs
-  that Addons can use — the most important of which is the
-  `node::ObjectWrap` class.
-
- - Node.js includes a number of other statically linked libraries including
-  OpenSSL. These other libraries are located in the `deps/` directory in the
-  Node.js source tree. Only the libuv, OpenSSL, V8 and zlib symbols are
-  purposefully re-exported by Node.js and may be used to various extents by
-  Addons.
-  See [Linking to Node.js' own dependencies][] for additional information.
+- V8: the C++ library Node.js currently 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
+ tree), which is also available [online][v8-docs].
+
+- [libuv][]: The C library that implements the Node.js event loop, its worker
+ 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
+ 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.
+
+- Internal Node.js libraries. Node.js itself exports a number of C++ APIs
+ that Addons can use — the most important of which is the
+ `node::ObjectWrap` class.
+
+- Node.js includes a number of other statically linked libraries including
+ OpenSSL. These other libraries are located in the `deps/` directory in the
+ Node.js source tree. Only the libuv, OpenSSL, V8 and zlib symbols are
+ purposefully re-exported by Node.js and may be used to various extents by
+ Addons.
+ See [Linking to Node.js' own dependencies][] for additional information.
 
 All of the following examples are available for [download][] and may
 be used as the starting-point for an Addon.

doc/api/buffer.md

@@ -1363,11 +1363,11 @@ changes:
 
 If `value` is:
 
- * a string, `value` is interpreted according to the character encoding in
-  `encoding`.
- * a `Buffer` or [`Uint8Array`][], `value` will be used in its entirety.
-  To compare a partial `Buffer`, use [`buf.slice()`][].
- * a number, `value` will be interpreted as an unsigned 8-bit integer
+* a string, `value` is interpreted according to the character encoding in
+ `encoding`.
+* a `Buffer` or [`Uint8Array`][], `value` will be used in its entirety.
+ To compare a partial `Buffer`, use [`buf.slice()`][].
+* a number, `value` will be interpreted as an unsigned 8-bit integer
  value between `0` and `255`.
 
 ```js

doc/api/child_process.md

@@ -43,19 +43,19 @@ and asynchronous alternatives to [`child_process.spawn()`][] and
 [`child_process.spawnSync()`][]. Each of these alternatives are implemented on
 top of [`child_process.spawn()`][] or [`child_process.spawnSync()`][].
 
- * [`child_process.exec()`][]: spawns a shell and runs a command within that
-  shell, passing the `stdout` and `stderr` to a callback function when
-  complete.
- * [`child_process.execFile()`][]: similar to [`child_process.exec()`][] except
-  that it spawns the command directly without first spawning a shell by
-  default.
- * [`child_process.fork()`][]: spawns a new Node.js process and invokes a
-  specified module with an IPC communication channel established that allows
-  sending messages between parent and child.
- * [`child_process.execSync()`][]: a synchronous version of
-  [`child_process.exec()`][] that will block the Node.js event loop.
- * [`child_process.execFileSync()`][]: a synchronous version of
-  [`child_process.execFile()`][] that will block the Node.js event loop.
+* [`child_process.exec()`][]: spawns a shell and runs a command within that
+ shell, passing the `stdout` and `stderr` to a callback function when
+ complete.
+* [`child_process.execFile()`][]: similar to [`child_process.exec()`][] except
+ that it spawns the command directly without first spawning a shell by
+ default.
+* [`child_process.fork()`][]: spawns a new Node.js process and invokes a
+ specified module with an IPC communication channel established that allows
+ sending messages between parent and child.
+* [`child_process.execSync()`][]: a synchronous version of
+ [`child_process.exec()`][] that will block the Node.js event loop.
+* [`child_process.execFileSync()`][]: a synchronous version of
+ [`child_process.execFile()`][] that will block the Node.js event loop.
 
 For certain use cases, such as automating shell scripts, the
 [synchronous counterparts][] may be more convenient. In many cases, however,

doc/api/http2.md

@@ -1977,20 +1977,20 @@ changes:
  exceed this limit will result in a `'frameError'` event being emitted
  and the stream being closed and destroyed.
  * `paddingStrategy` {number} Identifies 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_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.
+ 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_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.
  * `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
@@ -2091,20 +2091,20 @@ changes:
  exceed this limit will result in a `'frameError'` event being emitted
  and the stream being closed and destroyed.
  * `paddingStrategy` {number} Identifies 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_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.
+ 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_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.
  * `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
@@ -2191,20 +2191,20 @@ changes:
  exceed this limit will result in a `'frameError'` event being emitted
  and the stream being closed and destroyed.
  * `paddingStrategy` {number} Identifies 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_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.
+ 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_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.
  * `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