Refactor code-style

*   Add more docs to JSDoc
*   Refactor a bunch of code

Author: wooorm

lib/index.js

@@ -2,7 +2,10 @@
  * @typedef {import('unist').Parent} UnistParent
  * @typedef {import('nlcst').Root} Root
  * @typedef {import('nlcst').Content} Content
- * @typedef {Root|Content} Node
+ */
+
+/**
+ * @typedef {Root | Content} Node
  * @typedef {Extract<Node, UnistParent>} Parent
  */
 
@@ -50,19 +53,25 @@ const pairs = {
 const open = Object.keys(pairs)
 
 /**
- * Check if the node in `parent` at `position` is enclosed by matching
+ * Check if the child in `parent` at `index` is enclosed by matching
  * delimiters.
  *
- * @param {Parent} parent
- * @param {number} index
+ * @template {Parent} ParentType
+ *   Parent node.
+ * @param {ParentType} parent
+ *   Parent node.
+ * @param {number | ParentType['children'][number]} index
+ *   Child node of parent or index of child in parent.
  * @returns {boolean}
+ *   Whether the child is a literal.
  */
 export function isLiteral(parent, index) {
   if (!(parent && parent.children)) {
     throw new Error('Parent must be a node')
   }
 
   if (index !== null && typeof index === 'object' && 'type' in index) {
+    // @ts-expect-error: assume child of `parent`.
     index = parent.children.indexOf(index)
 
     if (index === -1) {
@@ -86,27 +95,41 @@ export function isLiteral(parent, index) {
 /**
  * Check if the node in `parent` at `position` is enclosed by matching
  * delimiters.
+ *
  * @param {Parent} parent
+ *   Parent node.
  * @param {number} position
- * @returns {Node|void}
+ *   Position to look around.
+ * @returns {boolean}
+ *   Whether a child is wrapped.
  */
 function isWrapped(parent, position) {
   const previous = siblingDelimiter(parent, position, -1, open)
 
   if (previous) {
-    return siblingDelimiter(parent, position, 1, pairs[toString(previous)])
+    return (
+      siblingDelimiter(parent, position, 1, pairs[toString(previous)]) !==
+      undefined
+    )
   }
+
+  return false
 }
 
 /**
  * Find the previous or next delimiter before or after `position` in `parent`.
  * Returns the delimiter node when found.
  *
  * @param {Parent} parent
+ *   Parent node.
  * @param {number} position
+ *   Start position in `parent`.
  * @param {number} step
+ *   Step (`-1` to move back, `1` to move forward).
  * @param {Array<string>} delimiters
- * @returns {Node|void}
+ *   Delimiters to look for.
+ * @returns {Node | void}
+ *   Delimiter, if found.
  */
 function siblingDelimiter(parent, position, step, delimiters) {
   let index = position + step
@@ -115,7 +138,7 @@ function siblingDelimiter(parent, position, step, delimiters) {
     const sibling = parent.children[index]
 
     if (sibling.type === 'WordNode' || sibling.type === 'SourceNode') {
-      return
+      break
     }
 
     if (sibling.type !== 'WhiteSpaceNode') {
@@ -127,17 +150,24 @@ function siblingDelimiter(parent, position, step, delimiters) {
 }
 
 /**
- * Check if parent contains word-nodes between `start` and `end` (both
+ * Check if parent contains word nodes between `start` and `end` (both
  * excluding).
+ *
  * @param {Parent} parent
+ *   Parent node.
  * @param {number} start
+ *   Start index in `parent` (excluding).
  * @param {number} end
- * @returns {boolean|void}
+ *   End index in `parent` (excluding).
+ * @returns {boolean}
+ *   Whether a child contains a word.
  */
 function containsWord(parent, start, end) {
   while (++start < end) {
     if (parent.children[start].type === 'WordNode') {
       return true
     }
   }
+
+  return false
 }