eslint-plugin-jsdoc 52.0.3 → 52.0.4

package/dist/rules/checkTypes.cjs

@@ -1,300 +1,394 @@
-const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
-const require_iterateJsdoc = require('../iterateJsdoc.cjs');
-const __es_joy_jsdoccomment = require_rolldown_runtime.__toESM(require("@es-joy/jsdoccomment"));
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _iterateJsdoc = _interopRequireDefault(require("../iterateJsdoc.cjs"));
+var _jsdoccomment = require("@es-joy/jsdoccomment");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const strictNativeTypes = ['undefined', 'null', 'boolean', 'number', 'bigint', 'string', 'symbol', 'object', 'Array', 'Function', 'Date', 'RegExp'];
 
-//#region src/rules/checkTypes.js
-const strictNativeTypes = [
-	"undefined",
-	"null",
-	"boolean",
-	"number",
-	"bigint",
-	"string",
-	"symbol",
-	"object",
-	"Array",
-	"Function",
-	"Date",
-	"RegExp"
-];
 /**
-* Adjusts the parent type node `meta` for generic matches (or type node
-* `type` for `JsdocTypeAny`) and sets the type node `value`.
-* @param {string} type The actual type
-* @param {string} preferred The preferred type
-* @param {boolean} isGenericMatch
-* @param {string} typeNodeName
-* @param {import('jsdoc-type-pratt-parser').NonRootResult} node
-* @param {import('jsdoc-type-pratt-parser').NonRootResult|undefined} parentNode
-* @returns {void}
-*/
+ * Adjusts the parent type node `meta` for generic matches (or type node
+ * `type` for `JsdocTypeAny`) and sets the type node `value`.
+ * @param {string} type The actual type
+ * @param {string} preferred The preferred type
+ * @param {boolean} isGenericMatch
+ * @param {string} typeNodeName
+ * @param {import('jsdoc-type-pratt-parser').NonRootResult} node
+ * @param {import('jsdoc-type-pratt-parser').NonRootResult|undefined} parentNode
+ * @returns {void}
+ */
 const adjustNames = (type, preferred, isGenericMatch, typeNodeName, node, parentNode) => {
-	let ret = preferred;
-	if (isGenericMatch) {
-		const parentMeta = parentNode.meta;
-		if (preferred === "[]") {
-			parentMeta.brackets = "square";
-			parentMeta.dot = false;
-			ret = "Array";
-		} else {
-			const dotBracketEnd = preferred.match(/\.(?:<>)?$/v);
-			if (dotBracketEnd) {
-				parentMeta.brackets = "angle";
-				parentMeta.dot = true;
-				ret = preferred.slice(0, -dotBracketEnd[0].length);
-			} else {
-				const bracketEnd = preferred.endsWith("<>");
-				if (bracketEnd) {
-					parentMeta.brackets = "angle";
-					parentMeta.dot = false;
-					ret = preferred.slice(0, -2);
-				} else if (parentMeta?.brackets === "square" && (typeNodeName === "[]" || typeNodeName === "Array")) {
-					parentMeta.brackets = "angle";
-					parentMeta.dot = false;
-				}
-			}
-		}
-	} else if (type === "JsdocTypeAny") node.type = "JsdocTypeName";
-	/** @type {import('jsdoc-type-pratt-parser').NameResult} */ node.value = ret.replace(/(?:\.|<>|\.<>|\[\])$/v, "");
-	if (!ret)
- /** @type {import('jsdoc-type-pratt-parser').NameResult} */ node.value = typeNodeName;
+  let ret = preferred;
+  if (isGenericMatch) {
+    const parentMeta = /** @type {import('jsdoc-type-pratt-parser').GenericResult} */parentNode.meta;
+    if (preferred === '[]') {
+      parentMeta.brackets = 'square';
+      parentMeta.dot = false;
+      ret = 'Array';
+    } else {
+      const dotBracketEnd = preferred.match(/\.(?:<>)?$/v);
+      if (dotBracketEnd) {
+        parentMeta.brackets = 'angle';
+        parentMeta.dot = true;
+        ret = preferred.slice(0, -dotBracketEnd[0].length);
+      } else {
+        const bracketEnd = preferred.endsWith('<>');
+        if (bracketEnd) {
+          parentMeta.brackets = 'angle';
+          parentMeta.dot = false;
+          ret = preferred.slice(0, -2);
+        } else if (parentMeta?.brackets === 'square' && (typeNodeName === '[]' || typeNodeName === 'Array')) {
+          parentMeta.brackets = 'angle';
+          parentMeta.dot = false;
+        }
+      }
+    }
+  } else if (type === 'JsdocTypeAny') {
+    node.type = 'JsdocTypeName';
+  }
+
+  /** @type {import('jsdoc-type-pratt-parser').NameResult} */
+  node.value = ret.replace(/(?:\.|<>|\.<>|\[\])$/v, '');
+
+  // For bare pseudo-types like `<>`
+  if (!ret) {
+    /** @type {import('jsdoc-type-pratt-parser').NameResult} */node.value = typeNodeName;
+  }
 };
