Refactor code-style

Author: wooorm

index.js

@@ -65,7 +65,7 @@ export function literal(node, parent) {
 export {_void, wrap}
 
 // Construct.
-var mdast = zwitch('type', {
+const mdast = zwitch('type', {
   // Core interface.
   unknown,
   invalid: unknown,
@@ -102,7 +102,7 @@ var mdast = zwitch('type', {
   }
 })
 
-var all = mapz(mdast, {key: 'children'})
+const all = mapz(mdast, {key: 'children'})
 
 /**
  * @param {unknown} node
@@ -439,21 +439,18 @@ function footnoteReference(node) {
  * @returns {asserts node is Table}
  */
 function table(node) {
-  var index = -1
-  /** @type {Array.<unknown>} */
-  var align
-  /** @type {unknown} */
-  var value
+  let index = -1
 
   parent(node)
   indexable(node)
 
   if (node.align != null) {
     nodeAssert.ok(Array.isArray(node.align), '`align` must be `array`')
-    align = node.align // type-coverage:ignore-line
+    /** @type {Array.<unknown>} */
+    const align = node.align // type-coverage:ignore-line
 
     while (++index < align.length) {
-      value = align[index]
+      const value = align[index]
 
       if (value != null) {
         nodeAssert.notStrictEqual(

index.test-d.ts

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

package.json

@@ -71,9 +71,7 @@
     "rules": {
       "capitalized-comments": "off",
       "eqeqeq": "off",
-      "no-eq-null": "off",
-      "no-var": "off",
-      "prefer-arrow-callback": "off"
+      "no-eq-null": "off"
     }
   },
   "remarkConfig": {

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: 'paragraph', children: {alpha: 'bravo'}})
     },
     /`children` should be an array: `{ type: 'paragraph', children: { alpha: 'bravo' } }`$/,
     'should throw if given a non-node child in children'
   )
 
   t.throws(
-    function () {
+    () => {
       assert({type: 'paragraph', children: ['one']})
     },
     /node should be an object: `'one'` in `{ type: 'paragraph', children: \[ 'one' ] }`$/,
     'should throw if given a non-node child in children'
   )
 
-  t.doesNotThrow(function () {
+  t.doesNotThrow(() => {
     assert({type: 'paragraph', children: [{type: 'text', value: 'alpha'}]})
   }, 'should not throw on vald children')
 
   t.throws(
-    function () {
+    () => {
       assert({
         type: 'paragraph',
         children: [{type: 'bar', children: ['one']}]

test/code.js

@@ -1,37 +1,37 @@
 import test from 'tape'
 import {assert} from '../index.js'
 
-test('assert(code)', function (t) {
+test('assert(code)', (t) => {
   t.throws(
-    function () {
+    () => {
       assert({type: 'code'})
     },
     /literal should have `value`: `{ type: 'code' }`$/,
     'should throw if `code` is not a text'
   )
 
-  t.doesNotThrow(function () {
+  t.doesNotThrow(() => {
     assert({type: 'code', value: ''})
   }, 'should not throw if `code` has no extra properties')
 
   t.throws(
-    function () {
+    () => {
       assert({type: 'code', lang: 0, value: ''})
     },
     /`lang` must be `string`: `{ type: 'code', lang: 0, value: '' }`$/,
     'should throw if `lang` is not a string'
   )
 
   t.throws(
-    function () {
+    () => {
       assert({type: 'code', lang: 'js', meta: 1, value: ''})
     },
     /`meta` must be `string`: `{ type: 'code', lang: 'js', meta: 1, value: '' }`$/,
     'should throw if `meta` is not a string'
   )
 
   t.throws(
-    function () {
+    () => {
       assert({type: 'code', meta: '', value: ''})
     },
     /code with `meta` must also have `lang`: `{ type: 'code', meta: '', value: '' }`$/,

test/definition.js

@@ -1,53 +1,53 @@
 import test from 'tape'
 import {assert} from '../index.js'
 
-test('assert(definition)', function (t) {
+test('assert(definition)', (t) => {
   t.throws(
-    function () {
+    () => {
       assert({type: 'definition'})
     },
     /`identifier` must be `string`: `{ type: 'definition' }`$/,
     'should throw if `definition` has no `identifier`'
   )
 
   t.throws(
-    function () {
+    () => {
       assert({type: 'definition', identifier: '1'})
     },
     /`url` must be `string`: `{ type: 'definition', identifier: '1' }`$/,
     'should throw if `definition` has no `url`'
   )
 
   t.throws(
-    function () {
+    () => {
       assert({type: 'definition', identifier: 1})
     },
     /`identifier` must be `string`: `{ type: 'definition', identifier: 1 }`$/,
     'should throw if `identifier` is not a `string`'
   )
 
   t.throws(
-    function () {
+    () => {
       assert({type: 'definition', url: 1})
     },
     /`identifier` must be `string`: `{ type: 'definition', url: 1 }`$/,
     'should throw if `url` is not a `string`'
   )
 
-  t.doesNotThrow(function () {
+  t.doesNotThrow(() => {
     assert({type: 'definition', identifier: '1', url: '1'})
   }, 'should not throw if `definition` has no other properties')
 
   t.throws(
-    function () {
+    () => {
       assert({type: 'definition', identifier: '1', url: '1', title: 1})
     },
     /`title` must be `string`: `{ type: 'definition', identifier: '1', url: '1', title: 1 }`$/,
     'should throw if `title` is not a `string`'
   )
 
   t.throws(
-    function () {
+    () => {
       assert({type: 'definition', identifier: '1', url: '1', label: 1})
     },
     /`label` must be `string`: `{ type: 'definition', identifier: '1', url: '1', label: 1 }`$/,

test/footnote-definition.js

@@ -1,37 +1,37 @@
 import test from 'tape'
 import {assert} from '../index.js'
 
-test('assert(footnoteDefinition)', function (t) {
+test('assert(footnoteDefinition)', (t) => {
   t.throws(
-    function () {
+    () => {
       assert({type: 'footnoteDefinition'})
     },
     /parent should have `children`: `{ type: 'footnoteDefinition' }`$/,
     'should throw if `footnoteDefinition` is not a parent'
   )
 
   t.throws(
-    function () {
+    () => {
       assert({type: 'footnoteDefinition', children: []})
     },
     /`footnoteDefinition` must have `identifier`: `{ type: 'footnoteDefinition', children: \[] }`$/,
     'should throw if `footnoteDefinition` has no identifier'
   )
 
   t.throws(
-    function () {
+    () => {
       assert({type: 'footnoteDefinition', identifier: 1, children: []})
     },
     /`footnoteDefinition` must have `identifier`: `{ type: 'footnoteDefinition', identifier: 1, children: \[] }`$/,
     'should throw if `identifier` is not a `string`'
   )
 
-  t.doesNotThrow(function () {
+  t.doesNotThrow(() => {
     assert({type: 'footnoteDefinition', identifier: '1', children: []})
   }, 'should not throw if `footnoteDefinition` has an identifier')
 
   t.throws(
-    function () {
+    () => {
       assert({
         type: 'footnoteDefinition',
         identifier: '1',

test/footnote-reference.js

@@ -1,29 +1,29 @@
 import test from 'tape'
 import {assert} from '../index.js'
 
-test('assert(footnoteReference)', function (t) {
+test('assert(footnoteReference)', (t) => {
   t.throws(
-    function () {
+    () => {
       assert({type: 'footnoteReference'})
     },
     /`identifier` must be `string`: `{ type: 'footnoteReference' }`$/,
     'should throw if `footnoteReference` has no `identifier`'
   )
 
   t.throws(
-    function () {
+    () => {
       assert({type: 'footnoteReference', identifier: 1})
     },
     /`identifier` must be `string`: `{ type: 'footnoteReference', identifier: 1 }`$/,
     'should throw if `identifier` is not a `string`'
   )
 
-  t.doesNotThrow(function () {
+  t.doesNotThrow(() => {
     assert({type: 'footnoteReference', identifier: '1'})
   }, 'should not throw if `footnoteReference` has no other properties')
 
   t.throws(
-    function () {
+    () => {
       assert({type: 'footnoteReference', identifier: '1', label: 1})
     },
     /`label` must be `string`: `{ type: 'footnoteReference', identifier: '1', label: 1 }`$/,

test/heading.js

@@ -1,32 +1,32 @@
 import test from 'tape'
 import {assert} from '../index.js'
 
-test('assert(heading)', function (t) {
+test('assert(heading)', (t) => {
   t.throws(
-    function () {
+    () => {
       assert({type: 'heading'})
     },
     /parent should have `children`: `{ type: 'heading' }`$/,
     'should throw if a `heading` is not a parent'
   )
 
   t.throws(
-    function () {
+    () => {
       assert({type: 'heading', depth: 0, children: []})
     },
     /`depth` should be gte `1`: `{ type: 'heading', depth: 0, children: \[] }`$/,
     'should throw if `depth` is lower than 1'
   )
 
   t.throws(
-    function () {
+    () => {
       assert({type: 'heading', depth: 7, children: []})
     },
     /`depth` should be lte `6`: `{ type: 'heading', depth: 7, children: \[] }`$/,
     'should throw if `depth` is lower than 7'
   )
 
-  t.doesNotThrow(function () {
+  t.doesNotThrow(() => {
     assert({type: 'heading', depth: 1, children: []})
   }, 'should not throw if `heading` is between 0 and 7')
 

test/image-reference.js

@@ -1,44 +1,44 @@
 import test from 'tape'
 import {assert} from '../index.js'
 
-test('assert(imageReference)', function (t) {
+test('assert(imageReference)', (t) => {
   t.throws(
-    function () {
+    () => {
       assert({type: 'imageReference'})
     },
     /`identifier` must be `string`: `{ type: 'imageReference' }`$/,
     'should throw if `imageReference` has no `identifier`'
   )
 
   t.throws(
-    function () {
+    () => {
       assert({type: 'imageReference', identifier: 1})
     },
     /`identifier` must be `string`: `{ type: 'imageReference', identifier: 1 }`$/,
     'should throw if `identifier` is not a `string`'
   )
 
-  t.doesNotThrow(function () {
+  t.doesNotThrow(() => {
     assert({type: 'imageReference', identifier: '1'})
   }, 'should not throw if `imageReference` has no other properties')
 
   t.throws(
-    function () {
+    () => {
       assert({type: 'imageReference', identifier: '1', alt: 1})
     },
     /`alt` must be `string`: `{ type: 'imageReference', identifier: '1', alt: 1 }`$/,
     'should throw if `alt` is not a `string`'
   )
 
   t.throws(
-    function () {
+    () => {
       assert({type: 'imageReference', identifier: '1', referenceType: 1})
     },
     /`referenceType` must be `shortcut`, `collapsed`, or `full`: `{ type: 'imageReference', identifier: '1', referenceType: 1 }`$/,
     'should throw if `referenceType` is not a `string`'
   )
 
-  t.doesNotThrow(function () {
+  t.doesNotThrow(() => {
     assert({
       type: 'imageReference',
       identifier: '1',
@@ -47,7 +47,7 @@ test('assert(imageReference)', function (t) {
   }, 'should not throw if `referenceType` is valid')
 
   t.throws(
-    function () {
+    () => {
       assert({type: 'imageReference', identifier: '1', label: 1})
     },
     /`label` must be `string`: `{ type: 'imageReference', identifier: '1', label: 1 }`$/,