docs: transported docs from e18e; slight stylistic cleanup (#258)

* a

* extra

* core-util-us + update index

* make shell stuff a bit more distinguishable

* fix diffs for chalk page

* extra space

* bash

* remote html comment

noway i did this with a regex find and replace

* :/

* add description frontmatter for lodash-underscore doc

* remove all the info from lodash doc to match the style

* ts -> diff codeblock

* Update js-yaml.md

* thank you james

* js -> ts

* tson -> json

* remove process-exec (old file)

* change docPaths & sort manifests

* Update docs/modules/globby.md

Co-authored-by: James Garbutt <43081j@users.noreply.github.com>

* Update find-up.md

* Update find-up.md

* Update docs/modules/tempy.md

Co-authored-by: James Garbutt <43081j@users.noreply.github.com>

* Update docs/modules/tempy.md

Co-authored-by: James Garbutt <43081j@users.noreply.github.com>

---------

Co-authored-by: James Garbutt <43081j@users.noreply.github.com>

Author: outslept

docs/modules/README.md

@@ -12,14 +12,16 @@ ESLint plugin.
 
 ## List of modules
 
-- [`@jsdevtools/ez-spawn`](./process-exec.md)
+- [`@jsdevtools/ezspawn`](./ez-spawn.md)
 - [`axios`](./axios.md)
-- [`bluebird` / `q`](./bluebird-q.md)
+- [`bluebird`](./bluebird-q.md)
 - [`body-parser`](./body-parser.md)
 - [`buf-compare`](./buf-compare.md)
-- [`buffer-equal` / `buffer-equals`](./buffer-equal.md)
+- [`buffer-equal`](./buffer-equal.md)
+- [`buffer-equals`](./buffer-equals.md)
+- [`builtin-modules`](./builtin-modules.md)
 - [`chalk`](./chalk.md)
-- [`core-util-is`](./core-util-is.md)
+| [`core-util-is`](./core-util-is.md)
 - [`cpx`](./cpx.md)
 - [`deep-equal`](./deep-equal.md)
 - [`depcheck`](./depcheck.md)
@@ -32,32 +34,39 @@ ESLint plugin.
 - [`eslint-plugin-node`](./eslint-plugin-node.md)
 - [`eslint-plugin-react`](./eslint-plugin-react.md)
 - [`eslint-plugin-vitest`](./eslint-plugin-vitest.md)
-- [`execa`](./process-exec.md)
-- [`ezspawn`](./process-exec.md)
+- [`execa`](./execa.md)
+- [`ezspawn`](./ez-spawn.md)
 - [`faker`](./faker.md)
-- [`fast-glob`](./glob.md)
-- [`find-up` and related](./find-up.md)
+- [`fast-glob`](./fast-glob.md)
+- [`find-cache-dir`](./find-cache-dir.md)
+- [`find-cache-directory`](./find-cache-directory.md)
+- [`find-file-up`](./find-file-up.md)
+- [`find-pkg`](./find-pkg.md)
+- [`find-up`](./find-up.md)
 - [`fs-extra`](./fs-extra.md)
 - [`glob`](./glob.md)
-- [`globby`](./glob.md)
-- [`grapheme`](./grapheme.md)
+- [`globby`](./globby.md)
+- [`graphemer`](./graphemer.md)
 - [`invariant`](./invariant.md)
 - [`is-builtin-module`](./is-builtin-module.md)
 - [`jQuery`](./jquery.md)
 - [`js-yaml`](./js-yaml.md)
 - [`jsx-ast-utils`](./jsx-ast-utils.md)
 - [`lint-staged`](./lint-staged.md)
 - [`lodash`, `underscore` and related](./lodash-underscore.md)
-- [`make-dir`](./mkdirp.md)
-- [`MaterializeCSS`](./materialize-css.md)
+- [`materialize-css`](./materialize-css.md)
 - [`md5`](./md5.md)
 - [`mkdirp`](./mkdirp.md)
-- [`moment.js`](./momentjs.md)
+- [`moment.js`](./moment.md)
 - [`npm-run-all`](./npm-run-all.md)
 - [`object-hash`](./object-hash.md)
 - [`ora`](./ora.md)
 - [`path-exists`](./path-exists.md)
+- [`pkg-dir`](./pkg-dir.md)
 - [`qs`](./qs.md)
+- [`read-pkg`](./read-pkg.md)
+- [`read-pkg-up`](./read-pkg-up.md)
+- [`read-package-up`](./read-package-up.md)
 - [`readable-stream`](./readable-stream.md)
 - [`rimraf`](./rimraf.md)
 - [`shortid`](./shortid.md)
@@ -67,4 +76,4 @@ ESLint plugin.
 - [`tempy`](./tempy.md)
 - [`traverse`](./traverse.md)
 - [`uri-js`](./uri-js.md)
-- [`xmldom`](./xmldom.md)
+- [`xmldom`](./xmldom.md)

docs/modules/axios.md

@@ -1,40 +1,58 @@
-# axios
+---
+description: Modern alternatives to the axios package for making HTTP requests in browsers and Node.js
+---
 
-`axios` is a popular HTTP client library, but modern JavaScript and Node.js provide native alternatives that can often replace it for many use cases.
-
-# Alternatives
+# Replacements for `axios`
 
 ## Native `fetch` API
 
-The native `fetch` API is now available in Node.js (since v18.x) and all modern browsers. For most HTTP requests, it can replace axios without additional dependencies.
+The native [`fetch`](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API) API is available in Node.js (since v18.x) and all modern browsers. For most HTTP requests, it can replace `axios` without extra dependencies.
+
+Example:
 
-```js
-// GET request
-const response = await fetch('https://api.example.com/data');
-const data = await response.json();
+```ts
+// GET
+const res = await fetch('https://api.example.com/data')
+const data = await res.json()
 
-// POST request with JSON
-const response = await fetch('https://api.example.com/data', {
+// POST
+await fetch('https://api.example.com/data', {
   method: 'POST',
-  headers: {
-    'Content-Type': 'application/json',
-  },
+  headers: { 'Content-Type': 'application/json' },
   body: JSON.stringify({ key: 'value' })
-});
+})
 ```
 
-[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API)
+## `ky`
+
+[`ky`](https://github.com/sindresorhus/ky) is a lightweight HTTP client based on the Fetch API with timeout support, hooks (interceptors) and other helpers.
 
-## ky
+Example:
 
-`ky` is a tiny and elegant HTTP client based on the Fetch API. It provides a more convenient API than raw fetch while being much smaller than axios. Also, includes `hooks` (interceptors) for request/response modification.
+```ts
+import ky from 'ky'
 
-[Project Page](https://github.com/sindresorhus/ky)
-[npm](https://www.npmjs.com/package/ky)
+const api = ky.create({
+  prefixUrl: 'https://api.example.com',
+  timeout: 5000, // ms
+})
+
+const data = await api.get('users').json()
+```
 
-## ofetch
+## `ofetch`
 
-`ofetch` is a better fetch API with automatic response parsing, request/response interceptors, and retry functionality.
+[`ofetch`](https://github.com/unjs/ofetch) s a fetch wrapper with automatic JSON parsing, request/response interceptors, and retries.
 
-[Project Page](https://github.com/unjs/ofetch)
-[npm](https://www.npmjs.com/package/ofetch)
+Example:
+
+```ts
+import { ofetch } from 'ofetch'
+
+const api = ofetch.create({
+  baseURL: 'https://api.example.com',
+})
+
+const data = await api('/user', { query: { id: 123 } })
+const created = await api('/items', { method: 'POST', body: { name: 'A' } })
+```

docs/modules/bluebird-q.md

@@ -1,18 +1,13 @@
-# `bluebird` / `q`
+---
+description: Modern alternatives to the Bluebird and Q Promise libraries for async control flow in JavaScript
+---
 
-[`bluebird`](https://github.com/petkaantonov/bluebird?tab=readme-ov-file#%EF%B8%8Fnote%EF%B8%8F) and [`q`](https://github.com/kriskowal/q#note) recommends that you switch away from them to native promises.
+# Replacements for `bluebird` / `q`
 
-# Alternatives
+## `Promise` (native)
 
-## Native JavaScript `Promise`
-
-For most cases, native JavaScript `Promise` is enough.
-
-[MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)
+[`bluebird`](https://github.com/petkaantonov/bluebird?tab=readme-ov-file#%EF%B8%8Fnote%EF%B8%8F) and [`q`](https://github.com/kriskowal/q#note) recommend switching away from them to native promises.
 
 ## NativeBird
 
-Ultralight native `Promise` extension compatible with `bluebird` if you need some helpers missed in native JavaScript `Promise`.
-
-[Project Page](https://github.com/doodlewind/nativebird)
-[npm](https://www.npmjs.com/package/nativebird)
+[`NativeBird`](https://github.com/doodlewind/nativebird) is an ultralight native `Promise` extension that provides Bluebird-like helpers if you miss a few conveniences from Bluebird.

docs/modules/body-parser.md

@@ -1,51 +1,27 @@
-# Body-parser
+---
+description: Modern alternatives to the body-parser package for parsing HTTP request bodies in Node.js servers
+---
 
-`body-parser` can be replaced with more modern alternatives which are both lighter and faster.
+# Replacements for `body-parser`
 
-# Alternatives
+## `milliparsec`
 
-## Native Implementation
+[`milliparsec`](https://github.com/tinyhttp/milliparsec) is a lightweight alternative to [`body-parser`](https://github.com/expressjs/body-parser) with a smaller footprint.
 
-For simple use cases, you can implement a minimal body parser in vanilla JavaScript:
+Example:
 
-```js
-const sizeLimit = 10 * 1024; // limit body size to 10kB
-req.body = {};
+```ts
+import bodyParser from 'body-parser' // [!code --]
+import { json, urlencoded } from 'milliparsec' // [!code ++]
+import express from 'express'
 
-await new Promise(function(res, rej) {
-  let buffers = [];
-  let size = 0;
+const app = express()
 
-  // parse each chunk and append them into Buffer array
-  req.on('data', chunk => {
-    size += chunk.length;
-    if (size > sizeLimit) {
-      return rej(new Error('Size limit'));
-    }
+app.use(bodyParser.json()) // [!code --]
+app.use(bodyParser.urlencoded({ extended: true })) // [!code --]
 
-    buffers.push(chunk);
-  });
-
-  req.on('end', () => res(buffers));
-})
-.then(function(buffers) {
-  if (!buffers.length) return;
-
-  try {
-    req.body = JSON.parse(Buffer.concat(buffers).toString());
-  } catch (err) {
-    return Promise.reject(new Error('Invalid JSON: ' + err.message));
-  }
-});
+app.use(json()) // [!code ++]
+app.use(urlencoded()) // [!code ++]
 ```
 
-Do note that the above implementation lacks sophisticated features such as better error handling, timeouts, flexible size limits, etc.
-
-
-## milliparsec
-
-`milliparsec` a modern `body-parser` alternative that supports `async / await`, lighter (8 kB vs 62.6 kB for `body-parser`), and [30% faster](https://github.com/tinyhttp/milliparsec/blob/master/bench/index.md)
-
-[Project Page](https://github.com/tinyhttp/milliparsec)
-[npm](https://www.npmjs.com/package/milliparsec)
-
+For API differences and feature comparison, see the [migration.md](https://github.com/tinyhttp/milliparsec/blob/master/migration.md).

docs/modules/buf-compare.md

@@ -1,21 +1,22 @@
-# buf-compare
+---
+description: Native Node.js alternatives to the buf-compare package for buffer comparison
+---
 
-[`buf-compare`](https://github.com/sindresorhus/buf-compare) recommends that you switch to native `Buffer.compare()` which has been available since Node.js v0.12.0
+# Replacements for `buf-compare`
 
-# Alternatives
+## `Buffer.compare` (native)
 
-## Node.js
+`Buffer.compare` is a native method which achieves the same result as `buf-compare`, available since Node v0.11.13.
 
-```js
-import {Buffer} from 'node:buffer';
+Example:
 
-const buf1 = Buffer.from('1234');
-const buf2 = Buffer.from('0123');
-const arr = [buf1, buf2];
+```ts
+import { Buffer } from 'node:buffer'
+import bufCompare from 'buf-compare' // [!code --]
 
-console.log(arr.sort(Buffer.compare));
-// Prints: [ <Buffer 30 31 32 33>, <Buffer 31 32 33 34> ]
-// (This result is equal to: [buf2, buf1].)
-```
+const buf1 = Buffer.from('303')
+const buf2 = Buffer.from('808')
 
-[Node.js Docs](https://nodejs.org/api/buffer.html#static-method-buffercomparebuf1-buf2)
+bufCompare(buf1, buf2) // [!code --]
+Buffer.compare(buf1, buf2) // [!code ++]
+```

docs/modules/buffer-equal.md

@@ -1,11 +1,22 @@
-# `buffer-equal`/`buffer-equals`
+---
+description: Native Node.js alternatives to the buffer-equal package for buffer equality checks
+---
 
-[`buffer-equal`](https://www.npmjs.com/package/buffer-equal) and [`buffer-equals`](https://www.npmjs.com/package/buffer-equals) recommends that you switch away from them to native `Buffer.prototype.equals` which has been available since Node.js v0.11.13
+# Replacements for `buffer-equal`
 
-# Alternative(s)
+## `Buffer#equals` (native)
 
-## Native `Buffer.prototype.equals`
+Buffers have an `equals` method since Node 0.12.
 
-For most cases, native Node.js `Buffer.prototype.equals` is enough.
+Example:
 
-[Node.js Docs](https://nodejs.org/api/buffer.html#bufequalsotherbuffer)
+```ts
+import { Buffer } from 'node:buffer'
+import bufferEqual from 'buffer-equal' // [!code --]
+
+const buf1 = Buffer.from('303')
+const buf2 = Buffer.from('303')
+
+bufferEqual(buf1, buf2) // [!code --]
+buf1.equals(buf2) // [!code ++]
+```

docs/modules/buffer-equals.md

@@ -0,0 +1,22 @@
+---
+description: Native Node.js alternatives to the buffer-equals package for buffer equality checks
+---
+
+# Replacements for `buffer-equals`
+
+## `Buffer#equals` (native)
+
+Buffers have an `equals` method since Node 0.12.
+
+Example:
+
+```ts
+import { Buffer } from 'node:buffer'
+import bufferEquals from 'buffer-equals' // [!code --]
+
+const buf1 = Buffer.from('303')
+const buf2 = Buffer.from('303')
+
+bufferEquals(buf1, buf2) // [!code --]
+buf1.equals(buf2) // [!code ++]
+```

docs/modules/builtin-modules.md

@@ -0,0 +1,17 @@
+---
+description: Native Node.js alternatives to the builtin-modules package for listing built-in modules
+---
+
+# Replacements for `builtin-modules`
+
+## Node.js (since 6.x)
+
+For getting the list of built-in modules, you can use [builtinModules](https://nodejs.org/api/module.html#modulebuiltinmodules):
+
+```ts
+import builtinModulesList from 'builtin-modules' // [!code --]
+import { builtinModules } from 'node:module' // [!code ++]
+
+builtinModulesList.includes('fs') // true [!code --]
+builtinModules.includes('fs') // true [!code ++]
+```