typedoc 0.24.8 → 0.25.1

package/dist/lib/converter/plugins/TypePlugin.js

@@ -1,9 +1,41 @@
 "use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypePlugin = void 0;
@@ -15,112 +47,127 @@ const application_events_1 = require("../../application-events");
 /**
  * Responsible for adding `implementedBy` / `implementedFrom`
  */
-let TypePlugin = exports.TypePlugin = class TypePlugin extends components_1.ConverterComponent {
-    constructor() {
-        super(...arguments);
-        this.reflections = new Set();
-    }
-    /**
-     * Create a new TypeHandler instance.
-     */
-    initialize() {
-        this.listenTo(this.owner, {
-            [converter_1.Converter.EVENT_RESOLVE]: this.onResolve,
-            [converter_1.Converter.EVENT_RESOLVE_END]: this.onResolveEnd,
-            [converter_1.Converter.EVENT_END]: () => this.reflections.clear(),
-        });
-        this.listenTo(this.application, {
-            [application_events_1.ApplicationEvents.REVIVE]: this.onRevive,
-        });
-    }
-    onRevive(project) {
-        for (const refl of Object.values(project.reflections)) {
-            this.resolve(project, refl);
+let TypePlugin = (() => {
+    let _classDecorators = [(0, components_1.Component)({ name: "type" })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = components_1.ConverterComponent;
+    var TypePlugin = _classThis = class extends _classSuper {
+        constructor() {
+            super(...arguments);
+            this.reflections = new Set();
         }
-        this.finishResolve(project);
-        this.reflections.clear();
-    }
-    onResolve(context, reflection) {
-        this.resolve(context.project, reflection);
-    }
-    resolve(project, reflection) {
-        if (!(reflection instanceof index_1.DeclarationReflection))
-            return;
-        if (reflection.kindOf(index_1.ReflectionKind.ClassOrInterface)) {
-            this.postpone(reflection);
-            walk(reflection.implementedTypes, (target) => {
-                this.postpone(target);
-                if (!target.implementedBy) {
-                    target.implementedBy = [];
-                }
-                target.implementedBy.push(types_1.ReferenceType.createResolvedReference(reflection.name, reflection, project));
+        /**
+         * Create a new TypeHandler instance.
+         */
+        initialize() {
+            this.listenTo(this.owner, {
+                [converter_1.Converter.EVENT_RESOLVE]: this.onResolve,
+                [converter_1.Converter.EVENT_RESOLVE_END]: this.onResolveEnd,
+                [converter_1.Converter.EVENT_END]: () => this.reflections.clear(),
             });
-            walk(reflection.extendedTypes, (target) => {
-                this.postpone(target);
-                if (!target.extendedBy) {
-                    target.extendedBy = [];
-                }
-                target.extendedBy.push(types_1.ReferenceType.createResolvedReference(reflection.name, reflection, project));
+            this.listenTo(this.application, {
+                [application_events_1.ApplicationEvents.REVIVE]: this.onRevive,
             });
         }
-        function walk(types, callback) {
-            if (!types) {
+        onRevive(project) {
+            for (const id in project.reflections) {
+                this.resolve(project, project.reflections[id], 
+                /* create links */ false);
+            }
+            this.finishResolve(project);
+            this.reflections.clear();
+        }
+        onResolve(context, reflection) {
+            this.resolve(context.project, reflection);
+        }
+        resolve(project, reflection, createLinks = true) {
+            if (!(reflection instanceof index_1.DeclarationReflection))
                 return;
+            if (reflection.kindOf(index_1.ReflectionKind.ClassOrInterface)) {
+                this.postpone(reflection);
+                walk(reflection.implementedTypes, (target) => {
+                    this.postpone(target);
+                    target.implementedBy ||= [];
+                    if (createLinks) {
+                        target.implementedBy.push(types_1.ReferenceType.createResolvedReference(reflection.name, reflection, project));
+                    }
+                });
+                walk(reflection.extendedTypes, (target) => {
+                    this.postpone(target);
+                    target.extendedBy ||= [];
+                    if (createLinks) {
+                        target.extendedBy.push(types_1.ReferenceType.createResolvedReference(reflection.name, reflection, project));
+                    }
+                });
             }
-            types.forEach((type) => {
-                if (!(type instanceof types_1.ReferenceType)) {
-                    return;
-                }
-                if (!type.reflection ||
-                    !(type.reflection instanceof index_1.DeclarationReflection)) {
+            function walk(types, callback) {
+                if (!types) {
                     return;
                 }
-                callback(type.reflection);
-            });
-        }
-    }
-    postpone(reflection) {
-        this.reflections.add(reflection);
-    }
-    onResolveEnd(context) {
-        this.finishResolve(context.project);
-    }
-    finishResolve(project) {
-        this.reflections.forEach((reflection) => {
-            if (reflection.implementedBy) {
-                reflection.implementedBy.sort((a, b) => {
-                    if (a.name === b.name) {
-                        return 0;
+                types.forEach((type) => {
+                    if (!(type instanceof types_1.ReferenceType)) {
+                        return;
                     }
-                    return a.name > b.name ? 1 : -1;
+                    if (!type.reflection ||
+                        !(type.reflection instanceof index_1.DeclarationReflection)) {
+                        return;
+                    }
+                    callback(type.reflection);
                 });
             }
-            let root;
-            let hierarchy;
-            function push(types) {
-                const level = { types: types };
-                if (hierarchy) {
-                    hierarchy.next = level;
-                    hierarchy = level;
+        }
+        postpone(reflection) {
+            this.reflections.add(reflection);
+        }
+        onResolveEnd(context) {
+            this.finishResolve(context.project);
+        }
+        finishResolve(project) {
+            this.reflections.forEach((reflection) => {
+                if (reflection.implementedBy) {
+                    reflection.implementedBy.sort((a, b) => {
+                        if (a.name === b.name) {
+                            return 0;
+                        }
+                        return a.name > b.name ? 1 : -1;
+                    });
+                }
+                let root;
+                let hierarchy;
+                function push(types) {
+                    const level = { types: types };
+                    if (hierarchy) {
+                        hierarchy.next = level;
+                        hierarchy = level;
+                    }
+                    else {
+                        root = hierarchy = level;
+                    }
                 }
-                else {
-                    root = hierarchy = level;
+                if (reflection.extendedTypes) {
+                    push(reflection.extendedTypes);
                 }
-            }
-            if (reflection.extendedTypes) {
-                push(reflection.extendedTypes);
-            }
-            push([
-                types_1.ReferenceType.createResolvedReference(reflection.name, reflection, project),
-            ]);
-            hierarchy.isTarget = true;
-            if (reflection.extendedBy) {
-                push(reflection.extendedBy);
-            }
-            reflection.typeHierarchy = root;
-        });
-    }
-};
-exports.TypePlugin = TypePlugin = __decorate([
-    (0, components_1.Component)({ name: "type" })
-], TypePlugin);
+                push([
+                    types_1.ReferenceType.createResolvedReference(reflection.name, reflection, project),
+                ]);
+                hierarchy.isTarget = true;
+                if (reflection.extendedBy) {
+                    push(reflection.extendedBy);
+                }
+                reflection.typeHierarchy = root;
+            });
+        }
+    };
+    __setFunctionName(_classThis, "TypePlugin");
+    (() => {
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        TypePlugin = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return TypePlugin = _classThis;
+})();
+exports.TypePlugin = TypePlugin;

package/dist/lib/converter/symbols.js

@@ -176,8 +176,16 @@ function convertNamespace(context, symbol, exportSymbol) {
             return;
         }
     }
-    const reflection = context.createDeclarationReflection(models_1.ReflectionKind.Namespace, symbol, exportSymbol);
-    context.finalizeDeclarationReflection(reflection);
+    // #2364, @namespace on a variable might be merged with a namespace containing types.
+    const existingReflection = context.project.getReflectionFromSymbol(exportSymbol || symbol);
+    let reflection;
+    if (existingReflection?.kind === models_1.ReflectionKind.Namespace) {
+        reflection = existingReflection;
+    }
+    else {
+        reflection = context.createDeclarationReflection(models_1.ReflectionKind.Namespace, symbol, exportSymbol);
+        context.finalizeDeclarationReflection(reflection);
+    }
     convertSymbols(context.withScope(reflection), context.checker
         .getExportsOfModule(symbol)
         .filter((s) => s.flags & exportFlags));
@@ -216,6 +224,9 @@ function convertTypeAliasAsInterface(context, symbol, exportSymbol, declaration)
     context.finalizeDeclarationReflection(reflection);
     const rc = context.withScope(reflection);
     const type = context.checker.getTypeAtLocation(declaration);
+    if (type.getFlags() & typescript_1.default.TypeFlags.Union) {
+        context.logger.warn(`Using @interface on a union type will discard properties not present on all branches of the union. TypeDoc's output may not accurately describe your source code.`, declaration);
+    }
     // Interfaces have properties
     convertSymbols(rc, type.getProperties());
     // And type arguments
@@ -511,7 +522,8 @@ function convertVariableAsNamespace(context, symbol, exportSymbol) {
     const reflection = context.createDeclarationReflection(models_1.ReflectionKind.Namespace, symbol, exportSymbol);
     context.finalizeDeclarationReflection(reflection);
     const rc = context.withScope(reflection);
-    const declaration = symbol.declarations[0];
+    const declaration = symbol.declarations?.find(typescript_1.default.isVariableDeclaration);
+    (0, assert_1.default)(declaration, "Missing variable declaration");
     const type = context.checker.getTypeAtLocation(declaration);
     convertSymbols(rc, type.getProperties());
     return typescript_1.default.SymbolFlags.Property;
@@ -529,7 +541,7 @@ function convertVariableAsFunction(context, symbol, exportSymbol) {
     reflection.conversionFlags |= models_1.ConversionFlags.VariableOrPropertySource;
     context.finalizeDeclarationReflection(reflection);
     const reflectionContext = context.withScope(reflection);
-    reflection.signatures ?? (reflection.signatures = []);
+    reflection.signatures ??= [];
     for (const signature of type.getCallSignatures()) {
         (0, signature_1.createSignature)(reflectionContext, models_1.ReflectionKind.CallSignature, signature, symbol);
     }

package/dist/lib/converter/types.js

@@ -29,6 +29,7 @@ function loadConverters() {
         indexedAccessConverter,
         inferredConverter,
         intersectionConverter,
+        intrinsicConverter,
         jsDocVariadicTypeConverter,
         keywordConverter,
         optionalConverter,
@@ -262,6 +263,15 @@ const intersectionConverter = {
         return new models_1.IntersectionType(type.types.map((type) => convertType(context, type)));
     },
 };
+const intrinsicConverter = {
+    kind: [typescript_1.default.SyntaxKind.IntrinsicKeyword],
+    convert() {
+        return new models_1.IntrinsicType("intrinsic");
+    },
+    convertType() {
+        return new models_1.IntrinsicType("intrinsic");
+    },
+};
 const jsDocVariadicTypeConverter = {
     kind: [typescript_1.default.SyntaxKind.JSDocVariadicType],
     convert(context, node) {
@@ -561,7 +571,12 @@ const tupleConverter = {
         let elements = types?.map((type) => convertType(context, type));
         if (type.target.labeledElementDeclarations) {
             const namedDeclarations = type.target.labeledElementDeclarations;
-            elements = elements?.map((el, i) => new models_1.NamedTupleMember(namedDeclarations[i].name.getText(), !!namedDeclarations[i].questionToken, (0, reflections_1.removeUndefined)(el)));
+            elements = elements?.map((el, i) => {
+                const namedDecl = namedDeclarations[i];
+                return namedDecl
+                    ? new models_1.NamedTupleMember(namedDecl.name.getText(), !!namedDecl.questionToken, (0, reflections_1.removeUndefined)(el))
+                    : el;
+            });
         }
         elements = elements?.map((el, i) => {
             if (type.target.elementFlags[i] & typescript_1.default.ElementFlags.Variable) {

package/dist/lib/converter/utils/nodes.d.ts

@@ -1,6 +1,6 @@
 import ts from "typescript";
-export declare function isNamedNode(node: ts.Node): node is ts.Node & {
-    name: ts.Identifier | ts.PrivateIdentifier | ts.ComputedPropertyName;
+export declare function isNamedNode(node: unknown): node is {
+    readonly name: ts.Identifier | ts.PrivateIdentifier | ts.ComputedPropertyName;
 };
 export declare function getHeritageTypes(declarations: readonly (ts.ClassDeclaration | ts.InterfaceDeclaration)[], kind: ts.SyntaxKind.ImplementsKeyword | ts.SyntaxKind.ExtendsKeyword): ts.ExpressionWithTypeArguments[];
 export declare function isObjectType(type: ts.Type): type is ts.ObjectType;

package/dist/lib/converter/utils/repository.d.ts

@@ -1,9 +1,19 @@
 import type { Logger } from "../../utils";
-export declare const gitIsInstalled: boolean;
+export declare function gitIsInstalled(): boolean;
+export interface Repository {
+    getURL(fileName: string, line: number): string | undefined;
+}
+export declare class AssumedRepository implements Repository {
+    readonly path: string;
+    readonly gitRevision: string;
+    readonly sourceLinkTemplate: string;
+    constructor(path: string, gitRevision: string, sourceLinkTemplate: string);
+    getURL(fileName: string, line: number): string | undefined;
+}
 /**
  * Stores data of a repository.
  */
-export declare class Repository {
+export declare class GitRepository implements Repository {
     /**
      * The path of this repository on disk.
      */
@@ -31,11 +41,11 @@ export declare class Repository {
      * Try to create a new repository instance.
      *
      * Checks whether the given path is the root of a valid repository and if so
-     * creates a new instance of {@link Repository}.
+     * creates a new instance of {@link GitRepository}.
      *
      * @param path  The potential repository root.
-     * @returns A new instance of {@link Repository} or undefined.
+     * @returns A new instance of {@link GitRepository} or undefined.
      */
-    static tryCreateRepository(path: string, sourceLinkTemplate: string, gitRevision: string, gitRemote: string, logger: Logger): Repository | undefined;
+    static tryCreateRepository(path: string, sourceLinkTemplate: string, gitRevision: string, gitRemote: string, logger: Logger): GitRepository | undefined;
 }
 export declare function guessSourceUrlTemplate(remotes: string[]): string | undefined;

package/dist/lib/converter/utils/repository.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.guessSourceUrlTemplate = exports.Repository = exports.gitIsInstalled = void 0;
+exports.guessSourceUrlTemplate = exports.GitRepository = exports.AssumedRepository = exports.gitIsInstalled = void 0;
 const child_process_1 = require("child_process");
 const base_path_1 = require("../utils/base-path");
 const TEN_MEGABYTES = 1024 * 10000;
@@ -11,11 +11,32 @@ function git(...args) {
         maxBuffer: TEN_MEGABYTES,
     });
 }
-exports.gitIsInstalled = git("--version").status === 0;
+let haveGit;
+function gitIsInstalled() {
+    haveGit ??= git("--version").status === 0;
+    return haveGit;
+}
+exports.gitIsInstalled = gitIsInstalled;
+class AssumedRepository {
+    constructor(path, gitRevision, sourceLinkTemplate) {
+        this.path = path;
+        this.gitRevision = gitRevision;
+        this.sourceLinkTemplate = sourceLinkTemplate;
+    }
+    getURL(fileName, line) {
+        const replacements = {
+            gitRevision: this.gitRevision,
+            path: fileName.substring(this.path.length + 1),
+            line,
+        };
+        return this.sourceLinkTemplate.replace(/\{(path|line)\}/g, (_, key) => replacements[key]);
+    }
+}
+exports.AssumedRepository = AssumedRepository;
 /**
  * Stores data of a repository.
  */
-class Repository {
+class GitRepository {
     /**
      * Create a new Repository instance.
      *
@@ -59,26 +80,22 @@ class Repository {
      * Try to create a new repository instance.
      *
      * Checks whether the given path is the root of a valid repository and if so
-     * creates a new instance of {@link Repository}.
+     * creates a new instance of {@link GitRepository}.
      *
      * @param path  The potential repository root.
-     * @returns A new instance of {@link Repository} or undefined.
+     * @returns A new instance of {@link GitRepository} or undefined.
      */
     static tryCreateRepository(path, sourceLinkTemplate, gitRevision, gitRemote, logger) {
         const topLevel = git("-C", path, "rev-parse", "--show-toplevel");
         if (topLevel.status !== 0)
             return;
-        gitRevision || (gitRevision = git("-C", path, "rev-parse", "--short", "HEAD").stdout.trim());
+        gitRevision ||= git("-C", path, "rev-parse", "--short", "HEAD").stdout.trim();
         if (!gitRevision)
             return; // Will only happen in a repo with no commits.
         let urlTemplate;
         if (sourceLinkTemplate) {
             urlTemplate = sourceLinkTemplate;
         }
-        else if (/^https?:\/\//.test(gitRemote)) {
-            logger.warn("Using a link as the gitRemote is deprecated and will be removed in 0.24.");
-            urlTemplate = `${gitRemote}/{gitRevision}`;
-        }
         else {
             const remotesOut = git("-C", path, "remote", "get-url", gitRemote);
             if (remotesOut.status === 0) {
@@ -90,10 +107,10 @@ class Repository {
         }
         if (!urlTemplate)
             return;
-        return new Repository(base_path_1.BasePath.normalize(topLevel.stdout.replace("\n", "")), gitRevision, urlTemplate);
+        return new GitRepository(base_path_1.BasePath.normalize(topLevel.stdout.replace("\n", "")), gitRevision, urlTemplate);
     }
 }
-exports.Repository = Repository;
+exports.GitRepository = GitRepository;
 // Should have three capturing groups:
 // 1. hostname
 // 2. user

package/dist/lib/models/ReflectionGroup.d.ts

@@ -1,5 +1,5 @@
 import { ReflectionCategory } from "./ReflectionCategory";
-import type { DeclarationReflection } from ".";
+import type { DeclarationReflection, Reflection } from ".";
 import type { Serializer, JSONOutput, Deserializer } from "../serialization";
 /**
  * A group of reflections. All reflections in a group are of the same kind.
@@ -9,6 +9,7 @@ import type { Serializer, JSONOutput, Deserializer } from "../serialization";
  * render human readable children lists in templates.
  */
 export declare class ReflectionGroup {
+    readonly owningReflection: Reflection;
     /**
      * The title, a string representation of the typescript kind, of this group.
      */
@@ -25,8 +26,9 @@ export declare class ReflectionGroup {
      * Create a new ReflectionGroup instance.
      *
      * @param title The title of this group.
+     * @param owningReflection The reflection containing this group, useful for changing rendering based on a comment on a reflection.
      */
-    constructor(title: string);
+    constructor(title: string, owningReflection: Reflection);
     /**
      * Do all children of this group have a separate document?
      */

package/dist/lib/models/ReflectionGroup.js

@@ -14,8 +14,10 @@ class ReflectionGroup {
      * Create a new ReflectionGroup instance.
      *
      * @param title The title of this group.
+     * @param owningReflection The reflection containing this group, useful for changing rendering based on a comment on a reflection.
      */
-    constructor(title) {
+    constructor(title, owningReflection) {
+        this.owningReflection = owningReflection;
         /**
          * All reflections of this group.
          */

package/dist/lib/models/comments/comment.d.ts

@@ -1,6 +1,10 @@
 import type { Reflection } from "../reflections";
 import { ReflectionSymbolId } from "../reflections/ReflectionSymbolId";
 import type { Serializer, Deserializer, JSONOutput } from "../../serialization";
+/**
+ * Represents a parsed piece of a comment.
+ * @category Comments
+ */
 export type CommentDisplayPart = {
     kind: "text";
     text: string;
@@ -13,6 +17,7 @@ export type CommentDisplayPart = {
  * property set indicating which reflection/url they link to. They may also
  * have a `tsLinkText` property which includes the part of the `text` which
  * TypeScript thinks should be displayed as the link text.
+ * @category Comments
  */
 export interface InlineTagDisplayPart {
     kind: "inline-tag";
@@ -25,6 +30,7 @@ export interface InlineTagDisplayPart {
  * A model that represents a single TypeDoc comment tag.
  *
  * Tags are stored in the {@link Comment.blockTags} property.
+ * @category Comments
  */
 export declare class CommentTag {
     /**
@@ -53,6 +59,7 @@ export declare class CommentTag {
  *
  * Instances of this model are created by the CommentPlugin. You can retrieve comments
  * through the {@link DeclarationReflection.comment} property.
+ * @category Comments
  */
 export declare class Comment {
     /**
@@ -97,7 +104,7 @@ export declare class Comment {
     /**
      * All modifier tags present on the comment, e.g. `@alpha`, `@beta`.
      */
-    modifierTags: Set<string>;
+    modifierTags: Set<`@${string}`>;
     /**
      * Label associated with this reflection, if any (https://tsdoc.org/pages/tags/label/)
      */
@@ -105,7 +112,7 @@ export declare class Comment {
     /**
      * Creates a new Comment instance.
      */
-    constructor(summary?: CommentDisplayPart[], blockTags?: CommentTag[], modifierTags?: Set<string>);
+    constructor(summary?: CommentDisplayPart[], blockTags?: CommentTag[], modifierTags?: Set<`@${string}`>);
     /**
      * Create a deep clone of this comment.
      */

package/dist/lib/models/comments/comment.js

@@ -8,6 +8,7 @@ const ReflectionSymbolId_1 = require("../reflections/ReflectionSymbolId");
  * A model that represents a single TypeDoc comment tag.
  *
  * Tags are stored in the {@link Comment.blockTags} property.
+ * @category Comments
  */
 class CommentTag {
     /**
@@ -43,6 +44,7 @@ exports.CommentTag = CommentTag;
  *
  * Instances of this model are created by the CommentPlugin. You can retrieve comments
  * through the {@link DeclarationReflection.comment} property.
+ * @category Comments
  */
 class Comment {
     /**

package/dist/lib/models/reflections/ReflectionSymbolId.js

@@ -19,7 +19,7 @@ const paths_1 = require("../../utils/paths");
 class ReflectionSymbolId {
     constructor(symbol, declaration) {
         if ("name" in symbol) {
-            declaration ?? (declaration = symbol?.declarations?.[0]);
+            declaration ??= symbol?.declarations?.[0];
             this.fileName = (0, paths_1.normalizePath)(declaration?.getSourceFile().fileName ?? "\0");
             if (symbol.declarations?.some(typescript_1.default.isSourceFile)) {
                 this.qualifiedName = "";

package/dist/lib/models/reflections/abstract.d.ts

@@ -90,6 +90,9 @@ export interface TraverseCallback {
      */
     (reflection: Reflection, property: TraverseProperty): boolean | NeverIfInternal<void>;
 }
+export type ReflectionVisitor = {
+    [K in keyof ReflectionVariant]?: (refl: ReflectionVariant[K]) => void;
+};
 /**
  * Base class for all reflection classes.
  *
@@ -100,6 +103,7 @@ export interface TraverseCallback {
  * This base class exposes the basic properties one may use to traverse the reflection tree.
  * You can use the {@link ContainerReflection.children} and {@link parent} properties to walk the tree. The {@link ContainerReflection.groups} property
  * contains a list of all children grouped and sorted for rendering.
+ * @category Reflections
  */
 export declare abstract class Reflection {
     /**
@@ -207,7 +211,7 @@ export declare abstract class Reflection {
      * Traverse most potential child reflections of this reflection.
      *
      * Note: This may not necessarily traverse child reflections contained within the `type` property
-     * of the reflection, and should not be relied on for this. Support for checking object types will likely be removed in v0.25.
+     * of the reflection, and should not be relied on for this. Support for checking object types will likely be removed in v0.26.
      *
      * The given callback will be invoked for all children, signatures and type parameters
      * attached to this reflection.
@@ -215,6 +219,7 @@ export declare abstract class Reflection {
      * @param callback  The callback function that should be applied for each child reflection.
      */
     abstract traverse(callback: TraverseCallback): void;
+    visit(visitor: ReflectionVisitor): void;
     /**
      * Return a string representation of this reflection.
      */