eslint-plugin-jsdoc 55.4.0 → 56.0.0

package/dist/cjs/rules/checkAccess.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("eslint").Rule.RuleModule;
+export default _default;

package/dist/cjs/rules/checkAccess.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const iterateJsdoc_js_1 = __importDefault(require("../iterateJsdoc.js"));
+const accessLevels = [
+    'package', 'private', 'protected', 'public',
+];
+exports.default = (0, iterateJsdoc_js_1.default)(({ report, utils, }) => {
+    utils.forEachPreferredTag('access', (jsdocParameter, targetTagName) => {
+        const desc = jsdocParameter.name + ' ' + jsdocParameter.description;
+        if (!accessLevels.includes(desc.trim())) {
+            report(`Missing valid JSDoc @${targetTagName} level.`, null, jsdocParameter);
+        }
+    });
+    const accessLength = utils.getTags('access').length;
+    const individualTagLength = utils.getPresentTags(accessLevels).length;
+    if (accessLength && individualTagLength) {
+        report('The @access tag may not be used with specific access-control tags (@package, @private, @protected, or @public).');
+    }
+    if (accessLength > 1 || individualTagLength > 1) {
+        report('At most one access-control tag may be present on a jsdoc block.');
+    }
+}, {
+    checkPrivate: true,
+    iterateAllJsdocs: true,
+    meta: {
+        docs: {
+            description: 'Checks that `@access` tags have a valid value.',
+            url: 'https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/check-access.md#repos-sticky-header',
+        },
+        type: 'suggestion',
+    },
+});

package/dist/cjs/rules/checkAlignment.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("eslint").Rule.RuleModule;
+export default _default;

package/dist/cjs/rules/checkAlignment.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const iterateJsdoc_js_1 = __importDefault(require("../iterateJsdoc.js"));
+exports.default = (0, iterateJsdoc_js_1.default)(({ context, indent, jsdocNode, report, sourceCode, }) => {
+    const { innerIndent = 1, } = context.options[0] || {};
+    // `indent` is whitespace from line 1 (`/**`), so slice and account for "/".
+    const indentLevel = indent.length + innerIndent;
+    const sourceLines = sourceCode.getText(jsdocNode).split('\n')
+        .slice(1)
+        .map((line, number) => {
+        return {
+            line: line.split('*')[0],
+            number,
+        };
+    })
+        .filter(({ line, }) => {
+        return !line.trimStart().length;
+    });
+    /** @type {import('eslint').Rule.ReportFixer} */
+    const fix = (fixer) => {
+        const replacement = sourceCode.getText(jsdocNode).split('\n')
+            .map((line, index) => {
+            // Ignore the first line and all lines not starting with `*`
+            const ignored = !index || line.split('*')[0].trimStart().length;
+            return ignored ? line : `${indent}${''.padStart(innerIndent, ' ')}${line.trimStart()}`;
+        })
+            .join('\n');
+        return fixer.replaceText(jsdocNode, replacement);
+    };
+    sourceLines.some(({ line, number, }) => {
+        if (line.length !== indentLevel) {
+            report('Expected JSDoc block to be aligned.', fix, {
+                line: number + 1,
+            });
+            return true;
+        }
+        return false;
+    });
+}, {
+    iterateAllJsdocs: true,
+    meta: {
+        docs: {
+            description: 'Reports invalid alignment of JSDoc block asterisks.',
+            url: 'https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/check-alignment.md#repos-sticky-header',
+        },
+        fixable: 'code',
+        schema: [
+            {
+                additionalProperties: false,
+                properties: {
+                    innerIndent: {
+                        default: 1,
+                        type: 'integer',
+                    },
+                },
+            },
+        ],
+        type: 'layout',
+    },
+});

package/dist/cjs/rules/checkExamples.d.ts

@@ -0,0 +1,3 @@
+declare const _default: eslint.Rule.RuleModule;
+export default _default;
+import eslint from 'eslint';

package/dist/cjs/rules/checkExamples.js

