From 28d4e501b7d31643bb6006bb7826591941f07b85 Mon Sep 17 00:00:00 2001
From: Titus Wormer <tituswormer@gmail.com>
Date: Wed, 11 Aug 2021 13:05:30 +0200
Subject: [PATCH] Refactor code-style

---
 package.json                                  |  35 +-
 .../index.js                                  |  33 +-
 .../index.js                                  | 140 ++--
 .../index.js                                  |  79 +--
 .../remark-lint-code-block-style/index.js     |  28 +-
 packages/remark-lint-definition-case/index.js |  47 +-
 .../remark-lint-definition-spacing/index.js   |  44 +-
 packages/remark-lint-emphasis-marker/index.js |  64 +-
 .../remark-lint-fenced-code-flag/index.js     |  69 +-
 .../remark-lint-fenced-code-marker/index.js   |  83 ++-
 packages/remark-lint-file-extension/index.js  |  18 +-
 .../remark-lint-final-definition/index.js     |  64 +-
 packages/remark-lint-final-newline/index.js   |  18 +-
 .../remark-lint-first-heading-level/index.js  |  54 +-
 .../remark-lint-hard-break-spaces/index.js    |  40 +-
 .../remark-lint-heading-increment/index.js    |  39 +-
 packages/remark-lint-heading-style/index.js   |  12 +-
 packages/remark-lint-linebreak-style/index.js |  70 +-
 .../remark-lint-link-title-style/index.js     | 175 +++--
 .../index.js                                  |  56 +-
 .../index.js                                  | 107 ++-
 .../remark-lint-list-item-indent/index.js     | 114 ++--
 .../remark-lint-list-item-spacing/index.js    |  95 +--
 .../index.js                                  |  22 +-
 .../remark-lint-maximum-line-length/index.js  | 105 ++-
 .../index.js                                  |  37 +-
 .../index.js                                  |  58 +-
 .../index.js                                  |  90 ++-
 .../index.js                                  |  49 +-
 .../index.js                                  |  52 +-
 .../index.js                                  |  48 +-
 .../index.js                                  |  49 +-
 .../index.js                                  |  45 +-
 packages/remark-lint-no-empty-url/index.js    |  25 +-
 .../index.js                                  |  16 +-
 .../index.js                                  |  14 +-
 .../index.js                                  |  29 +-
 .../index.js                                  |  18 +-
 .../index.js                                  |  14 +-
 .../index.js                                  | 101 ++-
 .../remark-lint-no-heading-indent/index.js    |  46 +-
 .../index.js                                  |  44 +-
 .../index.js                                  |  41 +-
 packages/remark-lint-no-html/index.js         |  20 +-
 .../remark-lint-no-inline-padding/index.js    |  36 +-
 packages/remark-lint-no-literal-urls/index.js |  38 +-
 .../index.js                                  |  54 +-
 .../index.js                                  |  37 +-
 .../index.js                                  | 107 ++-
 .../index.js                                  |  59 +-
 .../remark-lint-no-shell-dollars/index.js     |  68 +-
 .../index.js                                  |  20 +-
 .../index.js                                  |  20 +-
 .../remark-lint-no-table-indentation/index.js |  98 ++-
 packages/remark-lint-no-tabs/index.js         |  22 +-
 .../index.js                                  | 294 ++++----
 .../index.js                                  |  35 +-
 .../index.js                                  |  39 +-
 .../index.js                                  |  62 +-
 .../index.js                                  |  77 +--
 .../index.js                                  |  96 +--
 packages/remark-lint-rule-style/index.js      |  54 +-
 .../remark-lint-strikethrough-marker/index.js |  70 +-
 packages/remark-lint-strong-marker/index.js   |  62 +-
 .../remark-lint-table-cell-padding/index.js   | 198 +++---
 .../remark-lint-table-pipe-alignment/index.js |  89 +--
 packages/remark-lint-table-pipes/index.js     |  46 +-
 .../index.js                                  |  80 ++-
 packages/unified-lint-rule/index.js           |  67 +-
 script.js                                     |  45 --
 script/build-presets.js                       | 467 ++++++-------
 script/build-rules.js                         | 642 +++++++++---------
 script/plugin/list-of-presets.js              |  57 +-
 script/plugin/list-of-rules.js                |  39 +-
 script/util/find.js                           |   8 +-
 script/util/presets.js                        |  16 +-
 script/util/rule.js                           |  55 +-
 script/util/rules.js                          |  10 +-
 test.js                                       | 322 ++++-----
 79 files changed, 2748 insertions(+), 3148 deletions(-)
 delete mode 100644 script.js

diff --git a/package.json b/package.json
index e2e2c177..bef668f4 100644
--- a/package.json
+++ b/package.json
@@ -51,7 +51,7 @@
     "to-vfile": "^7.0.0",
     "unist-builder": "^3.0.0",
     "unist-util-remove-position": "^4.0.0",
-    "xo": "^0.38.0"
+    "xo": "^0.39.0"
   },
   "scripts": {
     "postinstall": "lerna bootstrap --no-ci",
@@ -73,27 +73,20 @@
   },
   "xo": {
     "prettier": true,
-    "esnext": false,
     "rules": {
-      "unicorn/explicit-length-check": "off",
-      "unicorn/no-array-callback-reference": "off",
-      "unicorn/no-array-for-each": "off",
-      "unicorn/no-new-array": "off",
-      "unicorn/prefer-default-parameters": "off",
-      "unicorn/prefer-includes": "off",
-      "unicorn/prefer-number-properties": "off",
-      "unicorn/prefer-optional-catch-binding": "off",
-      "unicorn/string-content": "off",
-      "guard-for-in": "off",
-      "max-depth": "off",
-      "no-eq-null": "off",
-      "eqeqeq": [
-        "error",
-        "always",
-        {
-          "null": "ignore"
+      "unicorn/prefer-switch": "off"
+    },
+    "overrides": [
+      {
+        "files": [
+          "test.js",
+          "script/**/*.js"
+        ],
+        "rules": {
+          "max-depth": "off",
+          "no-await-in-loop": "off"
         }
-      ]
-    }
+      }
+    ]
   }
 }
diff --git a/packages/remark-lint-blockquote-indentation/index.js b/packages/remark-lint-blockquote-indentation/index.js
index 666319cb..d2dcf196 100644
--- a/packages/remark-lint-blockquote-indentation/index.js
+++ b/packages/remark-lint-blockquote-indentation/index.js
@@ -59,38 +59,33 @@ const remarkLintBlockquoteIndentation = lintRule(
 export default remarkLintBlockquoteIndentation
 
 function blockquoteIndentation(tree, file, option) {
-  var preferred = typeof option === 'number' && !isNaN(option) ? option : null
-
-  visit(tree, 'blockquote', visitor)
-
-  function visitor(node) {
-    var abs
-    var diff
-    var reason
+  let preferred = typeof option === 'number' ? option : null
 
+  visit(tree, 'blockquote', (node) => {
     if (generated(node) || node.children.length === 0) {
       return
     }
 
     if (preferred) {
-      diff = preferred - check(node)
+      const diff = preferred - check(node)
 
       if (diff !== 0) {
-        abs = Math.abs(diff)
-        reason =
-          (diff > 0 ? 'Add' : 'Remove') +
-          ' ' +
-          abs +
-          ' ' +
-          plural('space', abs) +
-          ' between block quote and content'
+        const abs = Math.abs(diff)
 
-        file.message(reason, pointStart(node.children[0]))
+        file.message(
+          (diff > 0 ? 'Add' : 'Remove') +
+            ' ' +
+            abs +
+            ' ' +
+            plural('space', abs) +
+            ' between block quote and content',
+          pointStart(node.children[0])
+        )
       }
     } else {
       preferred = check(node)
     }
-  }
+  })
 }
 
 function check(node) {
diff --git a/packages/remark-lint-checkbox-character-style/index.js b/packages/remark-lint-checkbox-character-style/index.js
index f8e647ef..4ce091a7 100644
--- a/packages/remark-lint-checkbox-character-style/index.js
+++ b/packages/remark-lint-checkbox-character-style/index.js
@@ -74,86 +74,78 @@ import {visit} from 'unist-util-visit'
 import {pointStart, pointEnd} from 'unist-util-position'
 import {generated} from 'unist-util-generated'
 
+const checked = {x: true, X: true}
+const unchecked = {' ': true, '\t': true}
+const types = {true: 'checked', false: 'unchecked'}
+
 const remarkLintCheckboxCharacterStyle = lintRule(
   'remark-lint:checkbox-character-style',
-  checkboxCharacterStyle
-)
-
-export default remarkLintCheckboxCharacterStyle
-
-var checked = {x: true, X: true}
-var unchecked = {' ': true, '\t': true}
-var types = {true: 'checked', false: 'unchecked'}
-
-function checkboxCharacterStyle(tree, file, option) {
-  var contents = String(file)
-  var preferred = typeof option === 'object' ? option : {}
-
-  if (preferred.unchecked && unchecked[preferred.unchecked] !== true) {
-    file.fail(
-      'Incorrect unchecked checkbox marker `' +
-        preferred.unchecked +
-        "`: use either `'\\t'`, or `' '`"
-    )
-  }
-
-  if (preferred.checked && checked[preferred.checked] !== true) {
-    file.fail(
-      'Incorrect checked checkbox marker `' +
-        preferred.checked +
-        "`: use either `'x'`, or `'X'`"
-    )
-  }
-
-  visit(tree, 'listItem', visitor)
-
-  function visitor(node) {
-    var type
-    var point
-    var value
-    var style
-    var reason
+  (tree, file, option) => {
+    const value = String(file)
+    const preferred = typeof option === 'object' ? option : {}
+
+    if (preferred.unchecked && unchecked[preferred.unchecked] !== true) {
+      file.fail(
+        'Incorrect unchecked checkbox marker `' +
+          preferred.unchecked +
+          "`: use either `'\\t'`, or `' '`"
+      )
+    }
 
-    // Exit early for items without checkbox.
-    if (typeof node.checked !== 'boolean' || generated(node)) {
-      return
+    if (preferred.checked && checked[preferred.checked] !== true) {
+      file.fail(
+        'Incorrect checked checkbox marker `' +
+          preferred.checked +
+          "`: use either `'x'`, or `'X'`"
+      )
     }
 
-    type = types[node.checked]
+    visit(tree, 'listItem', (node) => {
+      // Exit early for items without checkbox.
+      if (typeof node.checked !== 'boolean' || generated(node)) {
+        return
+      }
 
-    // A list item cannot be checked and empty, according to GFM, but
-    // theoretically it makes sense to get the end if that were possible.
-    point =
+      const type = types[node.checked]
+
+      // A list item cannot be checked and empty, according to GFM, but
+      // theoretically it makes sense to get the end if that were possible.
+      const point =
+        /* c8 ignore next 2 */
+        node.children.length === 0
+          ? pointEnd(node)
+          : pointStart(node.children[0])
+      // Move back to before `] `.
+      point.offset -= 2
+      point.column -= 2
+
+      // Assume we start with a checkbox, because well, `checked` is set.
+      const match = /\[([\t Xx])]/.exec(
+        value.slice(point.offset - 2, point.offset + 1)
+      )
+
+      // Failsafe to make sure we don‘t crash if there actually isn’t a checkbox.
       /* c8 ignore next */
-      node.children.length === 0 ? pointEnd(node) : pointStart(node.children[0])
-    // Move back to before `] `.
-    point.offset -= 2
-    point.column -= 2
-
-    // Assume we start with a checkbox, because well, `checked` is set.
-    value = /\[([\t Xx])]/.exec(
-      contents.slice(point.offset - 2, point.offset + 1)
-    )
-
-    // Failsafe to make sure we don‘t crash if there actually isn’t a checkbox.
-    /* c8 ignore next */
-    if (!value) return
-
-    style = preferred[type]
-
-    if (style) {
-      if (value[1] !== style) {
-        reason =
-          type.charAt(0).toUpperCase() +
-          type.slice(1) +
-          ' checkboxes should use `' +
-          style +
-          '` as a marker'
-
-        file.message(reason, point)
+      if (!match) return
+
+      const style = preferred[type]
+
+      if (style) {
+        if (match[1] !== style) {
+          file.message(
+            type.charAt(0).toUpperCase() +
+              type.slice(1) +
+              ' checkboxes should use `' +
+              style +
+              '` as a marker',
+            point
+          )
+        }
+      } else {
+        preferred[type] = match[1]
       }
-    } else {
-      preferred[type] = value[1]
-    }
+    })
   }
-}
+)
+
+export default remarkLintCheckboxCharacterStyle
diff --git a/packages/remark-lint-checkbox-content-indent/index.js b/packages/remark-lint-checkbox-content-indent/index.js
index 96232a38..d6233e4a 100644
--- a/packages/remark-lint-checkbox-content-indent/index.js
+++ b/packages/remark-lint-checkbox-content-indent/index.js
@@ -35,56 +35,47 @@ import {generated} from 'unist-util-generated'
 
 const remarkLintCheckboxContentIndent = lintRule(
   'remark-lint:checkbox-content-indent',
-  checkboxContentIndent
-)
-
-export default remarkLintCheckboxContentIndent
-
-var reason = 'Checkboxes should be followed by a single character'
-
-function checkboxContentIndent(tree, file) {
-  var contents = String(file)
-  var loc = location(file)
+  (tree, file) => {
+    const value = String(file)
+    const loc = location(file)
 
-  visit(tree, 'listItem', visitor)
+    visit(tree, 'listItem', (node) => {
+      // Exit early for items without checkbox.
+      if (typeof node.checked !== 'boolean' || generated(node)) {
+        return
+      }
 
-  function visitor(node) {
-    var initial
-    var final
-    var value
-    var point
+      // A list item cannot be checked and empty, according to GFM, but
+      // theoretically it makes sense to get the end if that were possible.
+      const point =
+        /* c8 ignore next 2 */
+        node.children.length === 0
+          ? pointEnd(node)
+          : pointStart(node.children[0])
 
-    // Exit early for items without checkbox.
-    if (typeof node.checked !== 'boolean' || generated(node)) {
-      return
-    }
+      // Assume we start with a checkbox, because well, `checked` is set.
+      const match = /\[([\t xX])]/.exec(
+        value.slice(point.offset - 4, point.offset + 1)
+      )
 
-    // A list item cannot be checked and empty, according to GFM, but
-    // theoretically it makes sense to get the end if that were possible.
-    point =
+      // Failsafe to make sure we don‘t crash if there actually isn’t a checkbox.
       /* c8 ignore next */
-      node.children.length === 0 ? pointEnd(node) : pointStart(node.children[0])
+      if (!match) return
 
-    // Assume we start with a checkbox, because well, `checked` is set.
-    value = /\[([\t xX])]/.exec(
-      contents.slice(point.offset - 4, point.offset + 1)
-    )
+      // Move past checkbox.
+      const initial = point.offset
+      let final = initial
 
-    // Failsafe to make sure we don‘t crash if there actually isn’t a checkbox.
-    /* c8 ignore next */
-    if (!value) return
+      while (/[\t ]/.test(value.charAt(final))) final++
 
-    // Move past checkbox.
-    initial = point.offset
-    final = initial
-
-    while (/[\t ]/.test(contents.charAt(final))) final++
-
-    if (final - initial > 0) {
-      file.message(reason, {
-        start: loc.toPoint(initial),
-        end: loc.toPoint(final)
-      })
-    }
+      if (final - initial > 0) {
+        file.message('Checkboxes should be followed by a single character', {
+          start: loc.toPoint(initial),
+          end: loc.toPoint(final)
+        })
+      }
+    })
   }
-}
+)
+
+export default remarkLintCheckboxContentIndent
diff --git a/packages/remark-lint-code-block-style/index.js b/packages/remark-lint-code-block-style/index.js
index 99982bec..ed67346c 100644
--- a/packages/remark-lint-code-block-style/index.js
+++ b/packages/remark-lint-code-block-style/index.js
@@ -97,6 +97,8 @@ import {visit} from 'unist-util-visit'
 import {pointStart, pointEnd} from 'unist-util-position'
 import {generated} from 'unist-util-generated'
 
+const styles = {null: true, fenced: true, indented: true}
+
 const remarkLintCodeBlockStyle = lintRule(
   'remark-lint:code-block-style',
   codeBlockStyle
@@ -104,11 +106,9 @@ const remarkLintCodeBlockStyle = lintRule(
 
 export default remarkLintCodeBlockStyle
 
-var styles = {null: true, fenced: true, indented: true}
-
 function codeBlockStyle(tree, file, option) {
-  var contents = String(file)
-  var preferred =
+  const value = String(file)
+  let preferred =
     typeof option === 'string' && option !== 'consistent' ? option : null
 
   if (styles[preferred] !== true) {
@@ -119,22 +119,16 @@ function codeBlockStyle(tree, file, option) {
     )
   }
 
-  visit(tree, 'code', visitor)
-
-  function visitor(node) {
-    var initial
-    var final
-    var current
-
+  visit(tree, 'code', (node) => {
     if (generated(node)) {
-      return null
+      return
     }
 
-    initial = pointStart(node).offset
-    final = pointEnd(node).offset
+    const initial = pointStart(node).offset
+    const final = pointEnd(node).offset
 
-    current =
-      node.lang || /^\s*([~`])\1{2,}/.test(contents.slice(initial, final))
+    const current =
+      node.lang || /^\s*([~`])\1{2,}/.test(value.slice(initial, final))
         ? 'fenced'
         : 'indented'
 
@@ -145,5 +139,5 @@ function codeBlockStyle(tree, file, option) {
     } else {
       preferred = current
     }
-  }
+  })
 }
diff --git a/packages/remark-lint-definition-case/index.js b/packages/remark-lint-definition-case/index.js
index 39fb5c1c..f9c3a51d 100644
--- a/packages/remark-lint-definition-case/index.js
+++ b/packages/remark-lint-definition-case/index.js
@@ -24,32 +24,31 @@ import {visit} from 'unist-util-visit'
 import {pointStart, pointEnd} from 'unist-util-position'
 import {generated} from 'unist-util-generated'
 
+const label = /^\s*\[((?:\\[\s\S]|[^[\]])+)]/
+
 const remarkLintDefinitionCase = lintRule(
   'remark-lint:definition-case',
-  definitionCase
+  (tree, file) => {
+    const value = String(file)
+
+    visit(tree, (node) => {
+      if (
+        (node.type === 'definition' || node.type === 'footnoteDefinition') &&
+        !generated(node)
+      ) {
+        const start = pointStart(node).offset
+        const end = pointEnd(node).offset
+        const slice = value.slice(start, end).match(label)[1]
+
+        if (slice !== slice.toLowerCase()) {
+          file.message(
+            'Do not use uppercase characters in definition labels',
+            node
+          )
+        }
+      }
+    })
+  }
 )
 
 export default remarkLintDefinitionCase
-
-var label = /^\s*\[((?:\\[\s\S]|[^[\]])+)]/
-var reason = 'Do not use uppercase characters in definition labels'
-
-function definitionCase(tree, file) {
-  var contents = String(file)
-
-  visit(tree, ['definition', 'footnoteDefinition'], check)
-
-  function check(node) {
-    var start = pointStart(node).offset
-    var end = pointEnd(node).offset
-    var value
-
-    if (!generated(node)) {
-      value = contents.slice(start, end).match(label)[1]
-
-      if (value !== value.toLowerCase()) {
-        file.message(reason, node)
-      }
-    }
-  }
-}
diff --git a/packages/remark-lint-definition-spacing/index.js b/packages/remark-lint-definition-spacing/index.js
index 20d5aed5..f28a168b 100644
--- a/packages/remark-lint-definition-spacing/index.js
+++ b/packages/remark-lint-definition-spacing/index.js
@@ -24,30 +24,30 @@ import {visit} from 'unist-util-visit'
 import {pointStart, pointEnd} from 'unist-util-position'
 import {generated} from 'unist-util-generated'
 
+const label = /^\s*\[((?:\\[\s\S]|[^[\]])+)]/
+
 const remarkLintDefinitionSpacing = lintRule(
   'remark-lint:definition-spacing',
-  definitionSpacing
+  (tree, file) => {
+    const value = String(file)
+
+    visit(tree, (node) => {
+      if (
+        (node.type === 'definition' || node.type === 'footnoteDefinition') &&
+        !generated(node)
+      ) {
+        const start = pointStart(node).offset
+        const end = pointEnd(node).offset
+
+        if (/[ \t\n]{2,}/.test(value.slice(start, end).match(label)[1])) {
+          file.message(
+            'Do not use consecutive whitespace in definition labels',
+            node
+          )
+        }
+      }
+    })
+  }
 )
 
 export default remarkLintDefinitionSpacing
-
-var label = /^\s*\[((?:\\[\s\S]|[^[\]])+)]/
-var reason = 'Do not use consecutive whitespace in definition labels'
-
-function definitionSpacing(tree, file) {
-  var contents = String(file)
-
-  visit(tree, ['definition', 'footnoteDefinition'], check)
-
-  function check(node) {
-    var start = pointStart(node).offset
-    var end = pointEnd(node).offset
-
-    if (
-      !generated(node) &&
-      /[ \t\n]{2,}/.test(contents.slice(start, end).match(label)[1])
-    ) {
-      file.message(reason, node)
-    }
-  }
-}
diff --git a/packages/remark-lint-emphasis-marker/index.js b/packages/remark-lint-emphasis-marker/index.js
index f6d480b1..c6eaa526 100644
--- a/packages/remark-lint-emphasis-marker/index.js
+++ b/packages/remark-lint-emphasis-marker/index.js
@@ -65,46 +65,40 @@ import {visit} from 'unist-util-visit'
 import {pointStart} from 'unist-util-position'
 import {generated} from 'unist-util-generated'
 
+const markers = {null: true, '*': true, _: true}
+
 const remarkLintEmphasisMarker = lintRule(
   'remark-lint:emphasis-marker',
-  emphasisMarker
-)
-
-export default remarkLintEmphasisMarker
-
-var markers = {null: true, '*': true, _: true}
-
-function emphasisMarker(tree, file, option) {
-  var contents = String(file)
-  var preferred =
-    typeof option === 'string' && option !== 'consistent' ? option : null
-
-  if (markers[preferred] !== true) {
-    file.fail(
-      'Incorrect emphasis marker `' +
-        preferred +
-        "`: use either `'consistent'`, `'*'`, or `'_'`"
-    )
-  }
-
-  visit(tree, 'emphasis', visitor)
+  (tree, file, option) => {
+    const value = String(file)
+    let preferred =
+      typeof option === 'string' && option !== 'consistent' ? option : null
 
-  function visitor(node) {
-    var marker
+    if (markers[preferred] !== true) {
+      file.fail(
+        'Incorrect emphasis marker `' +
+          preferred +
+          "`: use either `'consistent'`, `'*'`, or `'_'`"
+      )
+    }
 
-    if (!generated(node)) {
-      marker = contents.charAt(pointStart(node).offset)
+    visit(tree, 'emphasis', (node) => {
+      if (!generated(node)) {
+        const marker = value.charAt(pointStart(node).offset)
 
-      if (preferred) {
-        if (marker !== preferred) {
-          file.message(
-            'Emphasis should use `' + preferred + '` as a marker',
-            node
-          )
+        if (preferred) {
+          if (marker !== preferred) {
+            file.message(
+              'Emphasis should use `' + preferred + '` as a marker',
+              node
+            )
+          }
+        } else {
+          preferred = marker
         }
-      } else {
-        preferred = marker
       }
-    }
+    })
   }
-}
+)
+
+export default remarkLintEmphasisMarker
diff --git a/packages/remark-lint-fenced-code-flag/index.js b/packages/remark-lint-fenced-code-flag/index.js
index 6da302da..b72050de 100644
--- a/packages/remark-lint-fenced-code-flag/index.js
+++ b/packages/remark-lint-fenced-code-flag/index.js
@@ -69,49 +69,44 @@ import {visit} from 'unist-util-visit'
 import {pointStart, pointEnd} from 'unist-util-position'
 import {generated} from 'unist-util-generated'
 
+const fence = /^ {0,3}([~`])\1{2,}/
+
 const remarkLintFencedCodeFlag = lintRule(
   'remark-lint:fenced-code-flag',
-  fencedCodeFlag
-)
-
-export default remarkLintFencedCodeFlag
-
-var fence = /^ {0,3}([~`])\1{2,}/
-var reasonIncorrect = 'Incorrect code language flag'
-var reasonMissing = 'Missing code language flag'
+  (tree, file, option) => {
+    const value = String(file)
+    let allowEmpty = false
+    let allowed = []
+    let flags = option
 
-function fencedCodeFlag(tree, file, option) {
-  var contents = String(file)
-  var allowEmpty = false
-  var allowed = []
-  var flags = option
-
-  if (typeof flags === 'object' && !('length' in flags)) {
-    allowEmpty = Boolean(flags.allowEmpty)
-    flags = flags.flags
-  }
-
-  if (typeof flags === 'object' && 'length' in flags) {
-    allowed = String(flags).split(',')
-  }
-
-  visit(tree, 'code', visitor)
+    if (typeof flags === 'object' && !Array.isArray(flags)) {
+      allowEmpty = Boolean(flags.allowEmpty)
+      flags = flags.flags
+    }
 
-  function visitor(node) {
-    var value
+    if (Array.isArray(flags)) {
+      allowed = String(flags).split(',')
+    }
 
-    if (!generated(node)) {
-      if (node.lang) {
-        if (allowed.length !== 0 && allowed.indexOf(node.lang) === -1) {
-          file.message(reasonIncorrect, node)
-        }
-      } else {
-        value = contents.slice(pointStart(node).offset, pointEnd(node).offset)
+    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 (!allowEmpty && fence.test(value)) {
-          file.message(reasonMissing, node)
+          if (!allowEmpty && fence.test(slice)) {
+            file.message('Missing code language flag', node)
+          }
         }
       }
-    }
+    })
   }
-}
+)
+
+export default remarkLintFencedCodeFlag
diff --git a/packages/remark-lint-fenced-code-marker/index.js b/packages/remark-lint-fenced-code-marker/index.js
index d407b3ee..0e99dfdf 100644
--- a/packages/remark-lint-fenced-code-marker/index.js
+++ b/packages/remark-lint-fenced-code-marker/index.js
@@ -86,60 +86,53 @@ import {visit} from 'unist-util-visit'
 import {pointStart} from 'unist-util-position'
 import {generated} from 'unist-util-generated'
 
-const remarkLintFencedCodeMarker = lintRule(
-  'remark-lint:fenced-code-marker',
-  fencedCodeMarker
-)
-
-export default remarkLintFencedCodeMarker
-
-var markers = {
+const markers = {
   '`': true,
   '~': true,
   null: true
 }
 
-function fencedCodeMarker(tree, file, option) {
-  var contents = String(file)
-  var preferred =
-    typeof option === 'string' && option !== 'consistent' ? option : null
-
-  if (markers[preferred] !== true) {
-    file.fail(
-      'Incorrect fenced code marker `' +
-        preferred +
-        "`: use either `'consistent'`, `` '`' ``, or `'~'`"
-    )
-  }
-
-  visit(tree, 'code', visitor)
+const remarkLintFencedCodeMarker = lintRule(
+  'remark-lint:fenced-code-marker',
+  (tree, file, option) => {
+    const contents = String(file)
+    let preferred =
+      typeof option === 'string' && option !== 'consistent' ? option : null
 
-  function visitor(node) {
-    var start
-    var marker
-    var label
+    if (markers[preferred] !== true) {
+      file.fail(
+        'Incorrect fenced code marker `' +
+          preferred +
+          "`: use either `'consistent'`, `` '`' ``, or `'~'`"
+      )
+    }
 
-    if (!generated(node)) {
-      start = pointStart(node).offset
-      marker = contents
-        .slice(start, start + 4)
-        .replace(/^\s+/, '')
-        .charAt(0)
+    visit(tree, 'code', (node) => {
+      if (!generated(node)) {
+        const start = pointStart(node).offset
+        const marker = contents
+          .slice(start, start + 4)
+          .replace(/^\s+/, '')
+          .charAt(0)
 
-      // 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
-            )
+        // Ignore unfenced code blocks.
+        if (markers[marker] === true) {
+          if (preferred) {
+            if (marker !== preferred) {
+              file.message(
+                'Fenced code should use `' +
+                  (preferred === '~' ? preferred : '` ` `') +
+                  '` as a marker',
+                node
+              )
+            }
+          } else {
+            preferred = marker
           }
-        } else {
-          preferred = marker
         }
       }
-    }
+    })
   }
-}
+)
+
+export default remarkLintFencedCodeMarker
diff --git a/packages/remark-lint-file-extension/index.js b/packages/remark-lint-file-extension/index.js
index e10341e2..802c8371 100644
--- a/packages/remark-lint-file-extension/index.js
+++ b/packages/remark-lint-file-extension/index.js
@@ -26,16 +26,14 @@ import {lintRule} from 'unified-lint-rule'
 
 const remarkLintFileExtension = lintRule(
   'remark-lint:file-extension',
-  fileExtension
+  (tree, file, option) => {
+    const ext = file.extname
+    const preferred = typeof option === 'string' ? option : 'md'
+
+    if (ext && ext.slice(1) !== preferred) {
+      file.message('Incorrect extension: use `' + preferred + '`')
+    }
+  }
 )
 
 export default remarkLintFileExtension
-
-function fileExtension(tree, file, option) {
-  var ext = file.extname
-  var preferred = typeof option === 'string' ? option : 'md'
-
-  if (ext && ext.slice(1) !== preferred) {
-    file.message('Incorrect extension: use `' + preferred + '`')
-  }
-}
diff --git a/packages/remark-lint-final-definition/index.js b/packages/remark-lint-final-definition/index.js
index 5ea1fabb..47251d42 100644
--- a/packages/remark-lint-final-definition/index.js
+++ b/packages/remark-lint-final-definition/index.js
@@ -43,39 +43,39 @@ import {generated} from 'unist-util-generated'
 
 const remarkLintFinalDefinition = lintRule(
   'remark-lint:final-definition',
-  finalDefinition
-)
-
-export default remarkLintFinalDefinition
-
-function finalDefinition(tree, file) {
-  var last = null
+  (tree, file) => {
+    let last = null
 
-  visit(tree, visitor, true)
+    visit(
+      tree,
+      (node) => {
+        // Ignore generated and HTML comment nodes.
+        if (
+          node.type === 'root' ||
+          generated(node) ||
+          (node.type === 'html' && /^\s*<!--/.test(node.value))
+        ) {
+          return
+        }
 
-  function visitor(node) {
-    var line = pointStart(node).line
+        const line = pointStart(node).line
 
-    // Ignore generated and HTML comment nodes.
-    if (
-      node.type === 'root' ||
-      generated(node) ||
-      (node.type === 'html' && /^\s*<!--/.test(node.value))
-    ) {
-      return
-    }
-
-    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
-    }
+        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
+        }
+      },
+      true
+    )
   }
-}
+)
+
+export default remarkLintFinalDefinition
diff --git a/packages/remark-lint-final-newline/index.js b/packages/remark-lint-final-newline/index.js
index 9b0a0fc0..3bd6d857 100644
--- a/packages/remark-lint-final-newline/index.js
+++ b/packages/remark-lint-final-newline/index.js
@@ -54,16 +54,14 @@ import {lintRule} from 'unified-lint-rule'
 
 const remarkLintFinalNewline = lintRule(
   'remark-lint:final-newline',
-  finalNewline
+  (tree, 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')
+    }
+  }
 )
 
 export default remarkLintFinalNewline
-
-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')
-  }
-}
diff --git a/packages/remark-lint-first-heading-level/index.js b/packages/remark-lint-first-heading-level/index.js
index 57472c05..c59fa6e2 100644
--- a/packages/remark-lint-first-heading-level/index.js
+++ b/packages/remark-lint-first-heading-level/index.js
@@ -81,45 +81,41 @@ import {lintRule} from 'unified-lint-rule'
 import {visit, EXIT} from 'unist-util-visit'
 import {generated} from 'unist-util-generated'
 
+const re = /<h([1-6])/
+
 const remarkLintFirstHeadingLevel = lintRule(
   'remark-lint:first-heading-level',
-  firstHeadingLevel
-)
-
-export default remarkLintFirstHeadingLevel
+  (tree, file, option) => {
+    const preferred = option && option !== true ? option : 1
 
-var re = /<h([1-6])/
+    visit(tree, (node) => {
+      if (!generated(node)) {
+        let rank
 
-function firstHeadingLevel(tree, file, option) {
-  var preferred = option && option !== true ? option : 1
-
-  visit(tree, visitor)
+        if (node.type === 'heading') {
+          rank = node.depth
+        } else if (node.type === 'html') {
+          rank = infer(node)
+        }
 
-  function visitor(node) {
-    var rank
+        if (rank !== undefined) {
+          if (rank !== preferred) {
+            file.message(
+              'First heading level should be `' + preferred + '`',
+              node
+            )
+          }
 
-    if (!generated(node)) {
-      if (node.type === 'heading') {
-        rank = node.depth
-      } else if (node.type === 'html') {
-        rank = infer(node)
-      }
-
-      if (rank !== undefined) {
-        if (rank !== preferred) {
-          file.message(
-            'First heading level should be `' + preferred + '`',
-            node
-          )
+          return EXIT
         }
-
-        return EXIT
       }
-    }
+    })
   }
-}
+)
+
+export default remarkLintFirstHeadingLevel
 
 function infer(node) {
-  var results = node.value.match(re)
+  const results = node.value.match(re)
   return results ? Number(results[1]) : undefined
 }
diff --git a/packages/remark-lint-hard-break-spaces/index.js b/packages/remark-lint-hard-break-spaces/index.js
index 6d61ee03..fa9dcabc 100644
--- a/packages/remark-lint-hard-break-spaces/index.js
+++ b/packages/remark-lint-hard-break-spaces/index.js
@@ -28,30 +28,22 @@ import {generated} from 'unist-util-generated'
 
 const remarkLintHardBreakSpaces = lintRule(
   'remark-lint:hard-break-spaces',
-  hardBreakSpaces
+  (tree, file) => {
+    const value = String(file)
+
+    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)
+        }
+      }
+    })
+  }
 )
 
 export default remarkLintHardBreakSpaces
