Refactor code-style

Author: wooorm

index.js

@@ -8,10 +8,10 @@
  * @typedef {Node & {children: never, value: never}} _Void
  */
 
-import nodeAssert from 'assert'
+import nodeAssert from 'node:assert'
 import {inspect} from './inspect.js'
 
-var own = {}.hasOwnProperty
+const own = {}.hasOwnProperty
 
 /**
  * Assert that `node` is a valid unist node.
@@ -60,10 +60,10 @@ export function _void(node, parent) {
 }
 
 // Identifier to check if a value is seen.
-var ID = '__unist__'
+const ID = '__unist__'
 
 // List of specced properties.
-var defined = new Set(['type', 'value', 'children', 'position'])
+const defined = new Set(['type', 'value', 'children', 'position'])
 
 /**
  * Wrapper that adds the current node (and parent, if available) to error
@@ -103,13 +103,7 @@ export function wrap(fn) {
  * @returns {asserts node is Node}
  */
 function assertNode(node) {
-  var index = -1
-  /** @type {Parent} */
-  var parent
-  /** @type {unknown} */
-  var child
-  /** @type {string} */
-  var key
+  let index = -1
 
   nodeAssert.ok(
     node && typeof node === 'object' && !Array.isArray(node),
@@ -139,6 +133,9 @@ function assertNode(node) {
   // @ts-expect-error Looks like an indexed object.
   position(node.position)
 
+  /** @type {string} */
+  let key
+
   for (key in node) {
     if (!defined.has(key)) {
       vanilla(key, node[key])
@@ -147,17 +144,17 @@ function assertNode(node) {
 
   // @ts-expect-error Looks like an indexed object.
   if (node.children !== null && node.children !== undefined) {
+    /** @type {Parent} */
     // @ts-expect-error Looks like parent.
-    parent = node
+    const parent = node
     nodeAssert.ok(
       Array.isArray(parent.children),
       '`children` should be an array'
     )
     index = -1
 
     while (++index < parent.children.length) {
-      child = parent.children[index]
-      assert(child, parent)
+      assert(parent.children[index], parent)
     }
   }
 }

index.test-d.ts

@@ -2,9 +2,9 @@ import {expectType, expectNotType} from 'tsd'
 import {Node, Parent} from 'unist'
 import {assert, parent} from './index.js'
 
-var emptyNode = {type: 'a'}
-var literalNode = {type: 'b', value: 'c'}
-var parentNode = {type: 'd', children: [emptyNode, literalNode]}
+const emptyNode = {type: 'a'}
+const literalNode = {type: 'b', value: 'c'}
+const parentNode = {type: 'd', children: [emptyNode, literalNode]}
 
 expectNotType<Node>(emptyNode)
 expectNotType<Node>(literalNode)

inspect.js

@@ -1,4 +1,4 @@
-import {inspect as utilInspect} from 'util'
+import {inspect as utilInspect} from 'node:util'
 
 /**
  * @param {unknown} value

package.json

@@ -73,12 +73,7 @@
     "trailingComma": "none"
   },
   "xo": {
-    "prettier": true,
-    "rules": {
-      "no-var": "off",
-      "prefer-arrow-callback": "off",
-      "unicorn/prefer-node-protocol": "off"
-    }
+    "prettier": true
   },
   "remarkConfig": {
     "plugins": [

test/children.js

@@ -1,29 +1,29 @@
 import test from 'tape'
 import {assert} from '../index.js'
 
-test('children', function (t) {
+test('children', (t) => {
   t.throws(
-    function () {
+    () => {
       assert({type: 'foo', children: {alpha: 'bravo'}})
     },
     /`children` should be an array: `{ type: 'foo', children: { alpha: 'bravo' } }`$/,
     'should throw if given a non-node child in children'
   )
 
   t.throws(
-    function () {
+    () => {
       assert({type: 'foo', children: ['one']})
     },
     /node should be an object: `'one'` in `{ type: 'foo', children: \[ 'one' ] }`$/,
     'should throw if given a non-node child in children'
   )
 
-  t.doesNotThrow(function () {
+  t.doesNotThrow(() => {
     assert({type: 'parent', children: [{type: 'text', value: 'alpha'}]})
   }, 'should not throw on vald children')
 
   t.throws(
-    function () {
+    () => {
       assert({
         type: 'foo',
         children: [

test/literal.js

@@ -1,32 +1,32 @@
 import test from 'tape'
 import {literal} from '../index.js'
 
-test('literal()', function (t) {
+test('literal()', (t) => {
   t.throws(
-    function () {
+    () => {
       literal({})
     },
     /node should have a type: `{}`$/,
     'should throw the same errors as `assert()`'
   )
 
   t.throws(
-    function () {
+    () => {
       literal({type: 'strong', children: []})
     },
     /literal should not have `children`: `{ type: 'strong', children: \[] }`$/,
     'should throw if the given node has `children`'
   )
 
   t.throws(
-    function () {
+    () => {
       literal({type: 'break'})
     },
     /literal should have `value`: `{ type: 'break' }`$/,
     'should throw if the given node has no `value`'
   )
 
-  t.doesNotThrow(function () {
+  t.doesNotThrow(() => {
     literal({type: 'text', value: 'foo'})
   }, 'should not throw on valid text nodes')
 

test/node.js

@@ -1,33 +1,33 @@
 import test from 'tape'
 import {assert} from '../index.js'
 
-test('node', function (t) {
+test('node', (t) => {
   t.throws(
-    function () {
+    () => {
       assert()
     },
     /node should be an object: `undefined`$/,
     'should throw if not given a node (#1)'
   )
 
   t.throws(
-    function () {
+    () => {
       assert(null)
     },
     /node should be an object: `null`$/,
     'should throw if not given a node (#2)'
   )
 
   t.throws(
-    function () {
+    () => {
       assert('foo')
     },
     /node should be an object: `'foo'`$/,
     'should throw if given a non-node (#1)'
   )
 
   t.throws(
-    function () {
+    () => {
       assert(6)
     },
     /node should be an object: `6`$/,

test/non-defined.js

@@ -1,8 +1,8 @@
 import test from 'tape'
 import {assert} from '../index.js'
 
-test('non-defined', function (t) {
-  t.doesNotThrow(function () {
+test('non-defined', (t) => {
+  t.doesNotThrow(() => {
     assert({
       type: 'element',
       properties: {
@@ -18,7 +18,7 @@ test('non-defined', function (t) {
   }, 'should not throw if non-defined properties are found')
 
   t.throws(
-    function () {
+    () => {
       assert({
         type: 'break',
         data: {foo: Function}

test/parent.js

@@ -1,32 +1,32 @@
 import test from 'tape'
 import {parent} from '../index.js'
 
-test('parent()', function (t) {
+test('parent()', (t) => {
   t.throws(
-    function () {
+    () => {
       parent({})
     },
     /node should have a type: `{}`$/,
     'should throw the same errors as `assert()`'
   )
 
   t.throws(
-    function () {
+    () => {
       parent({type: 'text', value: 'foo'})
     },
     /parent should not have `value`: `{ type: 'text', value: 'foo' }`$/,
     'should throw if the given node has a `value`'
   )
 
   t.throws(
-    function () {
+    () => {
       parent({type: 'break'})
     },
     /parent should have `children`: `{ type: 'break' }`$/,
     'should throw if the given node has `children`'
   )
 
-  t.doesNotThrow(function () {
+  t.doesNotThrow(() => {
     parent({type: 'strong', children: []})
   }, 'should not throw on valid void nodes')
 

test/position.js

@@ -1,97 +1,97 @@
 import test from 'tape'
 import {assert} from '../index.js'
 
-test('position', function (t) {
+test('position', (t) => {
   t.throws(
-    function () {
+    () => {
       assert({type: 'foo', position: 1})
     },
     /`position` should be an object: `{ type: 'foo', position: 1 }`$/,
     'should throw if given a non-object `position`'
   )
 
-  t.doesNotThrow(function () {
+  t.doesNotThrow(() => {
     assert({type: 'foo', position: null})
   }, 'should not throw if given a null `position`')
 
-  t.doesNotThrow(function () {
+  t.doesNotThrow(() => {
     assert({type: 'foo', position: {}})
   }, 'should not throw if given an empty `position` object')
 
   t.throws(
-    function () {
+    () => {
       assert({type: 'foo', position: {start: 1}})
     },
     /`position.start` should be an object: `{ type: 'foo', position: { start: 1 } }`$/,
     'should throw if given a non-object `position.start`'
   )
 
-  t.doesNotThrow(function () {
+  t.doesNotThrow(() => {
     assert({type: 'foo', position: {start: null}})
   }, 'should not throw if given a null `position.start`')
 
-  t.doesNotThrow(function () {
+  t.doesNotThrow(() => {
     assert({type: 'foo', position: {start: {}}})
   }, 'should not throw if given an empty `position.start` object')
 
   t.throws(
-    function () {
+    () => {
       assert({type: 'foo', position: {end: 1}})
     },
     /`position.end` should be an object: `{ type: 'foo', position: { end: 1 } }`$/,
     'should throw if given a non-object `position.end`'
   )
 
-  t.doesNotThrow(function () {
+  t.doesNotThrow(() => {
     assert({type: 'foo', position: {end: null}})
   }, 'should not throw if given a null `position.end`')
 
-  t.doesNotThrow(function () {
+  t.doesNotThrow(() => {
     assert({type: 'foo', position: {end: {}}})
   }, 'should not throw if given an empty `position.end` object')
 
-  t.doesNotThrow(function () {
+  t.doesNotThrow(() => {
     assert({type: 'foo', position: {start: {line: null}}})
   }, 'should not throw if given a `position.start.line` to `null`')
 
-  t.doesNotThrow(function () {
+  t.doesNotThrow(() => {
     assert({type: 'foo', position: {start: {column: null}}})
   }, 'should not throw if given a `position.start.column` to `null`')
 
-  t.doesNotThrow(function () {
+  t.doesNotThrow(() => {
     assert({type: 'foo', position: {end: {line: null}}})
   }, 'should not throw if given a `position.end.line` to `null`')
 
-  t.doesNotThrow(function () {
+  t.doesNotThrow(() => {
     assert({type: 'foo', position: {end: {column: null}}})
   }, 'should not throw if given a `position.end.column` to `null`')
 
   t.throws(
-    function () {
+    () => {
       assert({type: 'foo', position: {start: {line: 0}}})
     },
     /`position.start.line` should be gte `1`: `{ type: 'foo', position: { start: { line: 0 } } }`$/,
     'should throw if `position.start.line` is less than 1'
   )
 
   t.throws(
-    function () {
+    () => {
       assert({type: 'foo', position: {start: {column: 0}}})
     },
     /`position.start.column` should be gte `1`: `{ type: 'foo', position: { start: { column: 0 } } }`$/,
     'should throw if `position.start.column` is less than 1'
   )
 
   t.throws(
-    function () {
+    () => {
       assert({type: 'foo', position: {end: {line: 0}}})
     },
     /`position.end.line` should be gte `1`: `{ type: 'foo', position: { end: { line: 0 } } }`$/,
     'should throw if `position.end.line` is less than 1'
   )
 
   t.throws(
-    function () {
+    () => {
       assert({type: 'foo', position: {end: {column: 0}}})
     },
     /`position.end.column` should be gte `1`: `{ type: 'foo', position: { end: { column: 0 } } }`$/,