eslint-plugin-jsdoc 56.0.0 → 56.0.1

package/dist/cjs/iterateJsdoc.js

@@ -1,1981 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseComment = exports.getSettings = void 0;
-exports.default = iterateJsdoc;
-const jsdocUtils = __importStar(require("./jsdocUtils.js"));
-const jsdoccomment_1 = require("@es-joy/jsdoccomment");
-const comment_parser_1 = require("comment-parser");
-const esquery_1 = __importDefault(require("esquery"));
-/**
- * @typedef {number} Integer
- */
-/**
- * @typedef {import('@es-joy/jsdoccomment').JsdocBlockWithInline} JsdocBlockWithInline
- */
-/**
- * @typedef {{
- *   disallowName?: string,
- *   allowName?: string,
- *   context?: string,
- *   comment?: string,
- *   tags?: string[],
- *   replacement?: string,
- *   minimum?: Integer,
- *   message?: string,
- *   forceRequireReturn?: boolean
- * }} ContextObject
- */
-/**
- * @typedef {string|ContextObject} Context
- */
-/**
- * @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 ForEachPreferredTag
- * @param {string} tagName
- * @param {(
- *   matchingJsdocTag: import('@es-joy/jsdoccomment').JsdocTagWithInline,
- *   targetTagName: string
- * ) => void} arrayHandler
- * @param {boolean} [skipReportingBlockedTag]
- * @returns {void}
- */
-/**
- * @callback ReportSettings
- * @param {string} message
- * @returns {void}
- */
-/**
- * @callback ParseClosureTemplateTag
- * @param {import('comment-parser').Spec} tag
- * @returns {string[]}
- */
-/**
- * @callback GetPreferredTagNameObject
- * @param {{
- *   tagName: string
- * }} cfg
- * @returns {string|false|{
- *   message: string;
- *   replacement?: string|undefined
- * }|{
- *   blocked: true,
- *   tagName: string
- * }}
- */
-/**
- * @typedef {{
- *   forEachPreferredTag: ForEachPreferredTag,
- *   reportSettings: ReportSettings,
- *   parseClosureTemplateTag: ParseClosureTemplateTag,
- *   getPreferredTagNameObject: GetPreferredTagNameObject,
- *   pathDoesNotBeginWith: import('./jsdocUtils.js').PathDoesNotBeginWith
- * }} BasicUtils
- */
-/**
- * @callback IsIteratingFunction
- * @returns {boolean}
- */
-/**
- * @callback IsVirtualFunction
- * @returns {boolean}
- */
-/**
- * @callback Stringify
- * @param {import('comment-parser').Block} tagBlock
- * @param {boolean} [specRewire]
- * @returns {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 GetRegexFromString
- * @param {string} str
- * @param {string} [requiredFlags]
- * @returns {RegExp}
- */
-/**
- * @callback GetTagDescription
- * @param {import('comment-parser').Spec} tg
- * @param {boolean} [returnArray]
- * @returns {string[]|string}
- */
-/**
- * @callback SetTagDescription
- * @param {import('comment-parser').Spec} tg
- * @param {RegExp} matcher
- * @param {(description: string) => string} setter
- * @returns {Integer}
- */
-/**
- * @callback GetDescription
- * @returns {{
- *   description: string,
- *   descriptions: string[],
- *   lastDescriptionLine: Integer
- * }}
- */
-/**
- * @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 SetDescriptionLines
- * @param {RegExp} matcher
- * @param {(description: string) => string} setter
- * @returns {Integer}
- */
-/**
- * @callback ChangeTag
- * @param {import('comment-parser').Spec} tag
- * @param {...Partial<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 RemoveTag
- * @param {Integer} tagIndex
- * @param {{
- *   removeEmptyBlock?: boolean,
- *   tagSourceOffset?: Integer
- * }} [cfg]
- * @returns {void}
- */
-/**
- * @callback AddTag
- * @param {string} targetTagName
- * @param {Integer} [number]
- * @param {import('comment-parser').Tokens|{}} [tokens]
- * @returns {void}
- */
-/**
- * @callback GetFirstLine
- * @returns {Integer|undefined}
- */
-/**
- * @typedef {(
- *   tokens?: Partial<import('comment-parser').Tokens> | undefined
- * ) => import('comment-parser').Tokens} SeedTokens
- */
-/**
- * Sets tokens to empty string.
- * @callback EmptyTokens
- * @param {import('comment-parser').Tokens} tokens
- * @returns {void}
- */
-/**
- * @callback AddLine
- * @param {Integer} sourceIndex
- * @param {Partial<import('comment-parser').Tokens>} tokens
- * @returns {void}
- */
-/**
- * @callback AddLines
- * @param {Integer} tagIndex
- * @param {Integer} tagSourceOffset
- * @param {Integer} numLines
- * @returns {void}
- */
-/**
- * @callback MakeMultiline
- * @returns {void}
- */
-/**
- * @callback GetFunctionParameterNames
- * @param {boolean} [useDefaultObjectProperties]
- * @returns {import('./jsdocUtils.js').ParamNameInfo[]}
- */
-/**
- * @callback HasParams
- * @returns {Integer}
- */
-/**
- * @callback IsGenerator
- * @returns {boolean}
- */
-/**
- * @callback IsConstructor
- * @returns {boolean}
- */
-/**
- * @callback GetJsdocTagsDeep
- * @param {string} tagName
- * @returns {false|{
- *   idx: Integer,
- *   name: string,
- *   type: string
- * }[]}
- */
-/**
- * @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 IsValidTag
- * @param {string} name
- * @param {string[]} definedTags
- * @returns {boolean}
- */
-/**
- * @callback HasATag
- * @param {string[]} names
- * @returns {boolean}
- */
-/**
- * @callback HasTag
- * @param {string} name
- * @returns {boolean}
- */
-/**
- * @callback ComparePaths
- * @param {string} name
- * @returns {(otherPathName: string) => boolean}
- */
-/**
- * @callback DropPathSegmentQuotes
- * @param {string} name
- * @returns {string}
- */
-/**
- * @callback AvoidDocs
- * @returns {boolean}
- */
-/**
- * @callback TagMightHaveNamePositionTypePosition
- * @param {string} tagName
- * @param {import('./getDefaultTagStructureForMode.js').
- *   TagStructure[]} [otherModeMaps]
- * @returns {boolean|{otherMode: true}}
- */
-/**
- * @callback TagMustHave
- * @param {string} tagName
- * @param {import('./getDefaultTagStructureForMode.js').
- *   TagStructure[]} otherModeMaps
- * @returns {boolean|{
- *   otherMode: false
- * }}
- */
-/**
- * @callback TagMissingRequiredTypeOrNamepath
- * @param {import('comment-parser').Spec} tag
- * @param {import('./getDefaultTagStructureForMode.js').
- *   TagStructure[]} otherModeMaps
- * @returns {boolean|{
- *   otherMode: false
- * }}
- */
-/**
- * @callback IsNamepathX
- * @param {string} tagName
- * @returns {boolean}
- */
-/**
- * @callback GetTagStructureForMode
- * @param {import('./jsdocUtils.js').ParserMode} mde
- * @returns {import('./getDefaultTagStructureForMode.js').TagStructure}
- */
-/**
- * @callback MayBeUndefinedTypeTag
- * @param {import('comment-parser').Spec} tag
- * @returns {boolean}
- */
-/**
- * @callback HasValueOrExecutorHasNonEmptyResolveValue
- * @param {boolean} anyPromiseAsReturn
- * @param {boolean} [allBranches]
- * @returns {boolean}
- */
-/**
- * @callback HasYieldValue
- * @returns {boolean}
- */
-/**
- * @callback HasYieldReturnValue
- * @returns {boolean}
- */
-/**
- * @callback HasThrowValue
- * @returns {boolean}
- */
-/**
- * @callback IsAsync
- * @returns {boolean|undefined}
- */
-/**
- * @callback GetTags
- * @param {string} tagName
- * @returns {import('comment-parser').Spec[]}
- */
-/**
- * @callback GetPresentTags
- * @param {string[]} tagList
- * @returns {import('@es-joy/jsdoccomment').JsdocTagWithInline[]}
- */
-/**
- * @callback FilterTags
- * @param {(tag: import('@es-joy/jsdoccomment').JsdocTagWithInline) => boolean} filter
- * @returns {import('@es-joy/jsdoccomment').JsdocTagWithInline[]}
- */
-/**
- * @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 GetTagsByType
- * @param {import('comment-parser').Spec[]} tags
- * @returns {{
- *   tagsWithNames: import('comment-parser').Spec[],
- *   tagsWithoutNames: import('comment-parser').Spec[]
- * }}
- */
-/**
- * @callback HasOptionTag
- * @param {string} tagName
- * @returns {boolean}
- */
-/**
- * @callback GetClassNode
- * @returns {Node|null}
- */
-/**
- * @callback GetClassJsdoc
- * @returns {null|JsdocBlockWithInline}
- */
-/**
- * @callback ClassHasTag
- * @param {string} tagName
- * @returns {boolean}
- */
-/**
- * @callback FindContext
- * @param {Context[]} contexts
- * @param {string|undefined} comment
- * @returns {{
- *   foundContext: Context|undefined,
- *   contextStr: string
- * }}
- */
-/**
- * @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_1.util;
-// todo: Change these `any` types once importing types properly.
-/**
- * Should use ESLint rule's typing.
- * @typedef {import('eslint').Rule.RuleMetaData} EslintRuleMeta
- */
-/**
- * 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 {
-   align as commentAlign,
-  flow: commentFlow,
-  indent: commentIndent,
-} = transforms;
-*/
-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;
-};
-/**
- * @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}
- */
-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 5 */
-            ) :
-            (
-            // @ts-expect-error ESLint 8
-            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;
-    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_1.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 = () => {
-        // eslint-disable-next-line canonical/no-use-extend-native -- Not extending
-        return [
-            ...ancestors, node,
-        ].toReversed().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_1.getJSDocComment)(sourceCode, classNode, {
-            maxLines,
-            minLines,
-        });
-        if (classJsdocNode) {
-            return (0, jsdoccomment_1.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_1.default.matches(
-                /** @type {Node} */ (node), esquery_1.default.parse(cntxt), undefined, {
-                    visitorKeys: sourceCode.visitorKeys,
-                }) :
-                (!cntxt.context || cntxt.context === 'any' ||
-                    esquery_1.default.matches(
-                    /** @type {Node} */ (node), esquery_1.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;
-};
-/**
- * @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 {{
- *   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) => {
-    /* 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;
-};
-exports.getSettings = getSettings;
-/**
- * Create the report function
- * @callback MakeReport
- * @param {import('eslint').Rule.RuleContext} context
- * @param {import('estree').Node} commentNode
- * @returns {Report}
- */
-/** @type {MakeReport} */
-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;
-};
-/**
- * @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}
- */
-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,
-    });
-};
-/**
- * @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_1.parseComment)(jsdocNode, '');
-    return [
-        indnt, jsdc,
-    ];
-};
-/**
- *
- * @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
- */
-/**
- * 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_1.commentHandler)(settings);
-            }
-            const state = {};
-            return {
-                /**
-                 * @param {import('eslint').Rule.Node & {
-                 *   range: [Integer, Integer];
-                 * }} node
-                 * @returns {void}
-                 */
-                '*:not(Program)'(node) {
-                    const commentNode = (0, jsdoccomment_1.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,
-    };
-};
-/**
- * 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,
-    };
-};
-/**
- * @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_1.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_1.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,
-    };
-}
-var jsdoccomment_2 = require("@es-joy/jsdoccomment");
-Object.defineProperty(exports, "parseComment", { enumerable: true, get: function () { return jsdoccomment_2.parseComment; } });