Refactor code-style

Author: wooorm

index.js

@@ -15,9 +15,9 @@
 import {convert} from 'unist-util-is'
 
 /** @type {Array.<Node>} */
-var empty = []
+const empty = []
 
-export var remove =
+export const remove =
   /**
    * @type {(
    *  (<T extends Node>(node: T, options: RemoveOptions, test: Type|Props|TestFunctionAnything|Array<Type|Props|TestFunctionAnything>) => T|null) &
@@ -35,8 +35,8 @@ export var remove =
      * @returns {Node|null}
      */
     function (tree, options, test) {
-      var is = convert(test || options)
-      var cascade =
+      const is = convert(test || options)
+      const cascade =
         options.cascade === undefined || options.cascade === null
           ? true
           : options.cascade
@@ -55,9 +55,9 @@ export var remove =
       function preorder(node, index, parent) {
         /** @type {Array.<Node>} */
         // @ts-ignore looks like a parent.
-        var children = node.children || empty
-        var childIndex = -1
-        var position = 0
+        const children = node.children || empty
+        let childIndex = -1
+        let position = 0
 
         if (is(node, index, parent)) {
           return null

package.json

@@ -72,12 +72,7 @@
     "trailingComma": "none"
   },
   "xo": {
-    "prettier": true,
-    "rules": {
-      "import/no-mutable-exports": "off",
-      "no-var": "off",
-      "prefer-arrow-callback": "off"
-    }
+    "prettier": true
   },
   "remarkConfig": {
     "plugins": [

readme.md

@@ -28,7 +28,7 @@ npm install unist-util-remove
 import {u} from 'unist-builder'
 import {remove} from 'unist-util-remove'
 
-var tree = u('root', [
+const tree = u('root', [
   u('leaf', '1'),
   u('node', [
     u('leaf', '2'),

test.js

@@ -12,12 +12,12 @@ import test from 'tape'
 import {u} from 'unist-builder'
 import {remove} from './index.js'
 
-test('should compare nodes by partial properties', function (t) {
-  var tree = u('node', [u('leaf', '1'), u('leaf', '2')])
-  var children = tree.children
-  var first = tree.children[0]
+test('should compare nodes by partial properties', (t) => {
+  const tree = u('node', [u('leaf', '1'), u('leaf', '2')])
+  const children = tree.children
+  const first = tree.children[0]
 
-  var next = remove(tree, {value: '2'})
+  const next = remove(tree, {value: '2'})
 
   t.equal(next, tree)
   t.deepEqual(tree, u('node', [first]))
@@ -27,13 +27,13 @@ test('should compare nodes by partial properties', function (t) {
   t.end()
 })
 
-test('should remove nodes with children', function (t) {
-  var tree = u('root', [u('node', [u('leaf', '1')]), u('leaf', '2')])
-  var children = tree.children
-  var first = tree.children[0]
-  var last = tree.children[1]
+test('should remove nodes with children', (t) => {
+  const tree = u('root', [u('node', [u('leaf', '1')]), u('leaf', '2')])
+  const children = tree.children
+  const first = tree.children[0]
+  const last = tree.children[1]
 
-  var next = remove(tree, test)
+  const next = remove(tree, test)
 
   t.equal(next, tree)
   t.deepEqual(tree, u('root', [last]))
@@ -51,22 +51,22 @@ test('should remove nodes with children', function (t) {
   }
 })
 
-test('should return `null` if root node is removed', function (t) {
-  var tree = u('root', [u('node', [u('leaf', '1')]), u('leaf', '2')])
+test('should return `null` if root node is removed', (t) => {
+  const tree = u('root', [u('node', [u('leaf', '1')]), u('leaf', '2')])
 
   t.equal(remove(tree, 'root'), null)
 
   t.end()
 })
 
-test('should cascade-remove parent nodes', function (t) {
-  var tree = u('root', [u('node', [u('leaf', '1')]), u('leaf', '2')])
-  var children = tree.children
+test('should cascade-remove parent nodes', (t) => {
+  const tree = u('root', [u('node', [u('leaf', '1')]), u('leaf', '2')])
+  const children = tree.children
   // @ts-ignore it exists!
-  var first = children[0].children[0]
-  var last = children[1]
+  const first = children[0].children[0]
+  const last = children[1]
 
-  var next = remove(tree, test)
+  const next = remove(tree, test)
 
   t.equal(next, tree)
   t.deepEqual(tree, u('root', [last]))
@@ -84,18 +84,18 @@ test('should cascade-remove parent nodes', function (t) {
   }
 })
 
-test('should cascade-remove root nodes', function (t) {
-  var tree = u('root', [u('node', [u('leaf', '1')]), u('leaf', '2')])
+test('should cascade-remove root nodes', (t) => {
+  const tree = u('root', [u('node', [u('leaf', '1')]), u('leaf', '2')])
 
-  var next = remove(tree, 'leaf')
+  const next = remove(tree, 'leaf')
 
   t.equal(next, null)
 
   t.end()
 })
 
-test('should not cascade-remove nodes that were empty initially', function (t) {
-  var tree = u('node', [u('node', []), u('node', [u('leaf')])])
+test('should not cascade-remove nodes that were empty initially', (t) => {
+  const tree = u('node', [u('node', []), u('node', [u('leaf')])])
 
   remove(tree, 'leaf')
 
@@ -104,8 +104,8 @@ test('should not cascade-remove nodes that were empty initially', function (t) {
   t.end()
 })
 
-test('should support type tests', function (t) {
-  var tree = u('node', [u('node', [u('leaf', '1')]), u('leaf', '2')])
+test('should support type tests', (t) => {
+  const tree = u('node', [u('node', [u('leaf', '1')]), u('leaf', '2')])
 
   remove(tree, {cascade: false}, 'leaf')
 
@@ -114,8 +114,8 @@ test('should support type tests', function (t) {
   t.end()
 })
 
-test('should support function tests', function (t) {
-  var tree = u('node', [u('node', [u('leaf', '1')]), u('leaf', '2')])
+test('should support function tests', (t) => {
+  const tree = u('node', [u('node', [u('leaf', '1')]), u('leaf', '2')])
 
   remove(tree, {cascade: false}, test)
 
@@ -132,24 +132,24 @@ test('should support function tests', function (t) {
   }
 })
 
-test('opts.cascade = true', function (t) {
-  var tree = u('root', [u('node', [u('leaf', '1')]), u('leaf', '2')])
+test('opts.cascade = true', (t) => {
+  const tree = u('root', [u('node', [u('leaf', '1')]), u('leaf', '2')])
 
-  var next = remove(tree, {cascade: true}, 'leaf')
+  const next = remove(tree, {cascade: true}, 'leaf')
 
   t.equal(next, null)
 
   t.end()
 })
 
-test('opts.cascade = false', function (t) {
-  var tree = u('root', [u('node', [u('leaf', '1')]), u('leaf', '2')])
-  var siblings = tree.children
-  var node = siblings[0]
+test('opts.cascade = false', (t) => {
+  const tree = u('root', [u('node', [u('leaf', '1')]), u('leaf', '2')])
+  const siblings = tree.children
+  const node = siblings[0]
   // @ts-ignore it exists!
-  var children = node.children
+  const children = node.children
 
-  var next = remove(tree, {cascade: false}, 'leaf')
+  const next = remove(tree, {cascade: false}, 'leaf')
 
   t.equal(next, tree)
   t.deepEqual(tree, u('root', [u('node', [])]))
@@ -161,8 +161,8 @@ test('opts.cascade = false', function (t) {
   t.end()
 })
 
-test('example from readme', function (t) {
-  var tree = u('root', [
+test('example from readme', (t) => {
+  const tree = u('root', [
     u('leaf', '1'),
     u('node', [
       u('leaf', '2'),