chore: Turn on ESLint for markdown

Author: nschonni

.eslintignore

@@ -2,3 +2,5 @@
 static/legacy/
 external/
 build/
+# Top level await isn't supported till ESLint 8
+locale/en/blog/release/v17.0.0.md

.eslintrc

@@ -9,5 +9,25 @@
   ],
   "rules": {
     "prettier/prettier": "error"
-  }
+  },
+  "overrides": [
+    {
+        "files": ["**/*.md"],
+        "plugins": ["markdown"],
+        "processor": "markdown/markdown"
+    },
+    {
+        "files": ["**/*.md/*.js"],
+        "rules": {
+          "eqeqeq": "off",
+          "no-const-assign": "off",
+          "no-undef":"off",
+          "no-unused-expressions": "off",
+          "no-unused-vars": "off",
+          "node/handle-callback-err": "off",
+          "node/no-deprecated-api": "off",
+          "prefer-const": "off"
+        }
+    }
+]
 }

locale/en/blog/release/v12.16.0.md

@@ -17,12 +17,12 @@ The `assert` module now provides experimental `assert.match()` and
 string and matches (or does not match) the provided regular expression:
 
 ```js
-const assert = require('assert').strict;
+const assert = require("assert").strict;
 
-assert.match('I will fail', /pass/);
+assert.match("I will fail", /pass/);
 // AssertionError [ERR_ASSERTION]: The input did not match the regular ...
 
-assert.doesNotMatch('I will fail', /fail/);
+assert.doesNotMatch("I will fail", /fail/);
 // AssertionError [ERR_ASSERTION]: The input was expected to not match the ...
 ```
 
@@ -89,17 +89,17 @@ to compute the digest between updates:
 
 ```js
 // Calculate a rolling hash.
-const crypto = require('crypto');
-const hash = crypto.createHash('sha256');
+const crypto = require("crypto");
+const hash = crypto.createHash("sha256");
 
-hash.update('one');
-console.log(hash.copy().digest('hex'));
+hash.update("one");
+console.log(hash.copy().digest("hex"));
 
-hash.update('two');
-console.log(hash.copy().digest('hex'));
+hash.update("two");
+console.log(hash.copy().digest("hex"));
 
-hash.update('three');
-console.log(hash.copy().digest('hex'));
+hash.update("three");
+console.log(hash.copy().digest("hex"));
 
 // Etc.
 ```
