Update dev-dependencies

Author: wooorm

.prettierignore

@@ -1,3 +1,5 @@
 coverage/
 unist-util-assert.js
 unist-util-assert.min.js
+*.json
+*.md

package.json

@@ -35,15 +35,15 @@
     "browserify": "^16.0.0",
     "dtslint": "^3.0.0",
     "nyc": "^15.0.0",
-    "prettier": "^1.0.0",
-    "remark-cli": "^7.0.0",
-    "remark-preset-wooorm": "^6.0.0",
-    "tape": "^4.0.0",
+    "prettier": "^2.0.0",
+    "remark-cli": "^8.0.0",
+    "remark-preset-wooorm": "^7.0.0",
+    "tape": "^5.0.0",
     "tinyify": "^2.0.0",
-    "xo": "^0.26.0"
+    "xo": "^0.32.0"
   },
   "scripts": {
-    "format": "remark . -qfo && prettier --write \"**/*.js\" && xo --fix",
+    "format": "remark . -qfo && prettier . --write && xo --fix",
     "build-bundle": "browserify . -s unistUtilAssert > unist-util-assert.js",
     "build-mangle": "browserify . -s unistUtilAssert -p tinyify > unist-util-assert.min.js",
     "build": "npm run build-bundle && npm run build-mangle",
@@ -64,10 +64,13 @@
     "prettier": true,
     "esnext": false,
     "rules": {
+      "unicorn/prefer-optional-catch-binding": "off",
+      "unicorn/prefer-set-has": "off",
       "no-eq-null": "off",
       "eqeqeq": "off"
     },
     "ignores": [
+      "types/",
       "unist-util-assert.js"
     ]
   },

test/children.js

@@ -3,29 +3,29 @@
 var test = require('tape')
 var assert = require('..')
 
-test('children', function(t) {
+test('children', function (t) {
   t.throws(
-    function() {
+    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() {
+    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(function () {
     assert({type: 'parent', children: [{type: 'text', value: 'alpha'}]})
   }, 'should not throw on vald children')
 
   t.throws(
-    function() {
+    function () {
       assert({
         type: 'foo',
         children: [

test/node.js

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

test/non-defined.js

@@ -3,8 +3,8 @@
 var test = require('tape')
 var assert = require('..')
 
-test('non-defined', function(t) {
-  t.doesNotThrow(function() {
+test('non-defined', function (t) {
+  t.doesNotThrow(function () {
     assert({
       type: 'element',
       properties: {
@@ -20,7 +20,7 @@ test('non-defined', function(t) {
   }, 'should not throw if non-defined properties are found')
 
   t.throws(
-    function() {
+    function () {
       assert({
         type: 'break',
         data: {foo: Function}

test/parent.js

@@ -3,32 +3,32 @@
 var test = require('tape')
 var assert = require('..')
 
-test('assert.parent()', function(t) {
+test('assert.parent()', function (t) {
   t.throws(
-    function() {
+    function () {
       assert.parent({})
     },
     /node should have a type: `{}`$/,
     'should throw the same errors as `assert()`'
   )
 
   t.throws(
-    function() {
+    function () {
       assert.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() {
+    function () {
       assert.parent({type: 'break'})
     },
     /parent should have `children`: `{ type: 'break' }`$/,
     'should throw if the given node has `children`'
   )
 
-  t.doesNotThrow(function() {
+  t.doesNotThrow(function () {
     assert.parent({type: 'strong', children: []})
   }, 'should not throw on valid void nodes')
 

test/position.js

@@ -3,97 +3,97 @@
 var test = require('tape')
 var assert = require('..')
 
-test('position', function(t) {
+test('position', function (t) {
   t.throws(
-    function() {
+    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(function () {
     assert({type: 'foo', position: null})
   }, 'should not throw if given a null `position`')
 
-  t.doesNotThrow(function() {
+  t.doesNotThrow(function () {
     assert({type: 'foo', position: {}})
   }, 'should not throw if given an empty `position` object')
 
   t.throws(
-    function() {
+    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(function () {
     assert({type: 'foo', position: {start: null}})
   }, 'should not throw if given a null `position.start`')
 
-  t.doesNotThrow(function() {
+  t.doesNotThrow(function () {
     assert({type: 'foo', position: {start: {}}})
   }, 'should not throw if given an empty `position.start` object')
 
   t.throws(
-    function() {
+    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(function () {
     assert({type: 'foo', position: {end: null}})
   }, 'should not throw if given a null `position.end`')
 
-  t.doesNotThrow(function() {
+  t.doesNotThrow(function () {
     assert({type: 'foo', position: {end: {}}})
   }, 'should not throw if given an empty `position.end` object')
 
-  t.doesNotThrow(function() {
+  t.doesNotThrow(function () {
     assert({type: 'foo', position: {start: {line: null}}})
   }, 'should not throw if given a `position.start.line` to `null`')
 
-  t.doesNotThrow(function() {
+  t.doesNotThrow(function () {
     assert({type: 'foo', position: {start: {column: null}}})
   }, 'should not throw if given a `position.start.column` to `null`')
 
-  t.doesNotThrow(function() {
+  t.doesNotThrow(function () {
     assert({type: 'foo', position: {end: {line: null}}})
   }, 'should not throw if given a `position.end.line` to `null`')
 
-  t.doesNotThrow(function() {
+  t.doesNotThrow(function () {
     assert({type: 'foo', position: {end: {column: null}}})
   }, 'should not throw if given a `position.end.column` to `null`')
 
   t.throws(
-    function() {
+    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() {
+    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() {
+    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() {
+    function () {
       assert({type: 'foo', position: {end: {column: 0}}})
     },
     /`position.end.column` should be gte `1`: `{ type: 'foo', position: { end: { column: 0 } } }`$/,

test/text.js

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

test/type.js

@@ -3,40 +3,40 @@
 var test = require('tape')
 var assert = require('..')
 
-test('type', function(t) {
+test('type', function (t) {
   t.throws(
-    function() {
+    function () {
       assert([1, 5])
     },
     /node should have a type: `\[ 1, 5 ]`$/,
     'should throw if not given a `type` (#1)'
   )
 
   t.throws(
-    function() {
+    function () {
       assert({value: 'foo'})
     },
     /node should have a type: `{ value: 'foo' }`$/,
     'should throw if not given a type (#2)'
   )
 
   t.throws(
-    function() {
+    function () {
       assert({type: 1})
     },
     /`type` should be a string: `{ type: 1 }`$/,
     'should throw if not given a non-string type'
   )
 
   t.throws(
-    function() {
+    function () {
       assert({type: ''})
     },
     /`type` should not be empty: `{ type: '' }`$/,
     'should throw if given an empty string type'
   )
 
-  t.doesNotThrow(function() {
+  t.doesNotThrow(function () {
     assert({type: 'foo'})
   }, 'should not throw if given a non-empty type string')