@cjser/es-joy__jsdoccomment 0.96.0-cjser.2

package/LICENSE-MIT.txt

@@ -0,0 +1,20 @@
+Copyright JS Foundation and other contributors, https://js.foundation
+Copyright (c) 2021 Brett Zamir
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,250 @@
+# @es-joy/jsdoccomment
+
+[![NPM](https://img.shields.io/npm/v/@es-joy/jsdoccomment.svg?label=npm)](https://www.npmjs.com/package/@es-joy/jsdoccomment)
+[![License](https://img.shields.io/badge/license-MIT-yellowgreen.svg?style=flat)](https://github.com/es-joy/jsdoccomment/blob/main/LICENSE-MIT.txt)
+[![Build Status](https://github.com/es-joy/jsdoccomment/workflows/CI/CD/badge.svg)](#)
+[![API Docs](https://img.shields.io/badge/API%20Documentation-476ff0)](https://es-joy.github.io/jsdoccomment/docs/)
+
+See the **[Demo](https://es-joy.github.io/jsdoccomment/demo/)** and
+**[Docs](https://es-joy.github.io/jsdoccomment/docs/)**.
+
+This project aims to preserve and expand upon the
+`SourceCode#getJSDocComment` functionality of the deprecated ESLint method.
+
+It also exports a number of functions currently for working with JSDoc:
+
+## API
+
+### `parseComment`
+
+For parsing `comment-parser` in a JSDoc-specific manner.
+Might wish to have tags with or without tags, etc. derived from a split off
+JSON file.
+
+### `commentParserToESTree`
+
+Converts [comment-parser](https://github.com/syavorsky/comment-parser)
+AST to ESTree/ESLint/Babel friendly AST. See the "ESLint AST..." section below.
+
+### `estreeToString`
+
+Stringifies. In addition to the node argument, it accepts an optional second
+options object with a single `preferRawType` key. If you don't need to modify
+JSDoc type AST, you might wish to set this to `true` to get the benefits of
+preserving the raw form, but for AST-based stringification of JSDoc types,
+keep it `false` (the default).
+
+### `jsdocVisitorKeys`
+
+The [VisitorKeys](https://github.com/eslint/eslint-visitor-keys)
+for `JsdocBlock`, `JsdocDescriptionLine`, and `JsdocTag`. More likely to be
+subject to change or dropped in favor of another type parser.
+
+### `jsdocTypeVisitorKeys`
+
+Just a re-export of [VisitorKeys](https://github.com/eslint/eslint-visitor-keys)
+from [`jsdoc-type-pratt-parser`](https://github.com/simonseyock/jsdoc-type-pratt-parser/).
+
+### `getDefaultTagStructureForMode`
+
+Provides info on JSDoc tags:
+
+- `nameContents` ('namepath-referencing'|'namepath-defining'|
+  'dual-namepath-referencing'|false) - Whether and how a name is allowed
+  following any type. Tags without a proper name (value `false`) may still
+  have a description (which can appear like a name); `descriptionAllowed`
+  in such cases would be `true`.
+  The presence of a truthy `nameContents` value is therefore only intended
+  to signify whether separate parsing should occur for a name vs. a
+  description, and what its nature should be.
+- `nameRequired` (boolean) - Whether a name must be present following any type.
+- `descriptionAllowed` (boolean) - Whether a description (following any name)
+  is allowed.
+- `typeAllowed` (boolean) - Whether the tag accepts a curly bracketed portion.
+  Even without a type, a tag may still have a name and/or description.
+- `typeRequired` (boolean) - Whether a curly bracketed type must be present.
+- `typeOrNameRequired` (boolean) - Whether either a curly bracketed type is
+  required or a name, but not necessarily both.
+
+### Miscellaneous
+
+Also currently exports these utilities:
+
+- `getTokenizers` - Used with `parseComment` (its main core).
+- `hasSeeWithLink` - A utility to detect if a tag is `@see` and has a `@link`.
+- `commentHandler` - Used by `eslint-plugin-jsdoc`.
+- `commentParserToESTree`- Converts [comment-parser](https://github.com/syavorsky/comment-parser)
+  AST to ESTree/ESLint/Babel friendly AST.
+- `jsdocVisitorKeys` - The [VisitorKeys](https://github.com/eslint/eslint-visitor-keys)
+  for `JSDocBlock`, `JSDocDescriptionLine`, and `JSDocTag`.
+- `jsdocTypeVisitorKeys` - [VisitorKeys](https://github.com/eslint/eslint-visitor-keys)
+  for `jsdoc-type-pratt-parser`.
+- `defaultNoTypes` = The tags which allow no types by default:
+  `default`, `defaultvalue`, `description`, `example`, `file`,
+  `fileoverview`, `license`, `overview`, `see`, `summary`
+- `defaultNoNames` - The tags which allow no names by default:
+  `access`, `author`, `default`, `defaultvalue`, `description`, `example`,
+  `exception`, `file`, `fileoverview`, `kind`, `license`, `overview`,
+  `return`, `returns`, `since`, `summary`, `throws`, `version`, `variation`
+
+## ESLint AST produced for `comment-parser` nodes (`JsdocBlock`, `JsdocTag`, and `JsdocDescriptionLine`)
+
+Note: Although not added in this package, `@es-joy/jsdoc-eslint-parser` adds
+a `jsdoc` property to other ES nodes (using this project's `getJSDocComment`
+to determine the specific comment-block that will be attached as AST).
+
+### `JsdocBlock`
+
+Has the following visitable properties:
+
+1. `descriptionLines` (an array of `JsdocDescriptionLine` for multiline
+   descriptions).
+1. `tags` (an array of `JsdocTag`; see below)
+1. `inlineTags` (an array of `JsdocInlineTag`; see below)
+
+Has the following custom non-visitable property:
+
+1. `delimiterLineBreak` - A string containing any line break after `delimiter`.
+2. `lastDescriptionLine` - A number
+3. `endLine` - A number representing the line number with `end`/`terminal`
+4. `descriptionStartLine` - A 0+ number indicating the line where any
+   description begins
+5. `descriptionEndLine` - A 0+ number indicating the line where the description
+   ends
+6. `hasPreterminalDescription` - Set to 0 or 1. On if has a block description
+   on the same line as the terminal `*/`.
+7. `hasPreterminalTagDescription` - Set to 0 or 1. On if has a tag description
+   on the same line as the terminal `*/`.
+8. `preterminalLineBreak` - A string containing any line break before `terminal`.
+
+May also have the following non-visitable properties from `comment-parser`:
+
+1. `description` - Same as `descriptionLines` but as a string with newlines.
+2. `delimiter`
+3. `postDelimiter`
+4. `lineEnd`
+5. `initial` (from `start`)
+6. `terminal` (from `end`)
+
+### `JsdocTag`
+
+Has the following visitable properties:
+
+1. `parsedType` (the `jsdoc-type-pratt-parser` AST representation of the tag's
+   type (see the `jsdoc-type-pratt-parser` section below)).
+1. `typeLines` (an array of `JsdocTypeLine` for multiline type strings)
+1. `descriptionLines` (an array of `JsdocDescriptionLine` for multiline
+   descriptions)
+1. `inlineTags` (an array of `JsdocInlineTag`)
+
+May also have the following non-visitable properties from `comment-parser`
+(note that all are included from `comment-parser` except `end` as that is only
+for JSDoc blocks and note that `type` is renamed to `rawType` and `start` to
+`initial`):
+
+1. `description` - Same as `descriptionLines` but as a string with newlines.
+2. `rawType` - `comment-parser` has this named as `type`, but because of a
+   conflict with ESTree using `type` for Node type, we renamed it to
+   `rawType`. It is otherwise the same as in `comment-parser`, i.e., a string
+   with newlines, though with the initial `{` and final `}` stripped out.
+   See `typeLines` for the array version of this property.
+3. `initial` - Renamed from `start` to avoid potential conflicts with
+   Acorn-style parser processing tools
+4. `delimiter`
+5. `postDelimiter`
+6. `tag` (this does differ from `comment-parser` now in terms of our stripping
+   the initial `@`)
+7. `postTag`
+8. `name`
+9. `postName`
+10. `postType`
+
+### `JsdocDescriptionLine`
+
+No visitable properties.
+
+May also have the following non-visitable properties from `comment-parser`:
+
+1. `delimiter`
+2. `postDelimiter`
+3. `initial` (from `start`)
+4. `description`
+
+### `JsdocTypeLine`
+
+No visitable properties.
+
+May also have the following non-visitable properties from `comment-parser`:
+
+1. `delimiter`
+2. `postDelimiter`
+3. `initial` (from `start`)
+4. `rawType` - Renamed from `comment-parser` to avoid a conflict. See
+   explanation under `JsdocTag`
+
+### `JsdocInlineTag`
+
+No visitable properties.
+
+Has the following non-visitable properties:
+
+1. `format`: 'pipe' | 'plain' | 'prefix' | 'space'. These follow the styles of [`@link`](https://jsdoc.app/tags-inline-link.html) or [`@tutorial`](https://jsdoc.app/tags-inline-tutorial.html).
+    1. `pipe`: `{@link namepathOrURL|link text}`
+    2. `plain`: `{@link namepathOrURL}`
+    3. `prefix`: `[link text]{@link namepathOrURL}`
+    4. `space`: `{@link namepathOrURL link text (after the first space)}`
+2. `namepathOrURL`: string
+3. `tag`: string. The standard allows `tutorial` or `link`
+4. `text`: string
+
+## ESLint AST produced for `jsdoc-type-pratt-parser`
+
+The AST, including `type`, remains as is from [jsdoc-type-pratt-parser](https://github.com/simonseyock/jsdoc-type-pratt-parser/).
+
+The type will always begin with a `JsdocType` prefix added, along with a
+camel-cased type name, e.g., `JsdocTypeUnion`.
+
+The `jsdoc-type-pratt-parser` visitor keys are also preserved without change.
+
+You can get a sense of the structure of these types using the parser's
+[tester](https://jsdoc-type-pratt-parser.github.io/jsdoc-type-pratt-parser/).
+
+## Installation
+
+```shell
+npm i @es-joy/jsdoccomment
+```
+
+## Changelog
+
+The changelog can be found on the [CHANGES.md](https://github.com/es-joy/jsdoccomment/blob/main/CHANGES.md).
+
+<!--## Contributing
+
+Everyone is welcome to contribute. Please take a moment to review the [contributing guidelines](CONTRIBUTING.md).
+-->
+
+## Authors and license
+
+[Brett Zamir](http://brett-zamir.me/) and
+[contributors](https://github.com/es-joy/jsdoccomment/graphs/contributors).
+
+MIT License, see the included [LICENSE-MIT.txt](https://github.com/es-joy/jsdoccomment/blob/main/LICENSE-MIT.txt) file.
+
+## To-dos
+
+1. Get complete code coverage
+1. Given that `esquery` expects a `right` property to search for `>` (the
+   child selector), we should perhaps insist, for example, that params are
+   the child property for `JsdocBlock` or such. Where `:has()` is currently
+   needed, one could thus instead just use `>`.
+1. Might add `trailing` for `JsdocBlock` to know whether it is followed by a
+   line break or what not; `comment-parser` does not provide, however
+1. Fix and properly utilize `indent` argument (challenging for
+   `eslint-plugin-jsdoc` but needed for `jsdoc-eslint-parser` stringifiers
+   to be more faithful); should also then use the proposed `trailing` as well
+
+## cjser
+
+This package is a CommonJS-compatible build generated by cjser for projects that still need `require()` support. The source version matches the original npm package version, with a cjser prerelease suffix for this generated build.
+Original repository: https://github.com/es-joy/jsdoccomment

package/dist/index.d.ts

@@ -0,0 +1,421 @@
+import * as estree from 'estree';
+import * as comment_parser from 'comment-parser';
+import * as jsdoc_type_pratt_parser from '@cjser/jsdoc-type-pratt-parser';
+export * from '@cjser/jsdoc-type-pratt-parser';
+export { visitorKeys as jsdocTypeVisitorKeys } from '@cjser/jsdoc-type-pratt-parser';
+import * as _typescript_eslint_types from '@typescript-eslint/types';
+import * as eslint from 'eslint';
+
+type JsdocTypeLine = {
+  delimiter: string;
+  postDelimiter: string;
+  rawType: string;
+  initial: string;
+  type: 'JsdocTypeLine';
+};
+type JsdocDescriptionLine = {
+  delimiter: string;
+  description: string;
+  postDelimiter: string;
+  initial: string;
+  type: 'JsdocDescriptionLine';
+};
+/**
+ * An inline tag whose `text` is the unescaped label value.
+ */
+type JsdocInlineTagNoType = {
+  format: 'pipe' | 'plain' | 'prefix' | 'space';
+  namepathOrURL: string;
+  tag: string;
+  text: string;
+};
+type JsdocInlineTag = JsdocInlineTagNoType & {
+  type: 'JsdocInlineTag';
+};
+type JsdocTag = {
+  delimiter: string;
+  description: string;
+  descriptionLines: JsdocDescriptionLine[];
+  initial: string;
+  inlineTags: JsdocInlineTag[];
+  name: string;
+  postDelimiter: string;
+  postName: string;
+  postTag: string;
+  postType: string;
+  rawType: string;
+  parsedType: jsdoc_type_pratt_parser.RootResult | null;
+  tag: string;
+  type: 'JsdocTag';
+  typeLines: JsdocTypeLine[];
+};
+type Integer = number;
+type JsdocBlock = {
+  delimiter: string;
+  delimiterLineBreak: string;
+  description: string;
+  descriptionEndLine?: Integer;
+  descriptionLines: JsdocDescriptionLine[];
+  descriptionStartLine?: Integer;
+  hasPreterminalDescription: 0 | 1;
+  hasPreterminalTagDescription?: 1;
+  initial: string;
+  inlineTags: JsdocInlineTag[];
+  lastDescriptionLine?: Integer;
+  endLine: Integer;
+  lineEnd: string;
+  postDelimiter: string;
+  tags: JsdocTag[];
+  terminal: string;
+  preterminalLineBreak: string;
+  type: 'JsdocBlock';
+};
+type JtppOptions = {
+  module?: boolean;
+  strictMode?: boolean;
+  asyncFunctionBody?: boolean;
+  classContext?: boolean;
+  computedPropertyParser?: (text: string, options?: any) => unknown;
+};
+type CommentParserToESTreeOptions = {
+  /**
+   * By default, empty lines are
+   * compacted; set to 'preserve' to preserve empty comment lines.
+   */
+  spacing?: 'compact' | 'preserve';
+  throwOnTypeParsingErrors?: boolean;
+  jsdocTypePrattParserArgs?: JtppOptions;
+};
+/**
+ * @typedef {{
+ *   module?: boolean;
+ *   strictMode?: boolean;
+ *   asyncFunctionBody?: boolean;
+ *   classContext?: boolean;
+ *   computedPropertyParser?: (text: string, options?: any) => unknown;
+ * }} JtppOptions
+ */
+/**
+ * @typedef {object} CommentParserToESTreeOptions
+ * @property {'compact'|'preserve'} [spacing] By default, empty lines are
+ *        compacted; set to 'preserve' to preserve empty comment lines.
+ * @property {boolean} [throwOnTypeParsingErrors]
+ * @property {JtppOptions} [jsdocTypePrattParserArgs]
+ */
+/**
+ * Converts comment parser AST to ESTree format.
+ * @param {import('./index.js').JsdocBlockWithInline} jsdoc
+ * @param {import('@cjser/jsdoc-type-pratt-parser').ParseMode} mode
+ * @param {CommentParserToESTreeOptions} [opts]
+ * @returns {JsdocBlock}
+ */
+declare function commentParserToESTree(
+  jsdoc: JsdocBlockWithInline,
+  mode?: jsdoc_type_pratt_parser.ParseMode,
+  { spacing, throwOnTypeParsingErrors, jsdocTypePrattParserArgs }?: CommentParserToESTreeOptions,
+): JsdocBlock;
+declare namespace jsdocVisitorKeys {
+  let JsdocBlock: string[];
+  let JsdocDescriptionLine: any[];
+  let JsdocTypeLine: any[];
+  let JsdocTag: string[];
+  let JsdocInlineTag: any[];
+}
+
+/**
+ * @param {{
+ *   mode: import('@cjser/jsdoc-type-pratt-parser').ParseMode,
+ *   [key: string]: any
+ * }} settings
+ * @param {import('./commentParserToESTree.js').
+ *   CommentParserToESTreeOptions} [commentParserToESTreeOptions]
+ * @returns {import('./index.js').CommentHandler}
+ */
+declare function commentHandler(
+  settings: {
+    mode: jsdoc_type_pratt_parser.ParseMode;
+    [key: string]: any;
+  },
+  commentParserToESTreeOptions?: CommentParserToESTreeOptions,
+): CommentHandler;
+
+/**
+ * @todo convert for use by escodegen (until may be patched to support
+ *   custom entries?).
+ * @param {import('./commentParserToESTree.js').JsdocBlock|
+ *   import('./commentParserToESTree.js').JsdocDescriptionLine|
+ *   import('./commentParserToESTree.js').JsdocTypeLine|
+ *   import('./commentParserToESTree.js').JsdocTag|
+ *   import('./commentParserToESTree.js').JsdocInlineTag|
+ *   import('@cjser/jsdoc-type-pratt-parser').RootResult
+ * } node
+ * @param {import('./index.js').ESTreeToStringOptions} [opts]
+ * @throws {Error}
+ * @returns {string}
+ */
+declare function estreeToString(
+  node:
+    JsdocBlock | JsdocDescriptionLine | JsdocTypeLine | JsdocTag | JsdocInlineTag | jsdoc_type_pratt_parser.RootResult,
+  opts?: ESTreeToStringOptions,
+): string;
+
+type Token =
+  | eslint.AST.Token
+  | estree.Comment
+  | {
+      type: eslint.AST.TokenType | 'Line' | 'Block' | 'Shebang';
+      range: [number, number];
+      value: string;
+    };
+type ESLintOrTSNode = eslint.Rule.Node | _typescript_eslint_types.TSESTree.Node;
+type int = number;
+type DecoratedNode =
+  | ESLintOrTSNode
+  | estree.Comment
+  | (eslint.Rule.Node & {
+      declaration?: any;
+      decorators?: any[];
+    });
+type Settings = {
+  maxLines: int;
+  minLines: int;
+  skipInvokedExpressionsForCommentFinding?: boolean;
+  [name: string]: any;
+};
+/**
+ * @typedef {{
+ *   maxLines: int,
+ *   minLines: int,
+ *   skipInvokedExpressionsForCommentFinding?: boolean,
+ *   [name: string]: any
+ * }} Settings
+ */
+/**
+ * Reduces the provided node to the appropriate node for evaluating
+ * JSDoc comment status.
+ *
+ * @param {ESLintOrTSNode} node An AST node.
+ * @param {import('eslint').SourceCode} sourceCode The ESLint SourceCode.
+ * @param {Settings} [settings]
+ * @returns {ESLintOrTSNode} The AST node that
+ *   can be evaluated for appropriate JSDoc comments.
+ */
+declare function getReducedASTNode(
+  node: ESLintOrTSNode,
+  sourceCode: eslint.SourceCode,
+  settings?: Settings,
+): ESLintOrTSNode;
+/**
+ * Retrieves the JSDoc comment for a given node.
+ *
+ * @param {import('eslint').SourceCode} sourceCode The ESLint SourceCode
+ * @param {ESLintOrTSNode} node The AST node to get
+ *   the comment for.
+ * @param {Settings} settings The settings in context
+ * @param {{checkOverloads?: boolean}} [opts]
+ * @returns {Token|null} The Block comment
+ *   token containing the JSDoc comment for the given node or
+ *   null if not found.
+ * @public
+ */
+declare function getJSDocComment(
+  sourceCode: eslint.SourceCode,
+  node: ESLintOrTSNode,
+  settings: Settings,
+  opts?: {
+    checkOverloads?: boolean;
+  },
+): Token | null;
+/**
+ * Retrieves the comment preceding a given node.
+ *
+ * @param {import('eslint').SourceCode} sourceCode The ESLint SourceCode
+ * @param {ESLintOrTSNode} node The AST node to get
+ *   the comment for.
+ * @param {{maxLines: int, minLines: int, [name: string]: any}} settings The
+ *   settings in context
+ * @returns {Token|null} The Block comment
+ *   token containing the JSDoc comment for the given node or
+ *   null if not found.
+ * @public
+ */
+declare function getNonJsdocComment(
+  sourceCode: eslint.SourceCode,
+  node: ESLintOrTSNode,
+  settings: {
+    maxLines: int;
+    minLines: int;
+    [name: string]: any;
+  },
+): Token | null;
+/**
+ * @typedef {(
+ *   ESLintOrTSNode|
+ *   import('estree').Comment|
+ *   import('eslint').Rule.Node & {declaration?: any, decorators?: any[]}
+ * )} DecoratedNode
+ */
+/**
+ * @param {DecoratedNode} node
+ * @returns {import('@typescript-eslint/types').TSESTree.Decorator|undefined}
+ */
+declare function getDecorator(node: DecoratedNode): _typescript_eslint_types.TSESTree.Decorator | undefined;
+/**
+ * Checks for the presence of a JSDoc comment for the given node and returns it.
+ *
+ * @param {ESLintOrTSNode} astNode The AST node to get
+ *   the comment for.
+ * @param {import('eslint').SourceCode} sourceCode
+ * @param {{maxLines: int, minLines: int, [name: string]: any}} settings
+ * @param {{nonJSDoc?: boolean}} [opts]
+ * @returns {Token|null} The Block comment token containing the JSDoc comment
+ *    for the given node or null if not found.
+ */
+declare function findJSDocComment(
+  astNode: ESLintOrTSNode,
+  sourceCode: eslint.SourceCode,
+  settings: {
+    maxLines: int;
+    minLines: int;
+    [name: string]: any;
+  },
+  opts?: {
+    nonJSDoc?: boolean;
+  },
+): Token | null;
+/**
+ * Checks for the presence of a comment following the given node and
+ * returns it.
+ *
+ * This method is experimental.
+ *
+ * @param {import('eslint').SourceCode} sourceCode
+ * @param {ESLintOrTSNode} astNode The AST node to get
+ *   the comment for.
+ * @returns {Token|null} The comment token containing the comment
+ *    for the given node or null if not found.
+ */
+declare function getFollowingComment(sourceCode: eslint.SourceCode, astNode: ESLintOrTSNode): Token | null;
+
+declare function hasSeeWithLink(spec: comment_parser.Spec): boolean;
+declare const defaultNoTypes: string[];
+declare const defaultNoNames: string[];
+/**
+ * Can't import `comment-parser/es6/parser/tokenizers/index.js`,
+ *   so we redefine here.
+ */
+type CommentParserTokenizer = (spec: comment_parser.Spec) => comment_parser.Spec;
+/**
+ * Can't import `comment-parser/es6/parser/tokenizers/index.js`,
+ *   so we redefine here.
+ * @typedef {(spec: import('comment-parser').Spec) =>
+ *   import('comment-parser').Spec} CommentParserTokenizer
+ */
+/**
+ * @param {object} [cfg]
+ * @param {string[]} [cfg.noTypes]
+ * @param {string[]} [cfg.noNames]
+ * @returns {CommentParserTokenizer[]}
+ */
+declare function getTokenizers({
+  noTypes,
+  noNames,
+}?: {
+  noTypes?: string[];
+  noNames?: string[];
+}): CommentParserTokenizer[];
+/**
+ * Accepts a comment token or complete comment string and converts it into
+ * `comment-parser` AST.
+ * @param {string | {value: string}} commentOrNode
+ * @param {string} [indent] Whitespace
+ * @returns {import('./index.js').JsdocBlockWithInline}
+ */
+declare function parseComment(
+  commentOrNode:
+    | string
+    | {
+        value: string;
+      },
+  indent?: string,
+): JsdocBlockWithInline;
+
+/**
+ * Splits the `{@ prefix}` from remaining `Spec.lines[].token.description`
+ * into the `inlineTags` tokens, and populates `spec.inlineTags`
+ * @param {import('comment-parser').Block} block
+ * @returns {import('./index.js').JsdocBlockWithInline}
+ */
+declare function parseInlineTags(block: comment_parser.Block): JsdocBlockWithInline;
+
+/**
+ * An inline tag whose `text` is the unescaped label value.
+ */
+type InlineTag = JsdocInlineTagNoType & {
+  start: number;
+  end: number;
+};
+type JsdocTagWithInline = comment_parser.Spec & {
+  line?: Integer;
+  inlineTags: (JsdocInlineTagNoType & {
+    line?: Integer;
+  })[];
+};
+/**
+ * Expands on comment-parser's `Block` interface.
+ */
+type JsdocBlockWithInline = {
+  description: string;
+  source: comment_parser.Line[];
+  problems: comment_parser.Problem[];
+  tags: JsdocTagWithInline[];
+  inlineTags: (JsdocInlineTagNoType & {
+    line?: Integer;
+  })[];
+};
+type ESTreeToStringOptions = {
+  preferRawType?: boolean;
+  jtppStringificationRules?: (node: estree.Node, options?: any) => string;
+};
+type CommentHandler = (commentSelector: string, jsdoc: JsdocBlockWithInline) => boolean;
+
+export {
+  JsdocBlock,
+  JsdocDescriptionLine,
+  JsdocInlineTag,
+  JsdocTag,
+  JsdocTypeLine,
+  commentHandler,
+  commentParserToESTree,
+  defaultNoNames,
+  defaultNoTypes,
+  estreeToString,
+  findJSDocComment,
+  getDecorator,
+  getFollowingComment,
+  getJSDocComment,
+  getNonJsdocComment,
+  getReducedASTNode,
+  getTokenizers,
+  hasSeeWithLink,
+  jsdocVisitorKeys,
+  parseComment,
+  parseInlineTags,
+};
+export type {
+  CommentHandler,
+  CommentParserToESTreeOptions,
+  CommentParserTokenizer,
+  DecoratedNode,
+  ESLintOrTSNode,
+  ESTreeToStringOptions,
+  InlineTag,
+  Integer,
+  JsdocBlockWithInline,
+  JsdocInlineTagNoType,
+  JsdocTagWithInline,
+  JtppOptions,
+  Settings,
+  Token,
+  int,
+};