@@ -127,25 +127,23 @@ Michaël Zasso [#30109](https://github.com/nodejs/node/pull/30109).
 The new `EventEmitter.on` static method allows to async iterate over events:
 
 ```js
-const { on, EventEmitter } = require('events');
+const { on, EventEmitter } = require("events");
 
 (async () => {
-
   const ee = new EventEmitter();
 
   // Emit later on
   process.nextTick(() => {
-    ee.emit('foo', 'bar');
-    ee.emit('foo', 42);
+    ee.emit("foo", "bar");
+    ee.emit("foo", 42);
   });
 
-  for await (const event of on(ee, 'foo')) {
+  for await (const event of on(ee, "foo")) {
     // 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]
   }
-
 })();
 ```
 
@@ -164,7 +162,7 @@ myEmitter.on(EventEmitter.errorMonitor, (err) => {
   MyMonitoringTool.log(err);
 });
 
-myEmitter.emit('error', new Error('whoops!'));
+myEmitter.emit("error", new Error("whoops!"));
 // Still throws and crashes Node.js
 ```
 
@@ -178,8 +176,8 @@ can lead to an unhandled rejection in case of a thrown exception:
 ```js
 const ee = new EventEmitter();
 
-ee.on('something', async (value) => {
-  throw new Error('kaboom');
+ee.on("something", async (value) => {
+  throw new Error("kaboom");
 });
 ```
 
@@ -191,18 +189,18 @@ is one, or to the `'error'` event handler if there is none.
 
 ```js
 const ee1 = new EventEmitter({ captureRejections: true });
-ee1.on('something', async (value) => {
-  throw new Error('kaboom');
+ee1.on("something", async (value) => {
+  throw new Error("kaboom");
 });
 
-ee1.on('error', console.log);
+ee1.on("error", console.log);
 
 const ee2 = new EventEmitter({ captureRejections: true });
-ee2.on('something', async (value) => {
-  throw new Error('kaboom');
+ee2.on("something", async (value) => {
+  throw new Error("kaboom");
 });
 
-ee2[Symbol.for('nodejs.rejection')] = console.log;
+ee2[Symbol.for("nodejs.rejection")] = console.log;
 ```
 
 Setting `EventEmitter.captureRejections = true` will change the default for all
@@ -211,11 +209,11 @@ new instances of `EventEmitter`.
 ```js
 EventEmitter.captureRejections = true;
 const ee1 = new EventEmitter();
-ee1.on('something', async (value) => {
-  throw new Error('kaboom');
+ee1.on("something", async (value) => {
+  throw new Error("kaboom");
 });
 
-ee1.on('error', console.log);
+ee1.on("error", console.log);
 ```
 
 This is an experimental feature.

locale/en/blog/release/v12.17.0.md

@@ -51,27 +51,29 @@ 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 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);
+  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();
+http
+  .createServer((req, res) => {
+    asyncLocalStorage.run(idSeq++, () => {
+      logWithId("start");
+      // Imagine any chain of async operations here.
+      setImmediate(() => {
+        logWithId("finish");
+        res.end();
+      });
     });
-  });
-}).listen(8080);
+  })
+  .listen(8080);
 ```
 
 In this example, the `logWithId` function will always know what the current
@@ -156,7 +158,7 @@ myEmitter.on(EventEmitter.errorMonitor, (err) => {
   MyMonitoringTool.log(err);
 });
 
-myEmitter.emit('error', new Error('whoops!'));
+myEmitter.emit("error", new Error("whoops!"));
 // Still throws and crashes Node.js
 ```
 
@@ -169,7 +171,7 @@ the default behavior that exits the process by installing an
 `'uncaughtExceptionMonitor'` listener:
 
 ```js
-process.on('uncaughtExceptionMonitor', (err, origin) => {
+process.on("uncaughtExceptionMonitor", (err, origin) => {
   MyMonitoringTool.logSync(err, origin);
 });
 
@@ -205,17 +207,17 @@ The Console constructor (`require('console').Console`) now supports different gr
 This is useful in case you want different grouping width than 2 spaces.
 
 ```js
-const { Console } = require('console');
+const { Console } = require("console");
 const customConsole = new Console({
   stdout: process.stdout,
   stderr: process.stderr,
-  groupIndentation: 10
+  groupIndentation: 10,
 });
 
-customConsole.log('foo');
+customConsole.log("foo");
 // 'foo'
 customConsole.group();
-customConsole.log('foo');
+customConsole.log("foo");
 //           'foo'
 ```
 
@@ -227,9 +229,9 @@ 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 { inspect } = require("util");
 
-const string = inspect(['a'.repeat(1e8)], { maxStringLength: 10 });
+const string = inspect(["a".repeat(1e8)], { maxStringLength: 10 });
 
 console.log(string);
 // "[ 'aaaaaaaaaa'... 99999990 more characters ]"

locale/en/blog/release/v14.17.0.md

@@ -20,8 +20,8 @@ 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');
+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
@@ -37,8 +37,8 @@ MySQL.prototype.query = function query(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');
+const dc = require("diagnostics_channel");
+const channel = dc.channel("mysql.query");
 
 channel.subscribe(({ query, host }) => {
   console.log(`mysql query to ${host}: ${query}`);
@@ -55,7 +55,7 @@ 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');
+const { randomUUID } = require("crypto");
 
 console.log(randomUUID());
 // 'aa7c91a1-f8fc-4339-b9db-f93fc7233429'

locale/en/blog/release/v14.2.0.md

@@ -19,7 +19,7 @@ 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 assert = require("assert");
 
 const tracker = new assert.CallTracker();
 
@@ -36,7 +36,7 @@ callsotherFunc();
 
 // Calls tracker.verify() and verifies if all tracker.calls() functions have
 // been called the right number of times.
-process.on('exit', () => {
+process.on("exit", () => {
   tracker.verify();
 });
 ```
@@ -46,7 +46,7 @@ about the errors, if there are any:
 
 <!-- eslint-disable max-len -->
 ```js
-const assert = require('assert');
+const assert = require("assert");
 
 const tracker = new assert.CallTracker();
 
@@ -77,17 +77,17 @@ The Console constructor (`require('console').Console`) now supports different gr
 This is useful in case you want different grouping width than 2 spaces.
 
 ```js
-const { Console } = require('console');
+const { Console } = require("console");
 const customConsole = new Console({
   stdout: process.stdout,
   stderr: process.stderr,
-  groupIndentation: 10
+  groupIndentation: 10,
 });
 
-customConsole.log('foo');
+customConsole.log("foo");
 // 'foo'
 customConsole.group();
-customConsole.log('foo');
+customConsole.log("foo");
 //           'foo'
 ```
 

locale/en/blog/release/v14.5.0.md

@@ -30,8 +30,8 @@ Example Usage:
 ```js
 const target = getEventTargetSomehow();
 
-target.addEventListener('foo', (event) => {
-  console.log('foo event happened!');
+target.addEventListener("foo", (event) => {
+  console.log("foo event happened!");
 });
 ```
 

locale/en/blog/release/v15.1.0.md

@@ -17,8 +17,8 @@ author: Michaël Zasso
 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');
+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
@@ -34,8 +34,8 @@ MySQL.prototype.query = function query(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');
+const dc = require("diagnostics_channel");
+const channel = dc.channel("mysql.query");
 
 channel.subscribe(({ query, host }) => {
   console.log(`mysql query to ${host}: ${query}`);
@@ -67,11 +67,11 @@ systems.
 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.
 
 ```js
-const { Resolver } = require('dns');
+const { Resolver } = require("dns");
 
 const resolver = new Resolver();
 
-resolver.setLocalAddress('10.1.2.3');
+resolver.setLocalAddress("10.1.2.3");
 // Equivalent to: resolver.setLocalAddress('10.1.2.3', '::0');
 ```