@@ -0,0 +1,486 @@
+"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 });
+const iterateJsdoc_js_1 = __importDefault(require("../iterateJsdoc.js"));
+const eslint_1 = __importStar(require("eslint"));
+const semver_1 = __importDefault(require("semver"));
+const { 
+// @ts-expect-error Older ESLint
+CLIEngine, } = eslint_1.default;
+const zeroBasedLineIndexAdjust = -1;
+const likelyNestedJSDocIndentSpace = 1;
+const preTagSpaceLength = 1;
+// If a space is present, we should ignore it
+const firstLinePrefixLength = preTagSpaceLength;
+const hasCaptionRegex = /^\s*<caption>([\s\S]*?)<\/caption>/v;
+/**
+ * @param {string} str
+ * @returns {string}
+ */
+const escapeStringRegexp = (str) => {
+    return str.replaceAll(/[.*+?^$\{\}\(\)\|\[\]\\]/gv, '\\$&');
+};
+/**
+ * @param {string} str
+ * @param {string} ch
+ * @returns {import('../iterateJsdoc.js').Integer}
+ */
+const countChars = (str, ch) => {
+    return (str.match(new RegExp(escapeStringRegexp(ch), 'gv')) || []).length;
+};
+/** @type {import('eslint').Linter.RulesRecord} */
+const defaultMdRules = {
+    // "always" newline rule at end unlikely in sample code
+    'eol-last': 0,
+    // Wouldn't generally expect example paths to resolve relative to JS file
+    'import/no-unresolved': 0,
+    // Snippets likely too short to always include import/export info
+    'import/unambiguous': 0,
+    'jsdoc/require-file-overview': 0,
+    // The end of a multiline comment would end the comment the example is in.
+    'jsdoc/require-jsdoc': 0,
+    // Unlikely to have inadvertent debugging within examples
+    'no-console': 0,
+    // Often wish to start `@example` code after newline; also may use
+    //   empty lines for spacing
+    'no-multiple-empty-lines': 0,
+    // Many variables in examples will be `undefined`
+    'no-undef': 0,
+    // Common to define variables for clarity without always using them
+    'no-unused-vars': 0,
+    // See import/no-unresolved
+    'node/no-missing-import': 0,
+    'node/no-missing-require': 0,
+    // Can generally look nicer to pad a little even if code imposes more stringency
+    'padded-blocks': 0,
+};
+/** @type {import('eslint').Linter.RulesRecord} */
+const defaultExpressionRules = {
+    ...defaultMdRules,
+    'chai-friendly/no-unused-expressions': 'off',
+    'no-empty-function': 'off',
+    'no-new': 'off',
+    'no-unused-expressions': 'off',
+    quotes: [
+        'error', 'double',
+    ],
+    semi: [
+        'error', 'never',
+    ],
+    strict: 'off',
+};
+/**
+ * @param {string} text
+ * @returns {[
+ *   import('../iterateJsdoc.js').Integer,
+ *   import('../iterateJsdoc.js').Integer
+ * ]}
+ */
+const getLinesCols = (text) => {
+    const matchLines = countChars(text, '\n');
+    const colDelta = matchLines ?
+        text.slice(text.lastIndexOf('\n') + 1).length :
+        text.length;
+    return [
+        matchLines, colDelta,
+    ];
+};
+exports.default = (0, iterateJsdoc_js_1.default)(({ context, globalState, report, utils, }) => {
+    if (semver_1.default.gte(eslint_1.ESLint.version, '8.0.0')) {
+        report('This rule does not work for ESLint 8+; you should disable this rule and use' +
+            'the processor mentioned in the docs.', null, {
+            column: 1,
+            line: 1,
+        });
+        return;
+    }
+    if (!globalState.has('checkExamples-matchingFileName')) {
+        globalState.set('checkExamples-matchingFileName', new Map());
+    }
+    const matchingFileNameMap = /** @type {Map<string, string>} */ (globalState.get('checkExamples-matchingFileName'));
+    const options = context.options[0] || {};
+    let { exampleCodeRegex = null, rejectExampleCodeRegex = null, } = options;
+    const { allowInlineConfig = true, baseConfig = {}, captionRequired = false, checkDefaults = false, checkEslintrc = true, checkParams = false, checkProperties = false, configFile, matchingFileName = null, matchingFileNameDefaults = null, matchingFileNameParams = null, matchingFileNameProperties = null, noDefaultExampleRules = false, paddedIndent = 0, reportUnusedDisableDirectives = true, } = options;
+    // Make this configurable?
+    /**
+     * @type {never[]}
+     */
+    const rulePaths = [];
+    const mdRules = noDefaultExampleRules ? undefined : defaultMdRules;
+    const expressionRules = noDefaultExampleRules ? undefined : defaultExpressionRules;
+    if (exampleCodeRegex) {
+        exampleCodeRegex = utils.getRegexFromString(exampleCodeRegex);
+    }
+    if (rejectExampleCodeRegex) {
+        rejectExampleCodeRegex = utils.getRegexFromString(rejectExampleCodeRegex);
+    }
+    /**
+     * @param {{
+     *   filename: string,
+     *   defaultFileName: string|undefined,
+     *   source: string,
+     *   targetTagName: string,
+     *   rules?: import('eslint').Linter.RulesRecord|undefined,
+     *   lines?: import('../iterateJsdoc.js').Integer,
+     *   cols?: import('../iterateJsdoc.js').Integer,
+     *   skipInit?: boolean,
+     *   sources?: {
+     *     nonJSPrefacingCols: import('../iterateJsdoc.js').Integer,
+     *     nonJSPrefacingLines: import('../iterateJsdoc.js').Integer,
+     *     string: string,
+     *   }[],
+     *   tag?: import('comment-parser').Spec & {
+     *     line?: import('../iterateJsdoc.js').Integer,
+     *   }|{
+     *     line: import('../iterateJsdoc.js').Integer,
+     *   }
+     * }} cfg
+     */
+    const checkSource = ({ cols = 0, defaultFileName, filename, lines = 0, rules = expressionRules, skipInit, source, sources = [], tag = {
+        line: 0,
+    }, targetTagName, }) => {
+        if (!skipInit) {
+            sources.push({
+                nonJSPrefacingCols: cols,
+                nonJSPrefacingLines: lines,
+                string: source,
+            });
+        }
+        /**
+         * @param {{
+         *   nonJSPrefacingCols: import('../iterateJsdoc.js').Integer,
+         *   nonJSPrefacingLines: import('../iterateJsdoc.js').Integer,
+         *   string: string
+         * }} cfg
+         */
+        const checkRules = function ({ nonJSPrefacingCols, nonJSPrefacingLines, string, }) {
+            const cliConfig = {
+                allowInlineConfig,
+                baseConfig,
+                configFile,
+                reportUnusedDisableDirectives,
+                rulePaths,
+                rules,
+                useEslintrc: checkEslintrc,
+            };
+            const cliConfigStr = JSON.stringify(cliConfig);
+            const src = paddedIndent ?
+                string.replaceAll(new RegExp(`(^|\n) {${paddedIndent}}(?!$)`, 'gv'), '\n') :
+                string;
+            // Programmatic ESLint API: https://eslint.org/docs/developer-guide/nodejs-api
+            const fileNameMapKey = filename ?
+                'a' + cliConfigStr + filename :
+                'b' + cliConfigStr + defaultFileName;
+            const file = filename || defaultFileName;
+            let cliFile;
+            if (matchingFileNameMap.has(fileNameMapKey)) {
+                cliFile = matchingFileNameMap.get(fileNameMapKey);
+            }
+            else {
+                const cli = new CLIEngine(cliConfig);
+                let config;
+                if (filename || checkEslintrc) {
+                    config = cli.getConfigForFile(file);
+                }
+                // We need a new instance to ensure that the rules that may only
+                //  be available to `file` (if it has its own `.eslintrc`),
+                //  will be defined.
+                cliFile = new CLIEngine({
+                    allowInlineConfig,
+                    baseConfig: {
+                        ...baseConfig,
+                        ...config,
+                    },
+                    configFile,
+                    reportUnusedDisableDirectives,
+                    rulePaths,
+                    rules,
+                    useEslintrc: false,
+                });
+                matchingFileNameMap.set(fileNameMapKey, cliFile);
+            }
+            const { results: [{ messages, },], } = cliFile.executeOnText(src);
+            if (!('line' in tag)) {
+                tag.line = tag.source[0].number;
+            }
+            // NOTE: `tag.line` can be 0 if of form `/** @tag ... */`
+            const codeStartLine = /**
+                                   * @type {import('comment-parser').Spec & {
+                                   *     line: import('../iterateJsdoc.js').Integer,
+                                   * }}
+                                   */ (tag).line + nonJSPrefacingLines;
+            const codeStartCol = likelyNestedJSDocIndentSpace;
+            for (const { column, line, message, ruleId, severity, } of messages) {
+                const startLine = codeStartLine + line + zeroBasedLineIndexAdjust;
+                const startCol = codeStartCol + (
+                // This might not work for line 0, but line 0 is unlikely for examples
+                line <= 1 ? nonJSPrefacingCols + firstLinePrefixLength : preTagSpaceLength) + column;
+                report('@' + targetTagName + ' ' + (severity === 2 ? 'error' : 'warning') +
+                    (ruleId ? ' (' + ruleId + ')' : '') + ': ' +
+                    message, null, {
+                    column: startCol,
+                    line: startLine,
+                });
+            }
+        };
+        for (const targetSource of sources) {
+            checkRules(targetSource);
+        }
+    };
+    /**
+     *
+     * @param {string} filename
+     * @param {string} [ext] Since `eslint-plugin-markdown` v2, and
+     *   ESLint 7, this is the default which other JS-fenced rules will used.
+     *   Formerly "md" was the default.
+     * @returns {{defaultFileName: string|undefined, filename: string}}
+     */
+    const getFilenameInfo = (filename, ext = 'md/*.js') => {
+        let defaultFileName;
+        if (!filename) {
+            const jsFileName = context.getFilename();
+            if (typeof jsFileName === 'string' && jsFileName.includes('.')) {
+                defaultFileName = jsFileName.replace(/\.[^.]*$/v, `.${ext}`);
+            }
+            else {
+                defaultFileName = `dummy.${ext}`;
+            }
+        }
+        return {
+            defaultFileName,
+            filename,
+        };
+    };
+    if (checkDefaults) {
+        const filenameInfo = getFilenameInfo(matchingFileNameDefaults, 'jsdoc-defaults');
+        utils.forEachPreferredTag('default', (tag, targetTagName) => {
+            if (!tag.description.trim()) {
+                return;
+            }
+            checkSource({
+                source: `(${utils.getTagDescription(tag)})`,
+                targetTagName,
+                ...filenameInfo,
+            });
+        });
+    }
+    if (checkParams) {
+        const filenameInfo = getFilenameInfo(matchingFileNameParams, 'jsdoc-params');
+        utils.forEachPreferredTag('param', (tag, targetTagName) => {
+            if (!tag.default || !tag.default.trim()) {
+                return;
+            }
+            checkSource({
+                source: `(${tag.default})`,
+                targetTagName,
+                ...filenameInfo,
+            });
+        });
+    }
+    if (checkProperties) {
+        const filenameInfo = getFilenameInfo(matchingFileNameProperties, 'jsdoc-properties');
+        utils.forEachPreferredTag('property', (tag, targetTagName) => {
+            if (!tag.default || !tag.default.trim()) {
+                return;
+            }
+            checkSource({
+                source: `(${tag.default})`,
+                targetTagName,
+                ...filenameInfo,
+            });
+        });
+    }
+    const tagName = /** @type {string} */ (utils.getPreferredTagName({
+        tagName: 'example',
+    }));
+    if (!utils.hasTag(tagName)) {
+        return;
+    }
+    const matchingFilenameInfo = getFilenameInfo(matchingFileName);
+    utils.forEachPreferredTag('example', (tag, targetTagName) => {
+        let source = /** @type {string} */ (utils.getTagDescription(tag));
+        const match = source.match(hasCaptionRegex);
+        if (captionRequired && (!match || !match[1].trim())) {
+            report('Caption is expected for examples.', null, tag);
+        }
+        source = source.replace(hasCaptionRegex, '');
+        const [lines, cols,] = match ? getLinesCols(match[0]) : [
+            0, 0,
+        ];
+        if (exampleCodeRegex && !exampleCodeRegex.test(source) ||
+            rejectExampleCodeRegex && rejectExampleCodeRegex.test(source)) {
+            return;
+        }
+        const sources = [];
+        let skipInit = false;
+        if (exampleCodeRegex) {
+            let nonJSPrefacingCols = 0;
+            let nonJSPrefacingLines = 0;
+            let startingIndex = 0;
+            let lastStringCount = 0;
+            let exampleCode;
+            exampleCodeRegex.lastIndex = 0;
+            while ((exampleCode = exampleCodeRegex.exec(source)) !== null) {
+                const { '0': n0, '1': n1, index, } = exampleCode;
+                // Count anything preceding user regex match (can affect line numbering)
+                const preMatch = source.slice(startingIndex, index);
+                const [preMatchLines, colDelta,] = getLinesCols(preMatch);
+                let nonJSPreface;
+                let nonJSPrefaceLineCount;
+                if (n1) {
+                    const idx = n0.indexOf(n1);
+                    nonJSPreface = n0.slice(0, idx);
+                    nonJSPrefaceLineCount = countChars(nonJSPreface, '\n');
+                }
+                else {
+                    nonJSPreface = '';
+                    nonJSPrefaceLineCount = 0;
+                }
+                nonJSPrefacingLines += lastStringCount + preMatchLines + nonJSPrefaceLineCount;
+                // Ignore `preMatch` delta if newlines here
+                if (nonJSPrefaceLineCount) {
+                    const charsInLastLine = nonJSPreface.slice(nonJSPreface.lastIndexOf('\n') + 1).length;
+                    nonJSPrefacingCols += charsInLastLine;
+                }
+                else {
+                    nonJSPrefacingCols += colDelta + nonJSPreface.length;
+                }
+                const string = n1 || n0;
+                sources.push({
+                    nonJSPrefacingCols,
+                    nonJSPrefacingLines,
+                    string,
+                });
+                startingIndex = exampleCodeRegex.lastIndex;
+                lastStringCount = countChars(string, '\n');
+                if (!exampleCodeRegex.global) {
+                    break;
+                }
+            }
+            skipInit = true;
+        }
+        checkSource({
+            cols,
+            lines,
+            rules: mdRules,
+            skipInit,
+            source,
+            sources,
+            tag,
+            targetTagName,
+            ...matchingFilenameInfo,
+        });
+    });
+}, {
+    iterateAllJsdocs: true,
+    meta: {
+        docs: {
+            description: 'Ensures that (JavaScript) examples within JSDoc adhere to ESLint rules.',
+            url: 'https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/check-examples.md#repos-sticky-header',
+        },
+        schema: [
+            {
+                additionalProperties: false,
+                properties: {
+                    allowInlineConfig: {
+                        default: true,
+                        type: 'boolean',
+                    },
+                    baseConfig: {
+                        type: 'object',
+                    },
+                    captionRequired: {
+                        default: false,
+                        type: 'boolean',
+                    },
+                    checkDefaults: {
+                        default: false,
+                        type: 'boolean',
+                    },
+                    checkEslintrc: {
+                        default: true,
+                        type: 'boolean',
+                    },
+                    checkParams: {
+                        default: false,
+                        type: 'boolean',
+                    },
+                    checkProperties: {
+                        default: false,
+                        type: 'boolean',
+                    },
+                    configFile: {
+                        type: 'string',
+                    },
+                    exampleCodeRegex: {
+                        type: 'string',
+                    },
+                    matchingFileName: {
+                        type: 'string',
+                    },
+                    matchingFileNameDefaults: {
+                        type: 'string',
+                    },
+                    matchingFileNameParams: {
+                        type: 'string',
+                    },
+                    matchingFileNameProperties: {
+                        type: 'string',
+                    },
+                    noDefaultExampleRules: {
+                        default: false,
+                        type: 'boolean',
+                    },
+                    paddedIndent: {
+                        default: 0,
+                        type: 'integer',
+                    },
+                    rejectExampleCodeRegex: {
+                        type: 'string',
+                    },
+                    reportUnusedDisableDirectives: {
+                        default: true,
+                        type: 'boolean',
+                    },
+                },
+                type: 'object',
+            },
+        ],
+        type: 'suggestion',
+    },
+});