-
-var reason = 'Use two spaces for hard line breaks'
-
-function hardBreakSpaces(tree, file) {
-  var contents = String(file)
-
-  visit(tree, 'break', visitor)
-
-  function visitor(node) {
-    var value
-
-    if (!generated(node)) {
-      value = contents
-        .slice(pointStart(node).offset, pointEnd(node).offset)
-        .split('\n', 1)[0]
-        .replace(/\r$/, '')
-
-      if (value.length > 2) {
-        file.message(reason, node)
-      }
-    }
-  }
-}
diff --git a/packages/remark-lint-heading-increment/index.js b/packages/remark-lint-heading-increment/index.js
index 4670df39..ba5d8a90 100644
--- a/packages/remark-lint-heading-increment/index.js
+++ b/packages/remark-lint-heading-increment/index.js
@@ -29,29 +29,22 @@ import {generated} from 'unist-util-generated'
 
 const remarkLintHeadingIncrement = lintRule(
   'remark-lint:heading-increment',
-  headingIncrement
+  (tree, file) => {
+    let previous
+
+    visit(tree, 'heading', (node) => {
+      if (!generated(node)) {
+        if (previous && node.depth > previous + 1) {
+          file.message(
+            'Heading levels should increment by one level at a time',
+            node
+          )
+        }
+
+        previous = node.depth
+      }
+    })
+  }
 )
 
 export default remarkLintHeadingIncrement
-
-var reason = 'Heading levels should increment by one level at a time'
-
-function headingIncrement(tree, file) {
-  var previous = null
-
-  visit(tree, 'heading', visitor)
-
-  function visitor(node) {
-    var depth
-
-    if (!generated(node)) {
-      depth = node.depth
-
-      if (previous && depth > previous + 1) {
-        file.message(reason, node)
-      }
-
-      previous = depth
-    }
-  }
-}
diff --git a/packages/remark-lint-heading-style/index.js b/packages/remark-lint-heading-style/index.js
index 06606471..c9c08b82 100644
--- a/packages/remark-lint-heading-style/index.js
+++ b/packages/remark-lint-heading-style/index.js
@@ -71,16 +71,14 @@ import {visit} from 'unist-util-visit'
 import {headingStyle} from 'mdast-util-heading-style'
 import {generated} from 'unist-util-generated'
 
