Use ESM

Author: wooorm

.gitignore

@@ -1,8 +1,5 @@
 .DS_Store
 *.log
-.nyc_output/
 coverage/
 node_modules/
-unist-util-is.js
-unist-util-is.min.js
 yarn.lock

.prettierignore

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

convert.d.ts

@@ -2,48 +2,46 @@
 
 import {Node, Parent} from 'unist'
 
-declare namespace unistUtilIs {
-  /**
-   * Check that type property matches expectation for a node
-   *
-   * @typeParam T type of node that passes test
-   */
-  type TestType<T extends Node> = T['type']
+/**
+ * Check that type property matches expectation for a node
+ *
+ * @typeParam T type of node that passes test
+ */
+export type TestType<T extends Node> = T['type']
 
-  /**
-   * Check that some attributes on a node are matched
-   *
-   * @typeParam T type of node that passes test
-   */
-  type TestObject<T extends Node> = Partial<T>
+/**
+ * Check that some attributes on a node are matched
+ *
+ * @typeParam T type of node that passes test
+ */
+export type TestObject<T extends Node> = Partial<T>
 
-  /**
-   * Check if a node passes a test
-   *
-   * @param node node to check
-   * @param index index of node in parent
-   * @param parent parent of node
-   * @typeParam T type of node that passes test
-   * @returns true if type T is found, false otherwise
-   */
-  type TestFunction<T extends Node> = (
-    node: unknown,
-    index?: number,
-    parent?: Parent
-  ) => node is T
+/**
+ * Check if a node passes a test
+ *
+ * @param node node to check
+ * @param index index of node in parent
+ * @param parent parent of node
+ * @typeParam T type of node that passes test
+ * @returns true if type T is found, false otherwise
+ */
+export type TestFunction<T extends Node> = (
+  node: unknown,
+  index?: number,
+  parent?: Parent
+) => node is T
 
-  /**
-   * Union of all the types of tests
-   *
-   * @typeParam T type of node that passes test
-   */
-  type Test<T extends Node> =
-    | TestType<T>
-    | TestObject<T>
-    | TestFunction<T>
-    | null
-    | undefined
-}
+/**
+ * Union of all the types of tests
+ *
+ * @typeParam T type of node that passes test
+ */
+export type Test<T extends Node> =
+  | TestType<T>
+  | TestObject<T>
+  | TestFunction<T>
+  | null
+  | undefined
 
 /**
  * Unist utility to check if a node passes a test.
@@ -60,12 +58,12 @@ declare namespace unistUtilIs {
  * @typeParam T type that node is compared with
  * @returns Whether test passed and `node` is a `Node` (object with `type` set to non-empty `string`).
  */
-declare function unistUtilIs<T extends Node>(
+export declare function is<T extends Node>(
   node: unknown,
-  test?: unistUtilIs.Test<T> | Array<unistUtilIs.Test<any>>,
+  test?: Test<T> | Array<Test<any>>,
   index?: number,
   parent?: Parent,
   context?: any
 ): node is T
 
-export = unistUtilIs
+export declare function convert<T extends Node>(test: Test<T>): TestFunction<T>

convert.js

@@ -1,32 +1,109 @@
-'use strict'
-
-var convert = require('./convert')
-
-module.exports = is
-
-is.convert = convert
-
 // Assert if `test` passes for `node`.
 // When a `parent` node is known the `index` of node should also be given.
-function is(node, test, index, parent, context) {
+// eslint-disable-next-line max-params
+export function is(node, test, index, parent, context) {
   var check = convert(test)
 
   if (
-    index != null &&
-    (typeof index !== 'number' || index < 0 || index === Infinity)
+    index !== undefined &&
+    index !== null &&
+    (typeof index !== 'number' ||
+      index < 0 ||
+      index === Number.POSITIVE_INFINITY)
   ) {
     throw new Error('Expected positive finite index')
   }
 
-  if (parent != null && (!is(parent) || !parent.children)) {
+  if (
+    parent !== undefined &&
+    parent !== null &&
+    (!is(parent) || !parent.children)
+  ) {
     throw new Error('Expected parent node')
   }
 
-  if ((parent == null) !== (index == null)) {
+  if (
+    (parent === undefined || parent === null) !==
+    (index === undefined || index === null)
+  ) {
     throw new Error('Expected both parent and index')
   }
 
   return node && node.type && typeof node.type === 'string'
     ? Boolean(check.call(context, node, index, parent))
     : false
 }
+
+export function convert(test) {
+  if (test === undefined || test === null) {
+    return ok
+  }
+
+  if (typeof test === 'string') {
+    return typeFactory(test)
+  }
+
+  if (typeof test === 'object') {
+    return 'length' in test ? anyFactory(test) : allFactory(test)
+  }
+
+  if (typeof test === 'function') {
+    return test
+  }
+
+  throw new Error('Expected function, string, or object as test')
+}
+
+// Utility to assert each property in `test` is represented in `node`, and each
+// values are strictly equal.
+function allFactory(test) {
+  return all
+
+  function all(node) {
+    var key
+
+    for (key in test) {
+      if (node[key] !== test[key]) return false
+    }
+
+    return true
+  }
+}
+
+function anyFactory(tests) {
+  var checks = []
+  var index = -1
+
+  while (++index < tests.length) {
+    checks[index] = convert(tests[index])
+  }
+
+  return any
+
+  function any(...parameters) {
+    var index = -1
+
+    while (++index < checks.length) {
+      if (checks[index].call(this, ...parameters)) {
+        return true
+      }
+    }
+
+    return false
+  }
+}
+
+// Utility to convert a string into a function which checks a given node’s type
+// for said string.
+function typeFactory(test) {
+  return type
+
+  function type(node) {
+    return Boolean(node && node.type === test)
+  }
+}
+
+// Utility to return true.
+function ok() {
+  return true
+}