typedoc 0.22.14 → 0.23.0-beta.1

package/dist/lib/converter/comments/discovery.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverSignatureComment = exports.discoverComment = void 0;
+const ts = require("typescript");
+const models_1 = require("../../models");
+const paths_1 = require("../../utils/paths");
+// Note: This does NOT include JSDoc syntax kinds. This is important!
+// Comments from @typedef and @callback tags are handled specially by
+// the JSDoc converter because we only want part of the comment when
+// getting them.
+const wantedKinds = {
+    [models_1.ReflectionKind.Project]: [ts.SyntaxKind.SourceFile],
+    [models_1.ReflectionKind.Module]: [ts.SyntaxKind.SourceFile],
+    [models_1.ReflectionKind.Namespace]: [
+        ts.SyntaxKind.ModuleDeclaration,
+        ts.SyntaxKind.SourceFile,
+        ts.SyntaxKind.BindingElement,
+        ts.SyntaxKind.ExportSpecifier,
+    ],
+    [models_1.ReflectionKind.Enum]: [
+        ts.SyntaxKind.EnumDeclaration,
+        ts.SyntaxKind.VariableDeclaration,
+    ],
+    [models_1.ReflectionKind.EnumMember]: [
+        ts.SyntaxKind.EnumMember,
+        // These here so that @enum gets comments
+        ts.SyntaxKind.PropertyAssignment,
+        ts.SyntaxKind.PropertySignature,
+    ],
+    [models_1.ReflectionKind.Variable]: [
+        ts.SyntaxKind.VariableDeclaration,
+        ts.SyntaxKind.BindingElement,
+        ts.SyntaxKind.ExportAssignment,
+    ],
+    [models_1.ReflectionKind.Function]: [
+        ts.SyntaxKind.FunctionDeclaration,
+        ts.SyntaxKind.BindingElement,
+    ],
+    [models_1.ReflectionKind.Class]: [
+        ts.SyntaxKind.ClassDeclaration,
+        ts.SyntaxKind.BindingElement,
+    ],
+    [models_1.ReflectionKind.Interface]: [ts.SyntaxKind.InterfaceDeclaration],
+    [models_1.ReflectionKind.Constructor]: [ts.SyntaxKind.Constructor],
+    [models_1.ReflectionKind.Property]: [
+        ts.SyntaxKind.PropertyDeclaration,
+        ts.SyntaxKind.PropertySignature,
+        ts.SyntaxKind.BinaryExpression,
+        ts.SyntaxKind.PropertyAssignment,
+    ],
+    [models_1.ReflectionKind.Method]: [
+        ts.SyntaxKind.FunctionDeclaration,
+        ts.SyntaxKind.MethodDeclaration,
+    ],
+    [models_1.ReflectionKind.CallSignature]: [
+        ts.SyntaxKind.FunctionDeclaration,
+        ts.SyntaxKind.VariableDeclaration,
+        ts.SyntaxKind.MethodDeclaration,
+        ts.SyntaxKind.MethodDeclaration,
+        ts.SyntaxKind.PropertyDeclaration,
+        ts.SyntaxKind.PropertySignature,
+        ts.SyntaxKind.CallSignature,
+    ],
+    [models_1.ReflectionKind.IndexSignature]: [ts.SyntaxKind.IndexSignature],
+    [models_1.ReflectionKind.ConstructorSignature]: [ts.SyntaxKind.ConstructSignature],
+    [models_1.ReflectionKind.Parameter]: [ts.SyntaxKind.Parameter],
+    [models_1.ReflectionKind.TypeLiteral]: [ts.SyntaxKind.TypeLiteral],
+    [models_1.ReflectionKind.TypeParameter]: [ts.SyntaxKind.TypeParameter],
+    [models_1.ReflectionKind.Accessor]: [
+        ts.SyntaxKind.GetAccessor,
+        ts.SyntaxKind.SetAccessor,
+    ],
+    [models_1.ReflectionKind.GetSignature]: [ts.SyntaxKind.GetAccessor],
+    [models_1.ReflectionKind.SetSignature]: [ts.SyntaxKind.SetAccessor],
+    [models_1.ReflectionKind.ObjectLiteral]: [ts.SyntaxKind.ObjectLiteralExpression],
+    [models_1.ReflectionKind.TypeAlias]: [ts.SyntaxKind.TypeAliasDeclaration],
+    [models_1.ReflectionKind.Reference]: [
+        ts.SyntaxKind.NamespaceExport,
+        ts.SyntaxKind.ExportSpecifier,
+    ],
+};
+function discoverComment(symbol, kind, logger) {
+    // For a module comment, we want the first one defined in the file,
+    // not the last one, since that will apply to the import or declaration.
+    const reverse = symbol.declarations?.some(ts.isSourceFile);
+    const discovered = [];
+    for (const decl of symbol.declarations || []) {
+        const text = decl.getSourceFile().text;
+        if (wantedKinds[kind].includes(decl.kind)) {
+            const node = declarationToCommentNode(decl);
+            if (!node) {
+                continue;
+            }
+            // Special behavior here! We temporarily put the implementation comment
+            // on the reflection which contains all the signatures. This lets us pull
+            // the comment on the implementation if some signature does not have a comment.
+            // However, we don't want to skip the node if it is a reference to something.
+            // See the gh1770 test for an example.
+            if (kind & models_1.ReflectionKind.ContainsCallSignatures &&
+                !node.body &&
+                node.kind !== ts.SyntaxKind.BindingElement) {
+                continue;
+            }
+            const comments = ts.getLeadingCommentRanges(text, node.pos);
+            if (reverse) {
+                comments?.reverse();
+            }
+            const lastDocComment = comments?.find((c) => text[c.pos] === "/" &&
+                text[c.pos + 1] === "*" &&
+                text[c.pos + 2] === "*");
+            if (lastDocComment) {
+                discovered.push([decl.getSourceFile(), lastDocComment]);
+            }
+        }
+    }
+    switch (discovered.length) {
+        case 0:
+            return undefined;
+        case 1:
+            return discovered[0];
+        default: {
+            logger.warn(`${symbol.name} has multiple declarations with a comment. An arbitrary comment will be used.`);
+            const locations = discovered.map(([sf, { pos }]) => {
+                const path = (0, paths_1.nicePath)(sf.fileName);
+                const line = ts.getLineAndCharacterOfPosition(sf, pos).line + 1;
+                return `${path}:${line}`;
+            });
+            logger.info(`The comments for ${symbol.name} are declared at:\n\t${locations.join("\n\t")}`);
+            return discovered[0];
+        }
+    }
+}
+exports.discoverComment = discoverComment;
+function discoverSignatureComment(declaration) {
+    const node = declarationToCommentNode(declaration);
+    if (!node) {
+        return;
+    }
+    const text = node.getSourceFile().text;
+    const comments = ts.getLeadingCommentRanges(text, node.pos);
+    const comment = comments?.find((c) => text[c.pos] === "/" &&
+        text[c.pos + 1] === "*" &&
+        text[c.pos + 2] === "*");
+    if (comment) {
+        return [node.getSourceFile(), comment];
+    }
+}
+exports.discoverSignatureComment = discoverSignatureComment;
+/**
+ * Check whether the given module declaration is the topmost.
+ *
+ * This function returns TRUE if there is no trailing module defined, in
+ * the following example this would be the case only for module <code>C</code>.
+ *
+ * ```
+ * module A.B.C { }
+ * ```
+ *
+ * @param node  The module definition that should be tested.
+ * @return TRUE if the given node is the topmost module declaration, FALSE otherwise.
+ */
+function isTopmostModuleDeclaration(node) {
+    return node.getChildren().some(ts.isModuleBlock);
+}
+/**
+ * Return the root module declaration of the given module declaration.
+ *
+ * In the following example this function would always return module
+ * <code>A</code> no matter which of the modules was passed in.
+ *
+ * ```
+ * module A.B.C { }
+ * ```
+ */
+function getRootModuleDeclaration(node) {
+    while (node.parent &&
+        node.parent.kind === ts.SyntaxKind.ModuleDeclaration) {
+        const parent = node.parent;
+        if (node.name.pos === parent.name.end + 1) {
+            node = parent;
+        }
+        else {
+            break;
+        }
+    }
+    return node;
+}
+function declarationToCommentNode(node) {
+    if (node.parent?.kind === ts.SyntaxKind.VariableDeclarationList) {
+        return node.parent.parent;
+    }
+    if (node.kind === ts.SyntaxKind.ModuleDeclaration) {
+        if (!isTopmostModuleDeclaration(node)) {
+            return;
+        }
+        else {
+            return getRootModuleDeclaration(node);
+        }
+    }
+    if (node.kind === ts.SyntaxKind.ExportSpecifier) {
+        return node.parent.parent;
+    }
+    if ([
+        ts.SyntaxKind.NamespaceExport,
+        ts.SyntaxKind.FunctionExpression,
+        ts.SyntaxKind.FunctionType,
+        ts.SyntaxKind.FunctionType,
+        ts.SyntaxKind.ArrowFunction,
+    ].includes(node.kind)) {
+        return node.parent;
+    }
+    return node;
+}