+
 /**
-* @param {boolean} [upperCase]
-* @returns {string}
-*/
-const getMessage = (upperCase) => {
-	return "Use object shorthand or index signatures instead of `" + (upperCase ? "O" : "o") + "bject`, e.g., `{[key: string]: string}`";
+ * @param {boolean} [upperCase]
+ * @returns {string}
+ */
+const getMessage = upperCase => {
+  return 'Use object shorthand or index signatures instead of ' + '`' + (upperCase ? 'O' : 'o') + 'bject`, e.g., `{[key: string]: string}`';
 };
-var checkTypes_default = require_iterateJsdoc.default(({ context, jsdocNode, report, settings, sourceCode, utils }) => {
-	const jsdocTagsWithPossibleType = utils.filterTags((tag) => {
-		return Boolean(utils.tagMightHaveTypePosition(tag.tag));
-	});
-	const { mode, preferredTypes: preferredTypesOriginal, structuredTags } = settings;
-	const injectObjectPreferredTypes = !("Object" in preferredTypesOriginal || "object" in preferredTypesOriginal || "object.<>" in preferredTypesOriginal || "Object.<>" in preferredTypesOriginal || "object<>" in preferredTypesOriginal);
-	/**
-	* @type {{
-	*   message: string,
-	*   replacement: false
-	* }}
-	*/
-	const info = {
-		message: getMessage(),
-		replacement: false
-	};
-	/**
-	* @type {{
-	*   message: string,
-	*   replacement: false
-	* }}
-	*/
-	const infoUC = {
-		message: getMessage(true),
-		replacement: false
-	};
-	/** @type {import('../iterateJsdoc.js').PreferredTypes} */
-	const typeToInject = mode === "typescript" ? {
-		Object: "object",
-		"object.<>": info,
-		"Object.<>": infoUC,
-		"object<>": info,
-		"Object<>": infoUC
-	} : {
-		Object: "object",
-		"object.<>": "Object<>",
-		"Object.<>": "Object<>",
-		"object<>": "Object<>"
-	};
-	/** @type {import('../iterateJsdoc.js').PreferredTypes} */
-	const preferredTypes = {
-		...injectObjectPreferredTypes ? typeToInject : {},
-		...preferredTypesOriginal
-	};
-	const { exemptTagContexts = [], noDefaults, unifyParentAndChildTypeChecks } = context.options[0] || {};
-	/**
-	* Gets information about the preferred type: whether there is a matching
-	* preferred type, what the type is, and whether it is a match to a generic.
-	* @param {string} _type Not currently in use
-	* @param {string} typeNodeName
-	* @param {import('jsdoc-type-pratt-parser').NonRootResult|undefined} parentNode
-	* @param {string|undefined} property
-	* @returns {[hasMatchingPreferredType: boolean, typeName: string, isGenericMatch: boolean]}
-	*/
-	const getPreferredTypeInfo = (_type, typeNodeName, parentNode, property) => {
-		let hasMatchingPreferredType = false;
-		let isGenericMatch = false;
-		let typeName = typeNodeName;
-		const isNameOfGeneric = parentNode !== void 0 && parentNode.type === "JsdocTypeGeneric" && property === "left";
-		if (unifyParentAndChildTypeChecks || isNameOfGeneric) {
-			const brackets = parentNode?.meta?.brackets;
-			const dot = parentNode?.meta?.dot;
-			if (brackets === "angle") {
-				const checkPostFixes = dot ? [".", ".<>"] : ["<>"];
-				isGenericMatch = checkPostFixes.some((checkPostFix) => {
-					if (preferredTypes?.[typeNodeName + checkPostFix] !== void 0) {
-						typeName += checkPostFix;
-						return true;
-					}
-					return false;
-				});
-			}
-			if (!isGenericMatch && property && parentNode.type === "JsdocTypeGeneric") {
-				const checkPostFixes = dot ? [".", ".<>"] : [brackets === "angle" ? "<>" : "[]"];
-				isGenericMatch = checkPostFixes.some((checkPostFix) => {
-					if (preferredTypes?.[checkPostFix] !== void 0) {
-						typeName = checkPostFix;
-						return true;
-					}
-					return false;
-				});
-			}
-		}
-		const directNameMatch = preferredTypes?.[typeNodeName] !== void 0 && !Object.values(preferredTypes).includes(typeNodeName);
-		const unifiedSyntaxParentMatch = property && directNameMatch && unifyParentAndChildTypeChecks;
-		isGenericMatch = isGenericMatch || Boolean(unifiedSyntaxParentMatch);
-		hasMatchingPreferredType = isGenericMatch || directNameMatch && !property;
-		return [
-			hasMatchingPreferredType,
-			typeName,
-			isGenericMatch
-		];
-	};
-	/**
-	* Iterates strict types to see if any should be added to `invalidTypes` (and
-	* the the relevant strict type returned as the new preferred type).
-	* @param {string} typeNodeName
-	* @param {string|undefined} preferred
-	* @param {import('jsdoc-type-pratt-parser').NonRootResult|undefined} parentNode
-	* @param {(string|false|undefined)[][]} invalidTypes
-	* @returns {string|undefined} The `preferred` type string, optionally changed
-	*/
-	const checkNativeTypes = (typeNodeName, preferred, parentNode, invalidTypes) => {
-		let changedPreferred = preferred;
-		for (const strictNativeType of strictNativeTypes) {
-			if (strictNativeType === "object" && (!preferredTypes?.[typeNodeName] || parentNode?.elements?.length && parentNode?.left?.type === "JsdocTypeName" && parentNode?.left?.value === "Object")) continue;
-			if (strictNativeType !== typeNodeName && strictNativeType.toLowerCase() === typeNodeName.toLowerCase() && (!preferredTypes || preferredTypes?.[strictNativeType] === void 0)) {
-				changedPreferred = strictNativeType;
-				invalidTypes.push([typeNodeName, changedPreferred]);
-				break;
-			}
-		}
-		return changedPreferred;
-	};
-	/**
-	* Collect invalid type info.
-	* @param {string} type
-	* @param {string} value
-	* @param {string} tagName
-	* @param {string} nameInTag
-	* @param {number} idx
-	* @param {string|undefined} property
-	* @param {import('jsdoc-type-pratt-parser').NonRootResult} node
-	* @param {import('jsdoc-type-pratt-parser').NonRootResult|undefined} parentNode
-	* @param {(string|false|undefined)[][]} invalidTypes
-	* @returns {void}
-	*/
-	const getInvalidTypes = (type, value, tagName, nameInTag, idx, property, node, parentNode, invalidTypes) => {
-		let typeNodeName = type === "JsdocTypeAny" ? "*" : value;
-		const [hasMatchingPreferredType, typeName, isGenericMatch] = getPreferredTypeInfo(type, typeNodeName, parentNode, property);
-		let preferred;
-		let types;
-		if (hasMatchingPreferredType) {
-			const preferredSetting = preferredTypes[typeName];
-			typeNodeName = typeName === "[]" ? typeName : typeNodeName;
-			if (!preferredSetting) invalidTypes.push([typeNodeName]);
-			else if (typeof preferredSetting === "string") {
-				preferred = preferredSetting;
-				invalidTypes.push([typeNodeName, preferred]);
-			} else if (preferredSetting && typeof preferredSetting === "object") {
-				const nextItem = preferredSetting.skipRootChecking && jsdocTagsWithPossibleType[idx + 1];
-				if (!nextItem || !nextItem.name.startsWith(`${nameInTag}.`)) {
-					preferred = preferredSetting.replacement;
-					invalidTypes.push([
-						typeNodeName,
-						preferred,
-						preferredSetting.message
-					]);
-				}
-			} else {
-				utils.reportSettings("Invalid `settings.jsdoc.preferredTypes`. Values must be falsy, a string, or an object.");
-				return;
-			}
-		} else if (Object.entries(structuredTags).some(([tag, { type: typs }]) => {
-			types = typs;
-			return tag === tagName && Array.isArray(types) && !types.includes(typeNodeName);
-		})) invalidTypes.push([typeNodeName, types]);
-		else if (!noDefaults && type === "JsdocTypeName") preferred = checkNativeTypes(typeNodeName, preferred, parentNode, invalidTypes);
-		if (preferred) adjustNames(type, preferred, isGenericMatch, typeNodeName, node, parentNode);
-	};
-	for (const [idx, jsdocTag] of jsdocTagsWithPossibleType.entries()) {
-		/** @type {(string|false|undefined)[][]} */
-		const invalidTypes = [];
-		let typeAst;
-		try {
-			typeAst = mode === "permissive" ? (0, __es_joy_jsdoccomment.tryParse)(jsdocTag.type) : (0, __es_joy_jsdoccomment.parse)(jsdocTag.type, mode);
-		} catch {
-			continue;
-		}
-		const { name: nameInTag, tag: tagName } = jsdocTag;
-		(0, __es_joy_jsdoccomment.traverse)(typeAst, (node, parentNode, property) => {
-			const { type, value } = node;
-			if (!["JsdocTypeAny", "JsdocTypeName"].includes(type)) return;
-			getInvalidTypes(type, value, tagName, nameInTag, idx, property, node, parentNode, invalidTypes);
-		});
-		if (invalidTypes.length) {
-			const fixedType = (0, __es_joy_jsdoccomment.stringify)(typeAst);
-			/**
-			* @type {import('eslint').Rule.ReportFixer}
-			*/
-			const fix = (fixer) => {
-				return fixer.replaceText(jsdocNode, sourceCode.getText(jsdocNode).replace(`{${jsdocTag.type}}`, `{${fixedType}}`));
-			};
-			for (const [badType, preferredType = "", msg] of invalidTypes) {
-				const tagValue = jsdocTag.name ? ` "${jsdocTag.name}"` : "";
-				if (exemptTagContexts.some(({ tag, types }) => {
-					return tag === tagName && (types === true || types.includes(jsdocTag.type));
-				})) continue;
-				report(msg || `Invalid JSDoc @${tagName}${tagValue} type "${badType}"` + (preferredType ? "; " : ".") + (preferredType ? `prefer: ${JSON.stringify(preferredType)}.` : ""), preferredType ? fix : null, jsdocTag, msg ? {
-					tagName,
-					tagValue
-				} : void 0);
-			}
-		}
-	}
+var _default = exports.default = (0, _iterateJsdoc.default)(({
+  context,
+  jsdocNode,
+  report,
+  settings,
+  sourceCode,
+  utils
+}) => {
+  const jsdocTagsWithPossibleType = utils.filterTags(tag => {
+    return Boolean(utils.tagMightHaveTypePosition(tag.tag));
+  });
+  const
+  /**
+   * @type {{
+   *   preferredTypes: import('../iterateJsdoc.js').PreferredTypes,
+   *   structuredTags: import('../iterateJsdoc.js').StructuredTags,
+   *   mode: import('../jsdocUtils.js').ParserMode
+   * }}
+   */
+  {
+    mode,
+    preferredTypes: preferredTypesOriginal,
+    structuredTags
+  } = settings;
+  const injectObjectPreferredTypes = !('Object' in preferredTypesOriginal || 'object' in preferredTypesOriginal || 'object.<>' in preferredTypesOriginal || 'Object.<>' in preferredTypesOriginal || 'object<>' in preferredTypesOriginal);
+
+  /**
+   * @type {{
+   *   message: string,
+   *   replacement: false
+   * }}
+   */
+  const info = {
+    message: getMessage(),
+    replacement: false
+  };
+
+  /**
+   * @type {{
+   *   message: string,
+   *   replacement: false
+   * }}
+   */
+  const infoUC = {
+    message: getMessage(true),
+    replacement: false
+  };
+
+  /** @type {import('../iterateJsdoc.js').PreferredTypes} */
+  const typeToInject = mode === 'typescript' ? {
+    Object: 'object',
+    'object.<>': info,
+    'Object.<>': infoUC,
+    'object<>': info,
+    'Object<>': infoUC
+  } : {
+    Object: 'object',
+    'object.<>': 'Object<>',
+    'Object.<>': 'Object<>',
+    'object<>': 'Object<>'
+  };
+
+  /** @type {import('../iterateJsdoc.js').PreferredTypes} */
+  const preferredTypes = {
+    ...(injectObjectPreferredTypes ? typeToInject : {}),
+    ...preferredTypesOriginal
+  };
+  const
+  /**
+   * @type {{
+   *   noDefaults: boolean,
+   *   unifyParentAndChildTypeChecks: boolean,
+   *   exemptTagContexts: ({
+   *     tag: string,
+   *     types: true|string[]
+   *   })[]
+   * }}
+   */
+  {
+    exemptTagContexts = [],
+    noDefaults,
+    unifyParentAndChildTypeChecks
+  } = context.options[0] || {};
+
+  /**
+   * Gets information about the preferred type: whether there is a matching
+   * preferred type, what the type is, and whether it is a match to a generic.
+   * @param {string} _type Not currently in use
+   * @param {string} typeNodeName
+   * @param {import('jsdoc-type-pratt-parser').NonRootResult|undefined} parentNode
+   * @param {string|undefined} property
+   * @returns {[hasMatchingPreferredType: boolean, typeName: string, isGenericMatch: boolean]}
+   */
+  const getPreferredTypeInfo = (_type, typeNodeName, parentNode, property) => {
+    let hasMatchingPreferredType = false;
+    let isGenericMatch = false;
+    let typeName = typeNodeName;
+    const isNameOfGeneric = parentNode !== undefined && parentNode.type === 'JsdocTypeGeneric' && property === 'left';
+    if (unifyParentAndChildTypeChecks || isNameOfGeneric) {
+      const brackets = /** @type {import('jsdoc-type-pratt-parser').GenericResult} */parentNode?.meta?.brackets;
+      const dot = /** @type {import('jsdoc-type-pratt-parser').GenericResult} */parentNode?.meta?.dot;
+      if (brackets === 'angle') {
+        const checkPostFixes = dot ? ['.', '.<>'] : ['<>'];
+        isGenericMatch = checkPostFixes.some(checkPostFix => {
+          if (preferredTypes?.[typeNodeName + checkPostFix] !== undefined) {
+            typeName += checkPostFix;
+            return true;
+          }
+          return false;
+        });
+      }
+      if (!isGenericMatch && property && /** @type {import('jsdoc-type-pratt-parser').NonRootResult} */parentNode.type === 'JsdocTypeGeneric') {
+        const checkPostFixes = dot ? ['.', '.<>'] : [brackets === 'angle' ? '<>' : '[]'];
+        isGenericMatch = checkPostFixes.some(checkPostFix => {
+          if (preferredTypes?.[checkPostFix] !== undefined) {
+            typeName = checkPostFix;
+            return true;
+          }
+          return false;
+        });
+      }
+    }
+    const directNameMatch = preferredTypes?.[typeNodeName] !== undefined && !Object.values(preferredTypes).includes(typeNodeName);
+    const unifiedSyntaxParentMatch = property && directNameMatch && unifyParentAndChildTypeChecks;
+    isGenericMatch = isGenericMatch || Boolean(unifiedSyntaxParentMatch);
+    hasMatchingPreferredType = isGenericMatch || directNameMatch && !property;
+    return [hasMatchingPreferredType, typeName, isGenericMatch];
+  };
+
+  /**
+   * Iterates strict types to see if any should be added to `invalidTypes` (and
+   * the the relevant strict type returned as the new preferred type).
+   * @param {string} typeNodeName
+   * @param {string|undefined} preferred
+   * @param {import('jsdoc-type-pratt-parser').NonRootResult|undefined} parentNode
+   * @param {(string|false|undefined)[][]} invalidTypes
+   * @returns {string|undefined} The `preferred` type string, optionally changed
+   */
+  const checkNativeTypes = (typeNodeName, preferred, parentNode, invalidTypes) => {
+    let changedPreferred = preferred;
+    for (const strictNativeType of strictNativeTypes) {
+      if (strictNativeType === 'object' && (
+      // This is not set to remap with exact type match (e.g.,
+      //   `object: 'Object'`), so can ignore (including if circular)
+      !preferredTypes?.[typeNodeName] ||
+      // Although present on `preferredTypes` for remapping, this is a
+      //   parent object without a parent match (and not
+      //   `unifyParentAndChildTypeChecks`) and we don't want
+      //   `object<>` given TypeScript issue https://github.com/microsoft/TypeScript/issues/20555
+      /**
+       * @type {import('jsdoc-type-pratt-parser').GenericResult}
+       */
+      parentNode?.elements?.length && (
+      /**
+       * @type {import('jsdoc-type-pratt-parser').GenericResult}
+       */
+      parentNode?.left?.type === 'JsdocTypeName' &&
+      /**
+       * @type {import('jsdoc-type-pratt-parser').GenericResult}
+       */
+      parentNode?.left?.value === 'Object'))) {
+        continue;
+      }
+      if (strictNativeType !== typeNodeName && strictNativeType.toLowerCase() === typeNodeName.toLowerCase() && (
+      // Don't report if user has own map for a strict native type
+      !preferredTypes || preferredTypes?.[strictNativeType] === undefined)) {
+        changedPreferred = strictNativeType;
+        invalidTypes.push([typeNodeName, changedPreferred]);
+        break;
+      }
+    }
+    return changedPreferred;
+  };
+
+  /**
+   * Collect invalid type info.
+   * @param {string} type
+   * @param {string} value
+   * @param {string} tagName
+   * @param {string} nameInTag
+   * @param {number} idx
+   * @param {string|undefined} property
+   * @param {import('jsdoc-type-pratt-parser').NonRootResult} node
+   * @param {import('jsdoc-type-pratt-parser').NonRootResult|undefined} parentNode
+   * @param {(string|false|undefined)[][]} invalidTypes
+   * @returns {void}
+   */
+  const getInvalidTypes = (type, value, tagName, nameInTag, idx, property, node, parentNode, invalidTypes) => {
+    let typeNodeName = type === 'JsdocTypeAny' ? '*' : value;
+    const [hasMatchingPreferredType, typeName, isGenericMatch] = getPreferredTypeInfo(type, typeNodeName, parentNode, property);
+    let preferred;
+    let types;
+    if (hasMatchingPreferredType) {
+      const preferredSetting = preferredTypes[typeName];
+      typeNodeName = typeName === '[]' ? typeName : typeNodeName;
+      if (!preferredSetting) {
+        invalidTypes.push([typeNodeName]);
+      } else if (typeof preferredSetting === 'string') {
+        preferred = preferredSetting;
+        invalidTypes.push([typeNodeName, preferred]);
+      } else if (preferredSetting && typeof preferredSetting === 'object') {
+        const nextItem = preferredSetting.skipRootChecking && jsdocTagsWithPossibleType[idx + 1];
+        if (!nextItem || !nextItem.name.startsWith(`${nameInTag}.`)) {
+          preferred = preferredSetting.replacement;
+          invalidTypes.push([typeNodeName, preferred, preferredSetting.message]);
+        }
+      } else {
+        utils.reportSettings('Invalid `settings.jsdoc.preferredTypes`. Values must be falsy, a string, or an object.');
+        return;
+      }
+    } else if (Object.entries(structuredTags).some(([tag, {
+      type: typs
+    }]) => {
+      types = typs;
+      return tag === tagName && Array.isArray(types) && !types.includes(typeNodeName);
+    })) {
+      invalidTypes.push([typeNodeName, types]);
+    } else if (!noDefaults && type === 'JsdocTypeName') {
+      preferred = checkNativeTypes(typeNodeName, preferred, parentNode, invalidTypes);
+    }
+
+    // For fixer
+    if (preferred) {
+      adjustNames(type, preferred, isGenericMatch, typeNodeName, node, parentNode);
+    }
+  };
+  for (const [idx, jsdocTag] of jsdocTagsWithPossibleType.entries()) {
+    /** @type {(string|false|undefined)[][]} */
+    const invalidTypes = [];
+    let typeAst;
+    try {
+      typeAst = mode === 'permissive' ? (0, _jsdoccomment.tryParse)(jsdocTag.type) : (0, _jsdoccomment.parse)(jsdocTag.type, mode);
+    } catch {
+      continue;
+    }
+    const {
+      name: nameInTag,
+      tag: tagName
+    } = jsdocTag;
+    (0, _jsdoccomment.traverse)(typeAst, (node, parentNode, property) => {
+      const {
+        type,
+        value
+      } =
+      /**
+       * @type {import('jsdoc-type-pratt-parser').NameResult}
+       */
+      node;
+      if (!['JsdocTypeAny', 'JsdocTypeName'].includes(type)) {
+        return;
+      }
+      getInvalidTypes(type, value, tagName, nameInTag, idx, property, node, parentNode, invalidTypes);
+    });
+    if (invalidTypes.length) {
+      const fixedType = (0, _jsdoccomment.stringify)(typeAst);
+
+      /**
+       * @type {import('eslint').Rule.ReportFixer}
+       */
+      const fix = fixer => {
+        return fixer.replaceText(jsdocNode, sourceCode.getText(jsdocNode).replace(`{${jsdocTag.type}}`, `{${fixedType}}`));
+      };
+      for (const [badType, preferredType = '', msg] of invalidTypes) {
+        const tagValue = jsdocTag.name ? ` "${jsdocTag.name}"` : '';
+        if (exemptTagContexts.some(({
+          tag,
+          types
+        }) => {
+          return tag === tagName && (types === true || types.includes(jsdocTag.type));
+        })) {
+          continue;
+        }
+        report(msg || `Invalid JSDoc @${tagName}${tagValue} type "${badType}"` + (preferredType ? '; ' : '.') + (preferredType ? `prefer: ${JSON.stringify(preferredType)}.` : ''), preferredType ? fix : null, jsdocTag, msg ? {
+          tagName,
+          tagValue
+        } : undefined);
+      }
+    }
+  }
 }, {
-	iterateAllJsdocs: true,
-	meta: {
-		docs: {
-			description: "Reports invalid types.",
-			url: "https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/check-types.md#repos-sticky-header"
-		},
-		fixable: "code",
-		schema: [{
-			additionalProperties: false,
-			properties: {
-				exemptTagContexts: {
-					items: {
-						additionalProperties: false,
-						properties: {
-							tag: { type: "string" },
-							types: { oneOf: [{ type: "boolean" }, {
-								items: { type: "string" },
-								type: "array"
-							}] }
-						},
-						type: "object"
-					},
-					type: "array"
-				},
-				noDefaults: { type: "boolean" },
-				unifyParentAndChildTypeChecks: { type: "boolean" }
-			},
-			type: "object"
-		}],
-		type: "suggestion"
-	}
+  iterateAllJsdocs: true,
+  meta: {
+    docs: {
+      description: 'Reports invalid types.',
+      url: 'https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/check-types.md#repos-sticky-header'
+    },
+    fixable: 'code',
+    schema: [{
+      additionalProperties: false,
+      properties: {
+        exemptTagContexts: {
+          items: {
+            additionalProperties: false,
+            properties: {
+              tag: {
+                type: 'string'
+              },
+              types: {
+                oneOf: [{
+                  type: 'boolean'
+                }, {
+                  items: {
+                    type: 'string'
+                  },
+                  type: 'array'
+                }]
+              }
+            },
+            type: 'object'
+          },
+          type: 'array'
+        },
+        noDefaults: {
+          type: 'boolean'
+        },
+        unifyParentAndChildTypeChecks: {
+          type: 'boolean'
+        }
+      },
+      type: 'object'
+    }],
+    type: 'suggestion'
+  }
 });
-
-//#endregion
-exports.default = checkTypes_default;
+module.exports = exports.default;
 //# sourceMappingURL=checkTypes.cjs.map