-var types = ['atx', 'atx-closed', 'setext']
+const types = new Set(['atx', 'atx-closed', 'setext'])
 
 const remarkLintHeadingStyle = lintRule(
   'remark-lint:heading-style',
-  function (tree, file, option) {
-    var preferred = types.indexOf(option) === -1 ? null : option
+  (tree, file, option) => {
+    let preferred = types.has(option) ? option : null
 
-    visit(tree, 'heading', visitor)
-
-    function visitor(node) {
+    visit(tree, 'heading', (node) => {
       if (!generated(node)) {
         if (preferred) {
           if (headingStyle(node, preferred) !== preferred) {
@@ -90,7 +88,7 @@ const remarkLintHeadingStyle = lintRule(
           preferred = headingStyle(node, preferred)
         }
       }
-    }
+    })
   }
 )
 
diff --git a/packages/remark-lint-linebreak-style/index.js b/packages/remark-lint-linebreak-style/index.js
index 08debcf0..16f061be 100644
--- a/packages/remark-lint-linebreak-style/index.js
+++ b/packages/remark-lint-linebreak-style/index.js
@@ -48,47 +48,43 @@
 import {lintRule} from 'unified-lint-rule'
 import {location} from 'vfile-location'
 
+const escaped = {unix: '\\n', windows: '\\r\\n'}
+const types = {true: 'windows', false: 'unix'}
+
 const remarkLintLinebreakStyle = lintRule(
   'remark-lint:linebreak-style',
-  linebreakStyle
-)
-
-export default remarkLintLinebreakStyle
-
-var escaped = {unix: '\\n', windows: '\\r\\n'}
-var types = {true: 'windows', false: 'unix'}
-
-function linebreakStyle(tree, file, option) {
-  var preferred =
-    typeof option === 'string' && option !== 'consistent' ? option : null
-  var content = String(file)
-  var toPoint = location(content).toPoint
-  var index = content.indexOf('\n')
-  var type
-  var reason
+  (tree, file, option) => {
+    const value = String(file)
+    const toPoint = location(value).toPoint
+    let preferred =
+      typeof option === 'string' && option !== 'consistent' ? option : null
+    let index = value.indexOf('\n')
 
-  while (index !== -1) {
-    type = types[content.charAt(index - 1) === '\r']
+    while (index !== -1) {
+      const type = types[value.charAt(index - 1) === '\r']
 
-    if (preferred) {
-      if (preferred !== type) {
-        reason =
-          'Expected linebreaks to be ' +
-          preferred +
-          ' (`' +
-          escaped[preferred] +
-          '`), not ' +
-          type +
-          ' (`' +
-          escaped[type] +
-          '`)'
-
-        file.message(reason, toPoint(index))
+      if (preferred) {
+        if (preferred !== type) {
+          file.message(
+            'Expected linebreaks to be ' +
+              preferred +
+              ' (`' +
+              escaped[preferred] +
+              '`), not ' +
+              type +
+              ' (`' +
+              escaped[type] +
+              '`)',
+            toPoint(index)
+          )
+        }
+      } else {
+        preferred = type
       }
-    } else {
-      preferred = type
-    }
 
-    index = content.indexOf('\n', index + 1)
+      index = value.indexOf('\n', index + 1)
+    }
   }
-}
+)
+
+export default remarkLintLinebreakStyle
diff --git a/packages/remark-lint-link-title-style/index.js b/packages/remark-lint-link-title-style/index.js
index 5f8dcbd1..34af5fa2 100644
--- a/packages/remark-lint-link-title-style/index.js
+++ b/packages/remark-lint-link-title-style/index.js
@@ -92,105 +92,100 @@ import {visit} from 'unist-util-visit'
 import {pointStart, pointEnd} from 'unist-util-position'
 import {generated} from 'unist-util-generated'
 
-const remarkLintLinkTitleStyle = lintRule(
-  'remark-lint:link-title-style',
-  linkTitleStyle
-)
-
-export default remarkLintLinkTitleStyle
-
-var own = {}.hasOwnProperty
+const own = {}.hasOwnProperty
 
-var markers = {
+const markers = {
   '"': '"',
   "'": "'",
   ')': '('
 }
 
-function linkTitleStyle(tree, file, option) {
-  var contents = String(file)
-  var loc = location(file)
-  var preferred =
-    typeof option === 'string' && option !== 'consistent' ? option : null
-
-  if (preferred === '()' || preferred === '(') {
-    preferred = ')'
-  }
-
-  if (preferred && !own.call(markers, preferred)) {
-    file.fail(
-      'Incorrect link title style marker `' +
-        preferred +
-        "`: use either `'consistent'`, `'\"'`, `'\\''`, or `'()'`"
-    )
-  }
-
-  visit(tree, ['link', 'image', 'definition'], check)
-
-  function check(node) {
-    var tail
-    var begin
-    var last
-    var first
-    var final
-    var initial
-    var reason
-
-    if (generated(node)) {
-      return
-    }
-
-    last = pointEnd(node).offset - 1
-    tail = node.children ? node.children[node.children.length - 1] : null
-    begin = tail ? pointEnd(tail) : pointStart(node)
-
-    if (node.type !== 'definition') {
-      last--
-    }
-
-    // Skip back to before whitespace.
-    while (last) {
-      final = contents.charAt(last)
-
-      // Legacy for remark before 8.0.0
-      /* c8 ignore next 2 */
-      if (/\s/.test(final)) {
-        last--
-      } else {
-        break
-      }
+const remarkLintLinkTitleStyle = lintRule(
+  'remark-lint:link-title-style',
+  (tree, file, option) => {
+    const value = String(file)
+    const loc = location(file)
+    let preferred =
+      typeof option === 'string' && option !== 'consistent' ? option : null
+
+    if (preferred === '()' || preferred === '(') {
+      preferred = ')'
     }
 
-    // Exit if the final marker is not a known marker.
-    if (!(final in markers)) {
-      return
+    if (preferred && !own.call(markers, preferred)) {
+      file.fail(
+        'Incorrect link title style marker `' +
+          preferred +
+          "`: use either `'consistent'`, `'\"'`, `'\\''`, or `'()'`"
+      )
     }
 
-    initial = markers[final]
-
-    // Find the starting delimiter
-    first = contents.lastIndexOf(initial, last - 1)
-
-    // Exit if there’s no starting delimiter, the starting delimiter is before
-    // the start of the node, or if it’s not preceded by whitespace.
-    if (first <= begin || !/\s/.test(contents.charAt(first - 1))) {
-      return
-    }
-
-    if (preferred) {
-      if (preferred !== final) {
-        reason =
-          'Titles should use `' +
-          (preferred === ')' ? '()' : preferred) +
-          '` as a quote'
-
-        file.message(reason, {
-          start: loc.toPoint(first),
-          end: loc.toPoint(last + 1)
-        })
+    visit(tree, (node) => {
+      if (
+        (node.type === 'link' ||
+          node.type === 'image' ||
+          node.type === 'definition') &&
+        !generated(node)
+      ) {
+        const tail = node.children
+          ? node.children[node.children.length - 1]
+          : null
+        const begin = tail ? pointEnd(tail) : pointStart(node)
+        let last = pointEnd(node).offset - 1
+
+        if (node.type !== 'definition') {
+          last--
+        }
+
+        let final
+
+        // Skip back to before whitespace.
+        while (last) {
+          final = value.charAt(last)
+
+          // Legacy for remark before 8.0.0
+          /* c8 ignore next 2 */
+          if (/\s/.test(final)) {
+            last--
+          } else {
+            break
+          }
+        }
+
+        // Exit if the final marker is not a known marker.
+        if (!(final in markers)) {
+          return
+        }
+
+        const initial = markers[final]
+
+        // Find the starting delimiter
+        const first = value.lastIndexOf(initial, last - 1)
+
+        // Exit if there’s no starting delimiter, the starting delimiter is before
+        // the start of the node, or if it’s not preceded by whitespace.
+        if (first <= begin || !/\s/.test(value.charAt(first - 1))) {
+          return
+        }
+
+        if (preferred) {
+          if (preferred !== final) {
+            file.message(
+              'Titles should use `' +
+                (preferred === ')' ? '()' : preferred) +
+                '` as a quote',
+              {
+                start: loc.toPoint(first),
+                end: loc.toPoint(last + 1)
+              }
+            )
+          }
+        } else {
+          preferred = final
+        }
       }
-    } else {
-      preferred = final
-    }
+    })
   }
-}
+)
+
+export default remarkLintLinkTitleStyle
diff --git a/packages/remark-lint-list-item-bullet-indent/index.js b/packages/remark-lint-list-item-bullet-indent/index.js
index 734d3488..96716992 100644
--- a/packages/remark-lint-list-item-bullet-indent/index.js
+++ b/packages/remark-lint-list-item-bullet-indent/index.js
@@ -41,39 +41,35 @@ import {generated} from 'unist-util-generated'
 
 const remarkLintListItemBulletIndent = lintRule(
   'remark-lint:list-item-bullet-indent',
-  listItemBulletIndent
-)
-
-export default remarkLintListItemBulletIndent
-
-function listItemBulletIndent(tree, file) {
-  visit(tree, 'list', visitor)
-
-  function visitor(list, _, grandparent) {
-    list.children.forEach(visitItems)
+  (tree, file) => {
+    visit(tree, 'list', (list, _, grandparent) => {
+      let index = -1
 
-    function visitItems(item) {
-      var indent
-      var reason
+      while (++index < list.children.length) {
+        const item = list.children[index]
 
-      if (
-        grandparent &&
-        grandparent.type === 'root' &&
-        !generated(item) &&
-        !generated(grandparent)
-      ) {
-        indent = item.position.start.column - grandparent.position.start.column
+        if (
+          grandparent &&
+          grandparent.type === 'root' &&
+          !generated(item) &&
+          !generated(grandparent)
+        ) {
+          const indent =
+            item.position.start.column - grandparent.position.start.column
 
-        if (indent) {
-          reason =
-            'Incorrect indentation before bullet: remove ' +
-            indent +
-            ' ' +
-            plural('space', indent)
-
-          file.message(reason, item.position.start)
+          if (indent) {
+            file.message(
+              'Incorrect indentation before bullet: remove ' +
+                indent +
+                ' ' +
+                plural('space', indent),
+              item.position.start
+            )
+          }
         }
       }
-    }
+    })
   }
-}
+)
+
+export default remarkLintListItemBulletIndent
diff --git a/packages/remark-lint-list-item-content-indent/index.js b/packages/remark-lint-list-item-content-indent/index.js
index 1b2a5a52..f30b2038 100644
--- a/packages/remark-lint-list-item-content-indent/index.js
+++ b/packages/remark-lint-list-item-content-indent/index.js
@@ -29,76 +29,63 @@ import {generated} from 'unist-util-generated'
 
 const remarkLintListItemContentIndent = lintRule(
   'remark-lint:list-item-content-indent',
-  listItemContentIndent
-)
-
-export default remarkLintListItemContentIndent
-
-function listItemContentIndent(tree, file) {
-  var contents = String(file)
-
-  visit(tree, 'listItem', visitor)
+  (tree, file) => {
+    const value = String(file)
 
-  function visitor(node) {
-    var style
+    visit(tree, 'listItem', (node) => {
+      let index = -1
+      let style
 
-    node.children.forEach(visitInItem)
+      while (++index < node.children.length) {
+        const item = node.children[index]
 
-    function visitInItem(item, index) {
-      var begin
-      var column
-      var char
-      var diff
-      var reason
-      var abs
+        if (generated(item)) {
+          continue
+        }
 
-      if (generated(item)) {
-        return
-      }
+        const begin = pointStart(item)
+        let column = begin.column
 
-      begin = pointStart(item)
-      column = begin.column
+        // Get indentation for the first child.  Only the first item can have a
+        // checkbox, so here we remove that from the column.
+        if (index === 0) {
+          // If there’s a checkbox before the content, look backwards to find the
+          // start of that checkbox.
+          if (typeof node.checked === 'boolean') {
+            let char = begin.offset - 1
 
-      // Get indentation for the first child.  Only the first item can have a
-      // checkbox, so here we remove that from the column.
-      if (index === 0) {
-        // If there’s a checkbox before the content, look backwards to find the
-        // start of that checkbox.
-        if (typeof node.checked === 'boolean') {
-          char = begin.offset - 1
+            while (char > 0 && value.charAt(char) !== '[') {
+              char--
+            }
 
-          while (char > 0 && contents.charAt(char) !== '[') {
-            char--
+            column -= begin.offset - char
           }
 
-          column -= begin.offset - char
-        }
-
-        style = column
+          style = column
 
-        return
-      }
-
-      // Warn for violating children.
-      if (column !== style) {
-        diff = style - column
-        abs = Math.abs(diff)
-
-        reason =
-          'Don’t use mixed indentation for children, ' +
-          // Hard to test, I couldn’t find it at least.
-          /* c8 ignore next */
-          (diff > 0 ? 'add' : 'remove') +
-          ' ' +
-          abs +
-          ' ' +
-          plural('space', abs)
+          continue
+        }
 
-        file.message(reason, {
-          line: pointStart(item).line,
-          column: column
-        })
+        // Warn for violating children.
+        if (column !== style) {
+          const diff = style - column
+          const abs = Math.abs(diff)
+
+          file.message(
+            'Don’t use mixed indentation for children, ' +
+              // Hard to test, I couldn’t find it at least.
+              /* c8 ignore next */
+              (diff > 0 ? 'add' : 'remove') +
+              ' ' +
+              abs +
+              ' ' +
+              plural('space', abs),
+            {line: pointStart(item).line, column}
+          )
+        }
       }
-    }
+    })
   }
-}
+)
+
+export default remarkLintListItemContentIndent
diff --git a/packages/remark-lint-list-item-indent/index.js b/packages/remark-lint-list-item-indent/index.js
index 23b58e6b..e4cd24c3 100644
--- a/packages/remark-lint-list-item-indent/index.js
+++ b/packages/remark-lint-list-item-indent/index.js
@@ -109,71 +109,61 @@ import {visit} from 'unist-util-visit'
 import {pointStart} from 'unist-util-position'
 import {generated} from 'unist-util-generated'
 
+const styles = {'tab-size': true, mixed: true, space: true}
+
 const remarkLintListItemIndent = lintRule(
   'remark-lint:list-item-indent',
-  listItemIndent
-)
-
-export default remarkLintListItemIndent
-
-var styles = {'tab-size': true, mixed: true, space: true}
-
-function listItemIndent(tree, file, option) {
-  var contents = String(file)
-  var preferred = typeof option === 'string' ? option : 'tab-size'
-
-  if (styles[preferred] !== true) {
-    file.fail(
-      'Incorrect list-item indent style `' +
-        preferred +
-        "`: use either `'tab-size'`, `'space'`, or `'mixed'`"
-    )
-  }
-
-  visit(tree, 'list', visitor)
-
-  function visitor(node) {
-    var spread = node.spread || node.loose
-
-    if (!generated(node)) {
-      node.children.forEach(visitItem)
+  (tree, file, option) => {
+    const preferred = typeof option === 'string' ? option : 'tab-size'
+    const value = String(file)
+
+    if (styles[preferred] !== true) {
+      file.fail(
+        'Incorrect list-item indent style `' +
+          preferred +
+          "`: use either `'tab-size'`, `'space'`, or `'mixed'`"
+      )
     }
 
-    function visitItem(item) {
-      var head = item.children[0]
-      var final = pointStart(head)
-      var marker
-      var bulletSize
-      var style
-      var diff
-      var reason
-      var abs
-
-      marker = contents
-        .slice(pointStart(item).offset, final.offset)
-        .replace(/\[[x ]?]\s*$/i, '')
-
-      bulletSize = marker.replace(/\s+$/, '').length
-
-      style =
-        preferred === 'tab-size' || (preferred === 'mixed' && spread)
-          ? Math.ceil(bulletSize / 4) * 4
-          : bulletSize + 1
-
-      if (marker.length !== style) {
-        diff = style - marker.length
-        abs = Math.abs(diff)
-
-        reason =
-          'Incorrect list-item indent: ' +
-          (diff > 0 ? 'add' : 'remove') +
-          ' ' +
-          abs +
-          ' ' +
-          plural('space', abs)
-
-        file.message(reason, final)
+    visit(tree, 'list', (node) => {
+      if (generated(node)) return
+
+      const spread = node.spread || node.loose
+      let index = -1
+
+      while (++index < node.children.length) {
+        const item = node.children[index]
+        const head = item.children[0]
+        const final = pointStart(head)
+
+        const marker = value
+          .slice(pointStart(item).offset, final.offset)
+          .replace(/\[[x ]?]\s*$/i, '')
+
+        const bulletSize = marker.replace(/\s+$/, '').length
+
+        const style =
+          preferred === 'tab-size' || (preferred === 'mixed' && spread)
+            ? Math.ceil(bulletSize / 4) * 4
+            : bulletSize + 1
+
+        if (marker.length !== style) {
+          const diff = style - marker.length
+          const abs = Math.abs(diff)
+
+          file.message(
+            'Incorrect list-item indent: ' +
+              (diff > 0 ? 'add' : 'remove') +
+              ' ' +
+              abs +
+              ' ' +
+              plural('space', abs),
+            final
+          )
+        }
       }
-    }
+    })
   }
-}
+)
+
+export default remarkLintListItemIndent
diff --git a/packages/remark-lint-list-item-spacing/index.js b/packages/remark-lint-list-item-spacing/index.js
index a2651880..1c420633 100644
--- a/packages/remark-lint-list-item-spacing/index.js
+++ b/packages/remark-lint-list-item-spacing/index.js
@@ -114,87 +114,64 @@ import {generated} from 'unist-util-generated'
 
 const remarkLintListItemSpacing = lintRule(
   'remark-lint:list-item-spacing',
-  listItemSpacing
-)
-
-export default remarkLintListItemSpacing
-
-var reasonLoose = 'Missing new line after list item'
-var reasonTight = 'Extraneous new line after list item'
-
-function listItemSpacing(tree, file, option) {
-  var infer =
-    option && typeof option === 'object' && option.checkBlanks
-      ? inferBlankLine
-      : inferMultiline
-
-  visit(tree, 'list', visitor)
-
-  function visitor(node) {
-    var tight = true
-    var children
-    var length
-    var index
-    var child
-    var next
-
-    if (!generated(node)) {
-      children = node.children
-      length = children.length
-      index = -1
-
-      while (++index < length) {
-        if (infer(children[index])) {
-          tight = false
-          break
+  (tree, file, option = {}) => {
+    const {checkBlanks} = option
+    const infer = checkBlanks ? inferBlankLine : inferMultiline
+
+    visit(tree, 'list', (node) => {
+      if (!generated(node)) {
+        let tight = true
+        let index = -1
+
+        while (++index < node.children.length) {
+          if (infer(node.children[index])) {
+            tight = false
+            break
+          }
         }
-      }
 
-      child = children[0]
-      index = 0 // Skip over first.
+        index = 0 // Skip over first.
 
-      while (++index < length) {
-        next = children[index]
+        while (++index < node.children.length) {
+          const child = node.children[index - 1]
+          const next = node.children[index]
 
-        if (pointStart(next).line - pointEnd(child).line < 2 !== tight) {
-          file.message(tight ? reasonTight : reasonLoose, {
-            start: pointEnd(child),
-            end: pointStart(next)
-          })
+          if (pointStart(next).line - pointEnd(child).line < 2 !== tight) {
+            file.message(
+              tight
+                ? 'Extraneous new line after list item'
+                : 'Missing new line after list item',
+              {start: pointEnd(child), end: pointStart(next)}
+            )
+          }
         }
-
-        child = next
       }
-    }
+    })
   }
-}
+)
+
+export default remarkLintListItemSpacing
 
 function inferBlankLine(node) {
-  var children = node.children
-  var child = children[0]
-  var length = children.length
-  var index = 0
-  var next
+  let index = 0
 
-  while (++index < length) {
-    next = children[index]
+  while (++index < node.children.length) {
+    const child = node.children[index - 1]
+    const next = node.children[index]
 
     // All children in `listItem`s are block.
     if (pointStart(next).line - pointEnd(child).line > 1) {
       return true
     }
-
-    child = next
   }
 
   return false
 }
 
 function inferMultiline(node) {
-  var children = node.children
   return (
-    pointEnd(children[children.length - 1]).line -
-      pointStart(children[0]).line >
+    pointEnd(node.children[node.children.length - 1]).line -
+      pointStart(node.children[0]).line >
     0
   )
 }
diff --git a/packages/remark-lint-maximum-heading-length/index.js b/packages/remark-lint-maximum-heading-length/index.js
index 20f186c8..d0fd56ab 100644
--- a/packages/remark-lint-maximum-heading-length/index.js
+++ b/packages/remark-lint-maximum-heading-length/index.js
@@ -32,19 +32,15 @@ import {toString} from 'mdast-util-to-string'
 
 const remarkLintMaximumHeadingLength = lintRule(
   'remark-lint:maximum-heading-length',
-  maximumHeadingLength
+  (tree, file, option) => {
+    const preferred = typeof option === 'number' ? option : 60
+
+    visit(tree, 'heading', (node) => {
+      if (!generated(node) && toString(node).length > preferred) {
+        file.message('Use headings shorter than `' + preferred + '`', node)
+      }
+    })
+  }
 )
 
 export default remarkLintMaximumHeadingLength
-
-function maximumHeadingLength(tree, file, option) {
-  var preferred = typeof option === 'number' && !isNaN(option) ? option : 60
-
-  visit(tree, 'heading', visitor)
-
-  function visitor(node) {
-    if (!generated(node) && toString(node).length > preferred) {
-      file.message('Use headings shorter than `' + preferred + '`', node)
-    }
-  }
-}
diff --git a/packages/remark-lint-maximum-line-length/index.js b/packages/remark-lint-maximum-line-length/index.js
index 3f1940e6..8f8620bc 100644
--- a/packages/remark-lint-maximum-line-length/index.js
+++ b/packages/remark-lint-maximum-line-length/index.js
@@ -103,73 +103,72 @@ const remarkLintMaximumLineLength = lintRule(
 export default remarkLintMaximumLineLength
 
 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
+  const preferred = typeof option === 'number' ? option : 80
+  const value = String(file)
+  const lines = value.split(/\r?\n/)
 
-  // Note: JSX is from MDX: <https://github.com/mdx-js/specification>.
-  visit(
-    tree,
-    ['heading', 'table', 'code', 'definition', 'html', 'jsx', 'yaml', 'toml'],
-    ignore
-  )
-  visit(tree, ['link', 'image', 'inlineCode'], inline)
-
-  // Iterate over every line, and warn for violating lines.
-  while (++index < length) {
-    lineLength = lines[index].length
-
-    if (lineLength > preferred) {
-      file.message('Line must be at most ' + preferred + ' characters', {
-        line: index + 1,
-        column: lineLength + 1
-      })
+  visit(tree, (node) => {
+    // Note: JSX is from MDX: <https://github.com/mdx-js/specification>.
+    if (
+      (node.type === 'heading' ||
+        node.type === 'table' ||
+        node.type === 'code' ||
+        node.type === 'definition' ||
+        node.type === 'html' ||
+        node.type === 'jsx' ||
+        node.type === 'yaml' ||
+        node.type === 'toml') &&
+      !generated(node)
+    ) {
+      allowList(pointStart(node).line - 1, pointEnd(node).line)
     }
-  }
+  })
 
   // 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.
-  function inline(node, pos, parent) {
-    var next = parent.children[pos + 1]
-    var initial
-    var final
+  visit(tree, (node, pos, parent) => {
+    if (
+      (node.type === 'link' ||
+        node.type === 'image' ||
+        node.type === 'inlineCode') &&
+      !generated(node)
+    ) {
+      const initial = pointStart(node)
+      const final = pointEnd(node)
 
-    // Nothing to allow when generated.
-    /* c8 ignore next 3 */
-    if (generated(node)) {
-      return
-    }
+      // Not allowing when starting after the border, or ending before it.
+      if (initial.column > preferred || final.column < preferred) {
+        return
+      }
 
-    initial = pointStart(node)
-    final = pointEnd(node)
+      const next = parent.children[pos + 1]
 
-    // Not allowing when starting after the border, or ending before it.
-    if (initial.column > preferred || final.column < preferred) {
-      return
-    }
+      // Not allowing when there’s whitespace after the link.
+      if (
+        next &&
+        pointStart(next).line === initial.line &&
+        (!next.value || /^(.+?[ \t].+?)/.test(next.value))
+      ) {
+        return
+      }
 
-    // Not allowing when there’s whitespace after the link.
-    if (
-      next &&
-      pointStart(next).line === initial.line &&
-      (!next.value || /^(.+?[ \t].+?)/.test(next.value))
-    ) {
-      return
+      allowList(initial.line - 1, final.line)
     }
+  })
 
-    allowList(initial.line - 1, final.line)
-  }
+  // Iterate over every line, and warn for violating lines.
+  let index = -1
 
-  function ignore(node) {
-    // Hard to test, as we only run this case on `position: true`.
-    /* c8 ignore next 3 */
-    if (!generated(node)) {
-      allowList(pointStart(node).line - 1, pointEnd(node).line)
+  while (++index < lines.length) {
+    const lineLength = lines[index].length
+
+    if (lineLength > preferred) {
+      file.message('Line must be at most ' + preferred + ' characters', {
+        line: index + 1,
+        column: lineLength + 1
+      })
     }
   }
 
diff --git a/packages/remark-lint-no-auto-link-without-protocol/index.js b/packages/remark-lint-no-auto-link-without-protocol/index.js
index 3eeb83fb..024ebb7c 100644
--- a/packages/remark-lint-no-auto-link-without-protocol/index.js
+++ b/packages/remark-lint-no-auto-link-without-protocol/index.js
@@ -39,36 +39,25 @@ import {pointStart, pointEnd} from 'unist-util-position'
 import {generated} from 'unist-util-generated'
 import {toString} from 'mdast-util-to-string'
 
-const remarkLintNoAutoLinkWithoutProtocol = lintRule(
-  'remark-lint:no-auto-link-without-protocol',
-  noAutoLinkWithoutProtocol
-)
-
-export default remarkLintNoAutoLinkWithoutProtocol
-
 // Protocol expression.
 // See: <https://en.wikipedia.org/wiki/URI_scheme#Generic_syntax>.
-var protocol = /^[a-z][a-z+.-]+:\/?/i
-
-var reason = 'All automatic links must start with a protocol'
-
-function noAutoLinkWithoutProtocol(tree, file) {
-  visit(tree, 'link', visitor)
-
-  function visitor(node) {
-    var children
-
-    if (!generated(node)) {
-      children = node.children
+const protocol = /^[a-z][a-z+.-]+:\/?/i
 
+const remarkLintNoAutoLinkWithoutProtocol = lintRule(
+  'remark-lint:no-auto-link-without-protocol',
+  (tree, file) => {
+    visit(tree, 'link', (node) => {
       if (
-        pointStart(node).column === pointStart(children[0]).column - 1 &&
+        !generated(node) &&
+        pointStart(node).column === pointStart(node.children[0]).column - 1 &&
         pointEnd(node).column ===
-          pointEnd(children[children.length - 1]).column + 1 &&
+          pointEnd(node.children[node.children.length - 1]).column + 1 &&
         !protocol.test(toString(node))
       ) {
-        file.message(reason, node)
+        file.message('All automatic links must start with a protocol', node)
       }
-    }
+    })
   }
-}
+)
+
+export default remarkLintNoAutoLinkWithoutProtocol
diff --git a/packages/remark-lint-no-blockquote-without-marker/index.js b/packages/remark-lint-no-blockquote-without-marker/index.js
index 03739b68..8a88fd11 100644
--- a/packages/remark-lint-no-blockquote-without-marker/index.js
+++ b/packages/remark-lint-no-blockquote-without-marker/index.js
@@ -57,45 +57,39 @@ import {generated} from 'unist-util-generated'
 
 const remarkLintNoBlockquoteWithoutMarker = lintRule(
   'remark-lint:no-blockquote-without-marker',
-  noBlockquoteWithoutMarker
-)
-
-export default remarkLintNoBlockquoteWithoutMarker
-
-var reason = 'Missing marker in block quote'
+  (tree, file) => {
+    const value = String(file)
+    const loc = location(file)
 
-function noBlockquoteWithoutMarker(tree, file) {
-  var contents = String(file)
-  var loc = location(file)
+    visit(tree, 'blockquote', (node) => {
+      let index = -1
 
-  visit(tree, 'blockquote', visitor)
+      while (++index < node.children.length) {
+        const child = node.children[index]
 
-  function onquotedchild(node) {
-    var line
-    var end
-    var column
-    var offset
+        if (child.type === 'paragraph' && !generated(child)) {
+          const end = pointEnd(child).line
+          const column = pointStart(child).column
+          let line = pointStart(child).line
 
-    if (node.type === 'paragraph' && !generated(node)) {
-      line = pointStart(node).line
-      end = pointEnd(node).line
-      column = pointStart(node).column
+          // Skip past the first line.
+          while (++line <= end) {
+            const offset = loc.toOffset({line, column})
 
-      // Skip past the first line.
-      while (++line <= end) {
-        offset = loc.toOffset({line: line, column: column})
+            if (/>[\t ]+$/.test(value.slice(offset - 5, offset))) {
+              continue
+            }
 
-        if (/>[\t ]+$/.test(contents.slice(offset - 5, offset))) {
-          continue
+            // Roughly here.
+            file.message('Missing marker in block quote', {
+              line,
+              column: column - 2
+            })
+          }
         }
-
-        // Roughly here.
-        file.message(reason, {line: line, column: column - 2})
       }
-    }
+    })
   }
+)
 
-  function visitor(node) {
-    node.children.forEach(onquotedchild)
-  }
-}
+export default remarkLintNoBlockquoteWithoutMarker
diff --git a/packages/remark-lint-no-consecutive-blank-lines/index.js b/packages/remark-lint-no-consecutive-blank-lines/index.js
index 433ea53a..81ff5a0f 100644
--- a/packages/remark-lint-no-consecutive-blank-lines/index.js
+++ b/packages/remark-lint-no-consecutive-blank-lines/index.js
@@ -48,65 +48,57 @@ import {generated} from 'unist-util-generated'
 
 const remarkLintNoConsecutiveBlankLines = lintRule(
   'remark-lint:no-consecutive-blank-lines',
-  noConsecutiveBlankLines
-)
-
-export default remarkLintNoConsecutiveBlankLines
-
-function noConsecutiveBlankLines(tree, file) {
-  visit(tree, visitor)
+  (tree, file) => {
+    visit(tree, (node) => {
+      if (!generated(node) && 'children' in node) {
+        const head = node.children[0]
 
-  function visitor(node) {
-    var children = node.children
-    var head
-    var tail
+        if (head && !generated(head)) {
+          // Compare parent and first child.
+          compare(pointStart(node), pointStart(head), 0)
 
-    if (!generated(node) && children) {
-      head = children[0]
+          // Compare between each child.
+          let index = -1
 
-      if (head && !generated(head)) {
-        // Compare parent and first child.
-        compare(pointStart(node), pointStart(head), 0)
+          while (++index < node.children.length) {
+            const previous = node.children[index - 1]
+            const child = node.children[index]
 
-        // Compare between each child.
-        children.forEach(visitChild)
+            if (previous && !generated(previous) && !generated(child)) {
+              compare(pointEnd(previous), pointStart(child), 2)
+            }
+          }
 
-        tail = children[children.length - 1]
+          const tail = node.children[node.children.length - 1]
 
-        // Compare parent and last child.
-        if (tail !== head && !generated(tail)) {
-          compare(pointEnd(node), pointEnd(tail), 1)
+          // Compare parent and last child.
+          if (tail !== head && !generated(tail)) {
+            compare(pointEnd(node), pointEnd(tail), 1)
+          }
         }
       }
-    }
-  }
-
-  // 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
+    })
 
-    if (lines > 0) {
-      reason =
-        'Remove ' +
-        lines +
-        ' ' +
-        plural('line', Math.abs(lines)) +
-        ' ' +
-        (diff > 0 ? 'before' : 'after') +
-        ' node'
+    // Compare the difference between `start` and `end`, and warn when that
+    // difference exceeds `max`.
+    function compare(start, end, max) {
+      const diff = end.line - start.line
+      const lines = Math.abs(diff) - max
 
-      file.message(reason, end)
+      if (lines > 0) {
+        file.message(
+          'Remove ' +
+            lines +
+            ' ' +
+            plural('line', Math.abs(lines)) +
+            ' ' +
+            (diff > 0 ? 'before' : 'after') +
+            ' node',
+          end
+        )
+      }
     }
   }
+)
 
-  function visitChild(child, index, all) {
-    var previous = all[index - 1]
-
-    if (previous && !generated(previous) && !generated(child)) {
-      compare(pointEnd(previous), pointStart(child), 2)
-    }
-  }
-}
+export default remarkLintNoConsecutiveBlankLines
diff --git a/packages/remark-lint-no-duplicate-defined-urls/index.js b/packages/remark-lint-no-duplicate-defined-urls/index.js
index 53cf258c..743fd747 100644
--- a/packages/remark-lint-no-duplicate-defined-urls/index.js
+++ b/packages/remark-lint-no-duplicate-defined-urls/index.js
@@ -29,34 +29,27 @@ import {visit} from 'unist-util-visit'
 
 const remarkLintNoDuplicateDefinedUrls = lintRule(
   'remark-lint:no-duplicate-defined-urls',
-  noDuplicateDefinedUrls
+  (tree, file) => {
+    const map = Object.create(null)
+
+    visit(tree, 'definition', (node) => {
+      if (!generated(node) && node.url) {
+        const url = String(node.url).toUpperCase()
+        const duplicate = map[url]
+
+        if (duplicate) {
+          file.message(
+            'Do not use different definitions with the same URL (' +
+              stringifyPosition(pointStart(duplicate)) +
+              ')',
+            node
+          )
+        }
+
+        map[url] = node
+      }
+    })
+  }
 )
 
 export default remarkLintNoDuplicateDefinedUrls
-
-var reason = 'Do not use different definitions with the same URL'
-
-function noDuplicateDefinedUrls(tree, file) {
-  var map = {}
-
-  visit(tree, 'definition', check)
-
-  function check(node) {
-    var url
-    var duplicate
-
-    if (!generated(node) && node.url) {
-      url = String(node.url).toUpperCase()
-      duplicate = map[url]
-
-      if (duplicate && duplicate.type) {
-        file.message(
-          reason + ' (' + stringifyPosition(pointStart(duplicate)) + ')',
-          node
-        )
-      }
-
-      map[url] = node
-    }
-  }
-}
diff --git a/packages/remark-lint-no-duplicate-definitions/index.js b/packages/remark-lint-no-duplicate-definitions/index.js
index b3a0abea..8fe5c091 100644
--- a/packages/remark-lint-no-duplicate-definitions/index.js
+++ b/packages/remark-lint-no-duplicate-definitions/index.js
@@ -29,34 +29,30 @@ import {visit} from 'unist-util-visit'
 
 const remarkLintNoDuplicateDefinitions = lintRule(
   'remark-lint:no-duplicate-definitions',
-  noDuplicateDefinitions
+  (tree, file) => {
+    const map = Object.create(null)
+
+    visit(tree, (node) => {
+      if (
+        (node.type === 'definition' || node.type === 'footnoteDefinition') &&
+        !generated(node)
+      ) {
+        const identifier = node.identifier
+        const duplicate = map[identifier]
+
+        if (duplicate) {
+          file.message(
+            'Do not use definitions with the same identifier (' +
+              stringifyPosition(pointStart(duplicate)) +
+              ')',
+            node
+          )
+        }
+
+        map[identifier] = node
+      }
+    })
+  }
 )
 
 export default remarkLintNoDuplicateDefinitions
-
-var reason = 'Do not use definitions with the same identifier'
-
-function noDuplicateDefinitions(tree, file) {
-  var map = {}
-
-  visit(tree, ['definition', 'footnoteDefinition'], check)
-
-  function check(node) {
-    var identifier
-    var duplicate
-
-    if (!generated(node)) {
-      identifier = node.identifier
-      duplicate = map[identifier]
-
-      if (duplicate && duplicate.type) {
-        file.message(
-          reason + ' (' + stringifyPosition(pointStart(duplicate)) + ')',
-          node
-        )
-      }
-
-      map[identifier] = node
-    }
-  }
-}
diff --git a/packages/remark-lint-no-duplicate-headings-in-section/index.js b/packages/remark-lint-no-duplicate-headings-in-section/index.js
index 084be1f9..bdcd4667 100644
--- a/packages/remark-lint-no-duplicate-headings-in-section/index.js
+++ b/packages/remark-lint-no-duplicate-headings-in-section/index.js
@@ -63,33 +63,29 @@ import {toString} from 'mdast-util-to-string'
 
 const remarkLintNoDuplicateHeadingsInSection = lintRule(
   'remark-lint:no-duplicate-headings-in-section',
-  noDuplicateHeadingsInSection
-)
-
-export default remarkLintNoDuplicateHeadingsInSection
-
-var reason = 'Do not use headings with similar content per section'
-
-function noDuplicateHeadingsInSection(tree, file) {
-  var stack = []
+  (tree, file) => {
+    let stack = []
 
-  visit(tree, 'heading', visitor)
+    visit(tree, 'heading', (node) => {
+      const depth = node.depth
+      const value = toString(node).toUpperCase()
+      const index = depth - 1
+      const scope = stack[index] || (stack[index] = {})
+      const duplicate = scope[value]
 
-  function visitor(node) {
-    var depth = node.depth
-    var value = toString(node).toUpperCase()
-    var index = depth - 1
-    var scope = stack[index] || (stack[index] = {})
-    var duplicate = scope[value]
+      if (!generated(node) && duplicate) {
+        file.message(
+          'Do not use headings with similar content per section (' +
+            stringifyPosition(pointStart(duplicate)) +
+            ')',
+          node
+        )
+      }
 
-    if (!generated(node) && duplicate) {
-      file.message(
-        reason + ' (' + stringifyPosition(pointStart(duplicate)) + ')',
-        node
-      )
-    }
-
-    scope[value] = node
-    stack = stack.slice(0, depth)
+      scope[value] = node
+      stack = stack.slice(0, depth)
+    })
   }
-}
+)
+
+export default remarkLintNoDuplicateHeadingsInSection
diff --git a/packages/remark-lint-no-duplicate-headings/index.js b/packages/remark-lint-no-duplicate-headings/index.js
index d309683f..fc170eda 100644
--- a/packages/remark-lint-no-duplicate-headings/index.js
+++ b/packages/remark-lint-no-duplicate-headings/index.js
@@ -35,34 +35,27 @@ import {toString} from 'mdast-util-to-string'
 
 const remarkLintNoDuplicateHeadings = lintRule(
   'remark-lint:no-duplicate-headings',
-  noDuplicateHeadings
+  (tree, file) => {
+    const map = Object.create(null)
+
+    visit(tree, 'heading', (node) => {
+      if (!generated(node)) {
+        const value = toString(node).toUpperCase()
+        const duplicate = map[value]
+
+        if (duplicate) {
+          file.message(
+            'Do not use headings with similar content (' +
+              stringifyPosition(pointStart(duplicate)) +
+              ')',
+            node
+          )
+        }
+
+        map[value] = node
+      }
+    })
+  }
 )
 
 export default remarkLintNoDuplicateHeadings
-
-var reason = 'Do not use headings with similar content'
-
-function noDuplicateHeadings(tree, file) {
-  var map = {}
-
-  visit(tree, 'heading', visitor)
-
-  function visitor(node) {
-    var value
-    var duplicate
-
-    if (!generated(node)) {
-      value = toString(node).toUpperCase()
-      duplicate = map[value]
-
-      if (duplicate && duplicate.type === 'heading') {
-        file.message(
-          reason + ' (' + stringifyPosition(pointStart(duplicate)) + ')',
-          node
-        )
-      }
-
-      map[value] = node
-    }
-  }
-}
diff --git a/packages/remark-lint-no-emphasis-as-heading/index.js b/packages/remark-lint-no-emphasis-as-heading/index.js
index cdce5fe0..59f311fa 100644
--- a/packages/remark-lint-no-emphasis-as-heading/index.js
+++ b/packages/remark-lint-no-emphasis-as-heading/index.js
@@ -35,30 +35,27 @@ import {generated} from 'unist-util-generated'
 
 const remarkLintNoEmphasisAsHeading = lintRule(
   'remark-lint:no-emphasis-as-heading',
-  noEmphasisAsHeading
+  (tree, file) => {
+    visit(tree, 'paragraph', (node, index, parent) => {
+      const head = node.children[0]
+      const previous = parent.children[index - 1]
+      const next = parent.children[index + 1]
+
+      if (
+        !generated(node) &&
+        (!previous || previous.type !== 'heading') &&
+        next &&
+        next.type === 'paragraph' &&
+        node.children.length === 1 &&
+        (head.type === 'emphasis' || head.type === 'strong')
+      ) {
+        file.message(
+          'Don’t use emphasis to introduce a section, use a heading',
+          node
+        )
+      }
+    })
+  }
 )
 
 export default remarkLintNoEmphasisAsHeading
-
-var reason = 'Don’t use emphasis to introduce a section, use a heading'
-
-function noEmphasisAsHeading(tree, file) {
-  visit(tree, 'paragraph', visitor)
-
-  function visitor(node, index, parent) {
-    var head = node.children[0]
-    var previous = parent.children[index - 1]
-    var next = parent.children[index + 1]
-
-    if (
-      !generated(node) &&
-      (!previous || previous.type !== 'heading') &&
-      next &&
-      next.type === 'paragraph' &&
-      node.children.length === 1 &&
-      (head.type === 'emphasis' || head.type === 'strong')
-    ) {
-      file.message(reason, node)
-    }
-  }
-}
diff --git a/packages/remark-lint-no-empty-url/index.js b/packages/remark-lint-no-empty-url/index.js
index b2f94cb6..3bfb2dd5 100644
--- a/packages/remark-lint-no-empty-url/index.js
+++ b/packages/remark-lint-no-empty-url/index.js
@@ -28,16 +28,19 @@ import {lintRule} from 'unified-lint-rule'
 import {visit} from 'unist-util-visit'
 import {generated} from 'unist-util-generated'
 
-const remarkLintNoEmptyUrl = lintRule('remark-lint:no-empty-url', noEmptyURL)
+const remarkLintNoEmptyUrl = lintRule(
+  'remark-lint:no-empty-url',
+  (tree, file) => {
+    visit(tree, (node) => {
+      if (
+        (node.type === 'link' || node.type === 'image') &&
+        !generated(node) &&
+        !node.url
+      ) {
+        file.message('Don’t use ' + node.type + 's without URL', node)
+      }
+    })
+  }
+)
 
 export default remarkLintNoEmptyUrl
-
-function noEmptyURL(tree, file) {
-  visit(tree, ['link', 'image'], visitor)
-
-  function visitor(node) {
-    if (!generated(node) && !node.url) {
-      file.message('Don’t use ' + node.type + 's without URL', node)
-    }
-  }
-}
diff --git a/packages/remark-lint-no-file-name-articles/index.js b/packages/remark-lint-no-file-name-articles/index.js
index 5fef18d1..a2a70a55 100644
--- a/packages/remark-lint-no-file-name-articles/index.js
+++ b/packages/remark-lint-no-file-name-articles/index.js
@@ -29,15 +29,13 @@ import {lintRule} from 'unified-lint-rule'
 
 const remarkLintNoFileNameArticles = lintRule(
   'remark-lint:no-file-name-articles',
-  noFileNameArticles
+  (tree, file) => {
+    const match = file.stem && file.stem.match(/^(the|teh|an?)\b/i)
+
+    if (match) {
+      file.message('Do not start file names with `' + match[0] + '`')
+    }
+  }
 )
 
 export default remarkLintNoFileNameArticles
-
-function noFileNameArticles(tree, file) {
-  var match = file.stem && file.stem.match(/^(the|teh|an?)\b/i)
-
-  if (match) {
-    file.message('Do not start file names with `' + match[0] + '`')
-  }
-}
diff --git a/packages/remark-lint-no-file-name-consecutive-dashes/index.js b/packages/remark-lint-no-file-name-consecutive-dashes/index.js
index e9d14fe6..47f322e9 100644
--- a/packages/remark-lint-no-file-name-consecutive-dashes/index.js
+++ b/packages/remark-lint-no-file-name-consecutive-dashes/index.js
@@ -17,15 +17,11 @@ import {lintRule} from 'unified-lint-rule'
 
 const remarkLintNoFileNameConsecutiveDashes = lintRule(
   'remark-lint:no-file-name-consecutive-dashes',
-  noFileNameConsecutiveDashes
+  (tree, file) => {
+    if (file.stem && /-{2,}/.test(file.stem)) {
+      file.message('Do not use consecutive dashes in a file name')
+    }
+  }
 )
 
 export default remarkLintNoFileNameConsecutiveDashes
-
-var reason = 'Do not use consecutive dashes in a file name'
-
-function noFileNameConsecutiveDashes(tree, file) {
-  if (file.stem && /-{2,}/.test(file.stem)) {
-    file.message(reason)
-  }
-}
diff --git a/packages/remark-lint-no-file-name-irregular-characters/index.js b/packages/remark-lint-no-file-name-irregular-characters/index.js
index d5327746..93f46dda 100644
--- a/packages/remark-lint-no-file-name-irregular-characters/index.js
+++ b/packages/remark-lint-no-file-name-irregular-characters/index.js
@@ -34,26 +34,23 @@
 
 import {lintRule} from 'unified-lint-rule'
 
+const expression = /[^\\.a-zA-Z\d-]/
+
 const remarkLintNoFileNameIrregularCharacters = lintRule(
   'remark-lint:no-file-name-irregular-characters',
-  noFileNameIrregularCharacters
-)
-
-export default remarkLintNoFileNameIrregularCharacters
+  (tree, file, option) => {
+    let preferred = option || expression
 
-var expression = /[^\\.a-zA-Z\d-]/
+    if (typeof preferred === 'string') {
+      preferred = new RegExp('[^' + preferred + ']')
+    }
 
-function noFileNameIrregularCharacters(tree, file, option) {
-  var preferred = option || expression
-  var match
+    const match = file.stem && file.stem.match(preferred)
 
-  if (typeof preferred === 'string') {
-    preferred = new RegExp('[^' + preferred + ']')
+    if (match) {
+      file.message('Do not use `' + match[0] + '` in a file name')
+    }
   }
+)
 
-  match = file.stem && file.stem.match(preferred)
-
-  if (match) {
-    file.message('Do not use `' + match[0] + '` in a file name')
-  }
-}
+export default remarkLintNoFileNameIrregularCharacters
diff --git a/packages/remark-lint-no-file-name-mixed-case/index.js b/packages/remark-lint-no-file-name-mixed-case/index.js
index 2658d9d7..abea0e09 100644
--- a/packages/remark-lint-no-file-name-mixed-case/index.js
+++ b/packages/remark-lint-no-file-name-mixed-case/index.js
@@ -19,17 +19,13 @@ import {lintRule} from 'unified-lint-rule'
 
 const remarkLintNofileNameMixedCase = lintRule(
   'remark-lint:no-file-name-mixed-case',
-  noFileNameMixedCase
+  (tree, file) => {
+    const name = file.stem
+
+    if (name && !(name === name.toLowerCase() || name === name.toUpperCase())) {
+      file.message('Do not mix casing in file names')
+    }
+  }
 )
 
 export default remarkLintNofileNameMixedCase
-
-var reason = 'Do not mix casing in file names'
-
-function noFileNameMixedCase(tree, file) {
-  var name = file.stem
-
-  if (name && !(name === name.toLowerCase() || name === name.toUpperCase())) {
-    file.message(reason)
-  }
-}
diff --git a/packages/remark-lint-no-file-name-outer-dashes/index.js b/packages/remark-lint-no-file-name-outer-dashes/index.js
index 4d0552dd..993e0a4d 100644
--- a/packages/remark-lint-no-file-name-outer-dashes/index.js
+++ b/packages/remark-lint-no-file-name-outer-dashes/index.js
@@ -21,15 +21,11 @@ import {lintRule} from 'unified-lint-rule'
 
 const remarkLintNofileNameOuterDashes = lintRule(
   'remark-lint:no-file-name-outer-dashes',
-  noFileNameOuterDashes
+  (tree, file) => {
+    if (file.stem && /^-|-$/.test(file.stem)) {
+      file.message('Do not use initial or final dashes in a file name')
+    }
+  }
 )
 
 export default remarkLintNofileNameOuterDashes
-
-var reason = 'Do not use initial or final dashes in a file name'
-
-function noFileNameOuterDashes(tree, file) {
-  if (file.stem && /^-|-$/.test(file.stem)) {
-    file.message(reason)
-  }
-}
diff --git a/packages/remark-lint-no-heading-content-indent/index.js b/packages/remark-lint-no-heading-content-indent/index.js
index cafd3f88..92262acf 100644
--- a/packages/remark-lint-no-heading-content-indent/index.js
+++ b/packages/remark-lint-no-heading-content-indent/index.js
@@ -55,72 +55,55 @@ import {generated} from 'unist-util-generated'
 
 const remarkLintNoHeadingContentIndent = lintRule(
   'remark-lint:no-heading-content-indent',
-  noHeadingContentIndent
-)
-
-export default remarkLintNoHeadingContentIndent
-
-function noHeadingContentIndent(tree, file) {
-  visit(tree, 'heading', visitor)
-
-  function visitor(node) {
-    var depth
-    var children
-    var type
-    var head
-    var final
-    var diff
-    var reason
-    var abs
-
-    if (generated(node)) {
-      return
-    }
-
-    depth = node.depth
-    children = node.children
-    type = headingStyle(node, 'atx')
-
-    if (type === 'atx' || type === 'atx-closed') {
-      head = pointStart(children[0]).column
-
-      // Ignore empty headings.
-      if (!head) {
+  (tree, file) => {
+    visit(tree, 'heading', (node) => {
+      if (generated(node)) {
         return
       }
 
-      diff = head - pointStart(node).column - 1 - depth
-
-      if (diff) {
-        abs = Math.abs(diff)
+      const type = headingStyle(node, 'atx')
 
-        reason =
-          'Remove ' +
-          abs +
-          ' ' +
-          plural('space', abs) +
-          ' before this heading’s content'
+      if (type === 'atx' || type === 'atx-closed') {
+        const head = pointStart(node.children[0]).column
 
-        file.message(reason, pointStart(children[0]))
-      }
-    }
+        // Ignore empty headings.
+        if (!head) {
+          return
+        }
 
-    // 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 = pointEnd(children[children.length - 1])
-      diff = pointEnd(node).column - final.column - 1 - depth
+        const diff = head - pointStart(node).column - 1 - node.depth
 
-      if (diff) {
-        reason =
-          'Remove ' +
-          diff +
-          ' ' +
-          plural('space', diff) +
-          ' after this heading’s content'
+        if (diff) {
+          file.message(
+            'Remove ' +
+              Math.abs(diff) +
+              ' ' +
+              plural('space', Math.abs(diff)) +
+              ' before this heading’s content',
+            pointStart(node.children[0])
+          )
+        }
+      }
 
-        file.message(reason, final)
+      // 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
+
+        if (diff) {
+          file.message(
+            'Remove ' +
+              diff +
+              ' ' +
+              plural('space', diff) +
+              ' after this heading’s content',
+            final
+          )
+        }
       }
-    }
+    })
   }
-}
+)
+
+export default remarkLintNoHeadingContentIndent
diff --git a/packages/remark-lint-no-heading-indent/index.js b/packages/remark-lint-no-heading-indent/index.js
index 021c2dd7..5d057879 100644
--- a/packages/remark-lint-no-heading-indent/index.js
+++ b/packages/remark-lint-no-heading-indent/index.js
@@ -54,30 +54,28 @@ import {generated} from 'unist-util-generated'
 
 const remarkLintNoHeadingIndent = lintRule(
   'remark-lint:no-heading-indent',
-  noHeadingIndent
-)
-
-export default remarkLintNoHeadingIndent
-
-function noHeadingIndent(tree, file) {
-  visit(tree, 'heading', visitor)
-
-  function visitor(node, _, parent) {
-    var diff
+  (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
+      }
 
-    // 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
-    }
+      const diff = pointStart(node).column - 1
 
-    diff = pointStart(node).column - 1
-
-    if (diff) {
-      file.message(
-        'Remove ' + diff + ' ' + plural('space', diff) + ' before this heading',
-        pointStart(node)
-      )
-    }
+      if (diff) {
+        file.message(
+          'Remove ' +
+            diff +
+            ' ' +
+            plural('space', diff) +
+            ' before this heading',
+          pointStart(node)
+        )
+      }
+    })
   }
-}
+)
+
+export default remarkLintNoHeadingIndent
diff --git a/packages/remark-lint-no-heading-like-paragraph/index.js b/packages/remark-lint-no-heading-like-paragraph/index.js
index 8c8b57d9..f78312a2 100644
--- a/packages/remark-lint-no-heading-like-paragraph/index.js
+++ b/packages/remark-lint-no-heading-like-paragraph/index.js
@@ -27,32 +27,28 @@ import {lintRule} from 'unified-lint-rule'
 import {visit} from 'unist-util-visit'
 import {generated} from 'unist-util-generated'
 
+const fence = '#######'
+
 const remarkLintNoHeadingLikeParagraph = lintRule(
   'remark-lint:no-heading-like-paragraph',
-  noHeadingLikeParagraph
+  (tree, file) => {
+    visit(tree, 'paragraph', (node) => {
+      if (!generated(node)) {
+        const head = node.children[0]
+
+        if (
+          head &&
+          head.type === 'text' &&
+          head.value.slice(0, fence.length) === fence
+        ) {
+          file.message(
+            'This looks like a heading but has too many hashes',
+            node
+          )
+        }
+      }
+    })
+  }
 )
 
 export default remarkLintNoHeadingLikeParagraph
-
-var fence = '#######'
-var reason = 'This looks like a heading but has too many hashes'
-
-function noHeadingLikeParagraph(tree, file) {
-  visit(tree, 'paragraph', visitor)
-
-  function visitor(node) {
-    var head
-
-    if (!generated(node)) {
-      head = node.children[0]
-
-      if (
-        head &&
-        head.type === 'text' &&
-        head.value.slice(0, fence.length) === fence
-      ) {
-        file.message(reason, node)
-      }
-    }
-  }
-}
diff --git a/packages/remark-lint-no-heading-punctuation/index.js b/packages/remark-lint-no-heading-punctuation/index.js
index 642f4f2d..dc1ab2e0 100644
--- a/packages/remark-lint-no-heading-punctuation/index.js
+++ b/packages/remark-lint-no-heading-punctuation/index.js
@@ -45,33 +45,26 @@ import {visit} from 'unist-util-visit'
 import {generated} from 'unist-util-generated'
 import {toString} from 'mdast-util-to-string'
 
+const defaults = '\\.,;:!?'
+
 const remarkLintNoHeadingPunctuation = lintRule(
   'remark-lint:no-heading-punctuation',
-  noHeadingPunctuation
-)
-
-export default remarkLintNoHeadingPunctuation
-
-var defaults = '\\.,;:!?'
-
-function noHeadingPunctuation(tree, file, option) {
-  var expression = new RegExp(
-    '[' + (typeof option === 'string' ? option : defaults) + ']'
-  )
+  (tree, file, option) => {
+    const expression = new RegExp(
+      '[' + (typeof option === 'string' ? option : defaults) + ']'
+    )
 
-  visit(tree, 'heading', visitor)
+    visit(tree, 'heading', (node) => {
+      if (!generated(node)) {
+        const value = toString(node)
+        const tail = value.charAt(value.length - 1)
 
-  function visitor(node) {
-    var value
-    var tail
-
-    if (!generated(node)) {
-      value = toString(node)
-      tail = value.charAt(value.length - 1)
-
-      if (expression.test(tail)) {
-        file.message('Don’t add a trailing `' + tail + '` to headings', node)
+        if (expression.test(tail)) {
+          file.message('Don’t add a trailing `' + tail + '` to headings', node)
+        }
       }
-    }
+    })
   }
-}
+)
+
+export default remarkLintNoHeadingPunctuation
diff --git a/packages/remark-lint-no-html/index.js b/packages/remark-lint-no-html/index.js
index b537fc01..c3349a58 100644
--- a/packages/remark-lint-no-html/index.js
+++ b/packages/remark-lint-no-html/index.js
@@ -28,18 +28,12 @@ import {lintRule} from 'unified-lint-rule'
 import {visit} from 'unist-util-visit'
 import {generated} from 'unist-util-generated'
 
-const remarkLintNoHtml = lintRule('remark-lint:no-html', noHTML)
-
-export default remarkLintNoHtml
-
-var reason = 'Do not use HTML in markdown'
-
-function noHTML(tree, file) {
-  visit(tree, 'html', visitor)
-
-  function visitor(node) {
+const remarkLintNoHtml = lintRule('remark-lint:no-html', (tree, file) => {
+  visit(tree, 'html', (node) => {
     if (!generated(node) && !/^\s*<!--/.test(node.value)) {
-      file.message(reason, node)
+      file.message('Do not use HTML in markdown', node)
     }
-  }
-}
+  })
+})
+
+export default remarkLintNoHtml
diff --git a/packages/remark-lint-no-inline-padding/index.js b/packages/remark-lint-no-inline-padding/index.js
index 36559a95..47139d2e 100644
--- a/packages/remark-lint-no-inline-padding/index.js
+++ b/packages/remark-lint-no-inline-padding/index.js
@@ -29,28 +29,22 @@ import {toString} from 'mdast-util-to-string'
 
 const remarkLintNoInlinePadding = lintRule(
   'remark-lint:no-inline-padding',
-  noInlinePadding
-)
-
-export default remarkLintNoInlinePadding
-
-function noInlinePadding(tree, file) {
-  // Note: `emphasis`, `strong`, `delete` (GFM) can’t have padding anymore
-  // since CM.
-  visit(tree, ['link', 'linkReference'], visitor)
-
-  function visitor(node) {
-    var contents
-
-    if (!generated(node)) {
-      contents = toString(node)
-
+  (tree, file) => {
+    // Note: `emphasis`, `strong`, `delete` (GFM) can’t have padding anymore
+    // since CM.
+    visit(tree, (node) => {
       if (
-        contents.charAt(0) === ' ' ||
-        contents.charAt(contents.length - 1) === ' '
+        (node.type === 'link' || node.type === 'linkReference') &&
+        !generated(node)
       ) {
-        file.message('Don’t pad `' + node.type + '` with inner spaces', node)
+        const value = toString(node)
+
+        if (value.charAt(0) === ' ' || value.charAt(value.length - 1) === ' ') {
+          file.message('Don’t pad `' + node.type + '` with inner spaces', node)
+        }
       }
-    }
+    })
   }
-}
+)
+
+export default remarkLintNoInlinePadding
diff --git a/packages/remark-lint-no-literal-urls/index.js b/packages/remark-lint-no-literal-urls/index.js
index bf818286..65d98092 100644
--- a/packages/remark-lint-no-literal-urls/index.js
+++ b/packages/remark-lint-no-literal-urls/index.js
@@ -39,29 +39,21 @@ import {toString} from 'mdast-util-to-string'
 
 const remarkLintNoLiteralUrls = lintRule(
   'remark-lint:no-literal-urls',
-  noLiteralURLs
+  (tree, file) => {
+    visit(tree, 'link', (node) => {
+      const value = toString(node)
+
+      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)
+      }
+    })
+  }
 )
 
 export default remarkLintNoLiteralUrls
-
-var mailto = 'mailto:'
-var reason = 'Don’t use literal URLs without angle brackets'
-
-function noLiteralURLs(tree, file) {
-  visit(tree, 'link', visitor)
-
-  function visitor(node) {
-    var children = node.children
-    var value = toString(node)
-
-    if (
-      !generated(node) &&
-      pointStart(node).column === pointStart(children[0]).column &&
-      pointEnd(node).column ===
-        pointEnd(children[children.length - 1]).column &&
-      (node.url === mailto + value || node.url === value)
-    ) {
-      file.message(reason, node)
-    }
-  }
-}
diff --git a/packages/remark-lint-no-missing-blank-lines/index.js b/packages/remark-lint-no-missing-blank-lines/index.js
index ee5283b6..9cd28430 100644
--- a/packages/remark-lint-no-missing-blank-lines/index.js
+++ b/packages/remark-lint-no-missing-blank-lines/index.js
@@ -68,16 +68,7 @@ import {visit} from 'unist-util-visit'
 import {pointStart, pointEnd} from 'unist-util-position'
 import {generated} from 'unist-util-generated'
 
-const remarkLintNoMissingBlankLines = lintRule(
-  'remark-lint:no-missing-blank-lines',
-  noMissingBlankLines
-)
-
-export default remarkLintNoMissingBlankLines
-
-var reason = 'Missing blank line before block node'
-
-var types = [
+const types = new Set([
   'paragraph',
   'heading',
   'thematicBreak',
@@ -87,30 +78,31 @@ var types = [
   'html',
   'code',
   'yaml'
-]
-
-function noMissingBlankLines(tree, file, option) {
-  var exceptTightLists = (option || {}).exceptTightLists
+])
 
-  visit(tree, visitor)
-
-  function visitor(node, index, parent) {
-    var next
-
-    if (
-      parent &&
-      !generated(node) &&
-      (!exceptTightLists || parent.type !== 'listItem')
-    ) {
-      next = parent.children[index + 1]
+const remarkLintNoMissingBlankLines = lintRule(
+  'remark-lint:no-missing-blank-lines',
+  (tree, file, option = {}) => {
+    const {exceptTightLists} = option
 
+    visit(tree, (node, index, parent) => {
       if (
-        next &&
-        types.indexOf(next.type) !== -1 &&
-        pointStart(next).line === pointEnd(node).line + 1
+        parent &&
+        !generated(node) &&
+        (!exceptTightLists || parent.type !== 'listItem')
       ) {
-        file.message(reason, next)
+        const next = parent.children[index + 1]
+
+        if (
+          next &&
+          types.has(next.type) &&
+          pointStart(next).line === pointEnd(node).line + 1
+        ) {
+          file.message('Missing blank line before block node', next)
+        }
       }
-    }
+    })
   }
-}
+)
+
+export default remarkLintNoMissingBlankLines
diff --git a/packages/remark-lint-no-multiple-toplevel-headings/index.js b/packages/remark-lint-no-multiple-toplevel-headings/index.js
index fdd0e9ab..cb81ae5c 100644
--- a/packages/remark-lint-no-multiple-toplevel-headings/index.js
+++ b/packages/remark-lint-no-multiple-toplevel-headings/index.js
@@ -33,27 +33,22 @@ import {stringifyPosition} from 'unist-util-stringify-position'
 
 const remarkLintNoMultipleToplevelHeadings = lintRule(
   'remark-lint:no-multiple-toplevel-headings',
-  noMultipleToplevelHeadings
-)
-
-export default remarkLintNoMultipleToplevelHeadings
-
-function noMultipleToplevelHeadings(tree, file, option) {
-  var preferred = option || 1
-  var duplicate
+  (tree, file, option = 1) => {
+    let duplicate
 
-  visit(tree, 'heading', visitor)
-
-  function visitor(node) {
-    if (!generated(node) && node.depth === preferred) {
-      if (duplicate) {
-        file.message(
-          'Don’t use multiple top level headings (' + duplicate + ')',
-          node
-        )
-      } else {
-        duplicate = stringifyPosition(pointStart(node))
+    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(pointStart(node))
+        }
       }
-    }
+    })
   }
-}
+)
+
+export default remarkLintNoMultipleToplevelHeadings
diff --git a/packages/remark-lint-no-paragraph-content-indent/index.js b/packages/remark-lint-no-paragraph-content-indent/index.js
index 7dcfd683..046e553a 100644
--- a/packages/remark-lint-no-paragraph-content-indent/index.js
+++ b/packages/remark-lint-no-paragraph-content-indent/index.js
@@ -78,70 +78,65 @@ import {location} from 'vfile-location'
 
 const remarkLintNoParagraphContentIndent = lintRule(
   'remark-lint:no-paragraph-content-indent',
-  noParagraphContentIndent
-)
-
-export default remarkLintNoParagraphContentIndent
-
-var reason = 'Expected no indentation in paragraph content'
-
-function noParagraphContentIndent(tree, file) {
-  var content = String(file)
-  var loc = location(content)
-
-  visit(tree, 'paragraph', visitor)
-
-  function visitor(node, _, parent) {
-    var line = pointStart(node).line
-    var end = pointEnd(node).line
-    var column
-    var offset
-    var lineColumn
-
-    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
-
-      // Skip past the first line if we’re the first child of a list item.
-      if (parent.children[0] === node) {
-        line++
+  (tree, file) => {
+    const value = String(file)
+    const loc = location(value)
+
+    visit(tree, 'paragraph', (node, _, parent) => {
+      const end = pointEnd(node).line
+      let line = pointStart(node).line
+      let column = 0
+
+      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
+
+        // Skip past the first line if we’re the first child of a list item.
+        if (parent.children[0] === node) {
+          line++
+        }
       }
-    }
-
-    // In a parent we don’t know, exit.
-    if (!column || !line) {
-      return
-    }
-
-    while (line <= end) {
-      offset = loc.toOffset({line: line, column: column})
-      lineColumn = offset
 
-      while (/[ \t]/.test(content.charAt(offset - 1))) {
-        offset--
+      // In a parent we don’t know, exit.
+      if (!column || !line) {
+        return
       }
 
-      // Exit if we find some other content before this line.
-      // This might be because the paragraph line is lazy, which isn’t this
-      // rule.
-      if (!offset || /[\r\n>]/.test(content.charAt(offset - 1))) {
-        offset = lineColumn
+      while (line <= end) {
+        let offset = loc.toOffset({line, column})
+        const lineColumn = offset
 
-        while (/[ \t]/.test(content.charAt(offset))) {
-          offset++
+        while (/[ \t]/.test(value.charAt(offset - 1))) {
+          offset--
         }
 
-        if (lineColumn !== offset) {
-          file.message(reason, loc.toPoint(offset))
+        // Exit if we find some other content before this line.
+        // This might be because the paragraph line is lazy, which isn’t this
+        // rule.
+        if (!offset || /[\r\n>]/.test(value.charAt(offset - 1))) {
+          offset = lineColumn
+
+          while (/[ \t]/.test(value.charAt(offset))) {
+            offset++
+          }
+
+          if (lineColumn !== offset) {
+            file.message(
+              'Expected no indentation in paragraph content',
+              loc.toPoint(offset)
+            )
+          }
         }
-      }
 
-      line++
-    }
+        line++
+      }
 
-    return SKIP
+      return SKIP
+    })
   }
-}
+)
+
+export default remarkLintNoParagraphContentIndent
diff --git a/packages/remark-lint-no-reference-like-url/index.js b/packages/remark-lint-no-reference-like-url/index.js
index 1471cec0..67877b76 100644
--- a/packages/remark-lint-no-reference-like-url/index.js
+++ b/packages/remark-lint-no-reference-like-url/index.js
@@ -29,39 +29,32 @@ import {visit} from 'unist-util-visit'
 
 const remarkLintNoReferenceLikeUrl = lintRule(
   'remark-lint:no-reference-like-url',
-  noReferenceLikeURL
+  (tree, file) => {
+    const identifiers = []
+
+    visit(tree, 'definition', (node) => {
+      if (!generated(node)) {
+        identifiers.push(node.identifier.toLowerCase())
+      }
+    })
+
+    visit(tree, (node) => {
+      if (
+        (node.type === 'image' || node.type === 'link') &&
+        identifiers.includes(node.url.toLowerCase())
+      ) {
+        file.message(
+          'Did you mean to use `[' +
+            node.url +
+            ']` instead of ' +
+            '`(' +
+            node.url +
+            ')`, a reference?',
+          node
+        )
+      }
+    })
+  }
 )
 
 export default remarkLintNoReferenceLikeUrl
-
-function noReferenceLikeURL(tree, file) {
-  var identifiers = []
-
-  visit(tree, 'definition', find)
-  visit(tree, ['image', 'link'], check)
-
-  // Find identifiers.
-  function find(node) {
-    if (!generated(node)) {
-      identifiers.push(node.identifier.toLowerCase())
-    }
-  }
-
-  // Check `node`.
-  function check(node) {
-    var url = node.url
-    var reason
-
-    if (identifiers.indexOf(url.toLowerCase()) !== -1) {
-      reason =
-        'Did you mean to use `[' +
-        url +
-        ']` instead of ' +
-        '`(' +
-        url +
-        ')`, a reference?'
-
-      file.message(reason, node)
-    }
-  }
-}
diff --git a/packages/remark-lint-no-shell-dollars/index.js b/packages/remark-lint-no-shell-dollars/index.js
index 3690bd7c..08d12cfd 100644
--- a/packages/remark-lint-no-shell-dollars/index.js
+++ b/packages/remark-lint-no-shell-dollars/index.js
@@ -59,17 +59,39 @@ import {generated} from 'unist-util-generated'
 
 const remarkLintNoShellDollars = lintRule(
   'remark-lint:no-shell-dollars',
-  noShellDollars
+  (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
+        }
+
+        while (++index < lines.length) {
+          const line = lines[index]
+
+          if (line.trim() && !/^\s*\$\s*/.test(line)) {
+            return
+          }
+        }
+
+        file.message('Do not use dollar signs before shell commands', node)
+      }
+    })
+  }
 )
 
 export default remarkLintNoShellDollars
 
-var reason = 'Do not use dollar signs before shell commands'
-
 // 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 = [
+const flags = new Set([
   'sh',
   'bash',
   'bats',
@@ -80,40 +102,4 @@ var flags = [
   'tmux',
   'tool',
   'zsh'
-]
-
-function noShellDollars(tree, file) {
-  visit(tree, 'code', visitor)
-
-  function visitor(node) {
-    var lines
-    var line
-    var length
-    var index
-
-    // Check both known shell code and unknown code.
-    if (!generated(node) && node.lang && flags.indexOf(node.lang) !== -1) {
-      lines = node.value.split('\n').filter(notEmpty)
-      length = lines.length
-      index = -1
-
-      if (length === 0) {
-        return
-      }
-
-      while (++index < length) {
-        line = lines[index]
-
-        if (line.trim() && !/^\s*\$\s*/.test(line)) {
-          return
-        }
-      }
-
-      file.message(reason, node)
-    }
-  }
-
-  function notEmpty(line) {
-    return line.trim().length !== 0
-  }
-}
+])
diff --git a/packages/remark-lint-no-shortcut-reference-image/index.js b/packages/remark-lint-no-shortcut-reference-image/index.js
index f795e3d4..46115478 100644
--- a/packages/remark-lint-no-shortcut-reference-image/index.js
+++ b/packages/remark-lint-no-shortcut-reference-image/index.js
@@ -35,19 +35,13 @@ import {generated} from 'unist-util-generated'
 
 const remarkLintNoShortcutReferenceImage = lintRule(
   'remark-lint:no-shortcut-reference-image',
-  noShortcutReferenceImage
+  (tree, file) => {
+    visit(tree, 'imageReference', (node) => {
+      if (!generated(node) && node.referenceType === 'shortcut') {
+        file.message('Use the trailing [] on reference images', node)
+      }
+    })
+  }
 )
 
 export default remarkLintNoShortcutReferenceImage
-
-var reason = 'Use the trailing [] on reference images'
-
-function noShortcutReferenceImage(tree, file) {
-  visit(tree, 'imageReference', visitor)
-
-  function visitor(node) {
-    if (!generated(node) && node.referenceType === 'shortcut') {
-      file.message(reason, node)
-    }
-  }
-}
diff --git a/packages/remark-lint-no-shortcut-reference-link/index.js b/packages/remark-lint-no-shortcut-reference-link/index.js
index cc741408..9eb4c493 100644
--- a/packages/remark-lint-no-shortcut-reference-link/index.js
+++ b/packages/remark-lint-no-shortcut-reference-link/index.js
@@ -35,19 +35,13 @@ import {generated} from 'unist-util-generated'
 
 const remarkLintNoShortcutReferenceLink = lintRule(
   'remark-lint:no-shortcut-reference-link',
-  noShortcutReferenceLink
+  (tree, file) => {
+    visit(tree, 'linkReference', (node) => {
+      if (!generated(node) && node.referenceType === 'shortcut') {
+        file.message('Use the trailing `[]` on reference links', node)
+      }
+    })
+  }
 )
 
 export default remarkLintNoShortcutReferenceLink
-
-var reason = 'Use the trailing `[]` on reference links'
-
-function noShortcutReferenceLink(tree, file) {
-  visit(tree, 'linkReference', visitor)
-
-  function visitor(node) {
-    if (!generated(node) && node.referenceType === 'shortcut') {
-      file.message(reason, node)
-    }
-  }
-}
diff --git a/packages/remark-lint-no-table-indentation/index.js b/packages/remark-lint-no-table-indentation/index.js
index f605e0e5..c6e2fe3a 100644
--- a/packages/remark-lint-no-table-indentation/index.js
+++ b/packages/remark-lint-no-table-indentation/index.js
@@ -64,68 +64,60 @@ import {location} from 'vfile-location'
 
 const remarkLintNoTableIndentation = lintRule(
   'remark-lint:no-table-indentation',
-  noTableIndentation
-)
-
-export default remarkLintNoTableIndentation
-
-var reason = 'Do not indent table rows'
-
-function noTableIndentation(tree, file) {
-  var content = String(file)
-  var loc = location(content)
-
-  visit(tree, 'table', visitor)
-
-  function visitor(node, _, parent) {
-    var line = pointStart(node).line
-    var end = pointEnd(node).line
-    var column
-    var offset
-    var lineColumn
-
-    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
+  (tree, file) => {
+    const value = String(file)
+    const loc = location(value)
+
+    visit(tree, 'table', (node, _, parent) => {
+      const end = pointEnd(node).line
+      let line = pointStart(node).line
+      let column = 0
+
+      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
+
+        // 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++
+        }
+      }
 
-      // 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++
+      // In a parent we don’t know, exit.
+      if (!column || !line) {
+        return
       }
-    }
 
-    // In a parent we don’t know, exit.
-    if (!column || !line) {
-      return
-    }
+      while (line <= end) {
+        let offset = loc.toOffset({line, column})
+        const lineColumn = offset
 
-    while (line <= end) {
-      offset = loc.toOffset({line: line, column: column})
-      lineColumn = offset
+        while (/[ \t]/.test(value.charAt(offset - 1))) {
+          offset--
+        }
 
-      while (/[ \t]/.test(content.charAt(offset - 1))) {
-        offset--
-      }
+        if (!offset || /[\r\n>]/.test(value.charAt(offset - 1))) {
+          offset = lineColumn
 
-      if (!offset || /[\r\n>]/.test(content.charAt(offset - 1))) {
-        offset = lineColumn
+          while (/[ \t]/.test(value.charAt(offset))) {
+            offset++
+          }
 
-        while (/[ \t]/.test(content.charAt(offset))) {
-          offset++
+          if (lineColumn !== offset) {
+            file.message('Do not indent table rows', loc.toPoint(offset))
+          }
         }
 
-        if (lineColumn !== offset) {
-          file.message(reason, loc.toPoint(offset))
-        }
+        line++
       }
 
-      line++
-    }
-
-    return SKIP
+      return SKIP
+    })
   }
-}
+)
+
+export default remarkLintNoTableIndentation
diff --git a/packages/remark-lint-no-tabs/index.js b/packages/remark-lint-no-tabs/index.js
index dd1e6e97..65ba2b73 100644
--- a/packages/remark-lint-no-tabs/index.js
+++ b/packages/remark-lint-no-tabs/index.js
@@ -53,19 +53,15 @@
 import {lintRule} from 'unified-lint-rule'
 import {location} from 'vfile-location'
 
-const remarkLintNoTabs = lintRule('remark-lint:no-tabs', noTabs)
-
-export default remarkLintNoTabs
-
-var reason = 'Use spaces instead of tabs'
-
-function noTabs(tree, file) {
-  var content = String(file)
-  var toPoint = location(file).toPoint
-  var index = content.indexOf('\t')
+const remarkLintNoTabs = lintRule('remark-lint:no-tabs', (tree, file) => {
+  const value = String(file)
+  const toPoint = location(file).toPoint
+  let index = value.indexOf('\t')
 
   while (index !== -1) {
-    file.message(reason, toPoint(index))
-    index = content.indexOf('\t', index + 1)
+    file.message('Use spaces instead of tabs', toPoint(index))
+    index = value.indexOf('\t', index + 1)
   }
-}
+})
+
+export default remarkLintNoTabs
diff --git a/packages/remark-lint-no-undefined-references/index.js b/packages/remark-lint-no-undefined-references/index.js
index 06f527b2..02580e38 100644
--- a/packages/remark-lint-no-undefined-references/index.js
+++ b/packages/remark-lint-no-undefined-references/index.js
@@ -71,186 +71,184 @@ import {visit, SKIP, EXIT} from 'unist-util-visit'
 
 const remarkLintNoUndefinedReferences = lintRule(
   'remark-lint:no-undefined-references',
-  noUndefinedReferences
-)
-
-export default remarkLintNoUndefinedReferences
-
-var reason = 'Found reference to undefined definition'
-
-// 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(s) {
-  return collapseWhiteSpace(s.toUpperCase())
-}
-
-function noUndefinedReferences(tree, file, option) {
-  var contents = String(file)
-  var loc = location(file)
-  var lineEnding = /(\r?\n|\r)[\t ]*(>[\t ]*)*/g
-  var allow = ((option || {}).allow || []).map(normalize)
-  var map = {}
-
-  visit(tree, ['definition', 'footnoteDefinition'], mark)
-  visit(tree, ['imageReference', 'linkReference', 'footnoteReference'], find)
-  visit(tree, ['paragraph', 'heading'], findInPhrasing)
-
-  function mark(node) {
-    if (!generated(node)) {
-      map[normalize(node.identifier)] = true
-    }
-  }
-
-  function find(node) {
-    if (
-      !generated(node) &&
-      !(normalize(node.identifier) in map) &&
-      allow.indexOf(normalize(node.identifier)) === -1
-    ) {
-      file.message(reason, node)
-    }
-  }
-
-  function findInPhrasing(node) {
-    var ranges = []
-
-    visit(node, onchild)
-
-    ranges.forEach(handleRange)
-
-    return SKIP
+  (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) => normalize(d)))
+    const map = {}
+
+    visit(tree, (node) => {
+      if (
+        (node.type === 'definition' || node.type === 'footnoteDefinition') &&
+        !generated(node)
+      ) {
+        map[normalize(node.identifier)] = true
+      }
+    })
+
+    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) &&
+        !(normalize(node.identifier) in map) &&
+        !allow.has(normalize(node.identifier))
+      ) {
+        file.message('Found reference to undefined definition', node)
+      }
 
-    function onchild(child) {
-      var start
-      var end
-      var source
-      var lines
-      var last
-      var index
-      var match
-      var line
-      var code
-      var lineIndex
-      var next
-      var range
+      if (node.type === 'paragraph' || node.type === 'heading') {
+        findInPhrasing(node)
+      }
+    })
 
-      // Ignore the node itself.
-      if (child === node) return
+    function findInPhrasing(node) {
+      let ranges = []
 
-      // Can’t have links in links, so reset ranges.
-      if (child.type === 'link' || child.type === 'linkReference') {
-        ranges = []
-        return SKIP
-      }
+      visit(node, (child) => {
+        // Ignore the node itself.
+        if (child === node) return
 
-      // Enter non-text.
-      if (child.type !== 'text') return
+        // Can’t have links in links, so reset ranges.
+        if (child.type === 'link' || child.type === 'linkReference') {
+          ranges = []
+          return SKIP
+        }
 
-      start = pointStart(child).offset
-      end = pointEnd(child).offset
+        // Enter non-text.
+        if (child.type !== 'text') return
 
-      // Bail if there’s no positional info.
-      if (!end) return EXIT
+        const start = pointStart(child).offset
+        const end = pointEnd(child).offset
 
-      source = contents.slice(start, end)
-      lines = [[start, '']]
-      last = 0
+        // Bail if there’s no positional info.
+        if (!end) return EXIT
 
-      lineEnding.lastIndex = 0
-      match = lineEnding.exec(source)
+        const source = contents.slice(start, end)
+        const lines = [[start, '']]
+        let last = 0
 
-      while (match) {
-        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)
-      }
+        lineEnding.lastIndex = 0
+        let match = lineEnding.exec(source)
 
-      lines[lines.length - 1][1] = source.slice(last)
-      lineIndex = -1
+        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)
+        }
 
-      while (++lineIndex < lines.length) {
-        line = lines[lineIndex][1]
-        index = 0
+        lines[lines.length - 1][1] = source.slice(last)
+        let lineIndex = -1
 
-        while (index < line.length) {
-          code = line.charCodeAt(index)
+        while (++lineIndex < lines.length) {
+          const line = lines[lineIndex][1]
+          let index = 0
 
-          // Skip past escaped brackets.
-          if (code === 92) {
-            next = line.charCodeAt(index + 1)
-            index++
+          while (index < line.length) {
+            const code = line.charCodeAt(index)
 
-            if (next === 91 || next === 93) {
+            // Skip past escaped brackets.
+            if (code === 92) {
+              const next = line.charCodeAt(index + 1)
               index++
+
+              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) {
+            // Opening bracket.
+            else if (code === 91) {
+              ranges.push([lines[lineIndex][0] + index])
               index++
-
-              // Collapsed or full.
-              range = ranges.pop()
-              range.push(lines[lineIndex][0] + index)
-
-              // This is the end of a reference already.
-              if (range.length === 4) {
+            }
+            // 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.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++
+
+                // Shortcut or typical end of a reference.
+                const range = ranges.pop()
+                range.push(lines[lineIndex][0] + index)
                 handleRange(range)
-                range = []
               }
-
-              range.push(lines[lineIndex][0] + index)
-              ranges.push(range)
-              index++
-            } else {
+            }
+            // Anything else.
+            else {
               index++
-
-              // Shortcut or typical end of a reference.
-              range = ranges.pop()
-              range.push(lines[lineIndex][0] + index)
-              handleRange(range)
             }
           }
-          // Anything else.
-          else {
-            index++
-          }
         }
-      }
-    }
+      })
 
-    function handleRange(range) {
-      var offset
+      let index = -1
 
-      if (range.length === 1) return
-      if (range.length === 3) range.length = 2
+      while (++index < ranges.length) {
+        handleRange(ranges[index])
+      }
 
-      // No need to warn for just `[]`.
-      if (range.length === 2 && range[0] + 2 === range[1]) return
+      return SKIP
 
-      offset = range.length === 4 && range[2] + 2 !== range[3] ? 2 : 0
+      function handleRange(range) {
+        if (range.length === 1) return
+        if (range.length === 3) range.length = 2
 
-      find({
-        identifier: contents
+        // No need to warn for just `[]`.
+        if (range.length === 2 && range[0] + 2 === range[1]) return
+
+        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, ' '),
-        position: {
+          .replace(lineEnding, ' ')
+        const pos = {
           start: loc.toPoint(range[0]),
           end: loc.toPoint(range[range.length - 1])
         }
-      })
+
+        if (
+          !generated({position: pos}) &&
+          !(normalize(id) in map) &&
+          !allow.has(normalize(id))
+        ) {
+          file.message('Found reference to undefined definition', pos)
+        }
+      }
     }
   }
+)
+
+export default remarkLintNoUndefinedReferences
+
+// 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(s) {
+  return collapseWhiteSpace(s.toUpperCase())
 }
diff --git a/packages/remark-lint-no-unneeded-full-reference-image/index.js b/packages/remark-lint-no-unneeded-full-reference-image/index.js
index 7474c0d7..57238039 100644
--- a/packages/remark-lint-no-unneeded-full-reference-image/index.js
+++ b/packages/remark-lint-no-unneeded-full-reference-image/index.js
@@ -44,29 +44,26 @@ import {collapseWhiteSpace} from 'collapse-white-space'
 
 const remarkLintNoUnneededFullReferenceImage = lintRule(
   'remark-lint:no-unneeded-full-reference-image',
-  noUnneededFullReferenceImage
+  (tree, file) => {
+    visit(tree, 'imageReference', (node) => {
+      if (
+        generated(node) ||
+        node.referenceType !== 'full' ||
+        normalize(node.alt) !== node.identifier
+      ) {
+        return
+      }
+
+      file.message(
+        'Remove the image label as it matches the reference text',
+        node
+      )
+    })
+  }
 )
 
 export default remarkLintNoUnneededFullReferenceImage
 
-var reason = 'Remove the image label as it matches the reference text'
-
-function noUnneededFullReferenceImage(tree, file) {
-  visit(tree, 'imageReference', visitor)
-
-  function visitor(node) {
-    if (
-      generated(node) ||
-      node.referenceType !== 'full' ||
-      normalize(node.alt) !== node.identifier
-    ) {
-      return
-    }
-
-    file.message(reason, node)
-  }
-}
-
 // See: <https://github.com/remarkjs/remark/blob/cc7867b/packages/remark-parse/lib/util/normalize.js>
 function normalize(value) {
   return collapseWhiteSpace(value).toLowerCase()
diff --git a/packages/remark-lint-no-unneeded-full-reference-link/index.js b/packages/remark-lint-no-unneeded-full-reference-link/index.js
index cffee7ae..b36a4829 100644
--- a/packages/remark-lint-no-unneeded-full-reference-link/index.js
+++ b/packages/remark-lint-no-unneeded-full-reference-link/index.js
@@ -50,31 +50,28 @@ import {collapseWhiteSpace} from 'collapse-white-space'
 
 const remarkLintNoUnneededFullReferenceLink = lintRule(
   'remark-lint:no-unneeded-full-reference-link',
-  noUnneededFullReferenceLink
+  (tree, file) => {
+    visit(tree, 'linkReference', (node) => {
+      if (
+        generated(node) ||
+        node.referenceType !== 'full' ||
+        node.children.length !== 1 ||
+        node.children[0].type !== 'text' ||
+        normalize(node.children[0].value) !== node.identifier
+      ) {
+        return
+      }
+
+      file.message(
+        'Remove the link label as it matches the reference text',
+        node
+      )
+    })
+  }
 )
 
 export default remarkLintNoUnneededFullReferenceLink
 
-var reason = 'Remove the link label as it matches the reference text'
-
-function noUnneededFullReferenceLink(tree, file) {
-  visit(tree, 'linkReference', visitor)
-
-  function visitor(node) {
-    if (
-      generated(node) ||
-      node.referenceType !== 'full' ||
-      node.children.length !== 1 ||
-      node.children[0].type !== 'text' ||
-      normalize(node.children[0].value) !== node.identifier
-    ) {
-      return
-    }
-
-    file.message(reason, node)
-  }
-}
-
 // See: <https://github.com/remarkjs/remark/blob/cc7867b/packages/remark-parse/lib/util/normalize.js>
 function normalize(value) {
   return collapseWhiteSpace(value).toLowerCase()
diff --git a/packages/remark-lint-no-unused-definitions/index.js b/packages/remark-lint-no-unused-definitions/index.js
index 9542d60b..8760e2b9 100644
--- a/packages/remark-lint-no-unused-definitions/index.js
+++ b/packages/remark-lint-no-unused-definitions/index.js
@@ -25,42 +25,48 @@ import {lintRule} from 'unified-lint-rule'
 import {generated} from 'unist-util-generated'
 import {visit} from 'unist-util-visit'
 
+const own = {}.hasOwnProperty
+
 const remarkLintNoUnusedDefinitions = lintRule(
   'remark-lint:no-unused-definitions',
-  noUnusedDefinitions
-)
-
-export default remarkLintNoUnusedDefinitions
+  (tree, file) => {
+    const map = Object.create(null)
 
-var reason = 'Found unused definition'
+    visit(tree, (node) => {
+      if (
+        (node.type === 'definition' || node.type === 'footnoteDefinition') &&
+        !generated(node)
+      ) {
+        map[node.identifier.toUpperCase()] = {node, used: false}
+      }
+    })
 
-function noUnusedDefinitions(tree, file) {
-  var map = {}
-  var identifier
-  var entry
+    visit(tree, (node) => {
+      if (
+        node.type === 'imageReference' ||
+        node.type === 'linkReference' ||
+        node.type === 'footnoteReference'
+      ) {
+        const info = map[node.identifier.toUpperCase()]
 
-  visit(tree, ['definition', 'footnoteDefinition'], find)
-  visit(tree, ['imageReference', 'linkReference', 'footnoteReference'], mark)
+        if (!generated(node) && info) {
+          info.used = true
+        }
+      }
+    })
 
-  for (identifier in map) {
-    entry = map[identifier]
+    let identifier
 
-    if (!entry.used) {
-      file.message(reason, entry.node)
-    }
-  }
+    for (identifier in map) {
+      if (own.call(map, identifier)) {
+        const entry = map[identifier]
 
-  function find(node) {
-    if (!generated(node)) {
-      map[node.identifier.toUpperCase()] = {node: node, used: false}
+        if (!entry.used) {
+          file.message('Found unused definition', entry.node)
+        }
+      }
     }
   }
+)
 
-  function mark(node) {
-    var info = map[node.identifier.toUpperCase()]
-
-    if (!generated(node) && info) {
-      info.used = true
-    }
-  }
-}
+export default remarkLintNoUnusedDefinitions
diff --git a/packages/remark-lint-ordered-list-marker-style/index.js b/packages/remark-lint-ordered-list-marker-style/index.js
index d4a9aa39..24571048 100644
--- a/packages/remark-lint-ordered-list-marker-style/index.js
+++ b/packages/remark-lint-ordered-list-marker-style/index.js
@@ -54,58 +54,55 @@ import {visit} from 'unist-util-visit'
 import {pointStart} from 'unist-util-position'
 import {generated} from 'unist-util-generated'
 
-const remarkLintOrderedListMarkerStyle = lintRule(
-  'remark-lint:ordered-list-marker-style',
-  orderedListMarkerStyle
-)
-
-export default remarkLintOrderedListMarkerStyle
-
-var styles = {
+const styles = {
   ')': true,
   '.': true,
   null: true
 }
 
-function orderedListMarkerStyle(tree, file, option) {
-  var contents = String(file)
-  var preferred =
-    typeof option !== 'string' || option === 'consistent' ? null : option
+const remarkLintOrderedListMarkerStyle = lintRule(
+  'remark-lint:ordered-list-marker-style',
+  (tree, file, option) => {
+    const value = String(file)
+    let preferred =
+      typeof option !== 'string' || option === 'consistent' ? null : option
 
-  if (styles[preferred] !== true) {
-    file.fail(
-      'Incorrect ordered list item marker style `' +
-        preferred +
-        "`: use either `'.'` or `')'`"
-    )
-  }
+    if (styles[preferred] !== true) {
+      file.fail(
+        'Incorrect ordered list item marker style `' +
+          preferred +
+          "`: use either `'.'` or `')'`"
+      )
+    }
 
-  visit(tree, 'list', visitor)
+    visit(tree, 'list', (node) => {
+      let index = -1
 
-  function visitor(node) {
-    var children = node.children
-    var length = node.ordered ? children.length : 0
-    var index = -1
-    var marker
-    var child
+      if (!node.ordered) return
 
-    while (++index < length) {
-      child = children[index]
+      while (++index < node.children.length) {
+        const child = node.children[index]
 
-      if (!generated(child)) {
-        marker = contents
-          .slice(pointStart(child).offset, pointStart(child.children[0]).offset)
-          .replace(/\s|\d/g, '')
-          .replace(/\[[x ]?]\s*$/i, '')
+        if (!generated(child)) {
+          const marker = value
+            .slice(
+              pointStart(child).offset,
+              pointStart(child.children[0]).offset
+            )
+            .replace(/\s|\d/g, '')
+            .replace(/\[[x ]?]\s*$/i, '')
 
-        if (preferred) {
-          if (marker !== preferred) {
-            file.message('Marker style should be `' + preferred + '`', child)
+          if (preferred) {
+            if (marker !== preferred) {
+              file.message('Marker style should be `' + preferred + '`', child)
+            }
+          } else {
+            preferred = marker
           }
-        } else {
-          preferred = marker
         }
       }
-    }
+    })
   }
-}
+)
+
+export default remarkLintOrderedListMarkerStyle
diff --git a/packages/remark-lint-ordered-list-marker-value/index.js b/packages/remark-lint-ordered-list-marker-value/index.js
index aa2f3cbc..7b4e787a 100644
--- a/packages/remark-lint-ordered-list-marker-value/index.js
+++ b/packages/remark-lint-ordered-list-marker-value/index.js
@@ -131,63 +131,63 @@ import {visit} from 'unist-util-visit'
 import {pointStart} from 'unist-util-position'
 import {generated} from 'unist-util-generated'
 
+const styles = {ordered: true, single: true, one: true}
+
 const remarkLintOrderedListMarkerValue = lintRule(
   'remark-lint:ordered-list-marker-value',
-  orderedListMarkerValue
-)
-
-export default remarkLintOrderedListMarkerValue
-
-var styles = {ordered: true, single: true, one: true}
+  (tree, file, option) => {
+    const value = String(file)
+    const preferred = typeof option === 'string' ? option : 'ordered'
 
-function orderedListMarkerValue(tree, file, option) {
-  var contents = String(file)
-  var preferred = typeof option === 'string' ? option : 'ordered'
-
-  if (styles[preferred] !== true) {
-    file.fail(
-      'Incorrect ordered list item marker value `' +
-        preferred +
-        "`: use either `'ordered'` or `'one'`"
-    )
-  }
-
-  visit(tree, 'list', visitor)
+    if (styles[preferred] !== true) {
+      file.fail(
+        'Incorrect ordered list item marker value `' +
+          preferred +
+          "`: use either `'ordered'` or `'one'`"
+      )
+    }
 
-  function visitor(node) {
-    var children = node.children
-    var expected = preferred === 'one' ? 1 : node.start == null ? 1 : node.start
-    var length = node.ordered ? children.length : 0
-    var index = -1
-    var child
-    var marker
+    visit(tree, 'list', (node) => {
+      if (!node.ordered) return
 
-    while (++index < length) {
-      child = children[index]
+      let expected =
+        preferred === 'one' || node.start === null || node.start === undefined
+          ? 1
+          : node.start
+      let index = -1
 
-      // Ignore generated nodes, first items.
-      if (generated(child) || (index === 0 && preferred !== 'one')) {
-        continue
-      }
+      while (++index < node.children.length) {
+        const child = node.children[index]
 
-      // Increase the expected line number when in `ordered` mode.
-      if (preferred === 'ordered') {
-        expected++
-      }
+        // Ignore generated nodes, first items.
+        if (generated(child) || (index === 0 && preferred !== 'one')) {
+          continue
+        }
 
-      marker = Number(
-        contents
-          .slice(pointStart(child).offset, pointStart(child.children[0]).offset)
-          .replace(/[\s.)]/g, '')
-          .replace(/\[[x ]?]\s*$/i, '')
-      )
+        // Increase the expected line number when in `ordered` mode.
+        if (preferred === 'ordered') {
+          expected++
+        }
 
-      if (marker !== expected) {
-        file.message(
-          'Marker should be `' + expected + '`, was `' + marker + '`',
-          child
+        const marker = Number(
+          value
+            .slice(
+              pointStart(child).offset,
+              pointStart(child.children[0]).offset
+            )
+            .replace(/[\s.)]/g, '')
+            .replace(/\[[x ]?]\s*$/i, '')
         )
+
+        if (marker !== expected) {
+          file.message(
+            'Marker should be `' + expected + '`, was `' + marker + '`',
+            child
+          )
+        }
       }
-    }
+    })
   }
-}
+)
+
+export default remarkLintOrderedListMarkerValue
diff --git a/packages/remark-lint-rule-style/index.js b/packages/remark-lint-rule-style/index.js
index f30d5462..5e23a205 100644
--- a/packages/remark-lint-rule-style/index.js
+++ b/packages/remark-lint-rule-style/index.js
@@ -60,38 +60,36 @@ import {visit} from 'unist-util-visit'
 import {pointStart, pointEnd} from 'unist-util-position'
 import {generated} from 'unist-util-generated'
 
-const remarkLintRuleStyle = lintRule('remark-lint:rule-style', ruleStyle)
+const remarkLintRuleStyle = lintRule(
+  'remark-lint:rule-style',
+  (tree, file, option) => {
+    const value = String(file)
+    let preferred =
+      typeof option === 'string' && option !== 'consistent' ? option : null
 
-export default remarkLintRuleStyle
-
-function ruleStyle(tree, file, option) {
-  var contents = String(file)
-  var preferred =
-    typeof option === 'string' && option !== 'consistent' ? option : null
-
-  if (preferred !== null && /[^-_* ]/.test(preferred)) {
-    file.fail(
-      "Incorrect preferred rule style: provide a correct markdown rule or `'consistent'`"
-    )
-  }
-
-  visit(tree, 'thematicBreak', visitor)
+    if (preferred !== null && /[^-_* ]/.test(preferred)) {
+      file.fail(
+        "Incorrect preferred rule style: provide a correct markdown rule or `'consistent'`"
+      )
+    }
 
-  function visitor(node) {
-    var initial = pointStart(node).offset
-    var final = pointEnd(node).offset
-    var rule
+    visit(tree, 'thematicBreak', (node) => {
+      const initial = pointStart(node).offset
+      const final = pointEnd(node).offset
 
-    if (!generated(node)) {
-      rule = contents.slice(initial, final)
+      if (!generated(node)) {
+        const rule = value.slice(initial, final)
 
-      if (preferred) {
-        if (rule !== preferred) {
-          file.message('Rules should use `' + preferred + '`', node)
+        if (preferred) {
+          if (rule !== preferred) {
+            file.message('Rules should use `' + preferred + '`', node)
+          }
+        } else {
+          preferred = rule
         }
-      } else {
-        preferred = rule
       }
-    }
+    })
   }
-}
+)
+
+export default remarkLintRuleStyle
diff --git a/packages/remark-lint-strikethrough-marker/index.js b/packages/remark-lint-strikethrough-marker/index.js
index aaafaacb..8ea4d8b6 100644
--- a/packages/remark-lint-strikethrough-marker/index.js
+++ b/packages/remark-lint-strikethrough-marker/index.js
@@ -59,50 +59,42 @@ import {visit} from 'unist-util-visit'
 import {pointStart} from 'unist-util-position'
 import {generated} from 'unist-util-generated'
 
+const markers = {null: true, '~': true, '~~': true}
+
 const remarkLintStrikethroughMarker = lintRule(
   'remark-lint:strikethrough-marker',
-  strikethroughMarker
-)
-
-export default remarkLintStrikethroughMarker
-
-var markers = {null: true, '~': true, '~~': true}
-
-function strikethroughMarker(tree, file, option) {
-  var contents = String(file)
-  var preferred =
-    typeof option === 'string' && option !== 'consistent' ? option : null
-
-  if (markers[preferred] !== true) {
-    file.fail(
-      'Incorrect strikethrough marker `' +
-        preferred +
-        "`: use either `'consistent'`, `'~'`, or `'~~'`"
-    )
-  }
-
-  visit(tree, 'delete', visitor)
+  (tree, file, option) => {
+    const value = String(file)
+    let preferred =
+      typeof option === 'string' && option !== 'consistent' ? option : null
 
-  function visitor(node) {
-    var marker
+    if (markers[preferred] !== true) {
+      file.fail(
+        'Incorrect strikethrough marker `' +
+          preferred +
+          "`: use either `'consistent'`, `'~'`, or `'~~'`"
+      )
+    }
 
-    if (!generated(node)) {
-      var offset = pointStart(node).offset
-      marker =
-        contents.slice(offset, offset + 2) === '~~'
-          ? contents.slice(offset, offset + 2)
-          : contents.slice(offset, offset + 1)
+    visit(tree, 'delete', (node) => {
+      if (!generated(node)) {
+        const offset = pointStart(node).offset
+        const both = value.slice(offset, offset + 2)
+        const marker = both === '~~' ? '~~' : '~'
 
-      if (preferred) {
-        if (marker !== preferred) {
-          file.message(
-            'Strikethrough should use `' + preferred + '` as a marker',
-            node
-          )
+        if (preferred) {
+          if (marker !== preferred) {
+            file.message(
+              'Strikethrough should use `' + preferred + '` as a marker',
+              node
+            )
+          }
+        } else {
+          preferred = marker
         }
-      } else {
-        preferred = marker
       }
-    }
+    })
   }
-}
+)
+
+export default remarkLintStrikethroughMarker
diff --git a/packages/remark-lint-strong-marker/index.js b/packages/remark-lint-strong-marker/index.js
index 0312b0bf..ad6328f8 100644
--- a/packages/remark-lint-strong-marker/index.js
+++ b/packages/remark-lint-strong-marker/index.js
@@ -56,44 +56,40 @@ import {visit} from 'unist-util-visit'
 import {pointStart} from 'unist-util-position'
 import {generated} from 'unist-util-generated'
 
+const markers = {'*': true, _: true, null: true}
+
 const remarkLintStrongMarker = lintRule(
   'remark-lint:strong-marker',
-  strongMarker
-)
-
-export default remarkLintStrongMarker
+  (tree, file, option) => {
+    const value = String(file)
+    let preferred =
+      typeof option === 'string' && option !== 'consistent' ? option : null
 
-var markers = {'*': true, _: true, null: true}
-
-function strongMarker(tree, file, option) {
-  var contents = String(file)
-  var preferred =
-    typeof option === 'string' && option !== 'consistent' ? option : null
-
-  if (markers[preferred] !== true) {
-    file.fail(
-      'Incorrect strong marker `' +
-        preferred +
-        "`: use either `'consistent'`, `'*'`, or `'_'`"
-    )
-  }
-
-  visit(tree, 'strong', visitor)
+    if (markers[preferred] !== true) {
+      file.fail(
+        'Incorrect strong marker `' +
+          preferred +
+          "`: use either `'consistent'`, `'*'`, or `'_'`"
+      )
+    }
 
-  function visitor(node) {
-    var marker = contents.charAt(pointStart(node).offset)
+    visit(tree, 'strong', (node) => {
+      const marker = value.charAt(pointStart(node).offset)
 
-    if (!generated(node)) {
-      if (preferred) {
-        if (marker !== preferred) {
-          file.message(
-            'Strong should use `' + preferred + '` as a marker',
-            node
-          )
+      if (!generated(node)) {
+        if (preferred) {
+          if (marker !== preferred) {
+            file.message(
+              'Strong should use `' + preferred + '` as a marker',
+              node
+            )
+          }
+        } else {
+          preferred = marker
         }
-      } else {
-        preferred = marker
       }
-    }
+    })
   }
-}
+)
+
+export default remarkLintStrongMarker
diff --git a/packages/remark-lint-table-cell-padding/index.js b/packages/remark-lint-table-cell-padding/index.js
index 6f3a4139..05295bdd 100644
--- a/packages/remark-lint-table-cell-padding/index.js
+++ b/packages/remark-lint-table-cell-padding/index.js
@@ -159,142 +159,130 @@ import {visit, SKIP} from 'unist-util-visit'
 import {pointStart, pointEnd} from 'unist-util-position'
 import {generated} from 'unist-util-generated'
 
+const styles = {null: true, padded: true, compact: true}
+
 const remarkLintTableCellPadding = lintRule(
   'remark-lint:table-cell-padding',
-  tableCellPadding
-)
-
-export default remarkLintTableCellPadding
+  (tree, file, option) => {
+    const preferred =
+      typeof option === 'string' && option !== 'consistent' ? option : null
 
-var styles = {null: true, padded: true, compact: true}
-
-function tableCellPadding(tree, file, option) {
-  var preferred =
-    typeof option === 'string' && option !== 'consistent' ? option : null
-
-  if (styles[preferred] !== true) {
-    file.fail(
-      'Incorrect table cell padding style `' +
-        preferred +
-        "`, expected `'padded'`, `'compact'`, or `'consistent'`"
-    )
-  }
+    if (styles[preferred] !== true) {
+      file.fail(
+        'Incorrect table cell padding style `' +
+          preferred +
+          "`, expected `'padded'`, `'compact'`, or `'consistent'`"
+      )
+    }
 
-  visit(tree, 'table', visitor)
+    visit(tree, 'table', (node) => {
+      const rows = node.children
+      const sizes = Array.from({length: node.align.length})
+      const entries = []
+      let index = -1
 
-  function visitor(node) {
-    var rows = node.children
-    var sizes = new Array(node.align.length)
-    var length = generated(node) ? -1 : rows.length
-    var index = -1
-    var entries = []
-    var style
-    var row
-    var cells
-    var column
-    var cellCount
-    var cell
-    var entry
-    var contentStart
-    var contentEnd
+      if (generated(node)) return
 
-    // Check rows.
-    while (++index < length) {
-      row = rows[index]
-      cells = row.children
-      cellCount = cells.length
-      column = -1
+      // Check rows.
+      while (++index < rows.length) {
+        const row = rows[index]
+        let column = -1
 
-      // Check fences (before, between, and after cells).
-      while (++column < cellCount) {
-        cell = cells[column]
+        // Check fences (before, between, and after cells).
+        while (++column < row.children.length) {
+          const cell = row.children[column]
 
-        if (cell && cell.children.length !== 0) {
-          contentStart = pointStart(cell.children[0]).offset
-          contentEnd = pointEnd(cell.children[cell.children.length - 1]).offset
+          if (cell && cell.children.length > 0) {
+            const contentStart = pointStart(cell.children[0]).offset
+            const contentEnd = pointEnd(
+              cell.children[cell.children.length - 1]
+            ).offset
 
-          entries.push({
-            node: cell,
-            start: contentStart - pointStart(cell).offset - (column ? 0 : 1),
-            end: pointEnd(cell).offset - contentEnd - 1,
-            column: column
-          })
+            entries.push({
+              node: cell,
+              start: contentStart - pointStart(cell).offset - (column ? 0 : 1),
+              end: pointEnd(cell).offset - contentEnd - 1,
+              column
+            })
 
-          // Detect max space per column.
-          sizes[column] = Math.max(
-            sizes[column] || 0,
-            contentEnd - contentStart
-          )
+            // Detect max space per column.
+            sizes[column] = Math.max(
+              sizes[column] || 0,
+              contentEnd - contentStart
+            )
+          }
         }
       }
-    }
-
-    if (preferred) {
-      style = preferred === 'padded' ? 1 : 0
-    } else {
-      style = entries[0] && (!entries[0].start || !entries[0].end) ? 0 : 1
-    }
 
-    index = -1
-    length = entries.length
+      const style = preferred
+        ? preferred === 'padded'
+          ? 1
+          : 0
+        : entries[0] && (!entries[0].start || !entries[0].end)
+        ? 0
+        : 1
 
-    while (++index < length) {
-      entry = entries[index]
-      checkSide('start', entry, style, sizes)
-      checkSide('end', entry, style, sizes)
-    }
-
-    return SKIP
-  }
+      index = -1
 
-  function checkSide(side, entry, style, sizes) {
-    var cell = entry.node
-    var spacing = entry[side]
-    var column = entry.column
-    var reason
-    var point
+      while (++index < entries.length) {
+        checkSide('start', entries[index], style, sizes)
+        checkSide('end', entries[index], style, sizes)
+      }
 
-    if (spacing === undefined || spacing === style) {
-      return
-    }
+      return SKIP
+    })
 
-    reason = 'Cell should be '
+    function checkSide(side, entry, style, sizes) {
+      const cell = entry.node
+      const column = entry.column
+      const spacing = entry[side]
 
-    if (style === 0) {
-      // Ignore every cell except the biggest in the column.
-      if (size(cell) < sizes[column]) {
+      if (spacing === undefined || spacing === style) {
         return
       }
 
-      reason += 'compact'
-    } else {
-      reason += 'padded'
+      let reason = 'Cell should be '
 
-      if (spacing > style) {
-        // May be right or center aligned.
+      if (style === 0) {
+        // Ignore every cell except the biggest in the column.
         if (size(cell) < sizes[column]) {
           return
         }
 
-        reason += ' with 1 space, not ' + spacing
+        reason += 'compact'
+      } else {
+        reason += 'padded'
+
+        if (spacing > style) {
+          // May be right or center aligned.
+          if (size(cell) < sizes[column]) {
+            return
+          }
+
+          reason += ' with 1 space, not ' + spacing
+        }
       }
-    }
 
-    if (side === 'start') {
-      point = pointStart(cell)
-      if (!column) {
-        point.column++
-        point.offset++
+      let point
+
+      if (side === 'start') {
+        point = pointStart(cell)
+        if (!column) {
+          point.column++
+          point.offset++
+        }
+      } else {
+        point = pointEnd(cell)
+        point.column--
+        point.offset--
       }
-    } else {
-      point = pointEnd(cell)
-      point.column--
-      point.offset--
-    }
 
-    file.message(reason, point)
+      file.message(reason, point)
+    }
   }
-}
+)
+
+export default remarkLintTableCellPadding
 
 function size(node) {
   return (
diff --git a/packages/remark-lint-table-pipe-alignment/index.js b/packages/remark-lint-table-pipe-alignment/index.js
index 4b452134..1da2af21 100644
--- a/packages/remark-lint-table-pipe-alignment/index.js
+++ b/packages/remark-lint-table-pipe-alignment/index.js
@@ -48,65 +48,50 @@ import {visit} from 'unist-util-visit'
 import {pointStart, pointEnd} from 'unist-util-position'
 import {generated} from 'unist-util-generated'
 
+const reason = 'Misaligned table fence'
+
 const remarkLintTablePipeAlignment = lintRule(
   'remark-lint:table-pipe-alignment',
-  tablePipeAlignment
-)
-
-export default remarkLintTablePipeAlignment
-
-var reason = 'Misaligned table fence'
-
-function tablePipeAlignment(tree, file) {
-  var contents = String(file)
+  (tree, file) => {
+    const value = String(file)
 
-  visit(tree, 'table', visitor)
+    visit(tree, 'table', (node) => {
+      const indices = []
+      let index = -1
 
-  function visitor(node) {
-    var rows = node.children
-    var length = generated(node) ? 0 : rows.length
-    var index = -1
-    var indices = []
-    var row
-    var cells
-    var begin
-    var column
-    var columns
-    var cell
-    var initial
-    var final
-    var next
-    var nextIndex
-    var fence
-    var pos
-
-    while (++index < length) {
-      row = rows[index]
-      begin = pointStart(row)
-      cells = row.children
-      columns = cells.length
-      column = -2 // Start without a first cell.
-      next = null
+      if (generated(node)) {
+        return
+      }
 
-      while (++column < columns) {
-        cell = next
-        nextIndex = column + 1
-        next = cells[nextIndex]
+      while (++index < node.children.length) {
+        const row = node.children[index]
+        const begin = pointStart(row)
+        let column = -2 // Start without a first cell.
 
-        initial = cell ? pointEnd(cell).offset : pointStart(row).offset
-        final = next ? pointStart(next).offset : pointEnd(row).offset
-        fence = contents.slice(initial, final)
-        pos = initial + fence.indexOf('|') - begin.offset + 1
+        while (++column < row.children.length) {
+          const cell = row.children[column]
+          const nextColumn = column + 1
+          const next = row.children[nextColumn]
+          const initial = cell ? pointEnd(cell).offset : pointStart(row).offset
+          const final = next ? pointStart(next).offset : pointEnd(row).offset
+          const fence = value.slice(initial, final)
+          const pos = initial + fence.indexOf('|') - begin.offset + 1
 
-        if (indices[nextIndex] === undefined || indices[nextIndex] === null) {
-          indices[nextIndex] = pos
-        } else if (pos !== indices[nextIndex]) {
-          file.message(reason, {
-            start: {line: begin.line, column: pos},
-            end: {line: begin.line, column: pos + 1}
-          })
+          if (
+            indices[nextColumn] === undefined ||
+            indices[nextColumn] === null
+          ) {
+            indices[nextColumn] = pos
+          } else if (pos !== indices[nextColumn]) {
+            file.message(reason, {
+              start: {line: begin.line, column: pos},
+              end: {line: begin.line, column: pos + 1}
+            })
+          }
         }
       }
-    }
+    })
   }
-}
+)
+
+export default remarkLintTablePipeAlignment
diff --git a/packages/remark-lint-table-pipes/index.js b/packages/remark-lint-table-pipes/index.js
index e53bb7e0..16ed71ba 100644
--- a/packages/remark-lint-table-pipes/index.js
+++ b/packages/remark-lint-table-pipes/index.js
@@ -42,36 +42,32 @@ import {visit} from 'unist-util-visit'
 import {pointStart, pointEnd} from 'unist-util-position'
 import {generated} from 'unist-util-generated'
 
-const remarkLintTablePipes = lintRule('remark-lint:table-pipes', tablePipes)
+const reasonStart = 'Missing initial pipe in table fence'
+const reasonEnd = 'Missing final pipe in table fence'
 
-export default remarkLintTablePipes
-
-var reasonStart = 'Missing initial pipe in table fence'
-var reasonEnd = 'Missing final pipe in table fence'
+const remarkLintTablePipes = lintRule(
+  'remark-lint:table-pipes',
+  (tree, file) => {
+    const value = String(file)
 
-function tablePipes(tree, file) {
-  var contents = String(file)
+    visit(tree, 'table', (node) => {
+      let index = -1
 
-  visit(tree, 'table', visitor)
+      while (++index < node.children.length) {
+        const row = node.children[index]
 
-  function visitor(node) {
-    var rows = node.children
-    var length = rows.length
-    var index = -1
-    var row
+        if (!generated(row)) {
+          if (value.charCodeAt(pointStart(row).offset) !== 124) {
+            file.message(reasonStart, pointStart(row))
+          }
 
-    while (++index < length) {
-      row = rows[index]
-
-      if (!generated(row)) {
-        if (contents.charCodeAt(pointStart(row).offset) !== 124) {
-          file.message(reasonStart, pointStart(row))
-        }
-
-        if (contents.charCodeAt(pointEnd(row).offset - 1) !== 124) {
-          file.message(reasonEnd, pointEnd(row))
+          if (value.charCodeAt(pointEnd(row).offset - 1) !== 124) {
+            file.message(reasonEnd, pointEnd(row))
+          }
         }
       }
-    }
+    })
   }
-}
+)
+
+export default remarkLintTablePipes
diff --git a/packages/remark-lint-unordered-list-marker-style/index.js b/packages/remark-lint-unordered-list-marker-style/index.js
index 0054d9ff..3c733c83 100644
--- a/packages/remark-lint-unordered-list-marker-style/index.js
+++ b/packages/remark-lint-unordered-list-marker-style/index.js
@@ -71,59 +71,57 @@ import {visit} from 'unist-util-visit'
 import {pointStart} from 'unist-util-position'
 import {generated} from 'unist-util-generated'
 
-const remarkLintUnorderedListMarkerStyle = lintRule(
-  'remark-lint:unordered-list-marker-style',
-  unorderedListMarkerStyle
-)
-
-export default remarkLintUnorderedListMarkerStyle
-
-var styles = {
+const styles = {
   '-': true,
   '*': true,
   '+': true,
-  null: true
+  undefined: true
 }
 
-function unorderedListMarkerStyle(tree, file, option) {
-  var contents = String(file)
-  var preferred =
-    typeof option === 'string' && option !== 'consistent' ? option : null
+const remarkLintUnorderedListMarkerStyle = lintRule(
+  'remark-lint:unordered-list-marker-style',
+  (tree, file, option) => {
+    const value = String(file)
+    let preferred =
+      typeof option === 'string' && option !== 'consistent' ? option : undefined
 
-  if (styles[preferred] !== true) {
-    file.fail(
-      'Incorrect unordered list item marker style `' +
-        preferred +
-        "`: use either `'-'`, `'*'`, or `'+'`"
-    )
-  }
+    if (styles[preferred] !== true) {
+      file.fail(
+        'Incorrect unordered list item marker style `' +
+          preferred +
+          "`: use either `'-'`, `'*'`, or `'+'`"
+      )
+    }
 
-  visit(tree, 'list', visitor)
+    visit(tree, 'list', (node) => {
+      if (node.ordered) return
 
-  function visitor(node) {
-    var children = node.children
-    var length = node.ordered ? 0 : children.length
-    var index = -1
-    var child
-    var marker
+      const children = node.children
+      let index = -1
 
-    while (++index < length) {
-      child = children[index]
+      while (++index < children.length) {
+        const child = children[index]
 
-      if (!generated(child)) {
-        marker = contents
-          .slice(pointStart(child).offset, pointStart(child.children[0]).offset)
-          .replace(/\[[x ]?]\s*$/i, '')
-          .replace(/\s/g, '')
+        if (!generated(child)) {
+          const marker = value
+            .slice(
+              pointStart(child).offset,
+              pointStart(child.children[0]).offset
+            )
+            .replace(/\[[x ]?]\s*$/i, '')
+            .replace(/\s/g, '')
 
-        if (preferred) {
-          if (marker !== preferred) {
-            file.message('Marker style should be `' + preferred + '`', child)
+          if (preferred) {
+            if (marker !== preferred) {
+              file.message('Marker style should be `' + preferred + '`', child)
+            }
+          } else {
+            preferred = marker
           }
-        } else {
-          preferred = marker
         }
       }
-    }
+    })
   }
-}
+)
+
+export default remarkLintUnorderedListMarkerStyle
diff --git a/packages/unified-lint-rule/index.js b/packages/unified-lint-rule/index.js
index a51ca727..eccf33f7 100644
--- a/packages/unified-lint-rule/index.js
+++ b/packages/unified-lint-rule/index.js
@@ -1,87 +1,72 @@
 import wrapped from 'wrapped'
 
 export function lintRule(id, rule) {
-  var parts = id.split(':')
-  var source = parts[0]
-  var ruleId = parts[1]
-  var fn = wrapped(rule)
-
+  const parts = id.split(':')
+  const fn = wrapped(rule)
   // Possibly useful if externalised later.
-  /* c8 ignore next 4 */
-  if (!ruleId) {
-    ruleId = source
-    source = null
-  }
+  /* 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
+  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(error) {
-        var messages = file.messages
-        var message
+      fn(tree, file, options, (error) => {
+        const messages = file.messages
 
         // Add the error, if not already properly added.
         // Only happens for incorrect plugins.
         /* c8 ignore next 5 */
-        if (error && messages.indexOf(error) === -1) {
+        if (error && !messages.includes(error)) {
           try {
             file.fail(error)
-          } catch (_) {}
+          } 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()
-      }
+      })
     }
   }
 }
 
 // Coerce a value to a severity--options tuple.
 function coerce(name, value) {
-  var def = 1
-  var result
-  var level
+  const def = 1
+  let result
 
   // Handled by unified in v6.0.0.
   /* c8 ignore next 3 */
   if (typeof value === 'boolean') {
     result = [value]
-  } else if (value == null) {
+  } else if (value === null || value === undefined) {
     result = [def]
   } else if (
-    typeof value === 'object' &&
+    Array.isArray(value) &&
     (typeof value[0] === 'number' ||
       typeof value[0] === 'boolean' ||
       typeof value[0] === 'string')
   ) {
-    result = value.concat()
+    result = [...value]
   } else {
     result = [1, value]
   }
 
-  level = result[0]
+  let level = result[0]
 
   if (typeof level === 'boolean') {
     level = level ? 1 : 0
diff --git a/script.js b/script.js
deleted file mode 100644
index 3d2e0fa8..00000000
--- a/script.js
+++ /dev/null
@@ -1,45 +0,0 @@
-// .
-// import fs from 'fs'
-//
-// const pkgs = fs.readdirSync('packages')
-//
-// pkgs.forEach((d) => {
-//   const pkg = JSON.parse(fs.readFileSync('packages/' + d + '/package.json'))
-//   const {
-//     name,
-//     version,
-//     description,
-//     license,
-//     keywords,
-//     repository,
-//     bugs,
-//     funding,
-//     author,
-//     contributors,
-//     files,
-//     ...rest
-//   } = pkg
-//
-//   const clean = {
-//     name,
-//     version,
-//     description,
-//     license,
-//     keywords,
-//     repository,
-//     bugs,
-//     funding,
-//     author,
-//     contributors,
-//     sideEffects: false,
-//     type: 'module',
-//     main: 'index.js',
-//     files,
-//     ...rest
-//   }
-//
-//   fs.writeFileSync(
-//     'packages/' + d + '/package.json',
-//     JSON.stringify(clean, null, 2) + '\n'
-//   )
-// })
diff --git a/script/build-presets.js b/script/build-presets.js
index 1ca148b2..a2e9c5b8 100644
--- a/script/build-presets.js
+++ b/script/build-presets.js
@@ -13,253 +13,262 @@ import {presets} from './util/presets.js'
 const pkg = JSON.parse(fs.readFileSync('package.json'))
 const remote = pkg.repository
 
-var root = path.join(process.cwd(), 'packages')
+const own = {}.hasOwnProperty
 
-const presetObjects = await presets(root)
+const root = path.join(process.cwd(), 'packages')
 
-presetObjects.forEach(function ({name, packages}) {
-  var base = path.resolve(root, name)
-  var pack = JSON.parse(fs.readFileSync(path.join(base, 'package.json')))
-  var doc = fs.readFileSync(path.join(base, 'index.js'), 'utf8')
-  var tags = dox.parseComments(doc)[0].tags
-  var author = parseAuthor(pack.author)
-  var description = strip(find(tags, 'fileoverview')).trim()
-  var rows = []
-  var children
-  var short = name.replace(/^remark-/, '')
-  var camelcased = name.replace(/-(\w)/g, (_, $1) => $1.toUpperCase())
-  var org = remote.split('/').slice(0, -1).join('/')
-  var main = remote + '/blob/main'
-  var health = org + '/.github'
-  var hMain = health + '/blob/HEAD'
-  var slug = remote.split('/').slice(-2).join('/')
+presets(root).then((presetObjects) => {
+  let index = -1
+  while (++index < presetObjects) {
+    const {name, packages} = presetObjects[index]
+    const base = path.resolve(root, name)
+    const pack = JSON.parse(fs.readFileSync(path.join(base, 'package.json')))
+    const doc = fs.readFileSync(path.join(base, 'index.js'), 'utf8')
+    const tags = dox.parseComments(doc)[0].tags
+    const author = parseAuthor(pack.author)
+    const description = strip(find(tags, 'fileoverview')).trim()
+    const rows = []
+    let children
+    const short = name.replace(/^remark-/, '')
+    const camelcased = name.replace(/-(\w)/g, (_, $1) => $1.toUpperCase())
+    const org = remote.split('/').slice(0, -1).join('/')
+    const main = remote + '/blob/main'
+    const health = org + '/.github'
+    const hMain = health + '/blob/HEAD'
+    const slug = remote.split('/').slice(-2).join('/')
 
-  if (name !== pack.name) {
-    throw new Error(
-      'Expected package name (`' +
-        pack.name +
-        '`) to be the same as ' +
-        'directory name (`' +
-        name +
-        '`)'
+    if (name !== pack.name) {
+      throw new Error(
+        'Expected package name (`' +
+          pack.name +
+          '`) to be the same as ' +
+          'directory name (`' +
+          name +
+          '`)'
+      )
+    }
+
+    rows.push(
+      u('tableRow', [
+        u('tableCell', [u('text', 'Rule')]),
+        u('tableCell', [u('text', 'Setting')])
+      ])
     )
-  }
 
-  rows.push(
-    u('tableRow', [
-      u('tableCell', [u('text', 'Rule')]),
-      u('tableCell', [u('text', 'Setting')])
-    ])
-  )
+    let rule
 
-  let rule
+    for (rule in packages) {
+      if (own.call(packages, rule)) {
+        const url = remote + '/tree/main/packages/' + rule
+        const option = packages[rule]
 
-  for (rule in packages) {
-    var url = remote + '/tree/main/packages/' + rule
-    const option = packages[rule]
+        if (rule === 'remark-lint') continue
 
-    if (rule === 'remark-lint') continue
+        rows.push(
+          u('tableRow', [
+            u('tableCell', [
+              u('link', {url, title: null}, [u('inlineCode', rule)])
+            ]),
+            u('tableCell', option ? [u('inlineCode', inspect(option))] : [])
+          ])
+        )
+      }
+    }
 
-    rows.push(
-      u('tableRow', [
-        u('tableCell', [
-          u('link', {url: url, title: null}, [u('inlineCode', rule)])
+    children = [
+      u('html', '<!--This file is generated-->'),
+      u('heading', {depth: 1}, [u('text', name)]),
+      u('paragraph', [
+        u('linkReference', {identifier: 'build'}, [
+          u('imageReference', {identifier: 'build-badge', alt: 'Build'})
+        ]),
+        u('text', '\n'),
+        u('linkReference', {identifier: 'coverage'}, [
+          u('imageReference', {identifier: 'coverage-badge', alt: 'Coverage'})
         ]),
-        u('tableCell', option ? [u('inlineCode', inspect(option))] : [])
+        u('text', '\n'),
+        u('linkReference', {identifier: 'downloads'}, [
+          u('imageReference', {identifier: 'downloads-badge', alt: 'Downloads'})
+        ]),
+        u('text', '\n'),
+        u('linkReference', {identifier: 'size'}, [
+          u('imageReference', {identifier: 'size-badge', alt: 'Size'})
+        ]),
+        u('text', '\n'),
+        u('linkReference', {identifier: 'collective'}, [
+          u('imageReference', {identifier: 'sponsors-badge', alt: 'Sponsors'})
+        ]),
+        u('text', '\n'),
+        u('linkReference', {identifier: 'collective'}, [
+          u('imageReference', {identifier: 'backers-badge', alt: 'Backers'})
+        ]),
+        u('text', '\n'),
+        u('linkReference', {identifier: 'chat'}, [
+          u('imageReference', {identifier: 'chat-badge', alt: 'Chat'})
+        ])
       ])
-    )
-  }
+    ]
 
-  children = [
-    u('html', '<!--This file is generated-->'),
-    u('heading', {depth: 1}, [u('text', name)]),
-    u('paragraph', [
-      u('linkReference', {identifier: 'build'}, [
-        u('imageReference', {identifier: 'build-badge', alt: 'Build'})
-      ]),
-      u('text', '\n'),
-      u('linkReference', {identifier: 'coverage'}, [
-        u('imageReference', {identifier: 'coverage-badge', alt: 'Coverage'})
-      ]),
-      u('text', '\n'),
-      u('linkReference', {identifier: 'downloads'}, [
-        u('imageReference', {identifier: 'downloads-badge', alt: 'Downloads'})
-      ]),
-      u('text', '\n'),
-      u('linkReference', {identifier: 'size'}, [
-        u('imageReference', {identifier: 'size-badge', alt: 'Size'})
+    children = children.concat(remark().parse(description).children)
+
+    children.push(
+      u('heading', {depth: 2}, [u('text', 'Rules')]),
+      u('paragraph', [
+        u('text', 'This preset configures '),
+        u('link', {url: remote}, [u('inlineCode', 'remark-lint')]),
+        u('text', ' with the following rules:')
       ]),
-      u('text', '\n'),
-      u('linkReference', {identifier: 'collective'}, [
-        u('imageReference', {identifier: 'sponsors-badge', alt: 'Sponsors'})
+      u('table', {align: []}, rows),
+      u('heading', {depth: 2}, [u('text', 'Install')]),
+      u('paragraph', [
+        u('linkReference', {identifier: 'npm', referenceType: 'collapsed'}, [
+          u('text', 'npm')
+        ]),
+        u('text', ':')
       ]),
-      u('text', '\n'),
-      u('linkReference', {identifier: 'collective'}, [
-        u('imageReference', {identifier: 'backers-badge', alt: 'Backers'})
+      u('code', {lang: 'sh'}, 'npm install ' + name),
+      u('heading', {depth: 2}, [u('text', 'Use')]),
+      u('paragraph', [
+        u(
+          'text',
+          'You probably want to use it on the CLI through a config file:'
+        )
       ]),
-      u('text', '\n'),
-      u('linkReference', {identifier: 'chat'}, [
-        u('imageReference', {identifier: 'chat-badge', alt: 'Chat'})
-      ])
-    ])
-  ]
-
-  children = children.concat(remark().parse(description).children)
-
-  children.push(
-    u('heading', {depth: 2}, [u('text', 'Rules')]),
-    u('paragraph', [
-      u('text', 'This preset configures '),
-      u('link', {url: remote}, [u('inlineCode', 'remark-lint')]),
-      u('text', ' with the following rules:')
-    ]),
-    u('table', {align: []}, rows),
-    u('heading', {depth: 2}, [u('text', 'Install')]),
-    u('paragraph', [
-      u('linkReference', {identifier: 'npm', referenceType: 'collapsed'}, [
-        u('text', 'npm')
-      ]),
-      u('text', ':')
-    ]),
-    u('code', {lang: 'sh'}, 'npm install ' + name),
-    u('heading', {depth: 2}, [u('text', 'Use')]),
-    u('paragraph', [
-      u('text', 'You probably want to use it on the CLI through a config file:')
-    ]),
-    u(
-      'code',
-      {lang: 'diff'},
-      [
-        ' …',
-        ' "remarkConfig": {',
-        '+  "plugins": ["' + short + '"]',
-        ' }',
-        ' …'
-      ].join('\n')
-    ),
-    u('paragraph', [u('text', 'Or use it on the CLI directly')]),
-    u('code', {lang: 'sh'}, 'remark -u ' + short + ' readme.md'),
-    u('paragraph', [u('text', 'Or use this on the API:')]),
-    u(
-      'code',
-      {lang: 'diff'},
-      [
-        " import {remark} from 'remark'",
-        " import {reporter} from 'vfile-reporter'",
-        ' import ' + camelcased + " from '" + name + "'",
-        '',
-        ' remark()',
-        '+  .use(' + camelcased + ')',
-        "   .process('_Emphasis_ and **importance**')",
-        '   .then((file) => {',
-        '     console.error(reporter(file))',
-        '   })'
-      ].join('\n')
-    ),
-    u('heading', {depth: 2}, [u('text', 'Contribute')]),
-    u('paragraph', [
-      u('text', 'See '),
-      u('linkReference', {identifier: 'contributing'}, [
-        u('inlineCode', 'contributing.md')
+      u(
+        'code',
+        {lang: 'diff'},
+        [
+          ' …',
+          ' "remarkConfig": {',
+          '+  "plugins": ["' + short + '"]',
+          ' }',
+          ' …'
+        ].join('\n')
+      ),
+      u('paragraph', [u('text', 'Or use it on the CLI directly')]),
+      u('code', {lang: 'sh'}, 'remark -u ' + short + ' readme.md'),
+      u('paragraph', [u('text', 'Or use this on the API:')]),
+      u(
+        'code',
+        {lang: 'diff'},
+        [
+          " import {remark} from 'remark'",
+          " import {reporter} from 'vfile-reporter'",
+          ' import ' + camelcased + " from '" + name + "'",
+          '',
+          ' remark()',
+          '+  .use(' + camelcased + ')',
+          "   .process('_Emphasis_ and **importance**')",
+          '   .then((file) => {',
+          '     console.error(reporter(file))',
+          '   })'
+        ].join('\n')
+      ),
+      u('heading', {depth: 2}, [u('text', 'Contribute')]),
+      u('paragraph', [
+        u('text', 'See '),
+        u('linkReference', {identifier: 'contributing'}, [
+          u('inlineCode', 'contributing.md')
+        ]),
+        u('text', ' in '),
+        u('linkReference', {identifier: 'health'}, [
+          u('inlineCode', health.split('/').slice(-2).join('/'))
+        ]),
+        u('text', ' for ways\nto get started.\nSee '),
+        u('linkReference', {identifier: 'support'}, [
+          u('inlineCode', 'support.md')
+        ]),
+        u('text', ' for ways to get help.')
       ]),
-      u('text', ' in '),
-      u('linkReference', {identifier: 'health'}, [
-        u('inlineCode', health.split('/').slice(-2).join('/'))
+      u('paragraph', [
+        u('text', 'This project has a '),
+        u('linkReference', {identifier: 'coc'}, [u('text', 'code of conduct')]),
+        u(
+          'text',
+          '.\nBy interacting with this repository, organization, or community you agree to\nabide by its terms.'
+        )
       ]),
-      u('text', ' for ways\nto get started.\nSee '),
-      u('linkReference', {identifier: 'support'}, [
-        u('inlineCode', 'support.md')
+      u('heading', {depth: 2}, [u('text', 'License')]),
+      u('paragraph', [
+        u('linkReference', {identifier: 'license'}, [u('text', pack.license)]),
+        u('text', ' © '),
+        u('linkReference', {identifier: 'author'}, [u('text', author.name)])
       ]),
-      u('text', ' for ways to get help.')
-    ]),
-    u('paragraph', [
-      u('text', 'This project has a '),
-      u('linkReference', {identifier: 'coc'}, [u('text', 'code of conduct')]),
-      u(
-        'text',
-        '.\nBy interacting with this repository, organization, or community you agree to\nabide by its terms.'
-      )
-    ]),
-    u('heading', {depth: 2}, [u('text', 'License')]),
-    u('paragraph', [
-      u('linkReference', {identifier: 'license'}, [u('text', pack.license)]),
-      u('text', ' © '),
-      u('linkReference', {identifier: 'author'}, [u('text', author.name)])
-    ]),
-    u('definition', {
-      identifier: 'build-badge',
-      url: 'https://github.com/' + slug + '/workflows/main/badge.svg'
-    }),
-    u('definition', {
-      identifier: 'build',
-      url: 'https://github.com/' + slug + '/actions'
-    }),
-    u('definition', {
-      identifier: 'coverage-badge',
-      url: 'https://img.shields.io/codecov/c/github/' + slug + '.svg'
-    }),
-    u('definition', {
-      identifier: 'coverage',
-      url: 'https://codecov.io/github/' + slug
-    }),
-    u('definition', {
-      identifier: 'downloads-badge',
-      url: 'https://img.shields.io/npm/dm/' + name + '.svg'
-    }),
-    u('definition', {
-      identifier: 'downloads',
-      url: 'https://www.npmjs.com/package/' + name
-    }),
-    u('definition', {
-      identifier: 'size-badge',
-      url: 'https://img.shields.io/bundlephobia/minzip/' + name + '.svg'
-    }),
-    u('definition', {
-      identifier: 'size',
-      url: 'https://bundlephobia.com/result?p=' + name
-    }),
-    u('definition', {
-      identifier: 'sponsors-badge',
-      url: 'https://opencollective.com/unified/sponsors/badge.svg'
-    }),
-    u('definition', {
-      identifier: 'backers-badge',
-      url: 'https://opencollective.com/unified/backers/badge.svg'
-    }),
-    u('definition', {
-      identifier: 'collective',
-      url: 'https://opencollective.com/unified'
-    }),
-    u('definition', {
-      identifier: 'chat-badge',
-      url: 'https://img.shields.io/badge/chat-discussions-success.svg'
-    }),
-    u('definition', {
-      identifier: 'chat',
-      url: 'https://github.com/remarkjs/remark/discussions'
-    }),
-    u('definition', {
-      identifier: 'npm',
-      url: 'https://docs.npmjs.com/cli/install'
-    }),
-    u('definition', {identifier: 'health', url: health}),
-    u('definition', {
-      identifier: 'contributing',
-      url: hMain + '/contributing.md'
-    }),
-    u('definition', {identifier: 'support', url: hMain + '/support.md'}),
-    u('definition', {
-      identifier: 'coc',
-      url: hMain + '/code-of-conduct.md'
-    }),
-    u('definition', {identifier: 'license', url: main + '/license'}),
-    u('definition', {identifier: 'author', url: author.url})
-  )
+      u('definition', {
+        identifier: 'build-badge',
+        url: 'https://github.com/' + slug + '/workflows/main/badge.svg'
+      }),
+      u('definition', {
+        identifier: 'build',
+        url: 'https://github.com/' + slug + '/actions'
+      }),
+      u('definition', {
+        identifier: 'coverage-badge',
+        url: 'https://img.shields.io/codecov/c/github/' + slug + '.svg'
+      }),
+      u('definition', {
+        identifier: 'coverage',
+        url: 'https://codecov.io/github/' + slug
+      }),
+      u('definition', {
+        identifier: 'downloads-badge',
+        url: 'https://img.shields.io/npm/dm/' + name + '.svg'
+      }),
+      u('definition', {
+        identifier: 'downloads',
+        url: 'https://www.npmjs.com/package/' + name
+      }),
+      u('definition', {
+        identifier: 'size-badge',
+        url: 'https://img.shields.io/bundlephobia/minzip/' + name + '.svg'
+      }),
+      u('definition', {
+        identifier: 'size',
+        url: 'https://bundlephobia.com/result?p=' + name
+      }),
+      u('definition', {
+        identifier: 'sponsors-badge',
+        url: 'https://opencollective.com/unified/sponsors/badge.svg'
+      }),
+      u('definition', {
+        identifier: 'backers-badge',
+        url: 'https://opencollective.com/unified/backers/badge.svg'
+      }),
+      u('definition', {
+        identifier: 'collective',
+        url: 'https://opencollective.com/unified'
+      }),
+      u('definition', {
+        identifier: 'chat-badge',
+        url: 'https://img.shields.io/badge/chat-discussions-success.svg'
+      }),
+      u('definition', {
+        identifier: 'chat',
+        url: 'https://github.com/remarkjs/remark/discussions'
+      }),
+      u('definition', {
+        identifier: 'npm',
+        url: 'https://docs.npmjs.com/cli/install'
+      }),
+      u('definition', {identifier: 'health', url: health}),
+      u('definition', {
+        identifier: 'contributing',
+        url: hMain + '/contributing.md'
+      }),
+      u('definition', {identifier: 'support', url: hMain + '/support.md'}),
+      u('definition', {
+        identifier: 'coc',
+        url: hMain + '/code-of-conduct.md'
+      }),
+      u('definition', {identifier: 'license', url: main + '/license'}),
+      u('definition', {identifier: 'author', url: author.url})
+    )
 
-  fs.writeFileSync(
-    path.join(base, 'readme.md'),
-    remark().use(remarkGfm).stringify(u('root', children))
-  )
+    fs.writeFileSync(
+      path.join(base, 'readme.md'),
+      remark().use(remarkGfm).stringify(u('root', children))
+    )
 
-  console.log('✓ wrote `readme.md` in `' + name + '`')
+    console.log('✓ wrote `readme.md` in `' + name + '`')
+  }
 })
diff --git a/script/build-rules.js b/script/build-rules.js
index 6acef2d9..ad019464 100644
--- a/script/build-rules.js
+++ b/script/build-rules.js
@@ -10,347 +10,373 @@ import {rule} from './util/rule.js'
 import {presets} from './util/presets.js'
 import {characters} from './characters.js'
 
+const own = {}.hasOwnProperty
+
 const pkg = JSON.parse(fs.readFileSync('package.json'))
 const remote = pkg.repository
-var root = path.join(process.cwd(), 'packages')
+const root = path.join(process.cwd(), 'packages')
 
-const presetObjects = await presets(root)
+presets(root).then((presetObjects) => {
+  const allRules = rules(root)
+  let index = -1
 
-rules(root).forEach(function (basename) {
-  var base = path.resolve(root, basename)
-  var pack = JSON.parse(fs.readFileSync(path.join(base, 'package.json')))
-  var info = rule(base)
-  var tests = info.tests
-  var author = parseAuthor(pack.author)
-  var short = basename.replace(/^remark-/, '')
-  var camelcased = basename.replace(/-(\w)/g, (_, $1) => $1.toUpperCase())
-  var org = remote.split('/').slice(0, -1).join('/')
-  var main = remote + '/blob/main'
-  var health = org + '/.github'
-  var hMain = health + '/blob/HEAD'
-  var slug = remote.split('/').slice(-2).join('/')
-  var includes
-  var hasGfm
-  var children = [
-    u('html', '<!--This file is generated-->'),
-    u('heading', {depth: 1}, [u('text', basename)]),
-    u('paragraph', [
-      u('linkReference', {identifier: 'build'}, [
-        u('imageReference', {identifier: 'build-badge', alt: 'Build'})
-      ]),
-      u('text', '\n'),
-      u('linkReference', {identifier: 'coverage'}, [
-        u('imageReference', {identifier: 'coverage-badge', alt: 'Coverage'})
-      ]),
-      u('text', '\n'),
-      u('linkReference', {identifier: 'downloads'}, [
-        u('imageReference', {identifier: 'downloads-badge', alt: 'Downloads'})
-      ]),
-      u('text', '\n'),
-      u('linkReference', {identifier: 'size'}, [
-        u('imageReference', {identifier: 'size-badge', alt: 'Size'})
-      ]),
-      u('text', '\n'),
-      u('linkReference', {identifier: 'collective'}, [
-        u('imageReference', {identifier: 'sponsors-badge', alt: 'Sponsors'})
-      ]),
-      u('text', '\n'),
-      u('linkReference', {identifier: 'collective'}, [
-        u('imageReference', {identifier: 'backers-badge', alt: 'Backers'})
-      ]),
-      u('text', '\n'),
-      u('linkReference', {identifier: 'chat'}, [
-        u('imageReference', {identifier: 'chat-badge', alt: 'Chat'})
+  while (++index < allRules.length) {
+    const basename = allRules[index]
+    const base = path.resolve(root, basename)
+    const pack = JSON.parse(fs.readFileSync(path.join(base, 'package.json')))
+    const info = rule(base)
+    const tests = info.tests
+    const author = parseAuthor(pack.author)
+    const short = basename.replace(/^remark-/, '')
+    const camelcased = basename.replace(/-(\w)/g, (_, $1) => $1.toUpperCase())
+    const org = remote.split('/').slice(0, -1).join('/')
+    const main = remote + '/blob/main'
+    const health = org + '/.github'
+    const hMain = health + '/blob/HEAD'
+    const slug = remote.split('/').slice(-2).join('/')
+    let hasGfm = false
+    let children = [
+      u('html', '<!--This file is generated-->'),
+      u('heading', {depth: 1}, [u('text', basename)]),
+      u('paragraph', [
+        u('linkReference', {identifier: 'build'}, [
+          u('imageReference', {identifier: 'build-badge', alt: 'Build'})
+        ]),
+        u('text', '\n'),
+        u('linkReference', {identifier: 'coverage'}, [
+          u('imageReference', {identifier: 'coverage-badge', alt: 'Coverage'})
+        ]),
+        u('text', '\n'),
+        u('linkReference', {identifier: 'downloads'}, [
+          u('imageReference', {identifier: 'downloads-badge', alt: 'Downloads'})
+        ]),
+        u('text', '\n'),
+        u('linkReference', {identifier: 'size'}, [
+          u('imageReference', {identifier: 'size-badge', alt: 'Size'})
+        ]),
+        u('text', '\n'),
+        u('linkReference', {identifier: 'collective'}, [
+          u('imageReference', {identifier: 'sponsors-badge', alt: 'Sponsors'})
+        ]),
+        u('text', '\n'),
+        u('linkReference', {identifier: 'collective'}, [
+          u('imageReference', {identifier: 'backers-badge', alt: 'Backers'})
+        ]),
+        u('text', '\n'),
+        u('linkReference', {identifier: 'chat'}, [
+          u('imageReference', {identifier: 'chat-badge', alt: 'Chat'})
+        ])
       ])
-    ])
-  ].concat(remark().parse(info.description).children)
-
-  if (basename !== pack.name) {
-    throw new Error(
-      'Expected package name (`' +
-        pack.name +
-        '`) to be the same as directory name (`' +
-        basename +
-        '`)'
-    )
-  }
+    ].concat(remark().parse(info.description).children)
 
-  includes = presetObjects.filter(function (preset) {
-    return basename in preset.packages
-  })
+    if (basename !== pack.name) {
+      throw new Error(
+        'Expected package name (`' +
+          pack.name +
+          '`) to be the same as directory name (`' +
+          basename +
+          '`)'
+      )
+    }
 
-  children.push(u('heading', {depth: 2}, [u('text', 'Presets')]))
+    const includes = presetObjects.filter((preset) => {
+      return basename in preset.packages
+    })
 
-  if (includes.length === 0) {
-    children.push(
-      u('paragraph', [
-        u('text', 'This rule is not included in any default preset')
-      ])
-    )
-  } else {
-    children.push(
-      u('paragraph', [
-        u('text', 'This rule is included in the following presets:')
-      ]),
-      u(
-        'table',
-        {align: []},
-        [
-          u('tableRow', [
-            u('tableCell', [u('text', 'Preset')]),
-            u('tableCell', [u('text', 'Setting')])
-          ])
-        ].concat(
-          includes.map(function (preset) {
-            var url = remote + '/tree/main/packages/' + preset.name
-            var option = preset.packages[pack.name]
+    children.push(u('heading', {depth: 2}, [u('text', 'Presets')]))
 
-            return u('tableRow', [
-              u('tableCell', [
-                u('link', {url: url, title: null}, [
-                  u('inlineCode', preset.name)
-                ])
-              ]),
-              u('tableCell', option ? [u('inlineCode', inspect(option))] : [])
+    if (includes.length === 0) {
+      children.push(
+        u('paragraph', [
+          u('text', 'This rule is not included in any default preset')
+        ])
+      )
+    } else {
+      children.push(
+        u('paragraph', [
+          u('text', 'This rule is included in the following presets:')
+        ]),
+        u(
+          'table',
+          {align: []},
+          [
+            u('tableRow', [
+              u('tableCell', [u('text', 'Preset')]),
+              u('tableCell', [u('text', 'Setting')])
             ])
-          })
+          ].concat(
+            includes.map((preset) => {
+              const url = remote + '/tree/main/packages/' + preset.name
+              const option = preset.packages[pack.name]
+
+              return u('tableRow', [
+                u('tableCell', [
+                  u('link', {url, title: null}, [u('inlineCode', preset.name)])
+                ]),
+                u('tableCell', option ? [u('inlineCode', inspect(option))] : [])
+              ])
+            })
+          )
         )
       )
-    )
-  }
+    }
 
-  Object.keys(tests).forEach(function (setting, index) {
-    var fixtures = tests[setting]
+    let setting
+    let first = true
 
-    if (index === 0) {
-      children.push(u('heading', {depth: 2}, [u('text', 'Example')]))
-    }
+    for (setting in tests) {
+      if (own.call(tests, setting)) {
+        const fixtures = tests[setting]
 
-    Object.keys(fixtures).forEach(function (fileName) {
-      var fixture = fixtures[fileName]
-      var label = inspect(JSON.parse(setting))
-      var clean = fixture.input
+        if (first) {
+          children.push(u('heading', {depth: 2}, [u('text', 'Example')]))
+          first = false
+        }
 
-      children.push(u('heading', {depth: 5}, [u('inlineCode', fileName)]))
+        let fileName
 
-      if (label !== 'true') {
-        children.push(
-          u('paragraph', [
-            u('text', 'When configured with '),
-            u('inlineCode', label),
-            u('text', '.')
-          ])
-        )
-      }
+        for (fileName in fixtures) {
+          if (own.call(fixtures, fileName)) {
+            const fixture = fixtures[fileName]
+            const label = inspect(JSON.parse(setting))
+            let clean = fixture.input
 
-      if (fixture.input != null && fixture.input.trim() !== '') {
-        children.push(u('heading', {depth: 6}, [u('text', 'In')]))
+            children.push(u('heading', {depth: 5}, [u('inlineCode', fileName)]))
 
-        if (fixture.gfm) {
-          hasGfm = true
-          children.push(
-            u('paragraph', [
-              u('text', 'Note: this example uses '),
-              u('linkReference', {label: 'GFM', referenceType: 'collapsed'}, [
-                u('text', 'GFM')
-              ]),
-              u('text', '.')
-            ])
-          )
-        }
+            if (label !== 'true') {
+              children.push(
+                u('paragraph', [
+                  u('text', 'When configured with '),
+                  u('inlineCode', label),
+                  u('text', '.')
+                ])
+              )
+            }
 
-        characters.forEach(function (char) {
-          var next = clean.replace(char.in, char.out)
+            if (
+              fixture.input !== null &&
+              fixture.input !== undefined &&
+              fixture.input.trim() !== ''
+            ) {
+              children.push(u('heading', {depth: 6}, [u('text', 'In')]))
 
-          if (clean !== next) {
-            children.push(
-              u('paragraph', [
-                u('text', 'Note: '),
-                u('inlineCode', char.char),
-                u('text', ' represents ' + char.name + '.')
-              ])
-            )
+              if (fixture.gfm) {
+                hasGfm = true
+                children.push(
+                  u('paragraph', [
+                    u('text', 'Note: this example uses '),
+                    u(
+                      'linkReference',
+                      {label: 'GFM', referenceType: 'collapsed'},
+                      [u('text', 'GFM')]
+                    ),
+                    u('text', '.')
+                  ])
+                )
+              }
 
-            clean = next
-          }
-        })
+              let index = -1
+              while (++index < characters.length) {
+                const char = characters[index]
+                const next = clean.replace(char.in, char.out)
 
-        children.push(u('code', {lang: 'markdown'}, fixture.input))
-      }
+                if (clean !== next) {
+                  children.push(
+                    u('paragraph', [
+                      u('text', 'Note: '),
+                      u('inlineCode', char.char),
+                      u('text', ' represents ' + char.name + '.')
+                    ])
+                  )
+
+                  clean = next
+                }
+              }
 
-      children.push(u('heading', {depth: 6}, [u('text', 'Out')]))
+              children.push(u('code', {lang: 'markdown'}, fixture.input))
+            }
 
-      if (fixture.output.length === 0) {
-        children.push(u('paragraph', [u('text', 'No messages.')]))
-      } else {
-        children.push(u('code', {lang: 'text'}, fixture.output.join('\n')))
+            children.push(u('heading', {depth: 6}, [u('text', 'Out')]))
+
+            if (fixture.output.length === 0) {
+              children.push(u('paragraph', [u('text', 'No messages.')]))
+            } else {
+              children.push(
+                u('code', {lang: 'text'}, fixture.output.join('\n'))
+              )
+            }
+          }
+        }
       }
-    })
-  })
+    }
 
-  children = children.concat([
-    u('heading', {depth: 2}, [u('text', 'Install')]),
-    u('paragraph', [
-      u('linkReference', {identifier: 'npm', referenceType: 'collapsed'}, [
-        u('text', 'npm')
+    children = children.concat([
+      u('heading', {depth: 2}, [u('text', 'Install')]),
+      u('paragraph', [
+        u('linkReference', {identifier: 'npm', referenceType: 'collapsed'}, [
+          u('text', 'npm')
+        ]),
+        u('text', ':')
       ]),
-      u('text', ':')
-    ]),
-    u('code', {lang: 'sh'}, 'npm install ' + basename),
-    u('heading', {depth: 2}, [u('text', 'Use')]),
-    u('paragraph', [
-      u('text', 'You probably want to use it on the CLI through a config file:')
-    ]),
-    u(
-      'code',
-      {lang: 'diff'},
-      [
-        ' …',
-        ' "remarkConfig": {',
-        '   "plugins": [',
-        '     …',
-        '     "lint",',
-        '+    "' + short + '",',
-        '     …',
-        '   ]',
-        ' }',
-        ' …'
-      ].join('\n')
-    ),
-    u('paragraph', [u('text', 'Or use it on the CLI directly')]),
-    u('code', {lang: 'sh'}, 'remark -u lint -u ' + short + ' readme.md'),
-    u('paragraph', [u('text', 'Or use this on the API:')]),
-    u(
-      'code',
-      {lang: 'diff'},
-      [
-        " import {remark} from 'remark'",
-        " import {reporter} from 'vfile-reporter'",
-        " import remarkLint from 'remark-lint'",
-        ' import ' + camelcased + " from '" + basename + "'",
-        '',
-        ' remark()',
-        '   .use(remarkLint)',
-        '+  .use(' + camelcased + ')',
-        "   .process('_Emphasis_ and **importance**')",
-        '   .then((file) => {',
-        '     console.error(reporter(file))',
-        '   })'
-      ].join('\n')
-    ),
-    u('heading', {depth: 2}, [u('text', 'Contribute')]),
-    u('paragraph', [
-      u('text', 'See '),
-      u('linkReference', {identifier: 'contributing'}, [
-        u('inlineCode', 'contributing.md')
+      u('code', {lang: 'sh'}, 'npm install ' + basename),
+      u('heading', {depth: 2}, [u('text', 'Use')]),
+      u('paragraph', [
+        u(
+          'text',
+          'You probably want to use it on the CLI through a config file:'
+        )
       ]),
-      u('text', ' in '),
-      u('linkReference', {identifier: 'health'}, [
-        u('inlineCode', health.split('/').slice(-2).join('/'))
+      u(
+        'code',
+        {lang: 'diff'},
+        [
+          ' …',
+          ' "remarkConfig": {',
+          '   "plugins": [',
+          '     …',
+          '     "lint",',
+          '+    "' + short + '",',
+          '     …',
+          '   ]',
+          ' }',
+          ' …'
+        ].join('\n')
+      ),
+      u('paragraph', [u('text', 'Or use it on the CLI directly')]),
+      u('code', {lang: 'sh'}, 'remark -u lint -u ' + short + ' readme.md'),
+      u('paragraph', [u('text', 'Or use this on the API:')]),
+      u(
+        'code',
+        {lang: 'diff'},
+        [
+          " import {remark} from 'remark'",
+          " import {reporter} from 'vfile-reporter'",
+          " import remarkLint from 'remark-lint'",
+          ' import ' + camelcased + " from '" + basename + "'",
+          '',
+          ' remark()',
+          '   .use(remarkLint)',
+          '+  .use(' + camelcased + ')',
+          "   .process('_Emphasis_ and **importance**')",
+          '   .then((file) => {',
+          '     console.error(reporter(file))',
+          '   })'
+        ].join('\n')
+      ),
+      u('heading', {depth: 2}, [u('text', 'Contribute')]),
+      u('paragraph', [
+        u('text', 'See '),
+        u('linkReference', {identifier: 'contributing'}, [
+          u('inlineCode', 'contributing.md')
+        ]),
+        u('text', ' in '),
+        u('linkReference', {identifier: 'health'}, [
+          u('inlineCode', health.split('/').slice(-2).join('/'))
+        ]),
+        u('text', ' for ways\nto get started.\nSee '),
+        u('linkReference', {identifier: 'support'}, [
+          u('inlineCode', 'support.md')
+        ]),
+        u('text', ' for ways to get help.')
       ]),
-      u('text', ' for ways\nto get started.\nSee '),
-      u('linkReference', {identifier: 'support'}, [
-        u('inlineCode', 'support.md')
+      u('paragraph', [
+        u('text', 'This project has a '),
+        u('linkReference', {identifier: 'coc'}, [u('text', 'code of conduct')]),
+        u(
+          'text',
+          '.\nBy interacting with this repository, organization, or community you agree to\nabide by its terms.'
+        )
       ]),
-      u('text', ' for ways to get help.')
-    ]),
-    u('paragraph', [
-      u('text', 'This project has a '),
-      u('linkReference', {identifier: 'coc'}, [u('text', 'code of conduct')]),
-      u(
-        'text',
-        '.\nBy interacting with this repository, organization, or community you agree to\nabide by its terms.'
+      u('heading', {depth: 2}, [u('text', 'License')]),
+      u('paragraph', [
+        u('linkReference', {identifier: 'license'}, [u('text', pack.license)]),
+        u('text', ' © '),
+        u('linkReference', {identifier: 'author'}, [u('text', author.name)])
+      ]),
+      u('definition', {
+        identifier: 'build-badge',
+        url: 'https://github.com/' + slug + '/workflows/main/badge.svg'
+      }),
+      u('definition', {
+        identifier: 'build',
+        url: 'https://github.com/' + slug + '/actions'
+      }),
+      u('definition', {
+        identifier: 'coverage-badge',
+        url: 'https://img.shields.io/codecov/c/github/' + slug + '.svg'
+      }),
+      u('definition', {
+        identifier: 'coverage',
+        url: 'https://codecov.io/github/' + slug
+      }),
+      u('definition', {
+        identifier: 'downloads-badge',
+        url: 'https://img.shields.io/npm/dm/' + basename + '.svg'
+      }),
+      u('definition', {
+        identifier: 'downloads',
+        url: 'https://www.npmjs.com/package/' + basename
+      }),
+      u('definition', {
+        identifier: 'size-badge',
+        url: 'https://img.shields.io/bundlephobia/minzip/' + basename + '.svg'
+      }),
+      u('definition', {
+        identifier: 'size',
+        url: 'https://bundlephobia.com/result?p=' + basename
+      }),
+      u('definition', {
+        identifier: 'sponsors-badge',
+        url: 'https://opencollective.com/unified/sponsors/badge.svg'
+      }),
+      u('definition', {
+        identifier: 'backers-badge',
+        url: 'https://opencollective.com/unified/backers/badge.svg'
+      }),
+      u('definition', {
+        identifier: 'collective',
+        url: 'https://opencollective.com/unified'
+      }),
+      u('definition', {
+        identifier: 'chat-badge',
+        url: 'https://img.shields.io/badge/chat-discussions-success.svg'
+      }),
+      u('definition', {
+        identifier: 'chat',
+        url: 'https://github.com/remarkjs/remark/discussions'
+      }),
+      u('definition', {
+        identifier: 'npm',
+        url: 'https://docs.npmjs.com/cli/install'
+      }),
+      u('definition', {identifier: 'health', url: health}),
+      u('definition', {
+        identifier: 'contributing',
+        url: hMain + '/contributing.md'
+      }),
+      u('definition', {identifier: 'support', url: hMain + '/support.md'}),
+      u('definition', {
+        identifier: 'coc',
+        url: hMain + '/code-of-conduct.md'
+      }),
+      u('definition', {identifier: 'license', url: main + '/license'}),
+      u('definition', {identifier: 'author', url: author.url})
+    ])
+
+    if (hasGfm) {
+      children.push(
+        u('definition', {
+          identifier: 'gfm',
+          url: 'https://github.com/remarkjs/remark-gfm'
+        })
       )
-    ]),
-    u('heading', {depth: 2}, [u('text', 'License')]),
-    u('paragraph', [
-      u('linkReference', {identifier: 'license'}, [u('text', pack.license)]),
-      u('text', ' © '),
-      u('linkReference', {identifier: 'author'}, [u('text', author.name)])
-    ]),
-    u('definition', {
-      identifier: 'build-badge',
-      url: 'https://github.com/' + slug + '/workflows/main/badge.svg'
-    }),
-    u('definition', {
-      identifier: 'build',
-      url: 'https://github.com/' + slug + '/actions'
-    }),
-    u('definition', {
-      identifier: 'coverage-badge',
-      url: 'https://img.shields.io/codecov/c/github/' + slug + '.svg'
-    }),
-    u('definition', {
-      identifier: 'coverage',
-      url: 'https://codecov.io/github/' + slug
-    }),
-    u('definition', {
-      identifier: 'downloads-badge',
-      url: 'https://img.shields.io/npm/dm/' + basename + '.svg'
-    }),
-    u('definition', {
-      identifier: 'downloads',
-      url: 'https://www.npmjs.com/package/' + basename
-    }),
-    u('definition', {
-      identifier: 'size-badge',
-      url: 'https://img.shields.io/bundlephobia/minzip/' + basename + '.svg'
-    }),
-    u('definition', {
-      identifier: 'size',
-      url: 'https://bundlephobia.com/result?p=' + basename
-    }),
-    u('definition', {
-      identifier: 'sponsors-badge',
-      url: 'https://opencollective.com/unified/sponsors/badge.svg'
-    }),
-    u('definition', {
-      identifier: 'backers-badge',
-      url: 'https://opencollective.com/unified/backers/badge.svg'
-    }),
-    u('definition', {
-      identifier: 'collective',
-      url: 'https://opencollective.com/unified'
-    }),
-    u('definition', {
-      identifier: 'chat-badge',
-      url: 'https://img.shields.io/badge/chat-discussions-success.svg'
-    }),
-    u('definition', {
-      identifier: 'chat',
-      url: 'https://github.com/remarkjs/remark/discussions'
-    }),
-    u('definition', {
-      identifier: 'npm',
-      url: 'https://docs.npmjs.com/cli/install'
-    }),
-    u('definition', {identifier: 'health', url: health}),
-    u('definition', {
-      identifier: 'contributing',
-      url: hMain + '/contributing.md'
-    }),
-    u('definition', {identifier: 'support', url: hMain + '/support.md'}),
-    u('definition', {
-      identifier: 'coc',
-      url: hMain + '/code-of-conduct.md'
-    }),
-    u('definition', {identifier: 'license', url: main + '/license'}),
-    u('definition', {identifier: 'author', url: author.url})
-  ])
+    }
 
-  if (hasGfm) {
-    children.push(
-      u('definition', {
-        identifier: 'gfm',
-        url: 'https://github.com/remarkjs/remark-gfm'
-      })
+    fs.writeFileSync(
+      path.join(base, 'readme.md'),
+      remark().use(remarkGfm).stringify(u('root', children))
     )
-  }
 
-  fs.writeFileSync(
-    path.join(base, 'readme.md'),
-    remark().use(remarkGfm).stringify(u('root', children))
-  )
-
-  console.log('✓ wrote `readme.md` in `' + basename + '`')
+    console.log('✓ wrote `readme.md` in `' + basename + '`')
+  }
 })
diff --git a/script/plugin/list-of-presets.js b/script/plugin/list-of-presets.js
index b4e2b54d..b90f1831 100644
--- a/script/plugin/list-of-presets.js
+++ b/script/plugin/list-of-presets.js
@@ -4,38 +4,39 @@ import {zone} from 'mdast-zone'
 import {u} from 'unist-builder'
 import {presets} from '../util/presets.js'
 
-var root = path.join(process.cwd(), 'packages')
-const presetObjects = await presets(root)
+const root = path.join(process.cwd(), 'packages')
 
 export default function listOfPresets() {
-  return transformer
-}
-
-function transformer(tree) {
-  zone(tree, 'presets', replace)
-}
+  const presetPromise = presets(root)
 
-function replace(start, nodes, end) {
-  return [
-    start,
-    u('list', {ordered: false, spread: false}, presetObjects.map(item)),
-    end
-  ]
+  return async (tree) => {
+    const presetObjects = await presetPromise
 
-  function item({name}) {
-    var pack = JSON.parse(
-      fs.readFileSync(path.join(root, name, 'package.json'))
-    )
-    var description = pack.description.replace(
-      /^remark preset to configure remark-lint with ?/i,
-      ''
-    )
+    zone(tree, 'presets', (start, nodes, end) => {
+      return [
+        start,
+        u(
+          'list',
+          {ordered: false, spread: false},
+          presetObjects.map(({name}) => {
+            const pack = JSON.parse(
+              fs.readFileSync(path.join(root, name, 'package.json'))
+            )
+            const description = pack.description.replace(
+              /^remark preset to configure remark-lint with ?/i,
+              ''
+            )
 
-    return u('listItem', {spread: false}, [
-      u('paragraph', [
-        u('link', {url: pack.repository}, [u('inlineCode', name)]),
-        u('text', ' — ' + description)
-      ])
-    ])
+            return u('listItem', {spread: false}, [
+              u('paragraph', [
+                u('link', {url: pack.repository}, [u('inlineCode', name)]),
+                u('text', ' — ' + description)
+              ])
+            ])
+          })
+        ),
+        end
+      ]
+    })
   }
 }
diff --git a/script/plugin/list-of-rules.js b/script/plugin/list-of-rules.js
index 1a8c5024..7f6ee992 100644
--- a/script/plugin/list-of-rules.js
+++ b/script/plugin/list-of-rules.js
@@ -4,7 +4,7 @@ import {zone} from 'mdast-zone'
 import {u} from 'unist-builder'
 import {rules} from '../util/rules.js'
 
-var root = path.join(process.cwd(), 'packages')
+const root = path.join(process.cwd(), 'packages')
 
 export default function listOfRules() {
   return transformer
@@ -17,22 +17,27 @@ function transformer(tree) {
 function replace(start, nodes, end) {
   return [
     start,
-    u('list', {ordered: false, spread: false}, rules(root).map(item)),
+    u(
+      'list',
+      {ordered: false, spread: false},
+      rules(root).map((basename) => {
+        const name = basename.slice('remark-lint-'.length)
+        const pack = JSON.parse(
+          fs.readFileSync(path.join(root, basename, 'package.json'))
+        )
+        const description = pack.description.replace(
+          /^remark-lint rule to ?/i,
+          ''
+        )
+
+        return u('listItem', {spread: false}, [
+          u('paragraph', [
+            u('link', {url: pack.repository}, [u('inlineCode', name)]),
+            u('text', ' — ' + description)
+          ])
+        ])
+      })
+    ),
     end
   ]
-
-  function item(basename) {
-    var name = basename.slice('remark-lint-'.length)
-    var pack = JSON.parse(
-      fs.readFileSync(path.join(root, basename, 'package.json'))
-    )
-    var description = pack.description.replace(/^remark-lint rule to ?/i, '')
-
-    return u('listItem', {spread: false}, [
-      u('paragraph', [
-        u('link', {url: pack.repository}, [u('inlineCode', name)]),
-        u('text', ' — ' + description)
-      ])
-    ])
-  }
 }
diff --git a/script/util/find.js b/script/util/find.js
index 2259e51b..7d89145d 100755
--- a/script/util/find.js
+++ b/script/util/find.js
@@ -1,8 +1,8 @@
 // Find the first tag in `tags` with a type set to `key`.
 export function find(tags, key) {
-  var value = null
+  let value = null
 
-  tags.some(function (tag) {
+  tags.some((tag) => {
     if (tag && tag.type === key) {
       value = tag
 
@@ -18,10 +18,10 @@ export function find(tags, key) {
 // Find the first tag in `tags` with a type set to `key`.
 export function findAll(tags, key) {
   return tags
-    .filter(function (tag) {
+    .filter((tag) => {
       return tag && tag.type === key
     })
-    .map(function (tag) {
+    .map((tag) => {
       return tag.string
     })
 }
diff --git a/script/util/presets.js b/script/util/presets.js
index 3d2096e4..5e6fa915 100644
--- a/script/util/presets.js
+++ b/script/util/presets.js
@@ -2,13 +2,15 @@ import {promises as fs} from 'fs'
 import path from 'path'
 
 export async function presets(base) {
-  const files = (await fs.readdir(base)).filter(filter)
+  const files = (await fs.readdir(base)).filter((basename) =>
+    /remark-preset-lint/.test(basename)
+  )
 
   return Promise.all(
-    files.map(async function (name) {
+    files.map(async (name) => {
       const plugins = (await import(path.join(base, name, 'index.js'))).default
         .plugins
-      var packages = {}
+      const packages = {}
 
       let index = -1
       while (++index < plugins.length) {
@@ -23,7 +25,7 @@ export async function presets(base) {
           option = plugin[1]
         }
 
-        let name = fn.displayName || fn.name
+        const name = fn.displayName || fn.name
 
         packages[
           name
@@ -32,11 +34,7 @@ export async function presets(base) {
         ] = option
       }
 
-      return {name: name, packages: packages}
+      return {name, packages}
     })
   )
 }
-
-function filter(basename) {
-  return /remark-preset-lint/.test(basename)
-}
diff --git a/script/util/rule.js b/script/util/rule.js
index 678af521..86945edb 100755
--- a/script/util/rule.js
+++ b/script/util/rule.js
@@ -6,19 +6,13 @@ import {find, findAll} from './find.js'
 
 // Get information for a rule at `filePath`.
 export function rule(filePath) {
-  var ruleId = path.basename(filePath)
-  var result = {}
-  var tests = {}
-  var description
-  var code
-  var tags
-  var name
-
-  ruleId = ruleId.slice('remark-lint-'.length)
-  code = fs.readFileSync(path.join(filePath, 'index.js'), 'utf-8')
-  tags = dox.parseComments(code)[0].tags
-  description = find(tags, 'fileoverview')
-  name = find(tags, 'module')
+  const ruleId = path.basename(filePath).slice('remark-lint-'.length)
+  const result = {}
+  const tests = {}
+  const code = fs.readFileSync(path.join(filePath, 'index.js'), 'utf-8')
+  const tags = dox.parseComments(code)[0].tags
+  const name = find(tags, 'module')
+  let description = find(tags, 'fileoverview')
 
   /* c8 ignore next 3 */
   if (name !== ruleId) {
@@ -37,17 +31,14 @@ export function rule(filePath) {
   result.tests = tests
   result.filePath = filePath
 
-  findAll(tags, 'example').map(strip).forEach(check)
+  const examples = findAll(tags, 'example')
+  let index = -1
 
-  return result
-
-  function check(example) {
-    var lines = example.split('\n')
-    var value = strip(lines.slice(1).join('\n'))
-    var info
-    var setting
-    var context
-    var name
+  while (++index < examples.length) {
+    const example = strip(examples[index])
+    const lines = example.split('\n')
+    const value = strip(lines.slice(1).join('\n'))
+    let info
 
     try {
       info = JSON.parse(lines[0])
@@ -58,9 +49,9 @@ export function rule(filePath) {
       )
     }
 
-    setting = JSON.stringify(info.setting || true)
-    context = tests[setting]
-    name = info.name
+    const setting = JSON.stringify(info.setting || true)
+    const name = info.name
+    let context = tests[setting]
 
     if (!context) {
       context = []
@@ -71,12 +62,12 @@ export function rule(filePath) {
       context[name] = {
         positionless: info.positionless,
         gfm: info.gfm,
-        setting: setting,
+        setting,
         input: value,
         output: []
       }
 
-      return
+      continue
     }
 
     /* c8 ignore next 9 */
@@ -97,9 +88,11 @@ export function rule(filePath) {
     context[name].setting = setting
 
     if (info.label === 'output') {
-      value = value.split('\n')
+      context[name][info.label] = value.split('\n')
+    } else {
+      context[name][info.label] = value
     }
-
-    context[name][info.label] = value
   }
+
+  return result
 }
diff --git a/script/util/rules.js b/script/util/rules.js
index fca1dde9..6de22224 100644
--- a/script/util/rules.js
+++ b/script/util/rules.js
@@ -1,9 +1,9 @@
 import fs from 'fs'
 
 export function rules(filePath) {
-  return fs.readdirSync(filePath).filter(filter)
-}
-
-function filter(basename) {
-  return /remark-lint/.test(basename) && basename !== 'remark-lint'
+  return fs
+    .readdirSync(filePath)
+    .filter(
+      (basename) => /remark-lint/.test(basename) && basename !== 'remark-lint'
+    )
 }
diff --git a/test.js b/test.js
index fb9a58b5..5984a702 100644
--- a/test.js
+++ b/test.js
@@ -13,9 +13,11 @@ import noHeadingPunctuation from './packages/remark-lint-no-heading-punctuation/
 import noMultipleToplevelHeadings from './packages/remark-lint-no-multiple-toplevel-headings/index.js'
 import finalNewline from './packages/remark-lint-final-newline/index.js'
 
-test('core', function (t) {
-  t.test('should work', function (st) {
-    var doc = [
+const own = {}.hasOwnProperty
+
+test('core', (t) => {
+  t.test('should work', (t) => {
+    const doc = [
       '# A heading',
       '',
       '# Another main heading.',
@@ -25,114 +27,108 @@ test('core', function (t) {
       '# Another main heading.'
     ].join('\n')
 
-    st.plan(2)
+    t.plan(2)
 
     remark()
       .use(noHeadingPunctuation)
       .use(noMultipleToplevelHeadings)
       .use(lint)
-      .process(
-        toVFile({path: 'virtual.md', value: doc}),
-        function (error, file) {
-          st.deepEqual(
-            [error].concat(file.messages.map(String)),
-            [
-              null,
-              'virtual.md:3:1-3:24: Don’t add a trailing `.` to headings',
-              'virtual.md:3:1-3:24: Don’t use multiple top level headings (1:1)'
-            ],
-            'should support `remark-lint` last'
-          )
-        }
-      )
+      .process(toVFile({path: 'virtual.md', value: doc}), (error, file) => {
+        t.deepEqual(
+          [error].concat(file.messages.map((d) => String(d))),
+          [
+            null,
+            'virtual.md:3:1-3:24: Don’t add a trailing `.` to headings',
+            'virtual.md:3:1-3:24: Don’t use multiple top level headings (1:1)'
+          ],
+          'should support `remark-lint` last'
+        )
+      })
 
     remark()
       .use(lint)
       .use(noHeadingPunctuation)
       .use(noMultipleToplevelHeadings)
-      .process(
-        toVFile({path: 'virtual.md', value: doc}),
-        function (error, file) {
-          st.deepEqual(
-            [error].concat(file.messages.map(String)),
-            [
-              null,
-              'virtual.md:3:1-3:24: Don’t add a trailing `.` to headings',
-              'virtual.md:3:1-3:24: Don’t use multiple top level headings (1:1)'
-            ],
-            'should support `remark-lint` first'
-          )
-        }
-      )
+      .process(toVFile({path: 'virtual.md', value: doc}), (error, file) => {
+        t.deepEqual(
+          [error].concat(file.messages.map((d) => String(d))),
+          [
+            null,
+            'virtual.md:3:1-3:24: Don’t add a trailing `.` to headings',
+            'virtual.md:3:1-3:24: Don’t use multiple top level headings (1:1)'
+          ],
+          'should support `remark-lint` first'
+        )
+      })
   })
 
-  t.test('should support no rules', function (st) {
-    st.plan(1)
+  t.test('should support no rules', (t) => {
+    t.plan(1)
 
     remark()
       .use(lint)
-      .process('.', function (error, file) {
-        st.deepEqual(
-          [error].concat(file.messages.map(String)),
+      .process('.', (error, file) => {
+        t.deepEqual(
+          [error].concat(file.messages.map((d) => String(d))),
           [null],
           'should warn for missing new lines'
         )
       })
   })
 
-  t.test('should support successful rules', function (st) {
-    st.plan(1)
+  t.test('should support successful rules', (t) => {
+    t.plan(1)
 
     remark()
       .use(finalNewline)
-      .process('', function (error, file) {
-        st.deepEqual(
-          [error].concat(file.messages.map(String)),
+      .process('', (error, file) => {
+        t.deepEqual(
+          [error].concat(file.messages.map((d) => String(d))),
           [null],
           'should support successful rules'
         )
       })
   })
 
-  t.test('should support a list with a severity', function (st) {
-    st.plan(2)
+  t.test('should support a list with a severity', (t) => {
+    t.plan(2)
 
     remark()
       .use(finalNewline, [2])
-      .process('.', function (error, file) {
-        st.deepEqual(
-          [error].concat(file.messages.map(String)),
+      .process('.', (error, file) => {
+        t.deepEqual(
+          [error].concat(file.messages.map((d) => String(d))),
           [null, '1:1: Missing newline character at end of file'],
           'should emit fatally (1)'
         )
-        st.equal(file.messages[0].fatal, true, 'should emit fatally (2)')
+        t.equal(file.messages[0].fatal, true, 'should emit fatally (2)')
       })
   })
 
-  t.test('should support a boolean (`true`)', function (st) {
+  t.test('should support a boolean (`true`)', (t) => {
     // Note! This is handled by unified.
-    st.plan(1)
+    t.plan(1)
 
     remark()
       .use(finalNewline, true)
-      .process('.', function (error, file) {
-        st.deepEqual(
-          [error].concat(file.messages.map(String)),
+      .process('.', (error, file) => {
+        t.deepEqual(
+          [error].concat(file.messages.map((d) => String(d))),
           [null, '1:1: Missing newline character at end of file'],
           'should emit'
         )
       })
   })
 
-  t.test('should support a boolean (`false`)', function (st) {
+  t.test('should support a boolean (`false`)', (t) => {
     // Note! This is handled by unified.
-    st.plan(1)
+    t.plan(1)
 
     remark()
       .use(finalNewline, false)
-      .process('.', function (error, file) {
-        st.deepEqual(
-          [error].concat(file.messages.map(String)),
+      .process('.', (error, file) => {
+        t.deepEqual(
+          [error].concat(file.messages.map((d) => String(d))),
           [null],
           'should not emit'
         )
@@ -141,14 +137,14 @@ test('core', function (t) {
 
   t.test(
     'should support a list with a boolean severity (true, for on)',
-    function (st) {
-      st.plan(1)
+    (t) => {
+      t.plan(1)
 
       remark()
         .use(finalNewline, [true])
-        .process('.', function (error, file) {
-          st.deepEqual(
-            [error].concat(file.messages.map(String)),
+        .process('.', (error, file) => {
+          t.deepEqual(
+            [error].concat(file.messages.map((d) => String(d))),
             [null, '1:1: Missing newline character at end of file'],
             'should emit'
           )
@@ -158,14 +154,14 @@ test('core', function (t) {
 
   t.test(
     'should support a list with boolean severity (false, for off)',
-    function (st) {
-      st.plan(1)
+    (t) => {
+      t.plan(1)
 
       remark()
         .use(finalNewline, [false])
-        .process('.', function (error, file) {
-          st.deepEqual(
-            [error].concat(file.messages.map(String)),
+        .process('.', (error, file) => {
+          t.deepEqual(
+            [error].concat(file.messages.map((d) => String(d))),
             [null],
             'should not emit'
           )
@@ -173,149 +169,149 @@ test('core', function (t) {
     }
   )
 
-  t.test('should support a list with string severity (`error`)', function (st) {
-    st.plan(2)
+  t.test('should support a list with string severity (`error`)', (t) => {
+    t.plan(2)
 
     remark()
       .use(finalNewline, ['error'])
-      .process('.', function (error, file) {
-        st.deepEqual(
-          [error].concat(file.messages.map(String)),
+      .process('.', (error, file) => {
+        t.deepEqual(
+          [error].concat(file.messages.map((d) => String(d))),
           [null, '1:1: Missing newline character at end of file'],
           'should emit fatally (1)'
         )
-        st.equal(file.messages[0].fatal, true, 'should emit fatally (2)')
+        t.equal(file.messages[0].fatal, true, 'should emit fatally (2)')
       })
   })
 
-  t.test('should support a list with a string severity (`on`)', function (st) {
-    st.plan(2)
+  t.test('should support a list with a string severity (`on`)', (t) => {
+    t.plan(2)
 
     remark()
       .use(finalNewline, ['on'])
-      .process('.', function (error, file) {
-        st.deepEqual(
-          [error].concat(file.messages.map(String)),
+      .process('.', (error, file) => {
+        t.deepEqual(
+          [error].concat(file.messages.map((d) => String(d))),
           [null, '1:1: Missing newline character at end of file'],
           'should message'
         )
-        st.equal(file.messages[0].fatal, false, 'should not emit fatally')
+        t.equal(file.messages[0].fatal, false, 'should not emit fatally')
       })
   })
 
-  t.test(
-    'should support a list with a string severity (`warn`)',
-    function (st) {
-      st.plan(2)
+  t.test('should support a list with a string severity (`warn`)', (t) => {
+    t.plan(2)
 
-      remark()
-        .use(finalNewline, ['warn'])
-        .process('.', function (error, file) {
-          st.deepEqual(
-            [error].concat(file.messages.map(String)),
-            [null, '1:1: Missing newline character at end of file'],
-            'should message'
-          )
-          st.equal(file.messages[0].fatal, false, 'should not emit fatally')
-        })
-    }
-  )
+    remark()
+      .use(finalNewline, ['warn'])
+      .process('.', (error, file) => {
+        t.deepEqual(
+          [error].concat(file.messages.map((d) => String(d))),
+          [null, '1:1: Missing newline character at end of file'],
+          'should message'
+        )
+        t.equal(file.messages[0].fatal, false, 'should not emit fatally')
+      })
+  })
 
-  t.test('should support a list with a string severity (`off`)', function (st) {
-    st.plan(1)
+  t.test('should support a list with a string severity (`off`)', (t) => {
+    t.plan(1)
 
     remark()
       .use(finalNewline, ['off'])
-      .process('.', function (error, file) {
-        st.deepEqual(
-          [error].concat(file.messages.map(String)),
+      .process('.', (error, file) => {
+        t.deepEqual(
+          [error].concat(file.messages.map((d) => String(d))),
           [null],
           'should disable `final-newline`'
         )
       })
   })
 
-  t.test('should fail on incorrect severities', function (st) {
-    st.throws(
-      function () {
+  t.test('should fail on incorrect severities', (t) => {
+    t.throws(
+      () => {
         remark().use(finalNewline, [3]).freeze()
       },
       /^Error: Incorrect severity `3` for `final-newline`, expected 0, 1, or 2$/,
       'should throw when too high'
     )
 
-    st.throws(
-      function () {
+    t.throws(
+      () => {
         remark().use(finalNewline, [-1]).freeze()
       },
       /^Error: Incorrect severity `-1` for `final-newline`, expected 0, 1, or 2$/,
       'should throw too low'
     )
 
-    st.end()
+    t.end()
   })
 
   t.end()
 })
 
-test('rules', function (t) {
-  var root = path.join(process.cwd(), 'packages')
-  var all = rules(root)
-
-  t.plan(all.length)
-
-  all.forEach(each)
-
-  async function each(basename) {
-    var base = path.resolve(root, basename)
-    var info = rule(base)
-    var fn = (await import(url.pathToFileURL(base).href + '/index.js')).default
-    var handle = Object.keys(info.tests).length === 0 ? ignore : one
-
-    t.test(info.ruleId, handle)
-
-    function one(st) {
-      assertRule(st, fn, info)
-    }
-
-    function ignore(st) {
-      st.pass('no tests')
-      st.end()
+test('rules', async (t) => {
+  const root = path.join(process.cwd(), 'packages')
+  const all = rules(root)
+  let index = -1
+
+  while (++index < all.length) {
+    const basename = all[index]
+    const base = path.resolve(root, basename)
+    const info = rule(base)
+    const fn = (await import(url.pathToFileURL(base).href + '/index.js'))
+      .default
+
+    if (Object.keys(info.tests).length === 0) {
+      t.pass(info.ruleId + ': no tests')
+    } else {
+      t.test(info.ruleId, (t) => {
+        assertRule(t, fn, info)
+      })
     }
   }
+
+  t.end()
 })
 
 // Assert a rule.
 function assertRule(t, rule, info) {
-  var tests = info.tests
-  var settings = Object.keys(tests)
-
-  t.plan(settings.length)
-
-  settings.forEach(function (setting) {
-    var fixture = tests[setting]
-    var names = Object.keys(fixture)
-    var settings = JSON.parse(setting)
-
-    t.test(setting, function (st) {
-      st.plan(names.length)
-
-      names.forEach(function (name) {
-        st.test(name, function (sst) {
-          assertFixture(sst, rule, info, fixture[name], name, settings)
-        })
+  const tests = info.tests
+  let setting
+
+  for (setting in tests) {
+    if (own.call(tests, setting)) {
+      const checks = tests[setting]
+      const options = JSON.parse(setting)
+
+      t.test(setting, (t) => {
+        let name
+
+        for (name in checks) {
+          if (own.call(checks, name)) {
+            const basename = name
+            const check = checks[name]
+
+            t.test(name, (t) => {
+              assertFixture(t, rule, info, check, basename, options)
+            })
+          }
+        }
       })
-    })
-  })
+    }
+  }
+
+  t.end()
 }
 
 /* eslint-disable-next-line max-params */
 function assertFixture(t, rule, info, fixture, basename, settings) {
-  var ruleId = info.ruleId
-  var file = toVFile(basename)
-  var expected = fixture.output
-  var positionless = fixture.positionless
-  var proc = remark().use(rule, settings)
+  const ruleId = info.ruleId
+  const file = toVFile(basename)
+  const expected = fixture.output
+  const positionless = fixture.positionless
+  let proc = remark().use(rule, settings)
 
   if (fixture.gfm) proc.use(remarkGfm)
 
@@ -331,7 +327,9 @@ function assertFixture(t, rule, info, fixture, basename, settings) {
     }
   }
 
-  file.messages.forEach(function (message) {
+  let index = -1
+  while (++index < file.messages.length) {
+    const message = file.messages[index]
     if (message.ruleId !== ruleId) {
       throw new Error(
         'Expected `' +
@@ -342,7 +340,7 @@ function assertFixture(t, rule, info, fixture, basename, settings) {
           message
       )
     }
-  })
+  }
 
   t.deepEqual(normalize(file.messages), expected, 'should equal with position')
 
@@ -361,16 +359,18 @@ function assertFixture(t, rule, info, fixture, basename, settings) {
 }
 
 function normalize(messages) {
-  return messages.map(function (message) {
-    var value = String(message)
+  return messages.map((message) => {
+    const value = String(message)
     return value.slice(value.indexOf(':') + 1)
   })
 }
 
 function preprocess(value) {
-  characters.forEach(function (char) {
-    value = value.replace(char.in, char.out)
-  })
+  let index = -1
+
+  while (++index < characters.length) {
+    value = value.replace(characters[index].in, characters[index].out)
+  }
 
   return value
 }