package/dist/lib/converter/comments/index.d.ts

@@ -0,0 +1,11 @@
+import * as ts from "typescript";
+import { Comment, ReflectionKind } from "../../models";
+import { Logger } from "../../utils";
+export interface CommentParserConfig {
+    blockTags: Set<string>;
+    inlineTags: Set<string>;
+    modifierTags: Set<string>;
+}
+export declare function getComment(symbol: ts.Symbol, kind: ReflectionKind, config: CommentParserConfig, logger: Logger): Comment | undefined;
+export declare function getSignatureComment(declaration: ts.SignatureDeclaration | ts.JSDocSignature, config: CommentParserConfig, logger: Logger): Comment | undefined;
+export declare function getJsDocComment(declaration: ts.JSDocPropertyLikeTag | ts.JSDocCallbackTag | ts.JSDocTypedefTag | ts.JSDocTemplateTag | ts.JSDocEnumTag, config: CommentParserConfig, logger: Logger): Comment | undefined;

package/dist/lib/converter/comments/index.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getJsDocComment = exports.getSignatureComment = exports.getComment = void 0;
+const ts = require("typescript");
+const models_1 = require("../../models");
+const utils_1 = require("../../utils");
+const paths_1 = require("../../utils/paths");
+const blockLexer_1 = require("./blockLexer");
+const discovery_1 = require("./discovery");
+const parser_1 = require("./parser");
+const commentCache = new WeakMap();
+function getCommentWithCache(discovered, config, logger) {
+    if (!discovered)
+        return;
+    const [file, range] = discovered;
+    const cache = commentCache.get(file) || new Map();
+    if (cache?.has(range.pos)) {
+        return cache.get(range.pos).clone();
+    }
+    const line = ts.getLineAndCharacterOfPosition(file, range.pos).line + 1;
+    const warning = (warning) => logger.warn(`${warning} in comment at ${(0, paths_1.nicePath)(file.fileName)}:${line}.`);
+    let comment;
+    switch (range.kind) {
+        case ts.SyntaxKind.MultiLineCommentTrivia:
+            comment = (0, parser_1.parseComment)((0, blockLexer_1.lexBlockComment)(file.text, range.pos, range.end), config, warning);
+            break;
+        case ts.SyntaxKind.SingleLineCommentTrivia:
+            throw "GERRIT FIX ME"; // GERRIT
+        default:
+            (0, utils_1.assertNever)(range.kind);
+    }
+    cache.set(range.pos, comment);
+    commentCache.set(file, cache);
+    return comment.clone();
+}
+function getComment(symbol, kind, config, logger) {
+    const comment = getCommentWithCache((0, discovery_1.discoverComment)(symbol, kind, logger), config, logger);
+    if (symbol.declarations?.some(ts.isSourceFile) && comment) {
+        // Module comment, make sure it is tagged with @packageDocumentation or @module.
+        // If it isn't then the comment applies to the first statement in the file, so throw it away.
+        if (!comment.hasModifier("@packageDocumentation") &&
+            !comment.getTag("@module")) {
+            return;
+        }
+    }
+    return comment;
+}
+exports.getComment = getComment;
+function getSignatureComment(declaration, config, logger) {
+    return getCommentWithCache((0, discovery_1.discoverSignatureComment)(declaration), config, logger);
+}
+exports.getSignatureComment = getSignatureComment;
+function getJsDocComment(declaration, config, logger) {
+    const file = declaration.getSourceFile();
+    // First, get the whole comment. We know we'll need all of it.
+    let parent = declaration.parent;
+    while (!ts.isJSDoc(parent)) {
+        parent = parent.parent;
+    }
+    // Then parse it.
+    const comment = getCommentWithCache([
+        file,
+        {
+            kind: ts.SyntaxKind.MultiLineCommentTrivia,
+            pos: parent.pos,
+            end: parent.end,
+        },
+    ], config, logger);
+    // And pull out the tag we actually care about.
+    if (ts.isJSDocEnumTag(declaration)) {
+        return new models_1.Comment(comment.getTag("@enum")?.content);
+    }
+    if (ts.isJSDocTemplateTag(declaration) &&
+        declaration.comment &&
+        declaration.typeParameters.length > 1) {
+        // We could just put the same comment on everything, but due to how comment parsing works,
+        // we'd have to search for any @template with a name starting with the first type parameter's name
+        // which feels horribly hacky.
+        logger.warn(`TypeDoc does not support multiple type parameters defined in a single @template tag with a comment.`, declaration);
+        return;
+    }
+    let name;
+    if (ts.isJSDocTemplateTag(declaration)) {
+        // This isn't really ideal.
+        name = declaration.typeParameters[0].name.text;
+    }
+    else {
+        name = declaration.name?.getText();
+    }
+    if (!name) {
+        return;
+    }
+    const tag = comment.getIdentifiedTag(name, `@${declaration.tagName.text}`);
+    if (!tag) {
+        logger.error(`Failed to find JSDoc tag for ${name} after parsing comment, please file a bug report.`, declaration);
+    }
+    else {
+        return new models_1.Comment(tag.content.slice());
+    }
+}
+exports.getJsDocComment = getJsDocComment;

