Refactor code-style

Author: wooorm

index.js

@@ -33,25 +33,12 @@ import {toString} from 'mdast-util-to-string'
  */
 // eslint-disable-next-line complexity
 export function headingRange(node, options, handler) {
-  var test = options
+  let test = options
   /** @type {Array.<Node>} */
   // @ts-ignore looks like children.
-  var children = node.children || []
-  var index = -1
+  const children = node.children || []
   /** @type {boolean} */
-  var ignoreFinalDefinitions
-  /** @type {number} */
-  var depth
-  /** @type {number} */
-  var start
-  /** @type {number} */
-  var end
-  /** @type {Array.<Node>} */
-  var nodes
-  /** @type {Array.<Node>} */
-  var result
-  /** @type {Node} */
-  var child
+  let ignoreFinalDefinitions
 
   // Object, not regex.
   if (test && typeof test === 'object' && !('exec' in test)) {
@@ -77,9 +64,17 @@ export function headingRange(node, options, handler) {
     )
   }
 
+  let index = -1
+  /** @type {number} */
+  let start
+  /** @type {number} */
+  let end
+  /** @type {number} */
+  let depth
+
   // Find the range.
   while (++index < children.length) {
-    child = children[index]
+    const child = children[index]
 
     if (child.type === 'heading') {
       // @ts-expect-error: looks like a heading.
@@ -110,23 +105,21 @@ export function headingRange(node, options, handler) {
       }
     }
 
-    nodes = handler(
+    /** @type {Array.<Node>} */
+    const nodes = handler(
       // @ts-ignore `start` points to a heading.
       children[start],
       children.slice(start + 1, end),
       children[end],
-      {
-        parent: node,
-        start,
-        end: children[end] ? end : null
-      }
+      {parent: node, start, end: children[end] ? end : null}
     )
 
     if (nodes) {
       // Ensure no empty nodes are inserted.
       // This could be the case if `end` is in `nodes` but no `end` node exists.
-      result = []
-      index = -1
+      /** @type {Array.<Node>} */
+      const result = []
+      let index = -1
 
       while (++index < nodes.length) {
         if (nodes[index]) result.push(nodes[index])

package.json

@@ -67,11 +67,7 @@
     "trailingComma": "none"
   },
   "xo": {
-    "prettier": true,
-    "rules": {
-      "no-var": "off",
-      "prefer-arrow-callback": "off"
-    }
+    "prettier": true
   },
   "remarkConfig": {
     "plugins": [

readme.md

@@ -36,30 +36,26 @@ Bar.
 And our script, `example.js`, looks as follows:
 
 ```js
-import toVFile from 'to-vfile'
-import remark from 'remark'
+import {readSync} from 'to-vfile'
+import {remark} from 'remark'
 import {headingRange} from 'mdast-util-heading-range'
 
+const file = readSync('example.md')
+
 remark()
   .use(plugin)
-  .process(vfile.readSync('example.md'), function(err, file) {
-    if (err) throw err
+  .process(file)
+  .then((file) => {
     console.log(String(file))
   })
 
 function plugin() {
-  return transform
-
-  function transform(tree) {
-    headingRange(tree, 'foo', handler)
-  }
-
-  function handler(start, nodes, end) {
-    return [
+  return (tree) => {
+    headingRange(tree, 'foo', (start, nodes, end) => [
       start,
       {type: 'paragraph', children: [{type: 'text', value: 'Qux.'}]},
       end
-    ]
+    ])
   }
 }
 ```

test.js

@@ -9,35 +9,39 @@ import test from 'tape'
 import remark from 'remark'
 import {headingRange} from './index.js'
 
-test('mdast-util-heading-range()', function (t) {
-  t.plan(57)
+test('mdast-util-heading-range()', (t) => {
+  t.plan(58)
 
   t.equal(typeof headingRange, 'function', 'should be a function')
 
   t.throws(
-    function () {
+    () => {
       headingRange(
         /** @type {Root} */ ({type: 'root', children: []}),
         null,
-        function () {}
+        () => {}
       )
     },
     /^TypeError: Expected `string`, `regexp`, or `function` for `test`, not `null`$/,
     'should throw when `null` is passed in'
   )
 
   t.throws(
-    function () {
+    () => {
       headingRange(
         /** @type {Root} */ ({type: 'root', children: []}),
         undefined,
-        function () {}
+        () => {}
       )
     },
     /^TypeError: Expected `string`, `regexp`, or `function` for `test`, not `undefined`$/,
     'should throw when `undefined` is passed in'
   )
 
+  t.doesNotThrow(() => {
+    headingRange(/** @type {Root} */ ({type: 'root'}), 'x', () => {})
+  }, 'should not throw when a non-parent is passed')
+
   t.equal(
     process(
       t,
@@ -63,7 +67,7 @@ test('mdast-util-heading-range()', function (t) {
       t,
       ['# Fo', '', '## Fooooo', '', 'Bar', '', '# Fo', ''].join('\n'),
       /** @type {Options} */
-      function (value) {
+      (value) => {
         return value.toLowerCase().indexOf('foo') === 0
       }
     ),
@@ -133,58 +137,52 @@ test('mdast-util-heading-range()', function (t) {
   )
 
   remark()
-    .use(function () {
+    .use(() => {
       return function (node) {
-        headingRange(node, 'foo', function () {
+        headingRange(node, 'foo', () => {
           return null
         })
       }
     })
-    .process(
-      ['Foo', '', '## Foo', '', 'Bar', ''].join('\n'),
-      function (error, file) {
-        t.ifError(error, 'should not fail (#1)')
+    .process(['Foo', '', '## Foo', '', 'Bar', ''].join('\n'), (error, file) => {
+      t.ifError(error, 'should not fail (#1)')
 
-        t.equal(
-          String(file),
-          ['Foo', '', '## Foo', '', 'Bar', ''].join('\n'),
-          'should not remove anything when `null` is given'
-        )
-      }
-    )
+      t.equal(
+        String(file),
+        ['Foo', '', '## Foo', '', 'Bar', ''].join('\n'),
+        'should not remove anything when `null` is given'
+      )
+    })
 
   remark()
-    .use(function () {
+    .use(() => {
       return function (node) {
-        headingRange(node, 'foo', function () {
+        headingRange(node, 'foo', () => {
           return []
         })
       }
     })
-    .process(
-      ['Foo', '', '## Foo', '', 'Bar', ''].join('\n'),
-      function (error, file) {
-        t.ifError(error, 'should not fail (#2)')
+    .process(['Foo', '', '## Foo', '', 'Bar', ''].join('\n'), (error, file) => {
+      t.ifError(error, 'should not fail (#2)')
 
-        t.equal(
-          String(file),
-          ['Foo', ''].join('\n'),
-          'should replace all previous nodes otherwise'
-        )
-      }
-    )
+      t.equal(
+        String(file),
+        ['Foo', ''].join('\n'),
+        'should replace all previous nodes otherwise'
+      )
+    })
 
   remark()
-    .use(function () {
+    .use(() => {
       return function (node) {
-        headingRange(node, 'foo', function (start, _, end) {
+        headingRange(node, 'foo', (start, _, end) => {
           return [start, {type: 'thematicBreak'}, end]
         })
       }
     })
     .process(
       ['Foo', '', '## Foo', '', 'Bar', '', '## Baz', ''].join('\n'),
-      function (error, file) {
+      (error, file) => {
         t.ifError(error, 'should not fail (#3)')
 
         t.equal(
@@ -196,9 +194,9 @@ test('mdast-util-heading-range()', function (t) {
     )
 
   remark()
-    .use(function () {
+    .use(() => {
       return function (node) {
-        headingRange(node, 'foo', function (start, nodes, end) {
+        headingRange(node, 'foo', (start, nodes, end) => {
           t.equal(nodes.length, 3)
           return [start, ...nodes, end]
         })
@@ -208,7 +206,7 @@ test('mdast-util-heading-range()', function (t) {
       ['# Alpha', '', '## Foo', '', 'one', '', 'two', '', 'three', ''].join(
         '\n'
       ),
-      function (error, file) {
+      (error, file) => {
         t.ifError(error, 'should not fail (#4)')
 
         t.equal(
@@ -325,9 +323,9 @@ test('mdast-util-heading-range()', function (t) {
  */
 function process(t, value, options) {
   return remark()
-    .use(function () {
+    .use(() => {
       return function (node) {
-        headingRange(node, options, function (start, _, end, scope) {
+        headingRange(node, options, (start, _, end, scope) => {
           t.equal(typeof scope.start, 'number')
           t.assert(typeof scope.end === 'number' || scope.end === null)
           t.equal(scope.parent.type, 'root')