eslint-plugin-jsdoc 52.0.4 → 53.0.1

package/dist/iterateJsdoc.cjs

@@ -1,2086 +1,1637 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = iterateJsdoc;
-exports.getSettings = void 0;
-Object.defineProperty(exports, "parseComment", {
-  enumerable: true,
-  get: function () {
-    return _jsdoccomment.parseComment;
-  }
-});
-var jsdocUtils = _interopRequireWildcard(require("./jsdocUtils.cjs"));
-var _jsdoccomment = require("@es-joy/jsdoccomment");
-var _commentParser = require("comment-parser");
-var _esquery = _interopRequireDefault(require("esquery"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
-/**
- * @typedef {number} Integer
- */
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_hasReturnValue = require('./utils/hasReturnValue.cjs');
+const require_jsdocUtils = require('./jsdocUtils.cjs');
+const __es_joy_jsdoccomment = require_rolldown_runtime.__toESM(require("@es-joy/jsdoccomment"));
+const comment_parser = require_rolldown_runtime.__toESM(require("comment-parser"));
+const esquery = require_rolldown_runtime.__toESM(require("esquery"));
 
+//#region src/iterateJsdoc.js
 /**
- * @typedef {import('@es-joy/jsdoccomment').JsdocBlockWithInline} JsdocBlockWithInline
- */
-
+* @typedef {number} Integer
+*/
 /**
- * @typedef {{
- *   disallowName?: string,
- *   allowName?: string,
- *   context?: string,
- *   comment?: string,
- *   tags?: string[],
- *   replacement?: string,
- *   minimum?: Integer,
- *   message?: string,
- *   forceRequireReturn?: boolean
- * }} ContextObject
- */
-/**
- * @typedef {string|ContextObject} Context
- */
-
+* @typedef {import('@es-joy/jsdoccomment').JsdocBlockWithInline} JsdocBlockWithInline
+*/
 /**
- * @callback CheckJsdoc
- * @param {{
- *   lastIndex?: Integer,
- *   isFunctionContext?: boolean,
- *   selector?: string,
- *   comment?: string
- * }} info
- * @param {null|((jsdoc: import('@es-joy/jsdoccomment').JsdocBlockWithInline) => boolean|undefined)} handler
- * @param {import('eslint').Rule.Node} node
- * @returns {void}
- */
-
+* @typedef {{
+*   disallowName?: string,
+*   allowName?: string,
+*   context?: string,
+*   comment?: string,
+*   tags?: string[],
+*   replacement?: string,
+*   minimum?: Integer,
+*   message?: string,
+*   forceRequireReturn?: boolean
+* }} ContextObject
+*/
 /**
- * @callback ForEachPreferredTag
- * @param {string} tagName
- * @param {(
- *   matchingJsdocTag: import('@es-joy/jsdoccomment').JsdocTagWithInline,
- *   targetTagName: string
- * ) => void} arrayHandler
- * @param {boolean} [skipReportingBlockedTag]
- * @returns {void}
- */
-
+* @typedef {string|ContextObject} Context
+*/
 /**
- * @callback ReportSettings
- * @param {string} message
- * @returns {void}
- */
-
+* @callback CheckJsdoc
+* @param {{
+*   lastIndex?: Integer,
+*   isFunctionContext?: boolean,
+*   selector?: string,
+*   comment?: string
+* }} info
+* @param {null|((jsdoc: import('@es-joy/jsdoccomment').JsdocBlockWithInline) => boolean|undefined)} handler
+* @param {import('eslint').Rule.Node} node
+* @returns {void}
+*/
 /**
- * @callback ParseClosureTemplateTag
- * @param {import('comment-parser').Spec} tag
- * @returns {string[]}
- */
-
+* @callback ForEachPreferredTag
+* @param {string} tagName
+* @param {(
+*   matchingJsdocTag: import('@es-joy/jsdoccomment').JsdocTagWithInline,
+*   targetTagName: string
+* ) => void} arrayHandler
+* @param {boolean} [skipReportingBlockedTag]
+* @returns {void}
+*/
 /**
- * @callback GetPreferredTagNameObject
- * @param {{
- *   tagName: string
- * }} cfg
- * @returns {string|false|{
- *   message: string;
- *   replacement?: string|undefined
- * }|{
- *   blocked: true,
- *   tagName: string
- * }}
- */
-
+* @callback ReportSettings
+* @param {string} message
+* @returns {void}
+*/
 /**
- * @typedef {{
- *   forEachPreferredTag: ForEachPreferredTag,
- *   reportSettings: ReportSettings,
- *   parseClosureTemplateTag: ParseClosureTemplateTag,
- *   getPreferredTagNameObject: GetPreferredTagNameObject,
- *   pathDoesNotBeginWith: import('./jsdocUtils.js').PathDoesNotBeginWith
- * }} BasicUtils
- */
-
+* @callback ParseClosureTemplateTag
+* @param {import('comment-parser').Spec} tag
+* @returns {string[]}
+*/
 /**
- * @callback IsIteratingFunction
- * @returns {boolean}
- */
-
+* @callback GetPreferredTagNameObject
+* @param {{
+*   tagName: string
+* }} cfg
+* @returns {string|false|{
+*   message: string;
+*   replacement?: string|undefined
+* }|{
+*   blocked: true,
+*   tagName: string
+* }}
+*/
 /**
- * @callback IsVirtualFunction
- * @returns {boolean}
- */
-
+* @typedef {{
+*   forEachPreferredTag: ForEachPreferredTag,
+*   reportSettings: ReportSettings,
+*   parseClosureTemplateTag: ParseClosureTemplateTag,
+*   getPreferredTagNameObject: GetPreferredTagNameObject,
+*   pathDoesNotBeginWith: import('./jsdocUtils.js').PathDoesNotBeginWith
+* }} BasicUtils
+*/
 /**
- * @callback Stringify
- * @param {import('comment-parser').Block} tagBlock
- * @param {boolean} [specRewire]
- * @returns {string}
- */
-
+* @callback IsIteratingFunction
+* @returns {boolean}
+*/
 /**
- * @callback ReportJSDoc
- * @param {string} msg
- * @param {null|import('comment-parser').Spec|{line: Integer, column?: Integer}} [tag]
- * @param {(() => void)|null} [handler]
- * @param {boolean} [specRewire]
- * @param {undefined|{
- *   [key: string]: string
- * }} [data]
- */
-
+* @callback IsVirtualFunction
+* @returns {boolean}
+*/
 /**
- * @callback GetRegexFromString
- * @param {string} str
- * @param {string} [requiredFlags]
- * @returns {RegExp}
- */
-
+* @callback Stringify
+* @param {import('comment-parser').Block} tagBlock
+* @param {boolean} [specRewire]
+* @returns {string}
+*/
 /**
- * @callback GetTagDescription
- * @param {import('comment-parser').Spec} tg
- * @param {boolean} [returnArray]
- * @returns {string[]|string}
- */
-
+* @callback ReportJSDoc
+* @param {string} msg
+* @param {null|import('comment-parser').Spec|{line: Integer, column?: Integer}} [tag]
+* @param {(() => void)|null} [handler]
+* @param {boolean} [specRewire]
+* @param {undefined|{
+*   [key: string]: string
+* }} [data]
+*/
 /**
- * @callback SetTagDescription
- * @param {import('comment-parser').Spec} tg
- * @param {RegExp} matcher
- * @param {(description: string) => string} setter
- * @returns {Integer}
- */
-
+* @callback GetRegexFromString
+* @param {string} str
+* @param {string} [requiredFlags]
+* @returns {RegExp}
+*/
 /**
- * @callback GetDescription
- * @returns {{
- *   description: string,
- *   descriptions: string[],
- *   lastDescriptionLine: Integer
- * }}
- */
-
+* @callback GetTagDescription
+* @param {import('comment-parser').Spec} tg
+* @param {boolean} [returnArray]
+* @returns {string[]|string}
+*/
 /**
- * @callback SetBlockDescription
- * @param {(
- *   info: {
- *     delimiter: string,
- *     postDelimiter: string,
- *     start: string
- *   },
- *   seedTokens: (
- *     tokens?: Partial<import('comment-parser').Tokens>
- *   ) => import('comment-parser').Tokens,
- *   descLines: string[]
- * ) => import('comment-parser').Line[]} setter
- * @returns {void}
- */
-
+* @callback SetTagDescription
+* @param {import('comment-parser').Spec} tg
+* @param {RegExp} matcher
+* @param {(description: string) => string} setter
+* @returns {Integer}
+*/
 /**
- * @callback SetDescriptionLines
- * @param {RegExp} matcher
- * @param {(description: string) => string} setter
- * @returns {Integer}
- */
-
+* @callback GetDescription
+* @returns {{
+*   description: string,
+*   descriptions: string[],
+*   lastDescriptionLine: Integer
+* }}
+*/
 /**
- * @callback ChangeTag
- * @param {import('comment-parser').Spec} tag
- * @param {...Partial<import('comment-parser').Tokens>} tokens
- * @returns {void}
- */
-
+* @callback SetBlockDescription
+* @param {(
+*   info: {
+*     delimiter: string,
+*     postDelimiter: string,
+*     start: string
+*   },
+*   seedTokens: (
+*     tokens?: Partial<import('comment-parser').Tokens>
+*   ) => import('comment-parser').Tokens,
+*   descLines: string[]
+* ) => import('comment-parser').Line[]} setter
+* @returns {void}
+*/
 /**
- * @callback SetTag
- * @param {import('comment-parser').Spec & {
- *   line: Integer
- * }} tag
- * @param {Partial<import('comment-parser').Tokens>} [tokens]
- * @returns {void}
- */
-
+* @callback SetDescriptionLines
+* @param {RegExp} matcher
+* @param {(description: string) => string} setter
+* @returns {Integer}
+*/
 /**
- * @callback RemoveTag
- * @param {Integer} tagIndex
- * @param {{
- *   removeEmptyBlock?: boolean,
- *   tagSourceOffset?: Integer
- * }} [cfg]
- * @returns {void}
- */
-
+* @callback ChangeTag
+* @param {import('comment-parser').Spec} tag
+* @param {...Partial<import('comment-parser').Tokens>} tokens
+* @returns {void}
+*/
 /**
- * @callback AddTag
- * @param {string} targetTagName
- * @param {Integer} [number]
- * @param {import('comment-parser').Tokens|{}} [tokens]
- * @returns {void}
- */
-
+* @callback SetTag
+* @param {import('comment-parser').Spec & {
+*   line: Integer
+* }} tag
+* @param {Partial<import('comment-parser').Tokens>} [tokens]
+* @returns {void}
+*/
 /**
- * @callback GetFirstLine
- * @returns {Integer|undefined}
- */
-
+* @callback RemoveTag
+* @param {Integer} tagIndex
+* @param {{
+*   removeEmptyBlock?: boolean,
+*   tagSourceOffset?: Integer
+* }} [cfg]
+* @returns {void}
+*/
 /**
- * @typedef {(
- *   tokens?: Partial<import('comment-parser').Tokens> | undefined
- * ) => import('comment-parser').Tokens} SeedTokens
- */
-
+* @callback AddTag
+* @param {string} targetTagName
+* @param {Integer} [number]
+* @param {import('comment-parser').Tokens|{}} [tokens]
+* @returns {void}
+*/
 /**
- * Sets tokens to empty string.
- * @callback EmptyTokens
- * @param {import('comment-parser').Tokens} tokens
- * @returns {void}
- */
-
+* @callback GetFirstLine
+* @returns {Integer|undefined}
+*/
 /**
- * @callback AddLine
- * @param {Integer} sourceIndex
- * @param {Partial<import('comment-parser').Tokens>} tokens
- * @returns {void}
- */
-
+* @typedef {(
+*   tokens?: Partial<import('comment-parser').Tokens> | undefined
+* ) => import('comment-parser').Tokens} SeedTokens
+*/
 /**
- * @callback AddLines
- * @param {Integer} tagIndex
- * @param {Integer} tagSourceOffset
- * @param {Integer} numLines
- * @returns {void}
- */
-
+* Sets tokens to empty string.
+* @callback EmptyTokens
+* @param {import('comment-parser').Tokens} tokens
+* @returns {void}
+*/
 /**
- * @callback MakeMultiline
- * @returns {void}
- */
-
+* @callback AddLine
+* @param {Integer} sourceIndex
+* @param {Partial<import('comment-parser').Tokens>} tokens
+* @returns {void}
+*/
 /**
- * @callback GetFunctionParameterNames
- * @param {boolean} [useDefaultObjectProperties]
- * @returns {import('./jsdocUtils.js').ParamNameInfo[]}
- */
-
+* @callback AddLines
+* @param {Integer} tagIndex
+* @param {Integer} tagSourceOffset
+* @param {Integer} numLines
+* @returns {void}
+*/
 /**
- * @callback HasParams
- * @returns {Integer}
- */
-
+* @callback MakeMultiline
+* @returns {void}
+*/
 /**
- * @callback IsGenerator
- * @returns {boolean}
- */
-
+* @callback GetFunctionParameterNames
+* @param {boolean} [useDefaultObjectProperties]
+* @returns {import('./jsdocUtils.js').ParamNameInfo[]}
+*/
 /**
- * @callback IsConstructor
- * @returns {boolean}
- */
-
+* @callback HasParams
+* @returns {Integer}
+*/
 /**
- * @callback GetJsdocTagsDeep
- * @param {string} tagName
- * @returns {false|{
- *   idx: Integer,
- *   name: string,
- *   type: string
- * }[]}
- */
-
+* @callback IsGenerator
+* @returns {boolean}
+*/
 /**
- * @callback GetPreferredTagName
- * @param {{
- *   tagName: string,
- *   skipReportingBlockedTag?: boolean,
- *   allowObjectReturn?: boolean,
- *   defaultMessage?: string
- * }} cfg
- * @returns {string|undefined|false|{
- *   message: string;
- *   replacement?: string|undefined;
- * }|{
- *   blocked: true,
- *   tagName: string
- * }}
- */
-
+* @callback IsConstructor
+* @returns {boolean}
+*/
 /**
- * @callback IsValidTag
- * @param {string} name
- * @param {string[]} definedTags
- * @returns {boolean}
- */
-
+* @callback GetJsdocTagsDeep
+* @param {string} tagName
+* @returns {false|{
+*   idx: Integer,
+*   name: string,
+*   type: string
+* }[]}
+*/
 /**
- * @callback HasATag
- * @param {string[]} names
- * @returns {boolean}
- */
-
+* @callback GetPreferredTagName
+* @param {{
+*   tagName: string,
+*   skipReportingBlockedTag?: boolean,
+*   allowObjectReturn?: boolean,
+*   defaultMessage?: string
+* }} cfg
+* @returns {string|undefined|false|{
+*   message: string;
+*   replacement?: string|undefined;
+* }|{
+*   blocked: true,
+*   tagName: string
+* }}
+*/
 /**
- * @callback HasTag
- * @param {string} name
- * @returns {boolean}
- */
-
+* @callback IsValidTag
+* @param {string} name
+* @param {string[]} definedTags
+* @returns {boolean}
+*/
 /**
- * @callback ComparePaths
- * @param {string} name
- * @returns {(otherPathName: string) => boolean}
- */
-
+* @callback HasATag
+* @param {string[]} names
+* @returns {boolean}
+*/
 /**
- * @callback DropPathSegmentQuotes
- * @param {string} name
- * @returns {string}
- */
-
+* @callback HasTag
+* @param {string} name
+* @returns {boolean}
+*/
 /**
- * @callback AvoidDocs
- * @returns {boolean}
- */
-
+* @callback ComparePaths
+* @param {string} name
+* @returns {(otherPathName: string) => boolean}
+*/
 /**
- * @callback TagMightHaveNamePositionTypePosition
- * @param {string} tagName
- * @param {import('./getDefaultTagStructureForMode.js').
- *   TagStructure[]} [otherModeMaps]
- * @returns {boolean|{otherMode: true}}
- */
-
+* @callback DropPathSegmentQuotes
+* @param {string} name
+* @returns {string}
+*/
 /**
- * @callback TagMustHave
- * @param {string} tagName
- * @param {import('./getDefaultTagStructureForMode.js').
- *   TagStructure[]} otherModeMaps
- * @returns {boolean|{
- *   otherMode: false
- * }}
- */
-
+* @callback AvoidDocs
+* @returns {boolean}
+*/
 /**
- * @callback TagMissingRequiredTypeOrNamepath
- * @param {import('comment-parser').Spec} tag
- * @param {import('./getDefaultTagStructureForMode.js').
- *   TagStructure[]} otherModeMaps
- * @returns {boolean|{
- *   otherMode: false
- * }}
- */
-
+* @callback TagMightHaveNamePositionTypePosition
+* @param {string} tagName
+* @param {import('./getDefaultTagStructureForMode.js').
+*   TagStructure[]} [otherModeMaps]
+* @returns {boolean|{otherMode: true}}
+*/
 /**
- * @callback IsNamepathX
- * @param {string} tagName
- * @returns {boolean}
- */
-
+* @callback TagMustHave
+* @param {string} tagName
+* @param {import('./getDefaultTagStructureForMode.js').
+*   TagStructure[]} otherModeMaps
+* @returns {boolean|{
+*   otherMode: false
+* }}
+*/
 /**
- * @callback GetTagStructureForMode
- * @param {import('./jsdocUtils.js').ParserMode} mde
- * @returns {import('./getDefaultTagStructureForMode.js').TagStructure}
- */
-
+* @callback TagMissingRequiredTypeOrNamepath
+* @param {import('comment-parser').Spec} tag
+* @param {import('./getDefaultTagStructureForMode.js').
+*   TagStructure[]} otherModeMaps
+* @returns {boolean|{
+*   otherMode: false
+* }}
+*/
 /**
- * @callback MayBeUndefinedTypeTag
- * @param {import('comment-parser').Spec} tag
- * @returns {boolean}
- */
-
+* @callback IsNamepathX
+* @param {string} tagName
+* @returns {boolean}
+*/
 /**
- * @callback HasValueOrExecutorHasNonEmptyResolveValue
- * @param {boolean} anyPromiseAsReturn
- * @param {boolean} [allBranches]
- * @returns {boolean}
- */
-
+* @callback GetTagStructureForMode
+* @param {import('./jsdocUtils.js').ParserMode} mde
+* @returns {import('./getDefaultTagStructureForMode.js').TagStructure}
+*/
 /**
- * @callback HasYieldValue
- * @returns {boolean}
- */
-
+* @callback MayBeUndefinedTypeTag
+* @param {import('comment-parser').Spec} tag
+* @returns {boolean}
+*/
 /**
- * @callback HasYieldReturnValue
- * @returns {boolean}
- */
-
+* @callback HasValueOrExecutorHasNonEmptyResolveValue
+* @param {boolean} anyPromiseAsReturn
+* @param {boolean} [allBranches]
+* @returns {boolean}
+*/
 /**
- * @callback HasThrowValue
- * @returns {boolean}
- */
-
+* @callback HasYieldValue
+* @returns {boolean}
+*/
 /**
- * @callback IsAsync
- * @returns {boolean|undefined}
- */
-
+* @callback HasYieldReturnValue
+* @returns {boolean}
+*/
 /**
- * @callback GetTags
- * @param {string} tagName
- * @returns {import('comment-parser').Spec[]}
- */
-
+* @callback HasThrowValue
+* @returns {boolean}
+*/
 /**
- * @callback GetPresentTags
- * @param {string[]} tagList
- * @returns {import('@es-joy/jsdoccomment').JsdocTagWithInline[]}
- */
-
+* @callback IsAsync
+* @returns {boolean|undefined}
+*/
 /**
- * @callback FilterTags
- * @param {(tag: import('@es-joy/jsdoccomment').JsdocTagWithInline) => boolean} filter
- * @returns {import('@es-joy/jsdoccomment').JsdocTagWithInline[]}
- */
-
+* @callback GetTags
+* @param {string} tagName
+* @returns {import('comment-parser').Spec[]}
+*/
 /**
- * @callback FilterAllTags
- * @param {(tag: (import('comment-parser').Spec|
- *   import('@es-joy/jsdoccomment').JsdocInlineTagNoType)) => boolean} filter
- * @returns {(import('comment-parser').Spec|
- *   import('@es-joy/jsdoccomment').JsdocInlineTagNoType)[]}
- */
-
+* @callback GetPresentTags
+* @param {string[]} tagList
+* @returns {import('@es-joy/jsdoccomment').JsdocTagWithInline[]}
+*/
 /**
- * @callback GetTagsByType
- * @param {import('comment-parser').Spec[]} tags
- * @returns {{
- *   tagsWithNames: import('comment-parser').Spec[],
- *   tagsWithoutNames: import('comment-parser').Spec[]
- * }}
- */
-
+* @callback FilterTags
+* @param {(tag: import('@es-joy/jsdoccomment').JsdocTagWithInline) => boolean} filter
+* @returns {import('@es-joy/jsdoccomment').JsdocTagWithInline[]}
+*/
 /**
- * @callback HasOptionTag
- * @param {string} tagName
- * @returns {boolean}
- */
-
+* @callback FilterAllTags
+* @param {(tag: (import('comment-parser').Spec|
+*   import('@es-joy/jsdoccomment').JsdocInlineTagNoType)) => boolean} filter
+* @returns {(import('comment-parser').Spec|
+*   import('@es-joy/jsdoccomment').JsdocInlineTagNoType)[]}
+*/
 /**
- * @callback GetClassNode
- * @returns {Node|null}
- */
-
+* @callback GetTagsByType
+* @param {import('comment-parser').Spec[]} tags
+* @returns {{
+*   tagsWithNames: import('comment-parser').Spec[],
+*   tagsWithoutNames: import('comment-parser').Spec[]
+* }}
+*/
 /**
- * @callback GetClassJsdoc
- * @returns {null|JsdocBlockWithInline}
- */
-
+* @callback HasOptionTag
+* @param {string} tagName
+* @returns {boolean}
+*/
 /**
- * @callback ClassHasTag
- * @param {string} tagName
- * @returns {boolean}
- */
-
+* @callback GetClassNode
+* @returns {Node|null}
+*/
 /**
- * @callback FindContext
- * @param {Context[]} contexts
- * @param {string|undefined} comment
- * @returns {{
- *   foundContext: Context|undefined,
- *   contextStr: string
- * }}
- */
-
+* @callback GetClassJsdoc
+* @returns {null|JsdocBlockWithInline}
+*/
 /**
- * @typedef {BasicUtils & {
- *   isIteratingFunction: IsIteratingFunction,
- *   isVirtualFunction: IsVirtualFunction,
- *   stringify: Stringify,
- *   reportJSDoc: ReportJSDoc,
- *   getRegexFromString: GetRegexFromString,
- *   getTagDescription: GetTagDescription,
- *   setTagDescription: SetTagDescription,
- *   getDescription: GetDescription,
- *   setBlockDescription: SetBlockDescription,
- *   setDescriptionLines: SetDescriptionLines,
- *   changeTag: ChangeTag,
- *   setTag: SetTag,
- *   removeTag: RemoveTag,
- *   addTag: AddTag,
- *   getFirstLine: GetFirstLine,
- *   seedTokens: SeedTokens,
- *   emptyTokens: EmptyTokens,
- *   addLine: AddLine,
- *   addLines: AddLines,
- *   makeMultiline: MakeMultiline,
- *   flattenRoots: import('./jsdocUtils.js').FlattenRoots,
- *   getFunctionParameterNames: GetFunctionParameterNames,
- *   hasParams: HasParams,
- *   isGenerator: IsGenerator,
- *   isConstructor: IsConstructor,
- *   getJsdocTagsDeep: GetJsdocTagsDeep,
- *   getPreferredTagName: GetPreferredTagName,
- *   isValidTag: IsValidTag,
- *   hasATag: HasATag,
- *   hasTag: HasTag,
- *   comparePaths: ComparePaths,
- *   dropPathSegmentQuotes: DropPathSegmentQuotes,
- *   avoidDocs: AvoidDocs,
- *   tagMightHaveNamePosition: TagMightHaveNamePositionTypePosition,
- *   tagMightHaveTypePosition: TagMightHaveNamePositionTypePosition,
- *   tagMustHaveNamePosition: TagMustHave,
- *   tagMustHaveTypePosition: TagMustHave,
- *   tagMissingRequiredTypeOrNamepath: TagMissingRequiredTypeOrNamepath,
- *   isNamepathDefiningTag: IsNamepathX,
- *   isNamepathReferencingTag: IsNamepathX,
- *   isNamepathOrUrlReferencingTag: IsNamepathX,
- *   tagMightHaveNamepath: IsNamepathX,
- *   getTagStructureForMode: GetTagStructureForMode,
- *   mayBeUndefinedTypeTag: MayBeUndefinedTypeTag,
- *   hasValueOrExecutorHasNonEmptyResolveValue: HasValueOrExecutorHasNonEmptyResolveValue,
- *   hasYieldValue: HasYieldValue,
- *   hasYieldReturnValue: HasYieldReturnValue,
- *   hasThrowValue: HasThrowValue,
- *   isAsync: IsAsync,
- *   getTags: GetTags,
- *   getPresentTags: GetPresentTags,
- *   filterTags: FilterTags,
- *   filterAllTags: FilterAllTags,
- *   getTagsByType: GetTagsByType,
- *   hasOptionTag: HasOptionTag,
- *   getClassNode: GetClassNode,
- *   getClassJsdoc: GetClassJsdoc,
- *   classHasTag: ClassHasTag,
- *   findContext: FindContext
- * }} Utils
- */
-
-const {
-  rewireSpecs,
-  seedTokens
-} = _commentParser.util;
-
-// todo: Change these `any` types once importing types properly.
-
+* @callback ClassHasTag
+* @param {string} tagName
+* @returns {boolean}
+*/
 /**
- * Should use ESLint rule's typing.
- * @typedef {import('eslint').Rule.RuleMetaData} EslintRuleMeta
- */
-
+* @callback FindContext
+* @param {Context[]} contexts
+* @param {string|undefined} comment
+* @returns {{
+*   foundContext: Context|undefined,
+*   contextStr: string
+* }}
+*/
 /**
- * A plain object for tracking state as needed by rules across iterations.
- * @typedef {{
- *   globalTags: {},
- *   hasDuplicates: {
- *     [key: string]: boolean
- *   },
- *   selectorMap: {
- *     [selector: string]: {
- *       [comment: string]: Integer
- *     }
- *   },
- *   hasTag: {
- *     [key: string]: boolean
- *   },
- *   hasNonComment: number,
- *   hasNonCommentBeforeTag: {
- *     [key: string]: boolean|number
- *   }
- * }} StateObject
- */
-
+* @typedef {BasicUtils & {
+*   isIteratingFunction: IsIteratingFunction,
+*   isIteratingFunctionOrVariable: IsIteratingFunction,
+*   isVirtualFunction: IsVirtualFunction,
+*   stringify: Stringify,
+*   reportJSDoc: ReportJSDoc,
+*   getRegexFromString: GetRegexFromString,
+*   getTagDescription: GetTagDescription,
+*   setTagDescription: SetTagDescription,
+*   getDescription: GetDescription,
+*   setBlockDescription: SetBlockDescription,
+*   setDescriptionLines: SetDescriptionLines,
+*   changeTag: ChangeTag,
+*   setTag: SetTag,
+*   removeTag: RemoveTag,
+*   addTag: AddTag,
+*   getFirstLine: GetFirstLine,
+*   seedTokens: SeedTokens,
+*   emptyTokens: EmptyTokens,
+*   addLine: AddLine,
+*   addLines: AddLines,
+*   makeMultiline: MakeMultiline,
+*   flattenRoots: import('./jsdocUtils.js').FlattenRoots,
+*   getFunctionParameterNames: GetFunctionParameterNames,
+*   hasParams: HasParams,
+*   isGenerator: IsGenerator,
+*   isConstructor: IsConstructor,
+*   getJsdocTagsDeep: GetJsdocTagsDeep,
+*   getPreferredTagName: GetPreferredTagName,
+*   isValidTag: IsValidTag,
+*   hasATag: HasATag,
+*   hasTag: HasTag,
+*   comparePaths: ComparePaths,
+*   dropPathSegmentQuotes: DropPathSegmentQuotes,
+*   avoidDocs: AvoidDocs,
+*   tagMightHaveNamePosition: TagMightHaveNamePositionTypePosition,
+*   tagMightHaveTypePosition: TagMightHaveNamePositionTypePosition,
+*   tagMustHaveNamePosition: TagMustHave,
+*   tagMustHaveTypePosition: TagMustHave,
+*   tagMissingRequiredTypeOrNamepath: TagMissingRequiredTypeOrNamepath,
+*   isNamepathDefiningTag: IsNamepathX,
+*   isNamepathReferencingTag: IsNamepathX,
+*   isNamepathOrUrlReferencingTag: IsNamepathX,
+*   tagMightHaveNamepath: IsNamepathX,
+*   getTagStructureForMode: GetTagStructureForMode,
+*   mayBeUndefinedTypeTag: MayBeUndefinedTypeTag,
+*   hasValueOrExecutorHasNonEmptyResolveValue: HasValueOrExecutorHasNonEmptyResolveValue,
+*   hasYieldValue: HasYieldValue,
+*   hasYieldReturnValue: HasYieldReturnValue,
+*   hasThrowValue: HasThrowValue,
+*   isAsync: IsAsync,
+*   getTags: GetTags,
+*   getPresentTags: GetPresentTags,
+*   filterTags: FilterTags,
+*   filterAllTags: FilterAllTags,
+*   getTagsByType: GetTagsByType,
+*   hasOptionTag: HasOptionTag,
+*   getClassNode: GetClassNode,
+*   getClassJsdoc: GetClassJsdoc,
+*   classHasTag: ClassHasTag,
+*   findContext: FindContext
+* }} Utils
+*/
+const { rewireSpecs, seedTokens } = comment_parser.util;
 /**
- * The Node AST as supplied by the parser.
- * @typedef {import('eslint').Rule.Node} Node
- */
-
-/*
-const {
-   align as commentAlign,
-  flow: commentFlow,
-  indent: commentIndent,
-} = transforms;
+* Should use ESLint rule's typing.
+* @typedef {import('eslint').Rule.RuleMetaData} EslintRuleMeta
 */
-
-const globalState = new Map();
-/**
- * @param {import('eslint').Rule.RuleContext} context
- * @param {{
- *   tagNamePreference?: import('./jsdocUtils.js').TagNamePreference,
- *   mode?: import('./jsdocUtils.js').ParserMode
- * }} cfg
- * @returns {BasicUtils}
- */
-const getBasicUtils = (context, {
-  mode,
-  tagNamePreference
-}) => {
-  /** @type {BasicUtils} */
-  const utils = {};
-
-  /** @type {ReportSettings} */
-  utils.reportSettings = message => {
-    context.report({
-      loc: {
-        end: {
-          column: 1,
-          line: 1
-        },
-        start: {
-          column: 1,
-          line: 1
-        }
-      },
-      message
-    });
-  };
-
-  /** @type {ParseClosureTemplateTag} */
-  utils.parseClosureTemplateTag = tag => {
-    return jsdocUtils.parseClosureTemplateTag(tag);
-  };
-  utils.pathDoesNotBeginWith = jsdocUtils.pathDoesNotBeginWith;
-
-  /** @type {GetPreferredTagNameObject} */
-  utils.getPreferredTagNameObject = ({
-    tagName
-  }) => {
-    const ret = jsdocUtils.getPreferredTagNameSimple(tagName, /** @type {import('./jsdocUtils.js').ParserMode} */mode, tagNamePreference, context);
-    const isObject = ret && typeof ret === 'object';
-    if (ret === false || isObject && !ret.replacement) {
-      return {
-        blocked: true,
-        tagName
-      };
-    }
-    return ret;
-  };
-  return utils;
+/**
+* A plain object for tracking state as needed by rules across iterations.
+* @typedef {{
+*   globalTags: {},
+*   hasDuplicates: {
+*     [key: string]: boolean
+*   },
+*   selectorMap: {
+*     [selector: string]: {
+*       [comment: string]: Integer
+*     }
+*   },
+*   hasTag: {
+*     [key: string]: boolean
+*   },
+*   hasNonComment: number,
+*   hasNonCommentBeforeTag: {
+*     [key: string]: boolean|number
+*   }
+* }} StateObject
+*/
+/**
+* The Node AST as supplied by the parser.
+* @typedef {import('eslint').Rule.Node} Node
+*/
+const globalState = /* @__PURE__ */ new Map();
+/**
+* @param {import('eslint').Rule.RuleContext} context
+* @param {{
+*   tagNamePreference?: import('./jsdocUtils.js').TagNamePreference,
+*   mode?: import('./jsdocUtils.js').ParserMode
+* }} cfg
+* @returns {BasicUtils}
+*/
+const getBasicUtils = (context, { mode, tagNamePreference }) => {
+	/** @type {BasicUtils} */
+	const utils = {};
+	/** @type {ReportSettings} */
+	utils.reportSettings = (message) => {
+		context.report({
+			loc: {
+				end: {
+					column: 1,
+					line: 1
+				},
+				start: {
+					column: 1,
+					line: 1
+				}
+			},
+			message
+		});
+	};
+	/** @type {ParseClosureTemplateTag} */
+	utils.parseClosureTemplateTag = (tag) => {
+		return require_jsdocUtils.parseClosureTemplateTag(tag);
+	};
+	utils.pathDoesNotBeginWith = require_jsdocUtils.pathDoesNotBeginWith;
+	/** @type {GetPreferredTagNameObject} */
+	utils.getPreferredTagNameObject = ({ tagName }) => {
+		const ret = require_jsdocUtils.getPreferredTagNameSimple(tagName, mode, tagNamePreference, context);
+		const isObject = ret && typeof ret === "object";
+		if (ret === false || isObject && !ret.replacement) return {
+			blocked: true,
+			tagName
+		};
+		return ret;
+	};
+	return utils;
 };
-
 /**
- * @callback Report
- * @param {string} message
- * @param {import('eslint').Rule.ReportFixer|null} [fix]
- * @param {null|
- *   {line?: Integer, column?: Integer}|
- *   import('comment-parser').Spec & {line?: Integer}
- * } [jsdocLoc]
- * @param {undefined|{
- *   [key: string]: string
- * }} [data]
- * @returns {void}
- */
-
+* @callback Report
+* @param {string} message
+* @param {import('eslint').Rule.ReportFixer|null} [fix]
+* @param {null|
+*   {line?: Integer, column?: Integer}|
+*   import('comment-parser').Spec & {line?: Integer}
+* } [jsdocLoc]
+* @param {undefined|{
+*   [key: string]: string
+* }} [data]
+* @returns {void}
+*/
 /**
- * @param {Node|null} node
- * @param {JsdocBlockWithInline} jsdoc
- * @param {import('eslint').AST.Token} jsdocNode
- * @param {Settings} settings
- * @param {Report} report
- * @param {import('eslint').Rule.RuleContext} context
- * @param {import('eslint').SourceCode} sc
- * @param {boolean|undefined} iteratingAll
- * @param {RuleConfig} ruleConfig
- * @param {string} indent
- * @returns {Utils}
- */
+* @param {Node|null} node
+* @param {JsdocBlockWithInline} jsdoc
+* @param {import('eslint').AST.Token} jsdocNode
+* @param {Settings} settings
+* @param {Report} report
+* @param {import('eslint').Rule.RuleContext} context
+* @param {import('eslint').SourceCode} sc
+* @param {boolean|undefined} iteratingAll
+* @param {RuleConfig} ruleConfig
+* @param {string} indent
+* @returns {Utils}
+*/
 const getUtils = (node, jsdoc, jsdocNode, settings, report, context, sc, iteratingAll, ruleConfig, indent) => {
-  const ancestors = /** @type {import('eslint').Rule.Node[]} */node ? sc.getAncestors ? sc.getAncestors(node)
-  /* c8 ignore next 4 */ : context.getAncestors() : [];
-
-  /* c8 ignore next -- Fallback to deprecated method */
-  const {
-    sourceCode = context.getSourceCode()
-  } = context;
-  const utils = /** @type {Utils} */getBasicUtils(context, settings);
-  const {
-    augmentsExtendsReplacesDocs,
-    ignoreReplacesDocs,
-    implementsReplacesDocs,
-    maxLines,
-    minLines,
-    mode,
-    overrideReplacesDocs,
-    tagNamePreference
-  } = settings;
-
-  /** @type {IsIteratingFunction} */
-  utils.isIteratingFunction = () => {
-    return !iteratingAll || ['ArrowFunctionExpression', 'FunctionDeclaration', 'FunctionExpression', 'MethodDefinition'].includes(String(node && node.type));
-  };
-
-  /** @type {IsVirtualFunction} */
-  utils.isVirtualFunction = () => {
-    return Boolean(iteratingAll) && utils.hasATag(['callback', 'function', 'func', 'method']);
-  };
-
-  /** @type {Stringify} */
-  utils.stringify = (tagBlock, specRewire) => {
-    let block;
-    if (specRewire) {
-      block = rewireSpecs(tagBlock);
-    }
-    return (0, _commentParser.stringify)(/** @type {import('comment-parser').Block} */
-    specRewire ? block : tagBlock);
-  };
-
-  /** @type {ReportJSDoc} */
-  utils.reportJSDoc = (msg, tag, handler, specRewire, data) => {
-    report(msg, handler ? /** @type {import('eslint').Rule.ReportFixer} */fixer => {
-      handler();
-      const replacement = utils.stringify(jsdoc, specRewire);
-      if (!replacement) {
-        const text = sourceCode.getText();
-        const lastLineBreakPos = text.slice(0, jsdocNode.range[0]).search(/\n[ \t]*$/v);
-        if (lastLineBreakPos > -1) {
-          return fixer.removeRange([lastLineBreakPos, jsdocNode.range[1]]);
-        }
-        return fixer.removeRange(/\s/v.test(text.charAt(jsdocNode.range[1])) ? [jsdocNode.range[0], jsdocNode.range[1] + 1] : jsdocNode.range);
-      }
-      return fixer.replaceText(jsdocNode, replacement);
-    } : null, tag, data);
-  };
-
-  /** @type {GetRegexFromString} */
-  utils.getRegexFromString = (str, requiredFlags) => {
-    return jsdocUtils.getRegexFromString(str, requiredFlags);
-  };
-
-  /** @type {GetTagDescription} */
-  utils.getTagDescription = (tg, returnArray) => {
-    return jsdocUtils.getTagDescription(tg, returnArray);
-  };
-
-  /** @type {SetTagDescription} */
-  utils.setTagDescription = (tg, matcher, setter) => {
-    let finalIdx = 0;
-    tg.source.some(({
-      tokens: {
-        description
-      }
-    }, idx) => {
-      if (description && matcher.test(description)) {
-        tg.source[idx].tokens.description = setter(description);
-        finalIdx = idx;
-        return true;
-      }
-      return false;
-    });
-    return finalIdx;
-  };
-
-  /** @type {GetDescription} */
-  utils.getDescription = () => {
-    /** @type {string[]} */
-    const descriptions = [];
-    let lastDescriptionLine = 0;
-    let tagsBegun = false;
-    jsdoc.source.some(({
-      tokens: {
-        description,
-        end,
-        tag
-      }
-    }, idx) => {
-      if (tag) {
-        tagsBegun = true;
-      }
-      if (idx && (tag || end)) {
-        lastDescriptionLine = idx - 1;
-        if (!tagsBegun && description) {
-          descriptions.push(description);
-        }
-        return true;
-      }
-      if (!tagsBegun && (idx || description)) {
-        descriptions.push(description || (descriptions.length ? '' : '\n'));
-      }
-      return false;
-    });
-    return {
-      description: descriptions.join('\n'),
-      descriptions,
-      lastDescriptionLine
-    };
-  };
-
-  /** @type {SetBlockDescription} */
-  utils.setBlockDescription = setter => {
-    /** @type {string[]} */
-    const descLines = [];
-    /**
-     * @type {undefined|Integer}
-     */
-    let startIdx;
-    /**
-     * @type {undefined|Integer}
-     */
-    let endIdx;
-
-    /**
-     * @type {undefined|{
-     *   delimiter: string,
-     *   postDelimiter: string,
-     *   start: string
-     * }}
-     */
-    let info;
-    jsdoc.source.some(({
-      tokens: {
-        delimiter,
-        description,
-        end,
-        postDelimiter,
-        start,
-        tag
-      }
-    }, idx) => {
-      if (delimiter === '/**') {
-        return false;
-      }
-      if (startIdx === undefined) {
-        startIdx = idx;
-        info = {
-          delimiter,
-          postDelimiter,
-          start
-        };
-      }
-      if (tag || end) {
-        endIdx = idx;
-        return true;
-      }
-      descLines.push(description);
-      return false;
-    });
-
-    /* c8 ignore else -- Won't be called if missing */
-    if (descLines.length) {
-      jsdoc.source.splice(/** @type {Integer} */startIdx, /** @type {Integer} */endIdx - (/** @type {Integer} */startIdx), ...setter(
-      /**
-       * @type {{
-       *   delimiter: string,
-       *   postDelimiter: string,
-       *   start: string
-       * }}
-       */
-      info, seedTokens, descLines));
-    }
-  };
-
-  /** @type {SetDescriptionLines} */
-  utils.setDescriptionLines = (matcher, setter) => {
-    let finalIdx = 0;
-    jsdoc.source.some(({
-      tokens: {
-        description,
-        end,
-        tag
-      }
-    }, idx) => {
-      /* c8 ignore next 3 -- Already checked */
-      if (idx && (tag || end)) {
-        return true;
-      }
-      if (description && matcher.test(description)) {
-        jsdoc.source[idx].tokens.description = setter(description);
-        finalIdx = idx;
-        return true;
-      }
-      return false;
-    });
-    return finalIdx;
-  };
-
-  /** @type {ChangeTag} */
-  utils.changeTag = (tag, ...tokens) => {
-    for (const [idx, src] of tag.source.entries()) {
-      src.tokens = {
-        ...src.tokens,
-        ...tokens[idx]
-      };
-    }
-  };
-
-  /** @type {SetTag} */
-  utils.setTag = (tag, tokens) => {
-    tag.source = [{
-      number: tag.line,
-      // Or tag.source[0].number?
-      source: '',
-      tokens: seedTokens({
-        delimiter: '*',
-        postDelimiter: ' ',
-        start: indent + ' ',
-        tag: '@' + tag.tag,
-        ...tokens
-      })
-    }];
-  };
-
-  /** @type {RemoveTag} */
-  utils.removeTag = (tagIndex, {
-    removeEmptyBlock = false,
-    tagSourceOffset = 0
-  } = {}) => {
-    const {
-      source: tagSource
-    } = jsdoc.tags[tagIndex];
-    /** @type {Integer|undefined} */
-    let lastIndex;
-    const firstNumber = jsdoc.source[0].number;
-    tagSource.some(({
-      number
-    }, tagIdx) => {
-      const sourceIndex = jsdoc.source.findIndex(({
-        number: srcNumber
-      }) => {
-        return number === srcNumber;
-      });
-      // c8 ignore else
-      if (sourceIndex > -1) {
-        let spliceCount = 1;
-        tagSource.slice(tagIdx + 1).some(({
-          tokens: {
-            end: ending,
-            tag
-          }
-        }) => {
-          if (!tag && !ending) {
-            spliceCount++;
-            return false;
-          }
-          return true;
-        });
-        const spliceIdx = sourceIndex + tagSourceOffset;
-        const {
-          delimiter,
-          end
-        } = jsdoc.source[spliceIdx].tokens;
-        if (spliceIdx === 0 && jsdoc.tags.length >= 2 || !removeEmptyBlock && (end || delimiter === '/**')) {
-          const {
-            tokens
-          } = jsdoc.source[spliceIdx];
-          for (const item of ['postDelimiter', 'tag', 'postTag', 'type', 'postType', 'name', 'postName', 'description']) {
-            tokens[(
-            /**
-             * @type {"postDelimiter"|"tag"|"type"|"postType"|
-             *   "postTag"|"name"|"postName"|"description"}
-             */
-            item)] = '';
-          }
-        } else {
-          jsdoc.source.splice(spliceIdx, spliceCount - tagSourceOffset + (spliceIdx ? 0 : jsdoc.source.length));
-          tagSource.splice(tagIdx + tagSourceOffset, spliceCount - tagSourceOffset + (spliceIdx ? 0 : jsdoc.source.length));
-        }
-        lastIndex = sourceIndex;
-        return true;
-      }
-      /* c8 ignore next 2 */
-      // eslint-disable-next-line @stylistic/padding-line-between-statements -- c8
-      return false;
-    });
-    for (const [idx, src] of jsdoc.source.slice(lastIndex).entries()) {
-      src.number = firstNumber + (/** @type {Integer} */lastIndex) + idx;
-    }
-
-    // Todo: Once rewiring of tags may be fixed in comment-parser to reflect
-    //         missing tags, this step should be added here (so that, e.g.,
-    //         if accessing `jsdoc.tags`, such as to add a new tag, the
-    //         correct information will be available)
-  };
-
-  /** @type {AddTag} */
-  utils.addTag = (targetTagName, number = (jsdoc.tags[jsdoc.tags.length - 1]?.source[0]?.number ?? jsdoc.source.findIndex(({
-    tokens: {
-      tag
-    }
-  }) => {
-    return tag;
-  }) - 1) + 1, tokens = {}) => {
-    jsdoc.source.splice(number, 0, {
-      number,
-      source: '',
-      tokens: seedTokens({
-        delimiter: '*',
-        postDelimiter: ' ',
-        start: indent + ' ',
-        tag: `@${targetTagName}`,
-        ...tokens
-      })
-    });
-    for (const src of jsdoc.source.slice(number + 1)) {
-      src.number++;
-    }
-  };
-
-  /** @type {GetFirstLine} */
-  utils.getFirstLine = () => {
-    let firstLine;
-    for (const {
-      number,
-      tokens: {
-        tag
-      }
-    } of jsdoc.source) {
-      if (tag) {
-        firstLine = number;
-        break;
-      }
-    }
-    return firstLine;
-  };
-
-  /** @type {SeedTokens} */
-  utils.seedTokens = seedTokens;
-
-  /** @type {EmptyTokens} */
-  utils.emptyTokens = tokens => {
-    for (const prop of ['start', 'postDelimiter', 'tag', 'type', 'postType', 'postTag', 'name', 'postName', 'description', 'end', 'lineEnd']) {
-      tokens[(
-      /**
-       * @type {"start"|"postDelimiter"|"tag"|"type"|"postType"|
-       *   "postTag"|"name"|"postName"|"description"|"end"|"lineEnd"}
-       */
-      prop)] = '';
-    }
-  };
-
-  /** @type {AddLine} */
-  utils.addLine = (sourceIndex, tokens) => {
-    const number = (jsdoc.source[sourceIndex - 1]?.number || 0) + 1;
-    jsdoc.source.splice(sourceIndex, 0, {
-      number,
-      source: '',
-      tokens: seedTokens(tokens)
-    });
-    for (const src of jsdoc.source.slice(number + 1)) {
-      src.number++;
-    }
-    // If necessary, we can rewire the tags (misnamed method)
-    // rewireSource(jsdoc);
-  };
-
-  /** @type {AddLines} */
-  utils.addLines = (tagIndex, tagSourceOffset, numLines) => {
-    const {
-      source: tagSource
-    } = jsdoc.tags[tagIndex];
-    /** @type {Integer|undefined} */
-    let lastIndex;
-    const firstNumber = jsdoc.source[0].number;
-    tagSource.some(({
-      number
-    }) => {
-      const makeLine = () => {
-        return {
-          number,
-          source: '',
-          tokens: seedTokens({
-            delimiter: '*',
-            start: indent + ' '
-          })
-        };
-      };
-      const makeLines = () => {
-        return Array.from({
-          length: numLines
-        }, makeLine);
-      };
-      const sourceIndex = jsdoc.source.findIndex(({
-        number: srcNumber,
-        tokens: {
-          end
-        }
-      }) => {
-        return number === srcNumber && !end;
-      });
-      // c8 ignore else
-      if (sourceIndex > -1) {
-        const lines = makeLines();
-        jsdoc.source.splice(sourceIndex + tagSourceOffset, 0, ...lines);
-
-        // tagSource.splice(tagIdx + 1, 0, ...makeLines());
-        lastIndex = sourceIndex;
-        return true;
-      }
-      /* c8 ignore next 2 */
-      // eslint-disable-next-line @stylistic/padding-line-between-statements -- c8
-      return false;
-    });
-    for (const [idx, src] of jsdoc.source.slice(lastIndex).entries()) {
-      src.number = firstNumber + (/** @type {Integer} */lastIndex) + idx;
-    }
-  };
-
-  /** @type {MakeMultiline} */
-  utils.makeMultiline = () => {
-    const {
-      source: [{
-        tokens
-      }]
-    } = jsdoc;
-    const {
-      description,
-      lineEnd,
-      name,
-      postDelimiter,
-      tag,
-      type
-    } = tokens;
-    let {
-      tokens: {
-        postName,
-        postTag,
-        postType
-      }
-    } = jsdoc.source[0];
-
-    // Strip trailing leftovers from single line ending
-    if (!description) {
-      if (postName) {
-        postName = '';
-      } else if (postType) {
-        postType = '';
-      } else /* c8 ignore else -- `comment-parser` prevents empty blocks currently per https://github.com/syavorsky/comment-parser/issues/128 */if (postTag) {
-          postTag = '';
-        }
-    }
-    utils.emptyTokens(tokens);
-    utils.addLine(1, {
-      delimiter: '*',
-      // If a description were present, it may have whitespace attached
-      //   due to being at the end of the single line
-      description: description.trimEnd(),
-      name,
-      postDelimiter,
-      postName,
-      postTag,
-      postType,
-      start: indent + ' ',
-      tag,
-      type
-    });
-    utils.addLine(2, {
-      end: '*/',
-      lineEnd,
-      start: indent + ' '
-    });
-  };
-
-  /**
-   * @type {import('./jsdocUtils.js').FlattenRoots}
-   */
-  utils.flattenRoots = jsdocUtils.flattenRoots;
-
-  /** @type {GetFunctionParameterNames} */
-  utils.getFunctionParameterNames = useDefaultObjectProperties => {
-    return jsdocUtils.getFunctionParameterNames(node, useDefaultObjectProperties);
-  };
-
-  /** @type {HasParams} */
-  utils.hasParams = () => {
-    return jsdocUtils.hasParams(/** @type {Node} */node);
-  };
-
-  /** @type {IsGenerator} */
-  utils.isGenerator = () => {
-    return node !== null && Boolean(
-    /**
-     * @type {import('estree').FunctionDeclaration|
-     *   import('estree').FunctionExpression}
-     */
-    node.generator || node.type === 'MethodDefinition' && node.value.generator || ['ExportDefaultDeclaration', 'ExportNamedDeclaration'].includes(node.type) && /** @type {import('estree').FunctionDeclaration} */
-    (
-    /**
-     * @type {import('estree').ExportNamedDeclaration|
-     *   import('estree').ExportDefaultDeclaration}
-     */
-    node.declaration)?.generator);
-  };
-
-  /** @type {IsConstructor} */
-  utils.isConstructor = () => {
-    return jsdocUtils.isConstructor(/** @type {Node} */node);
-  };
-
-  /** @type {GetJsdocTagsDeep} */
-  utils.getJsdocTagsDeep = tagName => {
-    const name = /** @type {string|false} */utils.getPreferredTagName({
-      tagName
-    });
-    if (!name) {
-      return false;
-    }
-    return jsdocUtils.getJsdocTagsDeep(jsdoc, name);
-  };
-
-  /** @type {GetPreferredTagName} */
-  utils.getPreferredTagName = args => {
-    return jsdocUtils.getPreferredTagName(jsdoc, {
-      ...args,
-      context,
-      mode,
-      report,
-      tagNamePreference
-    });
-  };
-
-  /** @type {IsValidTag} */
-  utils.isValidTag = (name, definedTags) => {
-    return jsdocUtils.isValidTag(context, mode, name, definedTags);
-  };
-
-  /** @type {HasATag} */
-  utils.hasATag = names => {
-    return jsdocUtils.hasATag(jsdoc, names);
-  };
-
-  /** @type {HasTag} */
-  utils.hasTag = name => {
-    return jsdocUtils.hasTag(jsdoc, name);
-  };
-
-  /** @type {ComparePaths} */
-  utils.comparePaths = name => {
-    return jsdocUtils.comparePaths(name);
-  };
-
-  /** @type {DropPathSegmentQuotes} */
-  utils.dropPathSegmentQuotes = name => {
-    return jsdocUtils.dropPathSegmentQuotes(name);
-  };
-
-  /** @type {AvoidDocs} */
-  utils.avoidDocs = () => {
-    if (ignoreReplacesDocs !== false && (utils.hasTag('ignore') || utils.classHasTag('ignore')) || overrideReplacesDocs !== false && (utils.hasTag('override') || utils.classHasTag('override')) || implementsReplacesDocs !== false && (utils.hasTag('implements') || utils.classHasTag('implements')) || augmentsExtendsReplacesDocs && (utils.hasATag(['augments', 'extends']) || utils.classHasTag('augments') || utils.classHasTag('extends'))) {
-      return true;
-    }
-    if (jsdocUtils.exemptSpeciaMethods(jsdoc, node, context, /** @type {import('json-schema').JSONSchema4|import('json-schema').JSONSchema4[]} */
-    ruleConfig.meta.schema)) {
-      return true;
-    }
-    const exemptedBy = context.options[0]?.exemptedBy ?? ['inheritDoc', ...(mode === 'closure' ? [] : ['inheritdoc'])];
-    if (exemptedBy.length && utils.getPresentTags(exemptedBy).length) {
-      return true;
-    }
-    return false;
-  };
-  for (const method of ['tagMightHaveNamePosition', 'tagMightHaveTypePosition']) {
-    /** @type {TagMightHaveNamePositionTypePosition} */
-    utils[(/** @type {"tagMightHaveNamePosition"|"tagMightHaveTypePosition"} */
-    method)] = (tagName, otherModeMaps) => {
-      const result = jsdocUtils[(/** @type {"tagMightHaveNamePosition"|"tagMightHaveTypePosition"} */
-      method)](tagName);
-      if (result) {
-        return true;
-      }
-      if (!otherModeMaps) {
-        return false;
-      }
-      const otherResult = otherModeMaps.some(otherModeMap => {
-        return jsdocUtils[(/** @type {"tagMightHaveNamePosition"|"tagMightHaveTypePosition"} */
-        method)](tagName, otherModeMap);
-      });
-      return otherResult ? {
-        otherMode: true
-      } : false;
-    };
-  }
-
-  /** @type {TagMissingRequiredTypeOrNamepath} */
-  utils.tagMissingRequiredTypeOrNamepath = (tagName, otherModeMaps) => {
-    const result = jsdocUtils.tagMissingRequiredTypeOrNamepath(tagName);
-    if (!result) {
-      return false;
-    }
-    const otherResult = otherModeMaps.every(otherModeMap => {
-      return jsdocUtils.tagMissingRequiredTypeOrNamepath(tagName, otherModeMap);
-    });
-    return otherResult ? true : {
-      otherMode: false
-    };
-  };
-  for (const method of ['tagMustHaveNamePosition', 'tagMustHaveTypePosition']) {
-    /** @type {TagMustHave} */
-    utils[(/** @type {"tagMustHaveNamePosition"|"tagMustHaveTypePosition"} */
-    method)] = (tagName, otherModeMaps) => {
-      const result = jsdocUtils[(/** @type {"tagMustHaveNamePosition"|"tagMustHaveTypePosition"} */
-      method)](tagName);
-      if (!result) {
-        return false;
-      }
-
-      // if (!otherModeMaps) { return true; }
-
-      const otherResult = otherModeMaps.every(otherModeMap => {
-        return jsdocUtils[(/** @type {"tagMustHaveNamePosition"|"tagMustHaveTypePosition"} */
-        method)](tagName, otherModeMap);
-      });
-      return otherResult ? true : {
-        otherMode: false
-      };
-    };
-  }
-  for (const method of ['isNamepathDefiningTag', 'isNamepathReferencingTag', 'isNamepathOrUrlReferencingTag', 'tagMightHaveNamepath']) {
-    /** @type {IsNamepathX} */
-    utils[(/** @type {"isNamepathDefiningTag"|"isNamepathReferencingTag"|"isNamepathOrUrlReferencingTag"|"tagMightHaveNamepath"} */
-    method)] = tagName => {
-      return jsdocUtils[(/** @type {"isNamepathDefiningTag"|"isNamepathReferencingTag"|"isNamepathOrUrlReferencingTag"|"tagMightHaveNamepath"} */
-      method)](tagName);
-    };
-  }
-
-  /** @type {GetTagStructureForMode} */
-  utils.getTagStructureForMode = mde => {
-    return jsdocUtils.getTagStructureForMode(mde, settings.structuredTags);
-  };
-
-  /** @type {MayBeUndefinedTypeTag} */
-  utils.mayBeUndefinedTypeTag = tag => {
-    return jsdocUtils.mayBeUndefinedTypeTag(tag, settings.mode);
-  };
-
-  /** @type {HasValueOrExecutorHasNonEmptyResolveValue} */
-  utils.hasValueOrExecutorHasNonEmptyResolveValue = (anyPromiseAsReturn, allBranches) => {
-    return jsdocUtils.hasValueOrExecutorHasNonEmptyResolveValue(/** @type {Node} */node, anyPromiseAsReturn, allBranches);
-  };
-
-  /** @type {HasYieldValue} */
-  utils.hasYieldValue = () => {
-    if (['ExportDefaultDeclaration', 'ExportNamedDeclaration'].includes(/** @type {Node} */node.type)) {
-      return jsdocUtils.hasYieldValue(/** @type {import('estree').Declaration|import('estree').Expression} */
-      /** @type {import('estree').ExportNamedDeclaration|import('estree').ExportDefaultDeclaration} */
-      node.declaration);
-    }
-    return jsdocUtils.hasYieldValue(/** @type {Node} */node);
-  };
-
-  /** @type {HasYieldReturnValue} */
-  utils.hasYieldReturnValue = () => {
-    return jsdocUtils.hasYieldValue(/** @type {Node} */node, true);
-  };
-
-  /** @type {HasThrowValue} */
-  utils.hasThrowValue = () => {
-    return jsdocUtils.hasThrowValue(node);
-  };
-
-  /** @type {IsAsync} */
-  utils.isAsync = () => {
-    return Boolean(node && 'async' in node && node.async);
-  };
-
-  /** @type {GetTags} */
-  utils.getTags = tagName => {
-    return jsdocUtils.getTags(jsdoc, tagName);
-  };
-
-  /** @type {GetPresentTags} */
-  utils.getPresentTags = tagList => {
-    return jsdocUtils.filterTags(jsdoc, tag => {
-      return tagList.includes(tag.tag);
-    });
-  };
-
-  /** @type {FilterTags} */
-  utils.filterTags = filter => {
-    return jsdocUtils.filterTags(jsdoc, tag => {
-      return filter(tag);
-    });
-  };
-
-  /** @type {FilterAllTags} */
-  utils.filterAllTags = filter => {
-    const tags = jsdocUtils.getAllTags(jsdoc);
-    return tags.filter(tag => {
-      return filter(tag);
-    });
-  };
-
-  /** @type {GetTagsByType} */
-  utils.getTagsByType = tags => {
-    return jsdocUtils.getTagsByType(context, mode, tags);
-  };
-
-  /** @type {HasOptionTag} */
-  utils.hasOptionTag = tagName => {
-    const {
-      tags
-    } = context.options[0] ?? {};
-    return Boolean(tags && tags.includes(tagName));
-  };
-
-  /** @type {GetClassNode} */
-  utils.getClassNode = () => {
-    return [...ancestors, node].reverse().find(parent => {
-      return parent && ['ClassDeclaration', 'ClassExpression'].includes(parent.type);
-    }) ?? null;
-  };
-
-  /** @type {GetClassJsdoc} */
-  utils.getClassJsdoc = () => {
-    const classNode = utils.getClassNode();
-    if (!classNode) {
-      return null;
-    }
-    const classJsdocNode = (0, _jsdoccomment.getJSDocComment)(sourceCode, classNode, {
-      maxLines,
-      minLines
-    });
-    if (classJsdocNode) {
-      return (0, _jsdoccomment.parseComment)(classJsdocNode, '');
-    }
-    return null;
-  };
-
-  /** @type {ClassHasTag} */
-  utils.classHasTag = tagName => {
-    const classJsdoc = utils.getClassJsdoc();
-    return classJsdoc !== null && jsdocUtils.hasTag(classJsdoc, tagName);
-  };
-
-  /** @type {ForEachPreferredTag} */
-  utils.forEachPreferredTag = (tagName, arrayHandler, skipReportingBlockedTag) => {
-    return jsdocUtils.forEachPreferredTag(jsdoc, tagName, arrayHandler, {
-      context,
-      mode,
-      report,
-      skipReportingBlockedTag,
-      tagNamePreference
-    });
-  };
-
-  /** @type {FindContext} */
-  utils.findContext = (contexts, comment) => {
-    const foundContext = contexts.find(cntxt => {
-      return typeof cntxt === 'string' ? _esquery.default.matches(/** @type {Node} */node, _esquery.default.parse(cntxt), undefined, {
-        visitorKeys: sourceCode.visitorKeys
-      }) : (!cntxt.context || cntxt.context === 'any' || _esquery.default.matches(/** @type {Node} */node, _esquery.default.parse(cntxt.context), undefined, {
-        visitorKeys: sourceCode.visitorKeys
-      })) && comment === cntxt.comment;
-    });
-    const contextStr = typeof foundContext === 'object' ? foundContext.context ?? 'any' : String(foundContext);
-    return {
-      contextStr,
-      foundContext
-    };
-  };
-  return utils;
+	const ancestors = node ? sc.getAncestors ? sc.getAncestors(node) : context.getAncestors() : [];
+	/* c8 ignore next -- Fallback to deprecated method */
+	const { sourceCode = context.getSourceCode() } = context;
+	const utils = getBasicUtils(context, settings);
+	const { augmentsExtendsReplacesDocs, ignoreReplacesDocs, implementsReplacesDocs, maxLines, minLines, mode, overrideReplacesDocs, tagNamePreference } = settings;
+	const functionTypes = [
+		"ArrowFunctionExpression",
+		"FunctionDeclaration",
+		"FunctionExpression",
+		"MethodDefinition"
+	];
+	/** @type {IsIteratingFunction} */
+	utils.isIteratingFunction = () => {
+		return !iteratingAll || functionTypes.includes(String(node?.type));
+	};
+	/** @type {IsIteratingFunction} */
+	utils.isIteratingFunctionOrVariable = () => {
+		if (utils.isIteratingFunction()) return true;
+		/** @type {import('estree').VariableDeclarator[]} */
+		const declarations = node?.type === "VariableDeclaration" ? node.declarations : node?.type === "ExportNamedDeclaration" && node.declaration?.type === "VariableDeclaration" ? node.declaration.declarations : [];
+		return declarations.some(({ init }) => {
+			return functionTypes.includes(String(init?.type));
+		});
+	};
+	/** @type {IsVirtualFunction} */
+	utils.isVirtualFunction = () => {
+		return Boolean(iteratingAll) && utils.hasATag([
+			"callback",
+			"function",
+			"func",
+			"method"
+		]);
+	};
+	/** @type {Stringify} */
+	utils.stringify = (tagBlock, specRewire) => {
+		let block;
+		if (specRewire) block = rewireSpecs(tagBlock);
+		return (0, comment_parser.stringify)(specRewire ? block : tagBlock);
+	};
+	/** @type {ReportJSDoc} */
+	utils.reportJSDoc = (msg, tag, handler, specRewire, data) => {
+		report(msg, handler ? (fixer) => {
+			handler();
+			const replacement = utils.stringify(jsdoc, specRewire);
+			if (!replacement) {
+				const text = sourceCode.getText();
+				const lastLineBreakPos = text.slice(0, jsdocNode.range[0]).search(/\n[ \t]*$/v);
+				if (lastLineBreakPos > -1) return fixer.removeRange([lastLineBreakPos, jsdocNode.range[1]]);
+				return fixer.removeRange(/\s/v.test(text.charAt(jsdocNode.range[1])) ? [jsdocNode.range[0], jsdocNode.range[1] + 1] : jsdocNode.range);
+			}
+			return fixer.replaceText(jsdocNode, replacement);
+		} : null, tag, data);
+	};
+	/** @type {GetRegexFromString} */
+	utils.getRegexFromString = (str, requiredFlags) => {
+		return require_jsdocUtils.getRegexFromString(str, requiredFlags);
+	};
+	/** @type {GetTagDescription} */
+	utils.getTagDescription = (tg, returnArray) => {
+		return require_jsdocUtils.getTagDescription(tg, returnArray);
+	};
+	/** @type {SetTagDescription} */
+	utils.setTagDescription = (tg, matcher, setter) => {
+		let finalIdx = 0;
+		tg.source.some(({ tokens: { description } }, idx) => {
+			if (description && matcher.test(description)) {
+				tg.source[idx].tokens.description = setter(description);
+				finalIdx = idx;
+				return true;
+			}
+			return false;
+		});
+		return finalIdx;
+	};
+	/** @type {GetDescription} */
+	utils.getDescription = () => {
+		/** @type {string[]} */
+		const descriptions = [];
+		let lastDescriptionLine = 0;
+		let tagsBegun = false;
+		jsdoc.source.some(({ tokens: { description, end, tag } }, idx) => {
+			if (tag) tagsBegun = true;
+			if (idx && (tag || end)) {
+				lastDescriptionLine = idx - 1;
+				if (!tagsBegun && description) descriptions.push(description);
+				return true;
+			}
+			if (!tagsBegun && (idx || description)) descriptions.push(description || (descriptions.length ? "" : "\n"));
+			return false;
+		});
+		return {
+			description: descriptions.join("\n"),
+			descriptions,
+			lastDescriptionLine
+		};
+	};
+	/** @type {SetBlockDescription} */
+	utils.setBlockDescription = (setter) => {
+		/** @type {string[]} */
+		const descLines = [];
+		/**
+		* @type {undefined|Integer}
+		*/
+		let startIdx;
+		/**
+		* @type {undefined|Integer}
+		*/
+		let endIdx;
+		/**
+		* @type {undefined|{
+		*   delimiter: string,
+		*   postDelimiter: string,
+		*   start: string
+		* }}
+		*/
+		let info;
+		jsdoc.source.some(({ tokens: { delimiter, description, end, postDelimiter, start, tag } }, idx) => {
+			if (delimiter === "/**") return false;
+			if (startIdx === void 0) {
+				startIdx = idx;
+				info = {
+					delimiter,
+					postDelimiter,
+					start
+				};
+			}
+			if (tag || end) {
+				endIdx = idx;
+				return true;
+			}
+			descLines.push(description);
+			return false;
+		});
+		/* c8 ignore else -- Won't be called if missing */
+		if (descLines.length) jsdoc.source.splice(
+			startIdx,
+			/** @type {Integer} */
+			endIdx - startIdx,
+			...setter(info, seedTokens, descLines)
+		);
+	};
+	/** @type {SetDescriptionLines} */
+	utils.setDescriptionLines = (matcher, setter) => {
+		let finalIdx = 0;
+		jsdoc.source.some(({ tokens: { description, end, tag } }, idx) => {
+			/* c8 ignore next 3 -- Already checked */
+			if (idx && (tag || end)) return true;
+			if (description && matcher.test(description)) {
+				jsdoc.source[idx].tokens.description = setter(description);
+				finalIdx = idx;
+				return true;
+			}
+			return false;
+		});
+		return finalIdx;
+	};
+	/** @type {ChangeTag} */
+	utils.changeTag = (tag, ...tokens) => {
+		for (const [idx, src] of tag.source.entries()) src.tokens = {
+			...src.tokens,
+			...tokens[idx]
+		};
+	};
+	/** @type {SetTag} */
+	utils.setTag = (tag, tokens) => {
+		tag.source = [{
+			number: tag.line,
+			source: "",
+			tokens: seedTokens({
+				delimiter: "*",
+				postDelimiter: " ",
+				start: indent + " ",
+				tag: "@" + tag.tag,
+				...tokens
+			})
+		}];
+	};
+	/** @type {RemoveTag} */
+	utils.removeTag = (tagIndex, { removeEmptyBlock = false, tagSourceOffset = 0 } = {}) => {
+		const { source: tagSource } = jsdoc.tags[tagIndex];
+		/** @type {Integer|undefined} */
+		let lastIndex;
+		const firstNumber = jsdoc.source[0].number;
+		tagSource.some(({ number }, tagIdx) => {
+			const sourceIndex = jsdoc.source.findIndex(({ number: srcNumber }) => {
+				return number === srcNumber;
+			});
+			// c8 ignore else
+			if (sourceIndex > -1) {
+				let spliceCount = 1;
+				tagSource.slice(tagIdx + 1).some(({ tokens: { end: ending, tag } }) => {
+					if (!tag && !ending) {
+						spliceCount++;
+						return false;
+					}
+					return true;
+				});
+				const spliceIdx = sourceIndex + tagSourceOffset;
+				const { delimiter, end } = jsdoc.source[spliceIdx].tokens;
+				if (spliceIdx === 0 && jsdoc.tags.length >= 2 || !removeEmptyBlock && (end || delimiter === "/**")) {
+					const { tokens } = jsdoc.source[spliceIdx];
+					for (const item of [
+						"postDelimiter",
+						"tag",
+						"postTag",
+						"type",
+						"postType",
+						"name",
+						"postName",
+						"description"
+					]) tokens[item] = "";
+				} else {
+					jsdoc.source.splice(spliceIdx, spliceCount - tagSourceOffset + (spliceIdx ? 0 : jsdoc.source.length));
+					tagSource.splice(tagIdx + tagSourceOffset, spliceCount - tagSourceOffset + (spliceIdx ? 0 : jsdoc.source.length));
+				}
+				lastIndex = sourceIndex;
+				return true;
+			}
+			/* c8 ignore next 2 */
+			return false;
+		});
+		for (const [idx, src] of jsdoc.source.slice(lastIndex).entries()) src.number = firstNumber + lastIndex + idx;
+	};
+	/** @type {AddTag} */
+	utils.addTag = (targetTagName, number = (jsdoc.tags[jsdoc.tags.length - 1]?.source[0]?.number ?? jsdoc.source.findIndex(({ tokens: { tag } }) => {
+		return tag;
+	}) - 1) + 1, tokens = {}) => {
+		jsdoc.source.splice(number, 0, {
+			number,
+			source: "",
+			tokens: seedTokens({
+				delimiter: "*",
+				postDelimiter: " ",
+				start: indent + " ",
+				tag: `@${targetTagName}`,
+				...tokens
+			})
+		});
+		for (const src of jsdoc.source.slice(number + 1)) src.number++;
+	};
+	/** @type {GetFirstLine} */
+	utils.getFirstLine = () => {
+		let firstLine;
+		for (const { number, tokens: { tag } } of jsdoc.source) if (tag) {
+			firstLine = number;
+			break;
+		}
+		return firstLine;
+	};
+	/** @type {SeedTokens} */
+	utils.seedTokens = seedTokens;
+	/** @type {EmptyTokens} */
+	utils.emptyTokens = (tokens) => {
+		for (const prop of [
+			"start",
+			"postDelimiter",
+			"tag",
+			"type",
+			"postType",
+			"postTag",
+			"name",
+			"postName",
+			"description",
+			"end",
+			"lineEnd"
+		]) tokens[prop] = "";
+	};
+	/** @type {AddLine} */
+	utils.addLine = (sourceIndex, tokens) => {
+		const number = (jsdoc.source[sourceIndex - 1]?.number || 0) + 1;
+		jsdoc.source.splice(sourceIndex, 0, {
+			number,
+			source: "",
+			tokens: seedTokens(tokens)
+		});
+		for (const src of jsdoc.source.slice(number + 1)) src.number++;
+	};
+	/** @type {AddLines} */
+	utils.addLines = (tagIndex, tagSourceOffset, numLines) => {
+		const { source: tagSource } = jsdoc.tags[tagIndex];
+		/** @type {Integer|undefined} */
+		let lastIndex;
+		const firstNumber = jsdoc.source[0].number;
+		tagSource.some(({ number }) => {
+			const makeLine = () => {
+				return {
+					number,
+					source: "",
+					tokens: seedTokens({
+						delimiter: "*",
+						start: indent + " "
+					})
+				};
+			};
+			const makeLines = () => {
+				return Array.from({ length: numLines }, makeLine);
+			};
+			const sourceIndex = jsdoc.source.findIndex(({ number: srcNumber, tokens: { end } }) => {
+				return number === srcNumber && !end;
+			});
+			// c8 ignore else
+			if (sourceIndex > -1) {
+				const lines = makeLines();
+				jsdoc.source.splice(sourceIndex + tagSourceOffset, 0, ...lines);
+				lastIndex = sourceIndex;
+				return true;
+			}
+			/* c8 ignore next 2 */
+			return false;
+		});
+		for (const [idx, src] of jsdoc.source.slice(lastIndex).entries()) src.number = firstNumber + lastIndex + idx;
+	};
+	/** @type {MakeMultiline} */
+	utils.makeMultiline = () => {
+		const { source: [{ tokens }] } = jsdoc;
+		const { description, lineEnd, name, postDelimiter, tag, type } = tokens;
+		let { tokens: { postName, postTag, postType } } = jsdoc.source[0];
+		if (!description) {
+			if (postName) postName = "";
+			else if (postType) postType = "";
+			else if (postTag) postTag = "";
+		}
+		utils.emptyTokens(tokens);
+		utils.addLine(1, {
+			delimiter: "*",
+			description: description.trimEnd(),
+			name,
+			postDelimiter,
+			postName,
+			postTag,
+			postType,
+			start: indent + " ",
+			tag,
+			type
+		});
+		utils.addLine(2, {
+			end: "*/",
+			lineEnd,
+			start: indent + " "
+		});
+	};
+	/**
+	* @type {import('./jsdocUtils.js').FlattenRoots}
+	*/
+	utils.flattenRoots = require_jsdocUtils.flattenRoots;
+	/** @type {GetFunctionParameterNames} */
+	utils.getFunctionParameterNames = (useDefaultObjectProperties) => {
+		return require_jsdocUtils.getFunctionParameterNames(node, useDefaultObjectProperties);
+	};
+	/** @type {HasParams} */
+	utils.hasParams = () => {
+		return require_jsdocUtils.hasParams(node);
+	};
+	/** @type {IsGenerator} */
+	utils.isGenerator = () => {
+		return node !== null && Boolean(
+			/**
+			* @type {import('estree').FunctionDeclaration|
+			*   import('estree').FunctionExpression}
+			*/
+			node.generator || node.type === "MethodDefinition" && node.value.generator || ["ExportDefaultDeclaration", "ExportNamedDeclaration"].includes(node.type) && node.declaration?.generator
+		);
+	};
+	/** @type {IsConstructor} */
+	utils.isConstructor = () => {
+		return require_jsdocUtils.isConstructor(node);
+	};
+	/** @type {GetJsdocTagsDeep} */
+	utils.getJsdocTagsDeep = (tagName) => {
+		const name = utils.getPreferredTagName({ tagName });
+		if (!name) return false;
+		return require_jsdocUtils.getJsdocTagsDeep(jsdoc, name);
+	};
+	/** @type {GetPreferredTagName} */
+	utils.getPreferredTagName = (args) => {
+		return require_jsdocUtils.getPreferredTagName(jsdoc, {
+			...args,
+			context,
+			mode,
+			report,
+			tagNamePreference
+		});
+	};
+	/** @type {IsValidTag} */
+	utils.isValidTag = (name, definedTags) => {
+		return require_jsdocUtils.isValidTag(context, mode, name, definedTags);
+	};
+	/** @type {HasATag} */
+	utils.hasATag = (names) => {
+		return require_jsdocUtils.hasATag(jsdoc, names);
+	};
+	/** @type {HasTag} */
+	utils.hasTag = (name) => {
+		return require_jsdocUtils.hasTag(jsdoc, name);
+	};
+	/** @type {ComparePaths} */
+	utils.comparePaths = (name) => {
+		return require_jsdocUtils.comparePaths(name);
+	};
+	/** @type {DropPathSegmentQuotes} */
+	utils.dropPathSegmentQuotes = (name) => {
+		return require_jsdocUtils.dropPathSegmentQuotes(name);
+	};
+	/** @type {AvoidDocs} */
+	utils.avoidDocs = () => {
+		if (ignoreReplacesDocs !== false && (utils.hasTag("ignore") || utils.classHasTag("ignore")) || overrideReplacesDocs !== false && (utils.hasTag("override") || utils.classHasTag("override")) || implementsReplacesDocs !== false && (utils.hasTag("implements") || utils.classHasTag("implements")) || augmentsExtendsReplacesDocs && (utils.hasATag(["augments", "extends"]) || utils.classHasTag("augments") || utils.classHasTag("extends"))) return true;
+		if (require_jsdocUtils.exemptSpeciaMethods(jsdoc, node, context, ruleConfig.meta.schema)) return true;
+		const exemptedBy = context.options[0]?.exemptedBy ?? ["inheritDoc", ...mode === "closure" ? [] : ["inheritdoc"]];
+		if (exemptedBy.length && utils.getPresentTags(exemptedBy).length) return true;
+		return false;
+	};
+	for (const method of ["tagMightHaveNamePosition", "tagMightHaveTypePosition"])
+ /** @type {TagMightHaveNamePositionTypePosition} */
+	utils[method] = (tagName, otherModeMaps) => {
+		const result = require_jsdocUtils.jsdocUtils_exports[method](tagName);
+		if (result) return true;
+		if (!otherModeMaps) return false;
+		const otherResult = otherModeMaps.some((otherModeMap) => {
+			return require_jsdocUtils.jsdocUtils_exports[method](tagName, otherModeMap);
+		});
+		return otherResult ? { otherMode: true } : false;
+	};
+	/** @type {TagMissingRequiredTypeOrNamepath} */
+	utils.tagMissingRequiredTypeOrNamepath = (tagName, otherModeMaps) => {
+		const result = require_jsdocUtils.tagMissingRequiredTypeOrNamepath(tagName);
+		if (!result) return false;
+		const otherResult = otherModeMaps.every((otherModeMap) => {
+			return require_jsdocUtils.tagMissingRequiredTypeOrNamepath(tagName, otherModeMap);
+		});
+		return otherResult ? true : { otherMode: false };
+	};
+	for (const method of ["tagMustHaveNamePosition", "tagMustHaveTypePosition"])
+ /** @type {TagMustHave} */
+	utils[method] = (tagName, otherModeMaps) => {
+		const result = require_jsdocUtils.jsdocUtils_exports[method](tagName);
+		if (!result) return false;
+		const otherResult = otherModeMaps.every((otherModeMap) => {
+			return require_jsdocUtils.jsdocUtils_exports[method](tagName, otherModeMap);
+		});
+		return otherResult ? true : { otherMode: false };
+	};
+	for (const method of [
+		"isNamepathDefiningTag",
+		"isNamepathReferencingTag",
+		"isNamepathOrUrlReferencingTag",
+		"tagMightHaveNamepath"
+	])
+ /** @type {IsNamepathX} */
+	utils[method] = (tagName) => {
+		return require_jsdocUtils.jsdocUtils_exports[method](tagName);
+	};
+	/** @type {GetTagStructureForMode} */
+	utils.getTagStructureForMode = (mde) => {
+		return require_jsdocUtils.getTagStructureForMode(mde, settings.structuredTags);
+	};
+	/** @type {MayBeUndefinedTypeTag} */
+	utils.mayBeUndefinedTypeTag = (tag) => {
+		return require_jsdocUtils.mayBeUndefinedTypeTag(tag, settings.mode);
+	};
+	/** @type {HasValueOrExecutorHasNonEmptyResolveValue} */
+	utils.hasValueOrExecutorHasNonEmptyResolveValue = (anyPromiseAsReturn, allBranches) => {
+		return require_hasReturnValue.hasValueOrExecutorHasNonEmptyResolveValue(node, anyPromiseAsReturn, allBranches);
+	};
+	/** @type {HasYieldValue} */
+	utils.hasYieldValue = () => {
+		if (["ExportDefaultDeclaration", "ExportNamedDeclaration"].includes(
+			/** @type {Node} */
+			node.type
+		)) return require_jsdocUtils.hasYieldValue(
+			/** @type {import('estree').ExportNamedDeclaration|import('estree').ExportDefaultDeclaration} */
+			node.declaration
+		);
+		return require_jsdocUtils.hasYieldValue(node);
+	};
+	/** @type {HasYieldReturnValue} */
+	utils.hasYieldReturnValue = () => {
+		return require_jsdocUtils.hasYieldValue(node, true);
+	};
+	/** @type {HasThrowValue} */
+	utils.hasThrowValue = () => {
+		return require_jsdocUtils.hasThrowValue(node);
+	};
+	/** @type {IsAsync} */
+	utils.isAsync = () => {
+		return Boolean(node && "async" in node && node.async);
+	};
+	/** @type {GetTags} */
+	utils.getTags = (tagName) => {
+		return require_jsdocUtils.getTags(jsdoc, tagName);
+	};
+	/** @type {GetPresentTags} */
+	utils.getPresentTags = (tagList) => {
+		return require_jsdocUtils.filterTags(jsdoc, (tag) => {
+			return tagList.includes(tag.tag);
+		});
+	};
+	/** @type {FilterTags} */
+	utils.filterTags = (filter) => {
+		return require_jsdocUtils.filterTags(jsdoc, (tag) => {
+			return filter(tag);
+		});
+	};
+	/** @type {FilterAllTags} */
+	utils.filterAllTags = (filter) => {
+		const tags = require_jsdocUtils.getAllTags(jsdoc);
+		return tags.filter((tag) => {
+			return filter(tag);
+		});
+	};
+	/** @type {GetTagsByType} */
+	utils.getTagsByType = (tags) => {
+		return require_jsdocUtils.getTagsByType(context, mode, tags);
+	};
+	/** @type {HasOptionTag} */
+	utils.hasOptionTag = (tagName) => {
+		const { tags } = context.options[0] ?? {};
+		return Boolean(tags && tags.includes(tagName));
+	};
+	/** @type {GetClassNode} */
+	utils.getClassNode = () => {
+		return [...ancestors, node].reverse().find((parent) => {
+			return parent && ["ClassDeclaration", "ClassExpression"].includes(parent.type);
+		}) ?? null;
+	};
+	/** @type {GetClassJsdoc} */
+	utils.getClassJsdoc = () => {
+		const classNode = utils.getClassNode();
+		if (!classNode) return null;
+		const classJsdocNode = (0, __es_joy_jsdoccomment.getJSDocComment)(sourceCode, classNode, {
+			maxLines,
+			minLines
+		});
+		if (classJsdocNode) return (0, __es_joy_jsdoccomment.parseComment)(classJsdocNode, "");
+		return null;
+	};
+	/** @type {ClassHasTag} */
+	utils.classHasTag = (tagName) => {
+		const classJsdoc = utils.getClassJsdoc();
+		return classJsdoc !== null && require_jsdocUtils.hasTag(classJsdoc, tagName);
+	};
+	/** @type {ForEachPreferredTag} */
+	utils.forEachPreferredTag = (tagName, arrayHandler, skipReportingBlockedTag) => {
+		return require_jsdocUtils.forEachPreferredTag(jsdoc, tagName, arrayHandler, {
+			context,
+			mode,
+			report,
+			skipReportingBlockedTag,
+			tagNamePreference
+		});
+	};
+	/** @type {FindContext} */
+	utils.findContext = (contexts, comment) => {
+		const foundContext = contexts.find((cntxt) => {
+			return typeof cntxt === "string" ? esquery.default.matches(node, esquery.default.parse(cntxt), void 0, { visitorKeys: sourceCode.visitorKeys }) : (!cntxt.context || cntxt.context === "any" || esquery.default.matches(node, esquery.default.parse(cntxt.context), void 0, { visitorKeys: sourceCode.visitorKeys })) && comment === cntxt.comment;
+		});
+		const contextStr = typeof foundContext === "object" ? foundContext.context ?? "any" : String(foundContext);
+		return {
+			contextStr,
+			foundContext
+		};
+	};
+	return utils;
 };
-
 /**
- * @typedef {{
- *   [key: string]: false|string|{
- *     message: string,
- *     replacement?: false|string
- *     skipRootChecking?: boolean
- *   }
- * }} PreferredTypes
- */
-/**
- * @typedef {{
- *   [key: string]: {
- *     name?: "text"|"namepath-defining"|"namepath-referencing"|false,
- *     type?: boolean|string[],
- *     required?: ("name"|"type"|"typeOrNameRequired")[]
- *   }
- * }} StructuredTags
- */
-/**
- * Settings from ESLint types.
- * @typedef {{
- *   maxLines: Integer,
- *   minLines: Integer,
- *   tagNamePreference: import('./jsdocUtils.js').TagNamePreference,
- *   mode: import('./jsdocUtils.js').ParserMode,
- *   preferredTypes: PreferredTypes,
- *   structuredTags: StructuredTags,
- *   [name: string]: any,
- *   contexts?: Context[]
- * }} Settings
- */
-
+* @typedef {{
+*   [key: string]: false|string|{
+*     message: string,
+*     replacement?: false|string
+*     skipRootChecking?: boolean
+*   }
+* }} PreferredTypes
+*/
 /**
- * @typedef {{
- *   settings?: {
- *     jsdoc?: {
- *       ignorePrivate: boolean,
- *       ignoreInternal: boolean,
- *       maxLines: Integer,
- *       minLines: Integer,
- *       tagNamePreference: import('./jsdocUtils.js').TagNamePreference,
- *       preferredTypes: PreferredTypes,
- *       structuredTags: StructuredTags,
- *       overrideReplacesDocs: boolean,
- *       ignoreReplacesDocs: boolean,
- *       implementsReplacesDocs: boolean,
- *       augmentsExtendsReplacesDocs: boolean,
- *       exemptDestructuredRootsFromChecks: boolean,
- *       mode: import('./jsdocUtils.js').ParserMode,
- *       contexts: Context[],
- *     }
- *   }
- * }} JSDocSettings
- */
-
+* @typedef {{
+*   [key: string]: {
+*     name?: "text"|"namepath-defining"|"namepath-referencing"|false,
+*     type?: boolean|string[],
+*     required?: ("name"|"type"|"typeOrNameRequired")[]
+*   }
+* }} StructuredTags
+*/
 /**
- * @param {import('eslint').Rule.RuleContext & JSDocSettings} context
- * @returns {Settings|false}
- */
-const getSettings = context => {
-  /* eslint-disable perfectionist/sort-objects */
-  const settings = {
-    // All rules
-    ignorePrivate: Boolean(context.settings.jsdoc?.ignorePrivate),
-    ignoreInternal: Boolean(context.settings.jsdoc?.ignoreInternal),
-    maxLines: Number(context.settings.jsdoc?.maxLines ?? 1),
-    minLines: Number(context.settings.jsdoc?.minLines ?? 0),
-    // `check-tag-names` and many returns/param rules
-    tagNamePreference: context.settings.jsdoc?.tagNamePreference ?? {},
-    // `check-types` and `no-undefined-types`
-    preferredTypes: context.settings.jsdoc?.preferredTypes ?? {},
-    // `check-types`, `no-undefined-types`, `valid-types`
-    structuredTags: context.settings.jsdoc?.structuredTags ?? {},
-    // `require-param`, `require-description`, `require-example`,
-    // `require-returns`, `require-throw`, `require-yields`
-    overrideReplacesDocs: context.settings.jsdoc?.overrideReplacesDocs,
-    ignoreReplacesDocs: context.settings.jsdoc?.ignoreReplacesDocs,
-    implementsReplacesDocs: context.settings.jsdoc?.implementsReplacesDocs,
-    augmentsExtendsReplacesDocs: context.settings.jsdoc?.augmentsExtendsReplacesDocs,
-    // `require-param-type`, `require-param-description`
-    exemptDestructuredRootsFromChecks: context.settings.jsdoc?.exemptDestructuredRootsFromChecks,
-    // Many rules, e.g., `check-tag-names`
-    mode: context.settings.jsdoc?.mode ?? 'typescript',
-    // Many rules
-    contexts: context.settings.jsdoc?.contexts
-  };
-  /* eslint-enable perfectionist/sort-objects */
-
-  jsdocUtils.setTagStructure(settings.mode);
-  try {
-    jsdocUtils.overrideTagStructure(settings.structuredTags);
-  } catch (error) {
-    context.report({
-      loc: {
-        end: {
-          column: 1,
-          line: 1
-        },
-        start: {
-          column: 1,
-          line: 1
-        }
-      },
-      message: /** @type {Error} */error.message
-    });
-    return false;
-  }
-  return settings;
+* Settings from ESLint types.
+* @typedef {{
+*   maxLines: Integer,
+*   minLines: Integer,
+*   tagNamePreference: import('./jsdocUtils.js').TagNamePreference,
+*   mode: import('./jsdocUtils.js').ParserMode,
+*   preferredTypes: PreferredTypes,
+*   structuredTags: StructuredTags,
+*   [name: string]: any,
+*   contexts?: Context[]
+* }} Settings
+*/
+/**
+* @typedef {{
+*   settings?: {
+*     jsdoc?: {
+*       ignorePrivate: boolean,
+*       ignoreInternal: boolean,
+*       maxLines: Integer,
+*       minLines: Integer,
+*       tagNamePreference: import('./jsdocUtils.js').TagNamePreference,
+*       preferredTypes: PreferredTypes,
+*       structuredTags: StructuredTags,
+*       overrideReplacesDocs: boolean,
+*       ignoreReplacesDocs: boolean,
+*       implementsReplacesDocs: boolean,
+*       augmentsExtendsReplacesDocs: boolean,
+*       exemptDestructuredRootsFromChecks: boolean,
+*       mode: import('./jsdocUtils.js').ParserMode,
+*       contexts: Context[],
+*     }
+*   }
+* }} JSDocSettings
+*/
+/**
+* @param {import('eslint').Rule.RuleContext & JSDocSettings} context
+* @returns {Settings|false}
+*/
+const getSettings = (context) => {
+	const settings = {
+		ignorePrivate: Boolean(context.settings.jsdoc?.ignorePrivate),
+		ignoreInternal: Boolean(context.settings.jsdoc?.ignoreInternal),
+		maxLines: Number(context.settings.jsdoc?.maxLines ?? 1),
+		minLines: Number(context.settings.jsdoc?.minLines ?? 0),
+		tagNamePreference: context.settings.jsdoc?.tagNamePreference ?? {},
+		preferredTypes: context.settings.jsdoc?.preferredTypes ?? {},
+		structuredTags: context.settings.jsdoc?.structuredTags ?? {},
+		overrideReplacesDocs: context.settings.jsdoc?.overrideReplacesDocs,
+		ignoreReplacesDocs: context.settings.jsdoc?.ignoreReplacesDocs,
+		implementsReplacesDocs: context.settings.jsdoc?.implementsReplacesDocs,
+		augmentsExtendsReplacesDocs: context.settings.jsdoc?.augmentsExtendsReplacesDocs,
+		exemptDestructuredRootsFromChecks: context.settings.jsdoc?.exemptDestructuredRootsFromChecks,
+		mode: context.settings.jsdoc?.mode ?? "typescript",
+		contexts: context.settings.jsdoc?.contexts
+	};
+	require_jsdocUtils.setTagStructure(settings.mode);
+	try {
+		require_jsdocUtils.overrideTagStructure(settings.structuredTags);
+	} catch (error) {
+		context.report({
+			loc: {
+				end: {
+					column: 1,
+					line: 1
+				},
+				start: {
+					column: 1,
+					line: 1
+				}
+			},
+			message: error.message
+		});
+		return false;
+	}
+	return settings;
 };
-
 /**
- * Create the report function
- * @callback MakeReport
- * @param {import('eslint').Rule.RuleContext} context
- * @param {import('estree').Node} commentNode
- * @returns {Report}
- */
-
+* Create the report function
+* @callback MakeReport
+* @param {import('eslint').Rule.RuleContext} context
+* @param {import('estree').Node} commentNode
+* @returns {Report}
+*/
 /** @type {MakeReport} */
-exports.getSettings = getSettings;
 const makeReport = (context, commentNode) => {
-  /** @type {Report} */
-  const report = (message, fix = null, jsdocLoc = null, data = undefined) => {
-    let loc;
-    if (jsdocLoc) {
-      if (!('line' in jsdocLoc)) {
-        jsdocLoc.line = /** @type {import('comment-parser').Spec & {line?: Integer}} */jsdocLoc.source[0].number;
-      }
-      const lineNumber = /** @type {import('eslint').AST.SourceLocation} */commentNode.loc.start.line + (/** @type {Integer} */jsdocLoc.line);
-      loc = {
-        end: {
-          column: 0,
-          line: lineNumber
-        },
-        start: {
-          column: 0,
-          line: lineNumber
-        }
-      };
-      if ('column' in jsdocLoc && typeof jsdocLoc.column === 'number') {
-        const colNumber = /** @type {import('eslint').AST.SourceLocation} */commentNode.loc.start.column + jsdocLoc.column;
-        loc.end.column = colNumber;
-        loc.start.column = colNumber;
-      }
-    }
-    context.report({
-      data,
-      fix,
-      loc,
-      message,
-      node: commentNode
-    });
-  };
-  return report;
+	/** @type {Report} */
+	const report = (message, fix = null, jsdocLoc = null, data = void 0) => {
+		let loc;
+		if (jsdocLoc) {
+			if (!("line" in jsdocLoc)) jsdocLoc.line = jsdocLoc.source[0].number;
+			const lineNumber = commentNode.loc.start.line + jsdocLoc.line;
+			loc = {
+				end: {
+					column: 0,
+					line: lineNumber
+				},
+				start: {
+					column: 0,
+					line: lineNumber
+				}
+			};
+			if ("column" in jsdocLoc && typeof jsdocLoc.column === "number") {
+				const colNumber = commentNode.loc.start.column + jsdocLoc.column;
+				loc.end.column = colNumber;
+				loc.start.column = colNumber;
+			}
+		}
+		context.report({
+			data,
+			fix,
+			loc,
+			message,
+			node: commentNode
+		});
+	};
+	return report;
 };
-
 /**
- * @typedef {(
- *   arg: {
- *     context: import('eslint').Rule.RuleContext,
- *     sourceCode: import('eslint').SourceCode,
- *     indent?: string,
- *     info?: {
- *       comment?: string|undefined,
- *       lastIndex?: Integer|undefined
- *     },
- *     state?: StateObject,
- *     globalState?: Map<string, Map<string, string>>,
- *     jsdoc?: JsdocBlockWithInline,
- *     jsdocNode?: import('eslint').Rule.Node & {
- *       range: [number, number]
- *     },
- *     node?: Node,
- *     allComments?: import('estree').Node[]
- *     report?: Report,
- *     makeReport?: MakeReport,
- *     settings: Settings,
- *     utils: BasicUtils,
- *   }
- * ) => any } JsdocVisitorBasic
- */
-/**
- * @typedef {(
- *   arg: {
- *     context: import('eslint').Rule.RuleContext,
- *     sourceCode: import('eslint').SourceCode,
- *     indent: string,
- *     info: {
- *       comment?: string|undefined,
- *       lastIndex?: Integer|undefined
- *     },
- *     state: StateObject,
- *     globalState: Map<string, Map<string, string>>,
- *     jsdoc: JsdocBlockWithInline,
- *     jsdocNode: import('eslint').Rule.Node & {
- *       range: [number, number]
- *     },
- *     node: Node|null,
- *     allComments?: import('estree').Node[]
- *     report: Report,
- *     makeReport?: MakeReport,
- *     settings: Settings,
- *     utils: Utils,
- *   }
- * ) => any } JsdocVisitor
- */
-
+* @typedef {(
+*   arg: {
+*     context: import('eslint').Rule.RuleContext,
+*     sourceCode: import('eslint').SourceCode,
+*     indent?: string,
+*     info?: {
+*       comment?: string|undefined,
+*       lastIndex?: Integer|undefined
+*     },
+*     state?: StateObject,
+*     globalState?: Map<string, Map<string, string>>,
+*     jsdoc?: JsdocBlockWithInline,
+*     jsdocNode?: import('eslint').Rule.Node & {
+*       range: [number, number]
+*     },
+*     node?: Node,
+*     allComments?: import('estree').Node[]
+*     report?: Report,
+*     makeReport?: MakeReport,
+*     settings: Settings,
+*     utils: BasicUtils,
+*   }
+* ) => any } JsdocVisitorBasic
+*/
+/**
+* @typedef {(
+*   arg: {
+*     context: import('eslint').Rule.RuleContext,
+*     sourceCode: import('eslint').SourceCode,
+*     indent: string,
+*     info: {
+*       comment?: string|undefined,
+*       lastIndex?: Integer|undefined
+*     },
+*     state: StateObject,
+*     globalState: Map<string, Map<string, string>>,
+*     jsdoc: JsdocBlockWithInline,
+*     jsdocNode: import('eslint').Rule.Node & {
+*       range: [number, number]
+*     },
+*     node: Node|null,
+*     allComments?: import('estree').Node[]
+*     report: Report,
+*     makeReport?: MakeReport,
+*     settings: Settings,
+*     utils: Utils,
+*   }
+* ) => any } JsdocVisitor
+*/
 /**
- * @param {{
- *   comment?: string,
- *   lastIndex?: Integer,
- *   selector?: string,
- *   isFunctionContext?: boolean,
- * }} info
- * @param {string} indent
- * @param {JsdocBlockWithInline} jsdoc
- * @param {RuleConfig} ruleConfig
- * @param {import('eslint').Rule.RuleContext} context
- * @param {import('@es-joy/jsdoccomment').Token} jsdocNode
- * @param {Node|null} node
- * @param {Settings} settings
- * @param {import('eslint').SourceCode} sourceCode
- * @param {JsdocVisitor} iterator
- * @param {StateObject} state
- * @param {boolean} [iteratingAll]
- * @returns {void}
- */
+* @param {{
+*   comment?: string,
+*   lastIndex?: Integer,
+*   selector?: string,
+*   isFunctionContext?: boolean,
+* }} info
+* @param {string} indent
+* @param {JsdocBlockWithInline} jsdoc
+* @param {RuleConfig} ruleConfig
+* @param {import('eslint').Rule.RuleContext} context
+* @param {import('@es-joy/jsdoccomment').Token} jsdocNode
+* @param {Node|null} node
+* @param {Settings} settings
+* @param {import('eslint').SourceCode} sourceCode
+* @param {JsdocVisitor} iterator
+* @param {StateObject} state
+* @param {boolean} [iteratingAll]
+* @returns {void}
+*/
 const iterate = (info, indent, jsdoc, ruleConfig, context, jsdocNode, node, settings, sourceCode, iterator, state, iteratingAll) => {
-  const jsdocNde = /** @type {unknown} */jsdocNode;
-  const report = makeReport(context, /** @type {import('estree').Node} */
-  jsdocNde);
-  const utils = getUtils(node, jsdoc, /** @type {import('eslint').AST.Token} */
-  jsdocNode, settings, report, context, sourceCode, iteratingAll, ruleConfig, indent);
-  if (!ruleConfig.checkInternal && settings.ignoreInternal && utils.hasTag('internal')) {
-    return;
-  }
-  if (!ruleConfig.checkPrivate && settings.ignorePrivate && (utils.hasTag('private') || jsdocUtils.filterTags(jsdoc, ({
-    tag
-  }) => {
-    return tag === 'access';
-  }).some(({
-    description
-  }) => {
-    return description === 'private';
-  }))) {
-    return;
-  }
-  iterator({
-    context,
-    globalState,
-    indent,
-    info,
-    jsdoc,
-    jsdocNode: (
-    /**
-     * @type {import('eslint').Rule.Node & {
-     *  range: [number, number];}}
-     */
-    jsdocNde),
-    node,
-    report,
-    settings,
-    sourceCode,
-    state,
-    utils
-  });
+	const jsdocNde = jsdocNode;
+	const report = makeReport(context, jsdocNde);
+	const utils = getUtils(node, jsdoc, jsdocNode, settings, report, context, sourceCode, iteratingAll, ruleConfig, indent);
+	if (!ruleConfig.checkInternal && settings.ignoreInternal && utils.hasTag("internal")) return;
+	if (!ruleConfig.checkPrivate && settings.ignorePrivate && (utils.hasTag("private") || require_jsdocUtils.filterTags(jsdoc, ({ tag }) => {
+		return tag === "access";
+	}).some(({ description }) => {
+		return description === "private";
+	}))) return;
+	iterator({
+		context,
+		globalState,
+		indent,
+		info,
+		jsdoc,
+		jsdocNode: jsdocNde,
+		node,
+		report,
+		settings,
+		sourceCode,
+		state,
+		utils
+	});
 };
-
 /**
- * @param {string[]} lines
- * @param {import('estree').Comment} jsdocNode
- * @returns {[indent: string, jsdoc: JsdocBlockWithInline]}
- */
-const getIndentAndJSDoc = function (lines, jsdocNode) {
-  const sourceLine = lines[/** @type {import('estree').SourceLocation} */
-  jsdocNode.loc.start.line - 1];
-  let indentChar = sourceLine.charAt(0);
-  if (indentChar !== ' ' && indentChar !== '\t') {
-    indentChar = ' ';
-  }
-  const indnt = indentChar.repeat(/** @type {import('estree').SourceLocation} */
-  jsdocNode.loc.start.column);
-  const jsdc = (0, _jsdoccomment.parseComment)(jsdocNode, '');
-  return [indnt, jsdc];
+* @param {string[]} lines
+* @param {import('estree').Comment} jsdocNode
+* @returns {[indent: string, jsdoc: JsdocBlockWithInline]}
+*/
+const getIndentAndJSDoc = function(lines, jsdocNode) {
+	const sourceLine = lines[jsdocNode.loc.start.line - 1];
+	let indentChar = sourceLine.charAt(0);
+	if (indentChar !== " " && indentChar !== "	") indentChar = " ";
+	const indnt = indentChar.repeat(
+		/** @type {import('estree').SourceLocation} */
+		jsdocNode.loc.start.column
+	);
+	const jsdc = (0, __es_joy_jsdoccomment.parseComment)(jsdocNode, "");
+	return [indnt, jsdc];
 };
-
 /**
- *
- * @typedef {{node: Node & {
- *   range: [number, number]
- * }, state: StateObject}} NonCommentArgs
- */
-
+*
+* @typedef {{node: Node & {
+*   range: [number, number]
+* }, state: StateObject}} NonCommentArgs
+*/
 /**
- * @typedef {object} RuleConfig
- * @property {EslintRuleMeta} meta ESLint rule meta
- * @property {import('./jsdocUtils.js').DefaultContexts} [contextDefaults] Any default contexts
- * @property {true} [contextSelected] Whether to force a `contexts` check
- * @property {true} [iterateAllJsdocs] Whether to iterate all JSDoc blocks by default
- *   regardless of context
- * @property {true} [checkPrivate] Whether to check `@private` blocks (normally exempted)
- * @property {true} [checkInternal] Whether to check `@internal` blocks (normally exempted)
- * @property {true} [checkFile] Whether to iterates over all JSDoc blocks regardless of attachment
- * @property {true} [nonGlobalSettings] Whether to avoid relying on settings for global contexts
- * @property {true} [noTracking] Whether to disable the tracking of visited comment nodes (as
- *   non-tracked may conduct further actions)
- * @property {true} [matchContext] Whether the rule expects contexts to be based on a match option
- * @property {(args: {
- *   context: import('eslint').Rule.RuleContext,
- *   state: StateObject,
- *   settings: Settings,
- *   utils: BasicUtils
- * }) => void} [exit] Handler to be executed upon exiting iteration of program AST
- * @property {(nca: NonCommentArgs) => void} [nonComment] Handler to be executed if rule wishes
- *   to be supplied nodes without comments
- */
-
+* @typedef {object} RuleConfig
+* @property {EslintRuleMeta} meta ESLint rule meta
+* @property {import('./jsdocUtils.js').DefaultContexts} [contextDefaults] Any default contexts
+* @property {true} [contextSelected] Whether to force a `contexts` check
+* @property {true} [iterateAllJsdocs] Whether to iterate all JSDoc blocks by default
+*   regardless of context
+* @property {true} [checkPrivate] Whether to check `@private` blocks (normally exempted)
+* @property {true} [checkInternal] Whether to check `@internal` blocks (normally exempted)
+* @property {true} [checkFile] Whether to iterates over all JSDoc blocks regardless of attachment
+* @property {true} [nonGlobalSettings] Whether to avoid relying on settings for global contexts
+* @property {true} [noTracking] Whether to disable the tracking of visited comment nodes (as
+*   non-tracked may conduct further actions)
+* @property {true} [matchContext] Whether the rule expects contexts to be based on a match option
+* @property {(args: {
+*   context: import('eslint').Rule.RuleContext,
+*   state: StateObject,
+*   settings: Settings,
+*   utils: BasicUtils
+* }) => void} [exit] Handler to be executed upon exiting iteration of program AST
+* @property {(nca: NonCommentArgs) => void} [nonComment] Handler to be executed if rule wishes
+*   to be supplied nodes without comments
+*/
 /**
- * Create an eslint rule that iterates over all JSDocs, regardless of whether
- * they are attached to a function-like node.
- * @param {JsdocVisitor} iterator
- * @param {RuleConfig} ruleConfig The rule's configuration
- * @param {ContextObject[]|null} [contexts] The `contexts` containing relevant `comment` info.
- * @param {boolean} [additiveCommentContexts] If true, will have a separate
- *   iteration for each matching comment context. Otherwise, will iterate
- *   once if there is a single matching comment context.
- * @returns {import('eslint').Rule.RuleModule}
- */
+* Create an eslint rule that iterates over all JSDocs, regardless of whether
+* they are attached to a function-like node.
+* @param {JsdocVisitor} iterator
+* @param {RuleConfig} ruleConfig The rule's configuration
+* @param {ContextObject[]|null} [contexts] The `contexts` containing relevant `comment` info.
+* @param {boolean} [additiveCommentContexts] If true, will have a separate
+*   iteration for each matching comment context. Otherwise, will iterate
+*   once if there is a single matching comment context.
+* @returns {import('eslint').Rule.RuleModule}
+*/
 const iterateAllJsdocs = (iterator, ruleConfig, contexts, additiveCommentContexts) => {
-  const trackedJsdocs = new Set();
-
-  /** @type {import('@es-joy/jsdoccomment').CommentHandler} */
-  let handler;
-
-  /** @type {Settings|false} */
-  let settings;
-
-  /**
-   * @param {import('eslint').Rule.RuleContext} context
-   * @param {Node|null} node
-   * @param {import('estree').Comment[]} jsdocNodes
-   * @param {StateObject} state
-   * @param {boolean} [lastCall]
-   * @returns {void}
-   */
-  const callIterator = (context, node, jsdocNodes, state, lastCall) => {
-    /* c8 ignore next -- Fallback to deprecated method */
-    const {
-      sourceCode = context.getSourceCode()
-    } = context;
-    const {
-      lines
-    } = sourceCode;
-    const utils = getBasicUtils(context, /** @type {Settings} */settings);
-    for (const jsdocNode of jsdocNodes) {
-      const jsdocNde = /** @type {unknown} */jsdocNode;
-      if (!/^\/\*\*\s/v.test(sourceCode.getText(/** @type {import('estree').Node} */
-      jsdocNde))) {
-        continue;
-      }
-      const [indent, jsdoc] = getIndentAndJSDoc(lines, jsdocNode);
-      if (additiveCommentContexts) {
-        for (const [idx, {
-          comment
-        }] of /** @type {ContextObject[]} */contexts.entries()) {
-          if (comment && handler(comment, jsdoc) === false) {
-            continue;
-          }
-          iterate({
-            comment,
-            lastIndex: idx,
-            selector: node?.type
-          }, indent, jsdoc, ruleConfig, context, jsdocNode, /** @type {Node} */
-          node, /** @type {Settings} */
-          settings, sourceCode, iterator, state, true);
-        }
-        continue;
-      }
-      let lastComment;
-      let lastIndex;
-      // eslint-disable-next-line no-loop-func
-      if (contexts && contexts.every(({
-        comment
-      }, idx) => {
-        lastComment = comment;
-        lastIndex = idx;
-        return comment && handler(comment, jsdoc) === false;
-      })) {
-        continue;
-      }
-      iterate(lastComment ? {
-        comment: lastComment,
-        lastIndex,
-        selector: node?.type
-      } : {
-        lastIndex,
-        selector: node?.type
-      }, indent, jsdoc, ruleConfig, context, jsdocNode, node, /** @type {Settings} */
-      settings, sourceCode, iterator, state, true);
-    }
-    const settngs = /** @type {Settings} */settings;
-    if (lastCall && ruleConfig.exit) {
-      ruleConfig.exit({
-        context,
-        settings: settngs,
-        state,
-        utils
-      });
-    }
-  };
-  return {
-    create(context) {
-      /* c8 ignore next -- Fallback to deprecated method */
-      const {
-        sourceCode = context.getSourceCode()
-      } = context;
-      settings = getSettings(context);
-      if (!settings) {
-        return {};
-      }
-      if (contexts) {
-        handler = (0, _jsdoccomment.commentHandler)(settings);
-      }
-      const state = {};
-      return {
-        /**
-         * @param {import('eslint').Rule.Node & {
-         *   range: [Integer, Integer];
-         * }} node
-         * @returns {void}
-         */
-        '*:not(Program)'(node) {
-          const commentNode = (0, _jsdoccomment.getJSDocComment)(sourceCode, node, /** @type {Settings} */settings);
-          if (!ruleConfig.noTracking && trackedJsdocs.has(commentNode)) {
-            return;
-          }
-          if (!commentNode) {
-            if (ruleConfig.nonComment) {
-              const ste = /** @type {StateObject} */state;
-              ruleConfig.nonComment({
-                node,
-                state: ste
-              });
-            }
-            return;
-          }
-          trackedJsdocs.add(commentNode);
-          callIterator(context, node, [(/** @type {import('estree').Comment} */
-          commentNode)], /** @type {StateObject} */state);
-        },
-        'Program:exit'() {
-          const allComments = sourceCode.getAllComments();
-          const untrackedJSdoc = allComments.filter(node => {
-            return !trackedJsdocs.has(node);
-          });
-          callIterator(context, null, untrackedJSdoc, /** @type {StateObject} */
-          state, true);
-        }
-      };
-    },
-    meta: ruleConfig.meta
-  };
+	const trackedJsdocs = /* @__PURE__ */ new Set();
+	/** @type {import('@es-joy/jsdoccomment').CommentHandler} */
+	let handler;
+	/** @type {Settings|false} */
+	let settings;
+	/**
+	* @param {import('eslint').Rule.RuleContext} context
+	* @param {Node|null} node
+	* @param {import('estree').Comment[]} jsdocNodes
+	* @param {StateObject} state
+	* @param {boolean} [lastCall]
+	* @returns {void}
+	*/
+	const callIterator = (context, node, jsdocNodes, state, lastCall) => {
+		/* c8 ignore next -- Fallback to deprecated method */
+		const { sourceCode = context.getSourceCode() } = context;
+		const { lines } = sourceCode;
+		const utils = getBasicUtils(context, settings);
+		for (const jsdocNode of jsdocNodes) {
+			const jsdocNde = jsdocNode;
+			if (!/^\/\*\*\s/v.test(sourceCode.getText(jsdocNde))) continue;
+			const [indent, jsdoc] = getIndentAndJSDoc(lines, jsdocNode);
+			if (additiveCommentContexts) {
+				for (const [idx, { comment }] of contexts.entries()) {
+					if (comment && handler(comment, jsdoc) === false) continue;
+					iterate({
+						comment,
+						lastIndex: idx,
+						selector: node?.type
+					}, indent, jsdoc, ruleConfig, context, jsdocNode, node, settings, sourceCode, iterator, state, true);
+				}
+				continue;
+			}
+			let lastComment;
+			let lastIndex;
+			if (contexts && contexts.every(({ comment }, idx) => {
+				lastComment = comment;
+				lastIndex = idx;
+				return comment && handler(comment, jsdoc) === false;
+			})) continue;
+			iterate(lastComment ? {
+				comment: lastComment,
+				lastIndex,
+				selector: node?.type
+			} : {
+				lastIndex,
+				selector: node?.type
+			}, indent, jsdoc, ruleConfig, context, jsdocNode, node, settings, sourceCode, iterator, state, true);
+		}
+		const settngs = settings;
+		if (lastCall && ruleConfig.exit) ruleConfig.exit({
+			context,
+			settings: settngs,
+			state,
+			utils
+		});
+	};
+	return {
+		create(context) {
+			/* c8 ignore next -- Fallback to deprecated method */
+			const { sourceCode = context.getSourceCode() } = context;
+			settings = getSettings(context);
+			if (!settings) return {};
+			if (contexts) handler = (0, __es_joy_jsdoccomment.commentHandler)(settings);
+			const state = {};
+			return {
+				"*:not(Program)"(node) {
+					const commentNode = (0, __es_joy_jsdoccomment.getJSDocComment)(sourceCode, node, settings);
+					if (!ruleConfig.noTracking && trackedJsdocs.has(commentNode)) return;
+					if (!commentNode) {
+						if (ruleConfig.nonComment) {
+							const ste = state;
+							ruleConfig.nonComment({
+								node,
+								state: ste
+							});
+						}
+						return;
+					}
+					trackedJsdocs.add(commentNode);
+					callIterator(context, node, [commentNode], state);
+				},
+				"Program:exit"() {
+					const allComments = sourceCode.getAllComments();
+					const untrackedJSdoc = allComments.filter((node) => {
+						return !trackedJsdocs.has(node);
+					});
+					callIterator(context, null, untrackedJSdoc, state, true);
+				}
+			};
+		},
+		meta: ruleConfig.meta
+	};
 };
-
 /**
- * Create an eslint rule that iterates over all JSDocs, regardless of whether
- * they are attached to a function-like node.
- * @param {JsdocVisitorBasic} iterator
- * @param {RuleConfig} ruleConfig
- * @returns {import('eslint').Rule.RuleModule}
- */
+* Create an eslint rule that iterates over all JSDocs, regardless of whether
+* they are attached to a function-like node.
+* @param {JsdocVisitorBasic} iterator
+* @param {RuleConfig} ruleConfig
+* @returns {import('eslint').Rule.RuleModule}
+*/
 const checkFile = (iterator, ruleConfig) => {
-  return {
-    create(context) {
-      /* c8 ignore next -- Fallback to deprecated method */
-      const {
-        sourceCode = context.getSourceCode()
-      } = context;
-      const settings = getSettings(context);
-      if (!settings) {
-        return {};
-      }
-      return {
-        'Program:exit'() {
-          const allComms = /** @type {unknown} */sourceCode.getAllComments();
-          const utils = getBasicUtils(context, settings);
-          iterator({
-            allComments: (/** @type {import('estree').Node[]} */allComms),
-            context,
-            makeReport,
-            settings,
-            sourceCode,
-            utils
-          });
-        }
-      };
-    },
-    meta: ruleConfig.meta
-  };
+	return {
+		create(context) {
+			/* c8 ignore next -- Fallback to deprecated method */
+			const { sourceCode = context.getSourceCode() } = context;
+			const settings = getSettings(context);
+			if (!settings) return {};
+			return { "Program:exit"() {
+				const allComms = sourceCode.getAllComments();
+				const utils = getBasicUtils(context, settings);
+				iterator({
+					allComments: allComms,
+					context,
+					makeReport,
+					settings,
+					sourceCode,
+					utils
+				});
+			} };
+		},
+		meta: ruleConfig.meta
+	};
 };
 /**
- * @param {JsdocVisitor} iterator
- * @param {RuleConfig} ruleConfig
- * @returns {import('eslint').Rule.RuleModule}
- */
+* @param {JsdocVisitor} iterator
+* @param {RuleConfig} ruleConfig
+* @returns {import('eslint').Rule.RuleModule}
+*/
 function iterateJsdoc(iterator, ruleConfig) {
-  const metaType = ruleConfig?.meta?.type;
-  if (!metaType || !['layout', 'problem', 'suggestion'].includes(metaType)) {
-    throw new TypeError('Rule must include `meta.type` option (with value "problem", "suggestion", or "layout")');
-  }
-  if (typeof iterator !== 'function') {
-    throw new TypeError('The iterator argument must be a function.');
-  }
-  if (ruleConfig.checkFile) {
-    return checkFile(/** @type {JsdocVisitorBasic} */iterator, ruleConfig);
-  }
-  if (ruleConfig.iterateAllJsdocs) {
-    return iterateAllJsdocs(iterator, ruleConfig);
-  }
-
-  /** @type {import('eslint').Rule.RuleModule} */
-  return {
-    /**
-     * The entrypoint for the JSDoc rule.
-     * @param {import('eslint').Rule.RuleContext} context
-     *   a reference to the context which hold all important information
-     *   like settings and the sourcecode to check.
-     * @returns {import('eslint').Rule.RuleListener}
-     *   a listener with parser callback function.
-     */
-    create(context) {
-      const settings = getSettings(context);
-      if (!settings) {
-        return {};
-      }
-
-      /**
-       * @type {Context[]|undefined}
-       */
-      let contexts;
-      if (ruleConfig.contextDefaults || ruleConfig.contextSelected || ruleConfig.matchContext) {
-        contexts = ruleConfig.matchContext && context.options[0]?.match ? context.options[0].match : jsdocUtils.enforcedContexts(context, ruleConfig.contextDefaults, ruleConfig.nonGlobalSettings ? {} : settings);
-        if (contexts) {
-          contexts = contexts.map(obj => {
-            if (typeof obj === 'object' && !obj.context) {
-              return {
-                ...obj,
-                context: 'any'
-              };
-            }
-            return obj;
-          });
-        }
-        const hasPlainAny = contexts?.includes('any');
-        const hasObjectAny = !hasPlainAny && contexts?.find(ctxt => {
-          if (typeof ctxt === 'string') {
-            return false;
-          }
-          return ctxt?.context === 'any';
-        });
-        if (hasPlainAny || hasObjectAny) {
-          return iterateAllJsdocs(iterator, ruleConfig, hasObjectAny ? (/** @type {ContextObject[]} */contexts) : null, ruleConfig.matchContext).create(context);
-        }
-      }
-
-      /* c8 ignore next -- Fallback to deprecated method */
-      const {
-        sourceCode = context.getSourceCode()
-      } = context;
-      const {
-        lines
-      } = sourceCode;
-
-      /** @type {Partial<StateObject>} */
-      const state = {};
-
-      /** @type {CheckJsdoc} */
-      const checkJsdoc = (info, handler, node) => {
-        const jsdocNode = (0, _jsdoccomment.getJSDocComment)(sourceCode, node, settings);
-        if (!jsdocNode) {
-          return;
-        }
-        const [indent, jsdoc] = getIndentAndJSDoc(lines, /** @type {import('estree').Comment} */
-        jsdocNode);
-        if (
-        // Note, `handler` should already be bound in its first argument
-        //  with these only to be called after the value of
-        //  `comment`
-        handler && handler(jsdoc) === false) {
-          return;
-        }
-        iterate(info, indent, jsdoc, ruleConfig, context, jsdocNode, node, settings, sourceCode, iterator, /** @type {StateObject} */
-        state);
-      };
-
-      /** @type {import('eslint').Rule.RuleListener} */
-      let contextObject = {};
-      if (contexts && (ruleConfig.contextDefaults || ruleConfig.contextSelected || ruleConfig.matchContext)) {
-        contextObject = jsdocUtils.getContextObject(contexts, checkJsdoc, (0, _jsdoccomment.commentHandler)(settings));
-      } else {
-        for (const prop of ['ArrowFunctionExpression', 'FunctionDeclaration', 'FunctionExpression', 'TSDeclareFunction']) {
-          contextObject[prop] = checkJsdoc.bind(null, {
-            selector: prop
-          }, null);
-        }
-      }
-      if (typeof ruleConfig.exit === 'function') {
-        contextObject['Program:exit'] = () => {
-          const ste = /** @type {StateObject} */state;
-
-          // @ts-expect-error `utils` not needed at this point
-          /** @type {Required<RuleConfig>} */
-          ruleConfig.exit({
-            context,
-            settings,
-            state: ste
-          });
-        };
-      }
-      return contextObject;
-    },
-    meta: ruleConfig.meta
-  };
+	const metaType = ruleConfig?.meta?.type;
+	if (!metaType || ![
+		"layout",
+		"problem",
+		"suggestion"
+	].includes(metaType)) throw new TypeError("Rule must include `meta.type` option (with value \"problem\", \"suggestion\", or \"layout\")");
+	if (typeof iterator !== "function") throw new TypeError("The iterator argument must be a function.");
+	if (ruleConfig.checkFile) return checkFile(iterator, ruleConfig);
+	if (ruleConfig.iterateAllJsdocs) return iterateAllJsdocs(iterator, ruleConfig);
+	/** @type {import('eslint').Rule.RuleModule} */
+	return {
+		create(context) {
+			const settings = getSettings(context);
+			if (!settings) return {};
+			/**
+			* @type {Context[]|undefined}
+			*/
+			let contexts;
+			if (ruleConfig.contextDefaults || ruleConfig.contextSelected || ruleConfig.matchContext) {
+				contexts = ruleConfig.matchContext && context.options[0]?.match ? context.options[0].match : require_jsdocUtils.enforcedContexts(context, ruleConfig.contextDefaults, ruleConfig.nonGlobalSettings ? {} : settings);
+				if (contexts) contexts = contexts.map((obj) => {
+					if (typeof obj === "object" && !obj.context) return {
+						...obj,
+						context: "any"
+					};
+					return obj;
+				});
+				const hasPlainAny = contexts?.includes("any");
+				const hasObjectAny = !hasPlainAny && contexts?.find((ctxt) => {
+					if (typeof ctxt === "string") return false;
+					return ctxt?.context === "any";
+				});
+				if (hasPlainAny || hasObjectAny) return iterateAllJsdocs(iterator, ruleConfig, hasObjectAny ? contexts : null, ruleConfig.matchContext).create(context);
+			}
+			/* c8 ignore next -- Fallback to deprecated method */
+			const { sourceCode = context.getSourceCode() } = context;
+			const { lines } = sourceCode;
+			/** @type {Partial<StateObject>} */
+			const state = {};
+			/** @type {CheckJsdoc} */
+			const checkJsdoc = (info, handler, node) => {
+				const jsdocNode = (0, __es_joy_jsdoccomment.getJSDocComment)(sourceCode, node, settings);
+				if (!jsdocNode) return;
+				const [indent, jsdoc] = getIndentAndJSDoc(lines, jsdocNode);
+				if (handler && handler(jsdoc) === false) return;
+				iterate(info, indent, jsdoc, ruleConfig, context, jsdocNode, node, settings, sourceCode, iterator, state);
+			};
+			/** @type {import('eslint').Rule.RuleListener} */
+			let contextObject = {};
+			if (contexts && (ruleConfig.contextDefaults || ruleConfig.contextSelected || ruleConfig.matchContext)) contextObject = require_jsdocUtils.getContextObject(contexts, checkJsdoc, (0, __es_joy_jsdoccomment.commentHandler)(settings));
+			else for (const prop of [
+				"ArrowFunctionExpression",
+				"FunctionDeclaration",
+				"FunctionExpression",
+				"TSDeclareFunction"
+			]) contextObject[prop] = checkJsdoc.bind(null, { selector: prop }, null);
+			if (typeof ruleConfig.exit === "function") contextObject["Program:exit"] = () => {
+				const ste = state;
+				/** @type {Required<RuleConfig>} */ ruleConfig.exit({
+					context,
+					settings,
+					state: ste
+				});
+			};
+			return contextObject;
+		},
+		meta: ruleConfig.meta
+	};
 }
+
+//#endregion
+exports.default = iterateJsdoc;
+exports.getSettings = getSettings;
+Object.defineProperty(exports, 'parseComment', {
+  enumerable: true,
+  get: function () {
+    return __es_joy_jsdoccomment.parseComment;
+  }
+});
 //# sourceMappingURL=iterateJsdoc.cjs.map