package/dist/lib/converter/comments/parser.d.ts

@@ -0,0 +1,4 @@
+import type { CommentParserConfig } from ".";
+import { Comment } from "../../models";
+import { Token } from "./blockLexer";
+export declare function parseComment(tokens: Generator<Token, undefined, undefined>, config: CommentParserConfig, warning: (message: string) => void): Comment;

package/dist/lib/converter/comments/parser.js

@@ -0,0 +1,263 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseComment = void 0;
+const assert_1 = require("assert");
+const models_1 = require("../../models");
+const utils_1 = require("../../utils");
+const blockLexer_1 = require("./blockLexer");
+function makeLookaheadGenerator(gen) {
+    let nextItem = gen.next();
+    return {
+        done() {
+            return !!nextItem.done;
+        },
+        peek() {
+            (0, assert_1.ok)(!nextItem.done);
+            return nextItem.value;
+        },
+        take() {
+            const thisItem = nextItem;
+            (0, assert_1.ok)(!thisItem.done);
+            nextItem = gen.next();
+            return thisItem.value;
+        },
+    };
+}
+function parseComment(tokens, config, warning) {
+    const lexer = makeLookaheadGenerator(tokens);
+    const comment = new models_1.Comment();
+    comment.summary = blockContent(comment, lexer, config, warning);
+    while (!lexer.done()) {
+        comment.blockTags.push(blockTag(comment, lexer, config, warning));
+    }
+    postProcessComment(comment, warning);
+    return comment;
+}
+exports.parseComment = parseComment;
+const HAS_USER_IDENTIFIER = [
+    "@callback",
+    "@param",
+    "@prop",
+    "@property",
+    "@template",
+    "@typedef",
+    "@typeParam",
+    "@inheritDoc",
+];
+function makeCodeBlock(text) {
+    return "```ts\n" + text + "\n```";
+}
+/**
+ * Loop over comment, produce lint warnings, and set tag names for tags
+ * which have them.
+ */
+function postProcessComment(comment, warning) {
+    for (const tag of comment.blockTags) {
+        if (HAS_USER_IDENTIFIER.includes(tag.tag) && tag.content.length) {
+            const first = tag.content[0];
+            if (first.kind === "text") {
+                let end = first.text.search(/\s/);
+                if (end === -1)
+                    end = first.text.length;
+                tag.name = first.text.substring(0, end);
+                if (tag.name.startsWith("[") && tag.name.endsWith("]")) {
+                    tag.name = tag.name.slice(1, tag.name.indexOf("="));
+                }
+                first.text = first.text.substring(end);
+                const endOfTrivia = first.text.search(/[^\-\s]/);
+                if (endOfTrivia !== -1) {
+                    first.text = first.text.substring(endOfTrivia);
+                }
+                else {
+                    // Remove this token, no real text in it.
+                    tag.content.shift();
+                }
+            }
+        }
+        if (tag.content.some((part) => part.kind === "inline-tag" && part.tag === "@inheritDoc")) {
+            warning("An inline @inheritDoc tag should not appear within a block tag as it will not be processed");
+        }
+        if (tag.tag === "@example" &&
+            !tag.content.some((part) => part.kind === "code")) {
+            const caption = tag.content[0].text.match(/^\s*<caption>(.*?)<\/caption>\s*(\n|$)/);
+            if (caption) {
+                const code = models_1.Comment.combineDisplayParts([
+                    {
+                        kind: "text",
+                        text: tag.content[0].text.slice(caption[0].length),
+                    },
+                    ...tag.content.slice(1),
+                ]);
+                tag.content = [
+                    {
+                        kind: "text",
+                        text: caption[1] + "\n",
+                    },
+                    {
+                        kind: "code",
+                        text: makeCodeBlock(code),
+                    },
+                ];
+            }
+            else {
+                tag.content = [
+                    {
+                        kind: "code",
+                        text: makeCodeBlock(models_1.Comment.combineDisplayParts(tag.content)),
+                    },
+                ];
+            }
+        }
+    }
+    const remarks = comment.blockTags.filter((tag) => tag.tag === "@remarks");
+    if (remarks.length > 1) {
+        warning("At most one @remarks tag is expected in a comment, ignoring all but the first");
+        (0, utils_1.removeIf)(comment.blockTags, (tag) => remarks.indexOf(tag) > 0);
+    }
+    const inheritDoc = comment.blockTags.filter((tag) => tag.tag === "@inheritDoc");
+    const inlineInheritDoc = comment.summary.filter((part) => part.kind === "inline-tag" && part.tag === "@inheritDoc");
+    if (inlineInheritDoc.length + inheritDoc.length > 1) {
+        warning("At most one @inheritDoc tag is expected in a comment, ignoring all but the first");
+        const allInheritTags = [...inlineInheritDoc, ...inheritDoc];
+        (0, utils_1.removeIf)(comment.summary, (part) => allInheritTags.indexOf(part) > 0);
+        (0, utils_1.removeIf)(comment.blockTags, (tag) => allInheritTags.indexOf(tag) > 0);
+    }
+    if ((inlineInheritDoc.length || inheritDoc.length) &&
+        comment.summary.some((part) => part.kind !== "inline-tag" && /\S/.test(part.text))) {
+        warning("Content in the summary section will be overwritten by the @inheritDoc tag");
+    }
+    if ((inlineInheritDoc.length || inheritDoc.length) && remarks.length) {
+        warning("Content in the @remarks block will be overwritten by the @inheritDoc tag");
+    }
+}
+const aliasedTags = new Map([["@return", "@returns"]]);
+function blockTag(comment, lexer, config, warning) {
+    const blockTag = lexer.take();
+    (0, assert_1.ok)(blockTag.kind === blockLexer_1.TokenSyntaxKind.Tag); // blockContent is broken if this fails.
+    const tagName = aliasedTags.get(blockTag.text) || blockTag.text;
+    return new models_1.CommentTag(tagName, blockContent(comment, lexer, config, warning));
+}
+function blockContent(comment, lexer, config, warning) {
+    const content = [];
+    let atNewLine = true;
+    loop: while (!lexer.done()) {
+        const next = lexer.peek();
+        let consume = true;
+        switch (next.kind) {
+            case blockLexer_1.TokenSyntaxKind.NewLine:
+            case blockLexer_1.TokenSyntaxKind.Text:
+                content.push({ kind: "text", text: next.text });
+                break;
+            case blockLexer_1.TokenSyntaxKind.Code:
+                content.push({ kind: "code", text: next.text });
+                break;
+            case blockLexer_1.TokenSyntaxKind.Tag:
+                if (config.modifierTags.has(next.text)) {
+                    comment.modifierTags.add(next.text);
+                    break;
+                }
+                else if (!atNewLine && !config.blockTags.has(next.text)) {
+                    // Treat unknown tag as a modifier, but warn about it.
+                    comment.modifierTags.add(next.text);
+                    warning(`Treating unrecognized tag "${next.text}" as a modifier tag`);
+                    break;
+                }
+                else {
+                    // Block tag or unknown tag, handled by our caller.
+                    break loop;
+                }
+            case blockLexer_1.TokenSyntaxKind.TypeAnnotation:
+                // We always ignore these. In TS files they are redundant, in JS files
+                // they are required.
+                break;
+            case blockLexer_1.TokenSyntaxKind.CloseBrace:
+                // Unmatched closing brace, generate a warning, and treat it as text.
+                warning(`Unmatched closing brace in comment`);
+                content.push({ kind: "text", text: next.text });
+                break;
+            case blockLexer_1.TokenSyntaxKind.OpenBrace:
+                inlineTag(lexer, content, config, warning);
+                consume = false;
+                break;
+            default:
+                (0, utils_1.assertNever)(next.kind);
+        }
+        if (consume && lexer.take().kind === blockLexer_1.TokenSyntaxKind.NewLine) {
+            atNewLine = true;
+        }
+    }
+    // Collapse adjacent text parts
+    for (let i = 0; i < content.length - 1 /* inside loop */;) {
+        if (content[i].kind === "text" && content[i + 1].kind === "text") {
+            content[i].text += content[i + 1].text;
+            content.splice(i + 1, 1);
+        }
+        else {
+            i++;
+        }
+    }
+    // Now get rid of extra whitespace, and any empty parts
+    for (let i = 0; i < content.length /* inside loop */;) {
+        if (i === 0 || content[i].kind === "inline-tag") {
+            content[i].text = content[i].text.trimStart();
+        }
+        if (i === content.length - 1 || content[i].kind === "inline-tag") {
+            content[i].text = content[i].text.trimEnd();
+        }
+        if (!content[i].text && content[i].kind === "text") {
+            content.splice(i, 1);
+        }
+        else {
+            i++;
+        }
+    }
+    return content;
+}
+function inlineTag(lexer, block, config, warning) {
+    const openBrace = lexer.take();
+    // Now skip whitespace to grab the tag name.
+    // If the first non-whitespace text after the brace isn't a tag,
+    // then produce a warning and treat what we've consumed as plain text.
+    if (lexer.done() ||
+        ![blockLexer_1.TokenSyntaxKind.Text, blockLexer_1.TokenSyntaxKind.Tag].includes(lexer.peek().kind)) {
+        warning("Encountered an unescaped open brace without an inline tag");
+        block.push({ kind: "text", text: openBrace.text });
+        return;
+    }
+    let tagName = lexer.take();
+    if (lexer.done() ||
+        (tagName.kind === blockLexer_1.TokenSyntaxKind.Text &&
+            (!/^\s+$/.test(tagName.text) ||
+                lexer.peek().kind != blockLexer_1.TokenSyntaxKind.Tag))) {
+        warning("Encountered an unescaped open brace without an inline tag");
+        block.push({ kind: "text", text: openBrace.text + tagName.text });
+        return;
+    }
+    if (tagName.kind !== blockLexer_1.TokenSyntaxKind.Tag) {
+        tagName = lexer.take();
+    }
+    if (!config.inlineTags.has(tagName.text)) {
+        warning(`Encountered an unknown inline tag "${tagName.text}"`);
+    }
+    const content = [];
+    // At this point, we know we have an inline tag. Treat everything following as plain text,
+    // until we get to the closing brace.
+    while (!lexer.done() && lexer.peek().kind !== blockLexer_1.TokenSyntaxKind.CloseBrace) {
+        const token = lexer.take();
+        if (token.kind === blockLexer_1.TokenSyntaxKind.OpenBrace) {
+            warning("Encountered an open brace within an inline tag, this is likely a mistake");
+        }
+        content.push(token.kind === blockLexer_1.TokenSyntaxKind.NewLine ? " " : token.text);
+    }
+    if (lexer.done()) {
+        warning("Inline tag is not closed");
+    }
+    else {
+        lexer.take(); // Close brace
+    }
+    block.push({
+        kind: "inline-tag",
+        tag: tagName.text,
+        text: content.join(""),
+    });
+}

