eslint-plugin-jsdoc 39.3.6 → 39.3.13

package/dist/jsdocUtils.js

@@ -4,30 +4,24 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-
 var _WarnSettings = _interopRequireDefault(require("./WarnSettings"));
-
 var _getDefaultTagStructureForMode = _interopRequireDefault(require("./getDefaultTagStructureForMode"));
-
 var _tagNames = require("./tagNames");
-
 var _hasReturnValue = require("./utils/hasReturnValue");
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 /* eslint-disable jsdoc/no-undefined-types */
 
 /**
  * @typedef {"jsdoc"|"typescript"|"closure"} ParserMode
  */
-let tagStructure;
 
+let tagStructure;
 const setTagStructure = mode => {
   tagStructure = (0, _getDefaultTagStructureForMode.default)(mode);
-}; // Given a nested array of property names, reduce them to a single array,
-// appending the name of the root element along the way if present.
-
+};
 
+// Given a nested array of property names, reduce them to a single array,
+// appending the name of the root element along the way if present.
 const flattenRoots = (params, root = '') => {
   let hasRestElement = false;
   let hasPropertyRest = false;
@@ -35,36 +29,28 @@ const flattenRoots = (params, root = '') => {
   const names = params.reduce((acc, cur) => {
     if (Array.isArray(cur)) {
       let nms;
-
       if (Array.isArray(cur[1])) {
         nms = cur[1];
       } else {
         if (cur[1].hasRestElement) {
           hasRestElement = true;
         }
-
         if (cur[1].hasPropertyRest) {
           hasPropertyRest = true;
         }
-
         nms = cur[1].names;
       }
-
       const flattened = flattenRoots(nms, root ? `${root}.${cur[0]}` : cur[0]);
-
       if (flattened.hasRestElement) {
         hasRestElement = true;
       }
-
       if (flattened.hasPropertyRest) {
         hasPropertyRest = true;
       }
-
       const inner = [root ? `${root}.${cur[0]}` : cur[0], ...flattened.names].filter(Boolean);
       rests.push(false, ...flattened.rests);
       return acc.concat(inner);
     }
-
     if (typeof cur === 'object') {
       if (cur.isRestProperty) {
         hasPropertyRest = true;
@@ -72,17 +58,14 @@ const flattenRoots = (params, root = '') => {
       } else {
         rests.push(false);
       }
-
       if (cur.restElement) {
         hasRestElement = true;
       }
-
       acc.push(root ? `${root}.${cur.name}` : cur.name);
     } else if (typeof cur !== 'undefined') {
       rests.push(false);
       acc.push(root ? `${root}.${cur}` : cur);
     }
-
     return acc;
   }, []);
   return {
@@ -92,79 +75,65 @@ const flattenRoots = (params, root = '') => {
     rests
   };
 };
+
 /**
  * @param {object} propSignature
  * @returns {undefined|Array|string}
  */
-
-
 const getPropertiesFromPropertySignature = propSignature => {
   if (propSignature.type === 'TSIndexSignature' || propSignature.type === 'TSConstructSignatureDeclaration' || propSignature.type === 'TSCallSignatureDeclaration') {
     return undefined;
   }
-
   if (propSignature.typeAnnotation && propSignature.typeAnnotation.typeAnnotation.type === 'TSTypeLiteral') {
     return [propSignature.key.name, propSignature.typeAnnotation.typeAnnotation.members.map(member => {
       return getPropertiesFromPropertySignature(member);
     })];
   }
-
   return propSignature.key.name;
 };
+
 /**
  * @param {object} functionNode
  * @param {boolean} checkDefaultObjects
  * @returns {Array}
  */
-
-
 const getFunctionParameterNames = (functionNode, checkDefaultObjects) => {
   var _functionNode$value;
-
   // eslint-disable-next-line complexity
   const getParamName = (param, isProperty) => {
     var _param$left, _param$left3;
-
     const hasLeftTypeAnnotation = 'left' in param && 'typeAnnotation' in param.left;
-
     if ('typeAnnotation' in param || hasLeftTypeAnnotation) {
       const typeAnnotation = hasLeftTypeAnnotation ? param.left.typeAnnotation : param.typeAnnotation;
-
       if (typeAnnotation.typeAnnotation.type === 'TSTypeLiteral') {
         const propertyNames = typeAnnotation.typeAnnotation.members.map(member => {
           return getPropertiesFromPropertySignature(member);
         });
-        const flattened = { ...flattenRoots(propertyNames),
+        const flattened = {
+          ...flattenRoots(propertyNames),
           annotationParamName: param.name
         };
         const hasLeftName = 'left' in param && 'name' in param.left;
-
         if ('name' in param || hasLeftName) {
           return [hasLeftName ? param.left.name : param.name, flattened];
         }
-
         return [undefined, flattened];
       }
     }
-
     if ('name' in param) {
       return param.name;
     }
-
     if ('left' in param && 'name' in param.left) {
       return param.left.name;
     }
-
     if (param.type === 'ObjectPattern' || ((_param$left = param.left) === null || _param$left === void 0 ? void 0 : _param$left.type) === 'ObjectPattern') {
       var _param$left2;
-
       const properties = param.properties || ((_param$left2 = param.left) === null || _param$left2 === void 0 ? void 0 : _param$left2.properties);
       const roots = properties.map(prop => {
         return getParamName(prop, true);
       });
       return [undefined, flattenRoots(roots)];
     }
-
     if (param.type === 'Property') {
       // eslint-disable-next-line default-case
       switch (param.value.type) {
@@ -175,12 +144,10 @@ const getFunctionParameterNames = (functionNode, checkDefaultObjects) => {
               restElement: prop.type === 'RestElement'
             };
           })];
-
         case 'ObjectPattern':
           return [param.key.name, param.value.properties.map(prop => {
             return getParamName(prop, isProperty);
           })];
-
         case 'AssignmentPattern':
           {
             // eslint-disable-next-line default-case
@@ -192,14 +159,11 @@ const getFunctionParameterNames = (functionNode, checkDefaultObjects) => {
                     return getParamName(prop, isProperty);
                   })];
                 }
-
                 break;
-
               case 'ObjectPattern':
                 return [param.key.name, param.value.left.properties.map(prop => {
                   return getParamName(prop, isProperty);
                 })];
-
               case 'ArrayPattern':
                 return [param.key.name, param.value.left.elements.map((prop, idx) => {
                   return {
@@ -210,17 +174,17 @@ const getFunctionParameterNames = (functionNode, checkDefaultObjects) => {
             }
           }
       }
-
       switch (param.key.type) {
         case 'Identifier':
           return param.key.name;
-        // The key of an object could also be a string or number
 
+        // The key of an object could also be a string or number
         case 'Literal':
-          return param.key.raw || // istanbul ignore next -- `raw` may not be present in all parsers
+          return param.key.raw ||
+          // istanbul ignore next -- `raw` may not be present in all parsers
           param.key.value;
-        // case 'MemberExpression':
 
+        // case 'MemberExpression':
         default:
           // Todo: We should really create a structure (and a corresponding
           //   option analogous to `checkRestProperty`) which allows for
@@ -229,10 +193,8 @@ const getFunctionParameterNames = (functionNode, checkDefaultObjects) => {
           return undefined;
       }
     }
-
     if (param.type === 'ArrayPattern' || ((_param$left3 = param.left) === null || _param$left3 === void 0 ? void 0 : _param$left3.type) === 'ArrayPattern') {
       var _param$left4;
-
       const elements = param.elements || ((_param$left4 = param.left) === null || _param$left4 === void 0 ? void 0 : _param$left4.elements);
       const roots = elements.map((prop, idx) => {
         return {
@@ -242,7 +204,6 @@ const getFunctionParameterNames = (functionNode, checkDefaultObjects) => {
       });
       return [undefined, flattenRoots(roots)];
     }
-
     if (['RestElement', 'ExperimentalRestProperty'].includes(param.type)) {
       return {
         isRestProperty: isProperty,
@@ -250,32 +211,28 @@ const getFunctionParameterNames = (functionNode, checkDefaultObjects) => {
         restElement: true
       };
     }
-
     if (param.type === 'TSParameterProperty') {
       return getParamName(param.parameter, true);
     }
-
     throw new Error(`Unsupported function signature format: \`${param.type}\`.`);
   };
-
   if (!functionNode) {
     return [];
   }
-
   return (functionNode.params || ((_functionNode$value = functionNode.value) === null || _functionNode$value === void 0 ? void 0 : _functionNode$value.params) || []).map(param => {
     return getParamName(param);
   });
 };
+
 /**
  * @param {Node} functionNode
  * @returns {Integer}
  */
-
-
 const hasParams = functionNode => {
   // Should also check `functionNode.value.params` if supporting `MethodDefinition`
   return functionNode.params.length;
 };
+
 /**
  * Gets all names of the target type, including those that refer to a path, e.g.
  * "@param foo; @param foo.bar".
@@ -284,11 +241,8 @@ const hasParams = functionNode => {
  * @param {string} targetTagName
  * @returns {Array<object>}
  */
-
-
 const getJsdocTagsDeep = (jsdoc, targetTagName) => {
   const ret = [];
-
   for (const [idx, {
     name,
     tag,
@@ -297,35 +251,29 @@ const getJsdocTagsDeep = (jsdoc, targetTagName) => {
     if (tag !== targetTagName) {
       continue;
     }
-
     ret.push({
       idx,
       name,
       type
     });
   }
-
   return ret;
 };
-
 const modeWarnSettings = (0, _WarnSettings.default)();
+
 /**
  * @param {string} mode
  * @param context
  */
-
 const getTagNamesForMode = (mode, context) => {
   switch (mode) {
     case 'jsdoc':
       return _tagNames.jsdocTags;
-
     case 'typescript':
       return _tagNames.typeScriptTags;
-
     case 'closure':
     case 'permissive':
       return _tagNames.closureTags;
-
     default:
       if (!modeWarnSettings.hasBeenWarned(context, 'mode')) {
         context.report({
@@ -338,12 +286,13 @@ const getTagNamesForMode = (mode, context) => {
           message: `Unrecognized value \`${mode}\` for \`settings.jsdoc.mode\`.`
         });
         modeWarnSettings.markSettingAsWarned(context, 'mode');
-      } // We'll avoid breaking too many other rules
-
+      }
 
+      // We'll avoid breaking too many other rules
       return _tagNames.jsdocTags;
   }
 };
+
 /**
  * @param context
  * @param {ParserMode} mode
@@ -351,43 +300,36 @@ const getTagNamesForMode = (mode, context) => {
  * @param {object} tagPreference
  * @returns {string|object}
  */
-
-
 const getPreferredTagName = (context, mode, name, tagPreference = {}) => {
   var _Object$entries$find;
-
   const prefValues = Object.values(tagPreference);
-
   if (prefValues.includes(name) || prefValues.some(prefVal => {
     return prefVal && typeof prefVal === 'object' && prefVal.replacement === name;
   })) {
     return name;
-  } // Allow keys to have a 'tag ' prefix to avoid upstream bug in ESLint
+  }
+
+  // Allow keys to have a 'tag ' prefix to avoid upstream bug in ESLint
   // that disallows keys that conflict with Object.prototype,
   // e.g. 'tag constructor' for 'constructor':
   // https://github.com/eslint/eslint/issues/13289
   // https://github.com/gajus/eslint-plugin-jsdoc/issues/537
-
-
   const tagPreferenceFixed = Object.fromEntries(Object.entries(tagPreference).map(([key, value]) => {
     return [key.replace(/^tag /u, ''), value];
   }));
-
   if (Object.prototype.hasOwnProperty.call(tagPreferenceFixed, name)) {
     return tagPreferenceFixed[name];
   }
-
   const tagNames = getTagNamesForMode(mode, context);
   const preferredTagName = (_Object$entries$find = Object.entries(tagNames).find(([, aliases]) => {
     return aliases.includes(name);
   })) === null || _Object$entries$find === void 0 ? void 0 : _Object$entries$find[0];
-
   if (preferredTagName) {
     return preferredTagName;
   }
-
   return name;
 };
+
 /**
  * @param context
  * @param {ParserMode} mode
@@ -395,8 +337,6 @@ const getPreferredTagName = (context, mode, name, tagPreference = {}) => {
  * @param {Array} definedTags
  * @returns {boolean}
  */
-
-
 const isValidTag = (context, mode, name, definedTags) => {
   const tagNames = getTagNamesForMode(mode, context);
   const validTagNames = Object.keys(tagNames).concat(Object.values(tagNames).flat());
@@ -404,31 +344,30 @@ const isValidTag = (context, mode, name, definedTags) => {
   const allTags = validTagNames.concat(additionalTags);
   return allTags.includes(name);
 };
+
 /**
  * @param {object} jsdoc
  * @param {string} targetTagName
  * @returns {boolean}
  */
-
-
 const hasTag = (jsdoc, targetTagName) => {
   const targetTagLower = targetTagName.toLowerCase();
   return jsdoc.tags.some(doc => {
     return doc.tag.toLowerCase() === targetTagLower;
   });
 };
+
 /**
  * @param {object} jsdoc
  * @param {Array} targetTagNames
  * @returns {boolean}
  */
-
-
 const hasATag = (jsdoc, targetTagNames) => {
   return targetTagNames.some(targetTagName => {
     return hasTag(jsdoc, targetTagName);
   });
 };
+
 /**
  * Checks if the JSDoc comment declares a defined type.
  *
@@ -437,44 +376,38 @@ const hasATag = (jsdoc, targetTagNames) => {
  * @returns {boolean}
  *   true in case a defined type is declared; otherwise false.
  */
-
-
 const hasDefinedTypeTag = tag => {
   // The function should not continue in the event the type is not defined...
   if (typeof tag === 'undefined' || tag === null) {
     return false;
-  } // .. same applies if it declares an `{undefined}` or `{void}` type
-
+  }
 
+  // .. same applies if it declares an `{undefined}` or `{void}` type
   const tagType = tag.type.trim();
-
   if (tagType === 'undefined' || tagType === 'void') {
     return false;
-  } // In any other case, a type is present
-
+  }
 
+  // In any other case, a type is present
   return true;
 };
+
 /**
  * @param map
  * @param tag
  * @returns {Map}
  */
-
-
 const ensureMap = (map, tag) => {
   if (!map.has(tag)) {
     map.set(tag, new Map());
   }
-
   return map.get(tag);
 };
+
 /**
  * @param structuredTags
  * @param tagMap
  */
-
-
 const overrideTagStructure = (structuredTags, tagMap = tagStructure) => {
   for (const [tag, {
     name,
@@ -485,150 +418,131 @@ const overrideTagStructure = (structuredTags, tagMap = tagStructure) => {
     tagStruct.set('nameContents', name);
     tagStruct.set('typeAllowed', type);
     const requiredName = required.includes('name');
-
     if (requiredName && name === false) {
       throw new Error('Cannot add "name" to `require` with the tag\'s `name` set to `false`');
     }
-
     tagStruct.set('nameRequired', requiredName);
     const requiredType = required.includes('type');
-
     if (requiredType && type === false) {
       throw new Error('Cannot add "type" to `require` with the tag\'s `type` set to `false`');
     }
-
     tagStruct.set('typeRequired', requiredType);
     const typeOrNameRequired = required.includes('typeOrNameRequired');
-
     if (typeOrNameRequired && name === false) {
       throw new Error('Cannot add "typeOrNameRequired" to `require` with the tag\'s `name` set to `false`');
     }
-
     if (typeOrNameRequired && type === false) {
       throw new Error('Cannot add "typeOrNameRequired" to `require` with the tag\'s `type` set to `false`');
     }
-
     tagStruct.set('typeOrNameRequired', typeOrNameRequired);
   }
 };
+
 /**
  * @param mode
  * @param structuredTags
  * @returns {Map}
  */
-
-
 const getTagStructureForMode = (mode, structuredTags) => {
   const tagStruct = (0, _getDefaultTagStructureForMode.default)(mode);
-
   try {
     overrideTagStructure(structuredTags, tagStruct);
-  } catch {//
+  } catch {
+    //
   }
-
   return tagStruct;
 };
+
 /**
  * @param tag
  * @param {Map} tagMap
  * @returns {boolean}
  */
-
-
 const isNamepathDefiningTag = (tag, tagMap = tagStructure) => {
   const tagStruct = ensureMap(tagMap, tag);
   return tagStruct.get('nameContents') === 'namepath-defining';
 };
+
 /**
  * @param tag
  * @param {Map} tagMap
  * @returns {boolean}
  */
-
-
 const tagMustHaveTypePosition = (tag, tagMap = tagStructure) => {
   const tagStruct = ensureMap(tagMap, tag);
   return tagStruct.get('typeRequired');
 };
+
 /**
  * @param tag
  * @param {Map} tagMap
  * @returns {boolean}
  */
-
-
 const tagMightHaveTypePosition = (tag, tagMap = tagStructure) => {
   if (tagMustHaveTypePosition(tag, tagMap)) {
     return true;
   }
-
   const tagStruct = ensureMap(tagMap, tag);
   const ret = tagStruct.get('typeAllowed');
   return ret === undefined ? true : ret;
 };
-
 const namepathTypes = new Set(['namepath-defining', 'namepath-referencing']);
+
 /**
  * @param tag
  * @param {Map} tagMap
  * @returns {boolean}
  */
-
 const tagMightHaveNamePosition = (tag, tagMap = tagStructure) => {
   const tagStruct = ensureMap(tagMap, tag);
   const ret = tagStruct.get('nameContents');
   return ret === undefined ? true : Boolean(ret);
 };
+
 /**
  * @param tag
  * @param {Map} tagMap
  * @returns {boolean}
  */
-
-
 const tagMightHaveNamepath = (tag, tagMap = tagStructure) => {
   const tagStruct = ensureMap(tagMap, tag);
   return namepathTypes.has(tagStruct.get('nameContents'));
 };
+
 /**
  * @param tag
  * @param {Map} tagMap
  * @returns {boolean}
  */
-
-
 const tagMustHaveNamePosition = (tag, tagMap = tagStructure) => {
   const tagStruct = ensureMap(tagMap, tag);
   return tagStruct.get('nameRequired');
 };
+
 /**
  * @param tag
  * @param {Map} tagMap
  * @returns {boolean}
  */
-
-
 const tagMightHaveEitherTypeOrNamePosition = (tag, tagMap) => {
   return tagMightHaveTypePosition(tag, tagMap) || tagMightHaveNamepath(tag, tagMap);
 };
+
 /**
  * @param tag
  * @param {Map} tagMap
  * @returns {boolean}
  */
-
-
 const tagMustHaveEitherTypeOrNamePosition = (tag, tagMap) => {
   const tagStruct = ensureMap(tagMap, tag);
   return tagStruct.get('typeOrNameRequired');
 };
+
 /**
  * @param tag
  * @param {Map} tagMap
  * @returns {boolean}
  */
-
-
 const tagMissingRequiredTypeOrNamepath = (tag, tagMap = tagStructure) => {
   const mustHaveTypePosition = tagMustHaveTypePosition(tag.tag, tagMap);
   const mightHaveTypePosition = tagMightHaveTypePosition(tag.tag, tagMap);
@@ -637,14 +551,13 @@ const tagMissingRequiredTypeOrNamepath = (tag, tagMap = tagStructure) => {
   const mustHaveEither = tagMustHaveEitherTypeOrNamePosition(tag.tag, tagMap);
   const hasEither = tagMightHaveEitherTypeOrNamePosition(tag.tag, tagMap) && (hasTypePosition || hasNameOrNamepathPosition);
   return mustHaveEither && !hasEither && !mustHaveTypePosition;
-}; // eslint-disable-next-line complexity
-
+};
 
+// eslint-disable-next-line complexity
 const hasNonFunctionYield = (node, checkYieldReturnValue) => {
   if (!node) {
     return false;
   }
-
   switch (node.type) {
     case 'BlockStatement':
       {
@@ -652,20 +565,18 @@ const hasNonFunctionYield = (node, checkYieldReturnValue) => {
           return !['ArrowFunctionExpression', 'FunctionDeclaration', 'FunctionExpression'].includes(bodyNode.type) && hasNonFunctionYield(bodyNode, checkYieldReturnValue);
         });
       }
-    // istanbul ignore next -- In Babel?
 
+    // istanbul ignore next -- In Babel?
     case 'OptionalCallExpression':
     case 'CallExpression':
       return node.arguments.some(element => {
         return hasNonFunctionYield(element, checkYieldReturnValue);
       });
-
     case 'ChainExpression':
     case 'ExpressionStatement':
       {
         return hasNonFunctionYield(node.expression, checkYieldReturnValue);
       }
-
     case 'LabeledStatement':
     case 'WhileStatement':
     case 'DoWhileStatement':
@@ -676,18 +587,15 @@ const hasNonFunctionYield = (node, checkYieldReturnValue) => {
       {
         return hasNonFunctionYield(node.body, checkYieldReturnValue);
       }
-
     case 'ConditionalExpression':
     case 'IfStatement':
       {
         return hasNonFunctionYield(node.test, checkYieldReturnValue) || hasNonFunctionYield(node.consequent, checkYieldReturnValue) || hasNonFunctionYield(node.alternate, checkYieldReturnValue);
       }
-
     case 'TryStatement':
       {
         return hasNonFunctionYield(node.block, checkYieldReturnValue) || hasNonFunctionYield(node.handler && node.handler.body, checkYieldReturnValue) || hasNonFunctionYield(node.finalizer, checkYieldReturnValue);
       }
-
     case 'SwitchStatement':
       {
         return node.cases.some(someCase => {
@@ -696,130 +604,113 @@ const hasNonFunctionYield = (node, checkYieldReturnValue) => {
           });
         });
       }
-
     case 'ArrayPattern':
     case 'ArrayExpression':
       return node.elements.some(element => {
         return hasNonFunctionYield(element, checkYieldReturnValue);
       });
-
     case 'AssignmentPattern':
       return hasNonFunctionYield(node.right, checkYieldReturnValue);
-
     case 'VariableDeclaration':
       {
         return node.declarations.some(nde => {
           return hasNonFunctionYield(nde, checkYieldReturnValue);
         });
       }
-
     case 'VariableDeclarator':
       {
         return hasNonFunctionYield(node.id, checkYieldReturnValue) || hasNonFunctionYield(node.init, checkYieldReturnValue);
       }
-
     case 'AssignmentExpression':
     case 'BinaryExpression':
     case 'LogicalExpression':
       {
         return hasNonFunctionYield(node.left, checkYieldReturnValue) || hasNonFunctionYield(node.right, checkYieldReturnValue);
       }
-    // Comma
 
+    // Comma
     case 'SequenceExpression':
     case 'TemplateLiteral':
       return node.expressions.some(subExpression => {
         return hasNonFunctionYield(subExpression, checkYieldReturnValue);
       });
-
     case 'ObjectPattern':
     case 'ObjectExpression':
       return node.properties.some(property => {
         return hasNonFunctionYield(property, checkYieldReturnValue);
       });
-    // istanbul ignore next -- In Babel?
 
+    // istanbul ignore next -- In Babel?
     case 'PropertyDefinition':
     /* eslint-disable no-fallthrough */
     // istanbul ignore next -- In Babel?
-
-    case 'ObjectProperty': // istanbul ignore next -- In Babel?
-
+    case 'ObjectProperty':
+    // istanbul ignore next -- In Babel?
     case 'ClassProperty':
     /* eslint-enable no-fallthrough */
-
     case 'Property':
       return node.computed && hasNonFunctionYield(node.key, checkYieldReturnValue) || hasNonFunctionYield(node.value, checkYieldReturnValue);
     // istanbul ignore next -- In Babel?
-
     case 'ObjectMethod':
       // istanbul ignore next -- In Babel?
       return node.computed && hasNonFunctionYield(node.key, checkYieldReturnValue) || node.arguments.some(nde => {
         return hasNonFunctionYield(nde, checkYieldReturnValue);
       });
-
     case 'SpreadElement':
     case 'UnaryExpression':
       return hasNonFunctionYield(node.argument, checkYieldReturnValue);
-
     case 'TaggedTemplateExpression':
       return hasNonFunctionYield(node.quasi, checkYieldReturnValue);
+
     // ?.
     // istanbul ignore next -- In Babel?
-
     case 'OptionalMemberExpression':
     case 'MemberExpression':
       return hasNonFunctionYield(node.object, checkYieldReturnValue) || hasNonFunctionYield(node.property, checkYieldReturnValue);
-    // istanbul ignore next -- In Babel?
 
+    // istanbul ignore next -- In Babel?
     case 'Import':
     case 'ImportExpression':
       return hasNonFunctionYield(node.source, checkYieldReturnValue);
-
     case 'ReturnStatement':
       {
         if (node.argument === null) {
           return false;
         }
-
         return hasNonFunctionYield(node.argument, checkYieldReturnValue);
       }
-
     case 'YieldExpression':
       {
         if (checkYieldReturnValue) {
           if (node.parent.type === 'VariableDeclarator') {
             return true;
           }
-
           return false;
-        } // void return does not count.
-
+        }
 
+        // void return does not count.
         if (node.argument === null) {
           return false;
         }
-
         return true;
       }
-
     default:
       {
         return false;
       }
   }
 };
+
 /**
  * Checks if a node has a return statement. Void return does not count.
  *
  * @param {object} node
  * @returns {boolean}
  */
-
-
 const hasYieldValue = (node, checkYieldReturnValue) => {
   return node.generator && (node.expression || hasNonFunctionYield(node.body, checkYieldReturnValue));
 };
+
 /**
  * Checks if a node has a throws statement.
  *
@@ -828,16 +719,14 @@ const hasYieldValue = (node, checkYieldReturnValue) => {
  * @returns {boolean}
  */
 // eslint-disable-next-line complexity
-
-
 const hasThrowValue = (node, innerFunction) => {
   if (!node) {
     return false;
-  } // There are cases where a function may execute its inner function which
+  }
+
+  // There are cases where a function may execute its inner function which
   //   throws, but we're treating functions atomically rather than trying to
   //   follow them
-
-
   switch (node.type) {
     case 'FunctionExpression':
     case 'FunctionDeclaration':
@@ -845,14 +734,12 @@ const hasThrowValue = (node, innerFunction) => {
       {
         return !innerFunction && !node.async && hasThrowValue(node.body, true);
       }
-
     case 'BlockStatement':
       {
         return node.body.some(bodyNode => {
           return bodyNode.type !== 'FunctionDeclaration' && hasThrowValue(bodyNode);
         });
       }
-
     case 'LabeledStatement':
     case 'WhileStatement':
     case 'DoWhileStatement':
@@ -863,18 +750,16 @@ const hasThrowValue = (node, innerFunction) => {
       {
         return hasThrowValue(node.body);
       }
-
     case 'IfStatement':
       {
         return hasThrowValue(node.consequent) || hasThrowValue(node.alternate);
       }
-    // We only consider it to throw an error if the catch or finally blocks throw an error.
 
+    // We only consider it to throw an error if the catch or finally blocks throw an error.
     case 'TryStatement':
       {
         return hasThrowValue(node.handler && node.handler.body) || hasThrowValue(node.finalizer);
       }
-
     case 'SwitchStatement':
       {
         return node.cases.some(someCase => {
@@ -883,22 +768,20 @@ const hasThrowValue = (node, innerFunction) => {
           });
         });
       }
-
     case 'ThrowStatement':
       {
         return true;
       }
-
     default:
       {
         return false;
       }
   }
 };
+
 /**
  * @param {string} tag
  */
-
 /*
 const isInlineTag = (tag) => {
   return /^(@link|@linkcode|@linkplain|@tutorial) /u.test(tag);
@@ -913,13 +796,12 @@ const isInlineTag = (tag) => {
  * @param {JsDocTag} tag
  * @returns {Array<string>}
  */
-
-
 const parseClosureTemplateTag = tag => {
   return tag.name.split(',').map(type => {
     return type.trim().replace(/^\[(?<name>.*?)=.*\]$/u, '$<name>');
   });
 };
+
 /**
  * @typedef {true|string[]} DefaultContexts
  */
@@ -933,37 +815,32 @@ const parseClosureTemplateTag = tag => {
  * @param {DefaultContexts} defaultContexts
  * @returns {string[]}
  */
-
-
 const enforcedContexts = (context, defaultContexts) => {
   const {
     contexts = defaultContexts === true ? ['ArrowFunctionExpression', 'FunctionDeclaration', 'FunctionExpression', 'TSDeclareFunction'] : defaultContexts
   } = context.options[0] || {};
   return contexts;
 };
+
 /**
  * @param {string[]} contexts
  * @param {Function} checkJsdoc
  * @param {Function} handler
  */
-
-
 const getContextObject = (contexts, checkJsdoc, handler) => {
   const properties = {};
-
   for (const [idx, prop] of contexts.entries()) {
     let property;
     let value;
-
     if (typeof prop === 'object') {
       const selInfo = {
         lastIndex: idx,
         selector: prop.context
       };
-
       if (prop.comment) {
         property = prop.context;
-        value = checkJsdoc.bind(null, { ...selInfo,
+        value = checkJsdoc.bind(null, {
+          ...selInfo,
           comment: prop.comment
         }, handler.bind(null, prop.comment));
       } else {
@@ -978,26 +855,22 @@ const getContextObject = (contexts, checkJsdoc, handler) => {
       property = prop;
       value = checkJsdoc.bind(null, selInfo, null);
     }
-
     const old = properties[property];
     properties[property] = old ? function (...args) {
       old(...args);
       value(...args);
     } : value;
   }
-
   return properties;
 };
-
 const filterTags = (tags, filter) => {
   return tags.filter(tag => {
     return filter(tag);
   });
 };
-
-const tagsWithNamesAndDescriptions = new Set(['param', 'arg', 'argument', 'property', 'prop', 'template', // These two are parsed by our custom parser as though having a `name`
+const tagsWithNamesAndDescriptions = new Set(['param', 'arg', 'argument', 'property', 'prop', 'template',
+// These two are parsed by our custom parser as though having a `name`
 'returns', 'return']);
-
 const getTagsByType = (context, mode, tags, tagPreference) => {
   const descName = getPreferredTagName(context, mode, 'description', tagPreference);
   const tagsWithoutNames = [];
@@ -1006,11 +879,9 @@ const getTagsByType = (context, mode, tags, tagPreference) => {
       tag: tagName
     } = tag;
     const tagWithName = tagsWithNamesAndDescriptions.has(tagName);
-
     if (!tagWithName && tagName !== descName) {
       tagsWithoutNames.push(tag);
     }
-
     return tagWithName;
   });
   return {
@@ -1018,31 +889,22 @@ const getTagsByType = (context, mode, tags, tagPreference) => {
     tagsWithoutNames
   };
 };
-
 const getIndent = sourceCode => {
   var _sourceCode$text$matc;
-
   return (((_sourceCode$text$matc = sourceCode.text.match(/^\n*([ \t]+)/u)) === null || _sourceCode$text$matc === void 0 ? void 0 : _sourceCode$text$matc[1]) ?? '') + ' ';
 };
-
 const isConstructor = node => {
   var _node$parent;
-
   return (node === null || node === void 0 ? void 0 : node.type) === 'MethodDefinition' && node.kind === 'constructor' || (node === null || node === void 0 ? void 0 : (_node$parent = node.parent) === null || _node$parent === void 0 ? void 0 : _node$parent.kind) === 'constructor';
 };
-
 const isGetter = node => {
   var _node$parent2;
-
   return node && ((_node$parent2 = node.parent) === null || _node$parent2 === void 0 ? void 0 : _node$parent2.kind) === 'get';
 };
-
 const isSetter = node => {
   var _node$parent3;
-
   return node && ((_node$parent3 = node.parent) === null || _node$parent3 === void 0 ? void 0 : _node$parent3.kind) === 'set';
 };
-
 const hasAccessorPair = node => {
   const {
     type,
@@ -1062,19 +924,17 @@ const hasAccessorPair = node => {
     return kind === oppositeKind && name === sourceName;
   });
 };
-
 const exemptSpeciaMethods = (jsdoc, node, context, schema) => {
   const hasSchemaOption = prop => {
     var _context$options$;
-
     const schemaProperties = schema[0].properties;
     return ((_context$options$ = context.options[0]) === null || _context$options$ === void 0 ? void 0 : _context$options$[prop]) ?? (schemaProperties[prop] && schemaProperties[prop].default);
   };
-
   const checkGetters = hasSchemaOption('checkGetters');
   const checkSetters = hasSchemaOption('checkSetters');
   return !hasSchemaOption('checkConstructors') && (isConstructor(node) || hasATag(jsdoc, ['class', 'constructor'])) || isGetter(node) && (!checkGetters || checkGetters === 'no-setter' && hasAccessorPair(node.parent)) || isSetter(node) && (!checkSetters || checkSetters === 'no-getter' && hasAccessorPair(node.parent));
 };
+
 /**
  * Since path segments may be unquoted (if matching a reserved word,
  * identifier or numeric literal) or single or double quoted, in either
@@ -1084,57 +944,48 @@ const exemptSpeciaMethods = (jsdoc, node, context, schema) => {
  * @param {string} str
  * @returns {string}
  */
-
-
 const dropPathSegmentQuotes = str => {
   return str.replace(/\.(['"])(.*)\1/gu, '.$2');
 };
+
 /**
  * @param {string} name
  * @returns {(otherPathName: string) => void}
  */
-
-
 const comparePaths = name => {
   return otherPathName => {
     return otherPathName === name || dropPathSegmentQuotes(otherPathName) === dropPathSegmentQuotes(name);
   };
 };
+
 /**
  * @param {string} name
  * @param {string} otherPathName
  * @returns {boolean}
  */
-
-
 const pathDoesNotBeginWith = (name, otherPathName) => {
   return !name.startsWith(otherPathName) && !dropPathSegmentQuotes(name).startsWith(dropPathSegmentQuotes(otherPathName));
 };
+
 /**
  * @param {string} regexString
  * @param {string} requiredFlags
  * @returns {RegExp}
  */
-
-
 const getRegexFromString = (regexString, requiredFlags) => {
   const match = regexString.match(/^\/(.*)\/([gimyus]*)$/us);
   let flags = 'u';
   let regex = regexString;
-
   if (match) {
     [, regex, flags] = match;
-
     if (!flags) {
       flags = 'u';
     }
   }
-
   const uniqueFlags = [...new Set(flags + (requiredFlags || ''))];
   flags = uniqueFlags.join('');
   return new RegExp(regex, flags);
 };
-
 var _default = {
   comparePaths,
   dropPathSegmentQuotes,