package/dist/cjs/rules/checkIndentation.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("eslint").Rule.RuleModule;
+export default _default;

package/dist/cjs/rules/checkIndentation.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const iterateJsdoc_js_1 = __importDefault(require("../iterateJsdoc.js"));
+/**
+ * @param {string} str
+ * @param {string[]} excludeTags
+ * @returns {string}
+ */
+const maskExcludedContent = (str, excludeTags) => {
+    const regContent = new RegExp(`([ \\t]+\\*)[ \\t]@(?:${excludeTags.join('|')})(?=[ \\n])([\\w\\|\\W]*?\\n)(?=[ \\t]*\\*(?:[ \\t]*@\\w+\\s|\\/))`, 'gv');
+    return str.replace(regContent, (_match, margin, code) => {
+        return (margin + '\n').repeat(code.match(/\n/gv).length);
+    });
+};
+/**
+ * @param {string} str
+ * @returns {string}
+ */
+const maskCodeBlocks = (str) => {
+    const regContent = /([ \t]+\*)[ \t]```[^\n]*?([\w\|\W]*?\n)(?=[ \t]*\*(?:[ \t]*(?:```|@\w+\s)|\/))/gv;
+    return str.replaceAll(regContent, (_match, margin, code) => {
+        return (margin + '\n').repeat(code.match(/\n/gv).length);
+    });
+};
+exports.default = (0, iterateJsdoc_js_1.default)(({ context, jsdocNode, report, sourceCode, }) => {
+    const options = context.options[0] || {};
+    const /** @type {{excludeTags: string[]}} */ { excludeTags = [
+        'example',
+    ], } = options;
+    const reg = /^(?:\/?\**|[ \t]*)\*[ \t]{2}/gmv;
+    const textWithoutCodeBlocks = maskCodeBlocks(sourceCode.getText(jsdocNode));
+    const text = excludeTags.length ? maskExcludedContent(textWithoutCodeBlocks, excludeTags) : textWithoutCodeBlocks;
+    if (reg.test(text)) {
+        const lineBreaks = text.slice(0, reg.lastIndex).match(/\n/gv) || [];
+        report('There must be no indentation.', null, {
+            line: lineBreaks.length,
+        });
+    }
+}, {
+    iterateAllJsdocs: true,
+    meta: {
+        docs: {
+            description: 'Reports invalid padding inside JSDoc blocks.',
+            url: 'https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/check-indentation.md#repos-sticky-header',
+        },
+        schema: [
+            {
+                additionalProperties: false,
+                properties: {
+                    excludeTags: {
+                        items: {
+                            pattern: '^\\S+$',
+                            type: 'string',
+                        },
+                        type: 'array',
+                    },
+                },
+                type: 'object',
+            },
+        ],
+        type: 'layout',
+    },
+});

package/dist/cjs/rules/checkLineAlignment.d.ts

@@ -0,0 +1,9 @@
+declare const _default: import("eslint").Rule.RuleModule;
+export default _default;
+export type CustomSpacings = {
+    postDelimiter: import("../iterateJsdoc.js").Integer;
+    postHyphen: import("../iterateJsdoc.js").Integer;
+    postName: import("../iterateJsdoc.js").Integer;
+    postTag: import("../iterateJsdoc.js").Integer;
+    postType: import("../iterateJsdoc.js").Integer;
+};