package/dist/lib/converter/context.d.ts

@@ -1,6 +1,7 @@
 import * as ts from "typescript";
 import { Reflection, ProjectReflection, DeclarationReflection, ReflectionKind } from "../models/index";
 import type { Converter } from "./converter";
+import { CommentParserConfig } from "./comments";
 /**
  * The context describes the current state the converter is in.
  */
@@ -35,18 +36,6 @@ export declare class Context {
     isConvertingTypeNode(): boolean;
     /** @internal */
     setConvertingTypeNode(): void;
-    /**
-     * This is a horrible hack to avoid breaking backwards compatibility for plugins
-     * that use EVENT_CREATE_DECLARATION. The comment plugin needs to be able to check
-     * this to properly get the comment for module re-exports:
-     * ```ts
-     * /** We should use this comment */
-     * export * as Mod from "./mod"
-     * ```
-     * Will be removed in 0.23.
-     * @internal
-     */
-    exportSymbol?: ts.Symbol;
     /** @internal */
     shouldBeStatic: boolean;
     private convertingTypeNode;
@@ -73,8 +62,10 @@ export declare class Context {
     getSymbolAtLocation(node: ts.Node): ts.Symbol | undefined;
     expectSymbolAtLocation(node: ts.Node): ts.Symbol;
     resolveAliasedSymbol(symbol: ts.Symbol): ts.Symbol;
+    config: CommentParserConfig;
     createDeclarationReflection(kind: ReflectionKind, symbol: ts.Symbol | undefined, exportSymbol: ts.Symbol | undefined, nameOverride?: string): DeclarationReflection;
-    finalizeDeclarationReflection(reflection: DeclarationReflection, symbol: ts.Symbol | undefined, exportSymbol?: ts.Symbol, commentNode?: ts.Node): void;
+    postReflectionCreation(reflection: Reflection, symbol: ts.Symbol | undefined, exportSymbol: ts.Symbol | undefined): void;
+    finalizeDeclarationReflection(reflection: DeclarationReflection): void;
     addChild(reflection: DeclarationReflection): void;
     shouldIgnore(symbol: ts.Symbol): boolean;
     /**