Refactor code-style

Author: wooorm

lib/index.js

@@ -9,55 +9,56 @@ import {convert} from 'unist-util-is'
 /**
  * Find the first node in `parent` after another `node` or after an index,
  * that passes `test`.
-
- * @param parent
+ *
+ * @template {Node} Kind
+ *   Node type.
+ *
+ * @overload
+ * @param {Parent} parent
+ * @param {Node | number} index
+ * @param {import('unist-util-is').PredicateTest<Kind>} test
+ * @returns {Kind | null}
+ *
+ * @overload
+ * @param {Parent} parent
+ * @param {Node | number} index
+ * @param {Test} [test]
+ * @returns {Node | null}
+ *
+ * @param {Parent} parent
  *   Parent node.
- * @param index
+ * @param {Node | number} index
  *   Child of `parent` or it’s index.
- * @param test
+ * @param {Test} [test]
  *   `unist-util-is`-compatible test.
- * @returns
+ * @returns {Node | null}
  *   Child of `parent` or `null`.
  */
-export const findAfter =
-  /**
-   * @type {(
-   *  (<T extends Node>(node: Parent, index: Node | number, test: import('unist-util-is').PredicateTest<T>) => T | null) &
-   *  ((node: Parent, index: Node | number, test?: Test) => Node | null)
-   * )}
-   */
-  (
-    /**
-     * @param {Parent} parent
-     * @param {Node | number} index
-     * @param {Test} [test]
-     * @returns {Node | null}
-     */
-    function (parent, index, test) {
-      const is = convert(test)
-
-      if (!parent || !parent.type || !parent.children) {
-        throw new Error('Expected parent node')
-      }
+// To do: next major: `undefined`.
+export function findAfter(parent, index, test) {
+  const is = convert(test)
 
-      if (typeof index === 'number') {
-        if (index < 0 || index === Number.POSITIVE_INFINITY) {
-          throw new Error('Expected positive finite number as index')
-        }
-      } else {
-        index = parent.children.indexOf(index)
+  if (!parent || !parent.type || !parent.children) {
+    throw new Error('Expected parent node')
+  }
 
-        if (index < 0) {
-          throw new Error('Expected child node or index')
-        }
-      }
+  if (typeof index === 'number') {
+    if (index < 0 || index === Number.POSITIVE_INFINITY) {
+      throw new Error('Expected positive finite number as index')
+    }
+  } else {
+    index = parent.children.indexOf(index)
 
-      while (++index < parent.children.length) {
-        if (is(parent.children[index], index, parent)) {
-          return parent.children[index]
-        }
-      }
+    if (index < 0) {
+      throw new Error('Expected child node or index')
+    }
+  }
 
-      return null
+  while (++index < parent.children.length) {
+    if (is(parent.children[index], index, parent)) {
+      return parent.children[index]
     }
-  )
+  }
+
+  return null
+}