typedoc 0.23.25 → 0.24.0-beta.1

package/dist/lib/converter/factories/signature.js

@@ -1,51 +1,73 @@
 "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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createTypeParamReflection = exports.convertTypeParameterNodes = exports.convertParameterNodes = exports.createSignature = void 0;
-const typescript_1 = __importDefault(require("typescript"));
+const ts = __importStar(require("typescript"));
 const assert_1 = __importDefault(require("assert"));
 const models_1 = require("../../models");
 const converter_events_1 = require("../converter-events");
 const convert_expression_1 = require("../convert-expression");
 const reflections_1 = require("../utils/reflections");
 const comments_1 = require("../comments");
-function createSignature(context, kind, signature, declaration) {
+const ReflectionSymbolId_1 = require("../../models/reflections/ReflectionSymbolId");
+function createSignature(context, kind, signature, symbol, declaration) {
     var _a;
     (0, assert_1.default)(context.scope instanceof models_1.DeclarationReflection);
     declaration || (declaration = signature.getDeclaration());
     const sigRef = new models_1.SignatureReflection(kind == models_1.ReflectionKind.ConstructorSignature
         ? `new ${context.scope.parent.name}`
         : context.scope.name, kind, context.scope);
-    // If we are creating signatures for a variable or property and it has a comment associated with it
-    // then we should prefer that comment over any comment on the signature. The comment plugin
-    // will copy the comment down if this signature doesn't have one, so don't set one.
-    let parentReflection = context.scope;
-    if (parentReflection.kindOf(models_1.ReflectionKind.TypeLiteral) &&
-        parentReflection.parent instanceof models_1.DeclarationReflection) {
-        parentReflection = parentReflection.parent;
+    const sigRefCtx = context.withScope(sigRef);
+    if (symbol && declaration) {
+        context.project.registerSymbolId(sigRef, new ReflectionSymbolId_1.ReflectionSymbolId(symbol, declaration));
     }
+    // If we are creating signatures for a variable and the variable has a comment associated with it
+    // then we should prefer that variable's comment over any comment on the signature. The comment plugin
+    // will copy the comment down if this signature doesn't have one, so don't set one.
     if (declaration &&
-        (!parentReflection.comment ||
-            !(parentReflection.conversionFlags &
-                models_1.ConversionFlags.VariableOrPropertySource))) {
+        (!context.scope.comment ||
+            !(context.scope.conversionFlags & models_1.ConversionFlags.VariableSource))) {
         sigRef.comment = (0, comments_1.getSignatureComment)(declaration, context.converter.config, context.logger, context.converter.commentStyle);
     }
-    sigRef.typeParameters = convertTypeParameters(context, sigRef, signature.typeParameters);
+    sigRef.typeParameters = convertTypeParameters(sigRefCtx, sigRef, signature.typeParameters);
     const parameterSymbols = signature.thisParameter
         ? [signature.thisParameter, ...signature.parameters]
         : signature.parameters;
-    sigRef.parameters = convertParameters(context, sigRef, parameterSymbols, declaration?.parameters);
+    sigRef.parameters = convertParameters(sigRefCtx, sigRef, parameterSymbols, declaration?.parameters);
     const predicate = context.checker.getTypePredicateOfSignature(signature);
     if (predicate) {
-        sigRef.type = convertPredicate(predicate, context.withScope(sigRef));
+        sigRef.type = convertPredicate(predicate, sigRefCtx);
     }
     else if (kind == models_1.ReflectionKind.SetSignature) {
         sigRef.type = new models_1.IntrinsicType("void");
     }
     else {
-        sigRef.type = context.converter.convertType(context.withScope(sigRef), (declaration?.kind === typescript_1.default.SyntaxKind.FunctionDeclaration &&
+        sigRef.type = context.converter.convertType(sigRefCtx, (declaration?.kind === ts.SyntaxKind.FunctionDeclaration &&
             declaration.type) ||
             signature.getReturnType());
     }
@@ -70,10 +92,10 @@ function convertParameters(context, sigRef, parameters, parameterNodes) {
     return parameters.map((param, i) => {
         const declaration = param.valueDeclaration;
         (0, assert_1.default)(!declaration ||
-            typescript_1.default.isParameter(declaration) ||
-            typescript_1.default.isJSDocParameterTag(declaration));
+            ts.isParameter(declaration) ||
+            ts.isJSDocParameterTag(declaration));
         const paramRefl = new models_1.ParameterReflection(/__\d+/.test(param.name) ? "__namedParameters" : param.name, models_1.ReflectionKind.Parameter, sigRef);
-        if (declaration && typescript_1.default.isJSDocParameterTag(declaration)) {
+        if (declaration && ts.isJSDocParameterTag(declaration)) {
             paramRefl.comment = (0, comments_1.getJsDocComment)(declaration, context.converter.config, context.logger);
         }
         paramRefl.comment || (paramRefl.comment = (0, comments_1.getComment)(param, paramRefl.kind, context.converter.config, context.logger, context.converter.commentStyle));
@@ -89,9 +111,9 @@ function convertParameters(context, sigRef, parameters, parameterNodes) {
         paramRefl.type = context.converter.convertType(context.withScope(paramRefl), type);
         let isOptional = false;
         if (declaration) {
-            isOptional = typescript_1.default.isParameter(declaration)
+            isOptional = ts.isParameter(declaration)
                 ? !!declaration.questionToken ||
-                    typescript_1.default
+                    ts
                         .getJSDocParameterTags(declaration)
                         .some((tag) => tag.isBracketed)
                 : declaration.isBracketed;
@@ -105,10 +127,10 @@ function convertParameters(context, sigRef, parameters, parameterNodes) {
         // because the method body uses `arguments`... which is always a rest argument
         let isRest = true;
         if (declaration) {
-            isRest = typescript_1.default.isParameter(declaration)
+            isRest = ts.isParameter(declaration)
                 ? !!declaration.dotDotDotToken
                 : !!declaration.typeExpression &&
-                    typescript_1.default.isJSDocVariadicType(declaration.typeExpression.type);
+                    ts.isJSDocVariadicType(declaration.typeExpression.type);
         }
         paramRefl.setFlag(models_1.ReflectionFlag.Rest, isRest);
         return paramRefl;
@@ -119,13 +141,13 @@ function convertParameterNodes(context, sigRef, parameters) {
         const paramRefl = new models_1.ParameterReflection(/__\d+/.test(param.name.getText())
             ? "__namedParameters"
             : param.name.getText(), models_1.ReflectionKind.Parameter, sigRef);
-        if (typescript_1.default.isJSDocParameterTag(param)) {
+        if (ts.isJSDocParameterTag(param)) {
             paramRefl.comment = (0, comments_1.getJsDocComment)(param, context.converter.config, context.logger);
         }
         context.registerReflection(paramRefl, context.getSymbolAtLocation(param));
         context.trigger(converter_events_1.ConverterEvents.CREATE_PARAMETER, paramRefl);
-        paramRefl.type = context.converter.convertType(context.withScope(paramRefl), typescript_1.default.isParameter(param) ? param.type : param.typeExpression?.type);
-        const isOptional = typescript_1.default.isParameter(param)
+        paramRefl.type = context.converter.convertType(context.withScope(paramRefl), ts.isParameter(param) ? param.type : param.typeExpression?.type);
+        const isOptional = ts.isParameter(param)
             ? !!param.questionToken
             : param.isBracketed;
         if (isOptional) {
@@ -133,10 +155,10 @@ function convertParameterNodes(context, sigRef, parameters) {
         }
         paramRefl.defaultValue = (0, convert_expression_1.convertDefaultValue)(param);
         paramRefl.setFlag(models_1.ReflectionFlag.Optional, isOptional);
-        paramRefl.setFlag(models_1.ReflectionFlag.Rest, typescript_1.default.isParameter(param)
+        paramRefl.setFlag(models_1.ReflectionFlag.Rest, ts.isParameter(param)
             ? !!param.dotDotDotToken
             : !!param.typeExpression &&
-                typescript_1.default.isJSDocVariadicType(param.typeExpression.type));
+                ts.isJSDocVariadicType(param.typeExpression.type));
         return paramRefl;
     });
 }
@@ -145,17 +167,18 @@ function convertTypeParameters(context, parent, parameters) {
     return parameters?.map((param) => {
         const constraintT = param.getConstraint();
         const defaultT = param.getDefault();
-        const constraint = constraintT
-            ? context.converter.convertType(context, constraintT)
-            : void 0;
-        const defaultType = defaultT
-            ? context.converter.convertType(context, defaultT)
-            : void 0;
         // There's no way to determine directly from a ts.TypeParameter what it's variance modifiers are
         // so unfortunately we have to go back to the node for this...
-        const variance = getVariance(param.getSymbol()?.declarations?.find(typescript_1.default.isTypeParameterDeclaration)
+        const variance = getVariance(param.getSymbol()?.declarations?.find(ts.isTypeParameterDeclaration)
             ?.modifiers);
-        const paramRefl = new models_1.TypeParameterReflection(param.symbol.name, constraint, defaultType, parent, variance);
+        const paramRefl = new models_1.TypeParameterReflection(param.symbol.name, parent, variance);
+        const paramCtx = context.withScope(paramRefl);
+        paramRefl.type = constraintT
+            ? context.converter.convertType(paramCtx, constraintT)
+            : void 0;
+        paramRefl.default = defaultT
+            ? context.converter.convertType(paramCtx, defaultT)
+            : void 0;
         context.registerReflection(paramRefl, param.getSymbol());
         context.trigger(converter_events_1.ConverterEvents.CREATE_TYPE_PARAMETER, paramRefl);
         return paramRefl;
@@ -166,15 +189,16 @@ function convertTypeParameterNodes(context, parameters) {
 }
 exports.convertTypeParameterNodes = convertTypeParameterNodes;
 function createTypeParamReflection(param, context) {
-    const constraint = param.constraint
-        ? context.converter.convertType(context, param.constraint)
+    const paramRefl = new models_1.TypeParameterReflection(param.name.text, context.scope, getVariance(param.modifiers));
+    const paramScope = context.withScope(paramRefl);
+    paramRefl.type = param.constraint
+        ? context.converter.convertType(paramScope, param.constraint)
         : void 0;
-    const defaultType = param.default
-        ? context.converter.convertType(context, param.default)
+    paramRefl.default = param.default
+        ? context.converter.convertType(paramScope, param.default)
         : void 0;
-    const paramRefl = new models_1.TypeParameterReflection(param.name.text, constraint, defaultType, context.scope, getVariance(param.modifiers));
     context.registerReflection(paramRefl, param.symbol);
-    if (typescript_1.default.isJSDocTemplateTag(param.parent)) {
+    if (ts.isJSDocTemplateTag(param.parent)) {
         paramRefl.comment = (0, comments_1.getJsDocComment)(param.parent, context.converter.config, context.logger);
     }
     context.trigger(converter_events_1.ConverterEvents.CREATE_TYPE_PARAMETER, paramRefl, param);
@@ -182,8 +206,8 @@ function createTypeParamReflection(param, context) {
 }
 exports.createTypeParamReflection = createTypeParamReflection;
 function getVariance(modifiers) {
-    const hasIn = modifiers?.some((mod) => mod.kind === typescript_1.default.SyntaxKind.InKeyword);
-    const hasOut = modifiers?.some((mod) => mod.kind === typescript_1.default.SyntaxKind.OutKeyword);
+    const hasIn = modifiers?.some((mod) => mod.kind === ts.SyntaxKind.InKeyword);
+    const hasOut = modifiers?.some((mod) => mod.kind === ts.SyntaxKind.OutKeyword);
     if (hasIn && hasOut) {
         return models_1.VarianceModifier.inOut;
     }
@@ -197,23 +221,23 @@ function getVariance(modifiers) {
 function convertPredicate(predicate, context) {
     let name;
     switch (predicate.kind) {
-        case typescript_1.default.TypePredicateKind.This:
-        case typescript_1.default.TypePredicateKind.AssertsThis:
+        case ts.TypePredicateKind.This:
+        case ts.TypePredicateKind.AssertsThis:
             name = "this";
             break;
-        case typescript_1.default.TypePredicateKind.Identifier:
-        case typescript_1.default.TypePredicateKind.AssertsIdentifier:
+        case ts.TypePredicateKind.Identifier:
+        case ts.TypePredicateKind.AssertsIdentifier:
             name = predicate.parameterName;
             break;
     }
     let asserts;
     switch (predicate.kind) {
-        case typescript_1.default.TypePredicateKind.This:
-        case typescript_1.default.TypePredicateKind.Identifier:
+        case ts.TypePredicateKind.This:
+        case ts.TypePredicateKind.Identifier:
             asserts = false;
             break;
-        case typescript_1.default.TypePredicateKind.AssertsThis:
-        case typescript_1.default.TypePredicateKind.AssertsIdentifier:
+        case ts.TypePredicateKind.AssertsThis:
+        case ts.TypePredicateKind.AssertsIdentifier:
             asserts = true;
             break;
     }

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

@@ -1,4 +1,4 @@
-import ts from "typescript";
+import * as ts from "typescript";
 import type { Context } from "./context";
 export declare function convertJsDocAlias(context: Context, symbol: ts.Symbol, declaration: ts.JSDocTypedefTag | ts.JSDocEnumTag, exportSymbol?: ts.Symbol): void;
 export declare function convertJsDocCallback(context: Context, symbol: ts.Symbol, declaration: ts.JSDocCallbackTag, exportSymbol?: ts.Symbol): void;

package/dist/lib/converter/jsdoc.js

@@ -2,20 +2,41 @@
 // Converter functions for JSDoc defined types
 // @typedef
 // @callback
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertJsDocCallback = exports.convertJsDocAlias = void 0;
 const assert_1 = require("assert");
-const typescript_1 = __importDefault(require("typescript"));
+const ts = __importStar(require("typescript"));
 const models_1 = require("../models");
+const ReflectionSymbolId_1 = require("../models/reflections/ReflectionSymbolId");
 const comments_1 = require("./comments");
 const converter_events_1 = require("./converter-events");
 const signature_1 = require("./factories/signature");
 function convertJsDocAlias(context, symbol, declaration, exportSymbol) {
     if (declaration.typeExpression &&
-        typescript_1.default.isJSDocTypeLiteral(declaration.typeExpression)) {
+        ts.isJSDocTypeLiteral(declaration.typeExpression)) {
         convertJsDocInterface(context, declaration, symbol, exportSymbol);
         return;
     }
@@ -64,6 +85,7 @@ function convertJsDocSignature(context, node) {
     context.registerReflection(reflection, symbol);
     context.trigger(converter_events_1.ConverterEvents.CREATE_DECLARATION, reflection);
     const signature = new models_1.SignatureReflection("__type", models_1.ReflectionKind.CallSignature, reflection);
+    context.project.registerSymbolId(signature, new ReflectionSymbolId_1.ReflectionSymbolId(symbol, node));
     context.registerReflection(signature, void 0);
     const signatureCtx = context.withScope(signature);
     reflection.signatures = [signature];
@@ -74,7 +96,7 @@ function convertJsDocSignature(context, node) {
 }
 function convertTemplateParameters(context, node) {
     (0, assert_1.ok)(context.scope instanceof models_1.DeclarationReflection);
-    context.scope.typeParameters = convertTemplateParameterNodes(context, node.tags?.filter(typescript_1.default.isJSDocTemplateTag));
+    context.scope.typeParameters = convertTemplateParameterNodes(context, node.tags?.filter(ts.isJSDocTemplateTag));
 }
 function convertTemplateParameterNodes(context, nodes) {
     const params = (nodes ?? []).flatMap((tag) => tag.typeParameters);
@@ -82,31 +104,31 @@ function convertTemplateParameterNodes(context, nodes) {
 }
 function getTypedefReExportTarget(context, declaration) {
     const typeExpression = declaration.typeExpression;
-    if (!typescript_1.default.isJSDocTypedefTag(declaration) ||
+    if (!ts.isJSDocTypedefTag(declaration) ||
         !typeExpression ||
-        typescript_1.default.isJSDocTypeLiteral(typeExpression) ||
-        !typescript_1.default.isImportTypeNode(typeExpression.type) ||
+        ts.isJSDocTypeLiteral(typeExpression) ||
+        !ts.isImportTypeNode(typeExpression.type) ||
         !typeExpression.type.qualifier ||
-        !typescript_1.default.isIdentifier(typeExpression.type.qualifier)) {
+        !ts.isIdentifier(typeExpression.type.qualifier)) {
         return;
     }
     const targetSymbol = context.expectSymbolAtLocation(typeExpression.type.qualifier);
     const decl = targetSymbol.declarations?.[0];
     if (!decl ||
-        !(typescript_1.default.isTypeAliasDeclaration(decl) ||
-            typescript_1.default.isInterfaceDeclaration(decl) ||
-            typescript_1.default.isJSDocTypedefTag(decl) ||
-            typescript_1.default.isJSDocCallbackTag(decl))) {
+        !(ts.isTypeAliasDeclaration(decl) ||
+            ts.isInterfaceDeclaration(decl) ||
+            ts.isJSDocTypedefTag(decl) ||
+            ts.isJSDocCallbackTag(decl))) {
         return;
     }
-    const targetParams = typescript_1.default.getEffectiveTypeParameterDeclarations(decl);
-    const localParams = typescript_1.default.getEffectiveTypeParameterDeclarations(declaration);
+    const targetParams = ts.getEffectiveTypeParameterDeclarations(decl);
+    const localParams = ts.getEffectiveTypeParameterDeclarations(declaration);
     const localArgs = typeExpression.type.typeArguments || [];
     // If we have type parameters, ensure they are forwarding parameters with no transformations.
     // This doesn't check constraints since they aren't checked in JSDoc types.
     if (targetParams.length !== localParams.length ||
-        localArgs.some((arg, i) => !typescript_1.default.isTypeReferenceNode(arg) ||
-            !typescript_1.default.isIdentifier(arg.typeName) ||
+        localArgs.some((arg, i) => !ts.isTypeReferenceNode(arg) ||
+            !ts.isIdentifier(arg.typeName) ||
             arg.typeArguments ||
             localParams[i]?.name.text !== arg.typeName.text)) {
         return;

package/dist/lib/converter/plugins/CommentPlugin.d.ts

@@ -61,8 +61,6 @@ export declare class CommentPlugin extends ConverterComponent {
     excludePrivate: boolean;
     excludeProtected: boolean;
     excludeNotDocumented: boolean;
-    private _excludeKinds;
-    private get excludeNotDocumentedKinds();
     /**
      * Create a new CommentPlugin instance.
      */

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

@@ -89,12 +89,6 @@ const NEVER_RENDERED = [
  *
  */
 let CommentPlugin = class CommentPlugin extends components_1.ConverterComponent {
-    get excludeNotDocumentedKinds() {
-        this._excludeKinds ?? (this._excludeKinds = this.application.options
-            .getValue("excludeNotDocumentedKinds")
-            .reduce((a, b) => a | models_1.ReflectionKind[b], 0));
-        return this._excludeKinds;
-    }
     /**
      * Create a new CommentPlugin instance.
      */
@@ -105,9 +99,6 @@ let CommentPlugin = class CommentPlugin extends components_1.ConverterComponent
             [converter_1.Converter.EVENT_CREATE_TYPE_PARAMETER]: this.onCreateTypeParameter,
             [converter_1.Converter.EVENT_RESOLVE_BEGIN]: this.onBeginResolve,
             [converter_1.Converter.EVENT_RESOLVE]: this.onResolve,
-            [converter_1.Converter.EVENT_END]: () => {
-                this._excludeKinds = undefined;
-            },
         });
     }
     /**
@@ -261,9 +252,9 @@ let CommentPlugin = class CommentPlugin extends components_1.ConverterComponent
      */
     onResolve(context, reflection) {
         if (reflection.comment) {
-            reflection.label = extractLabelTag(reflection.comment);
-            if (reflection.label && !/[A-Z_][A-Z0-9_]/.test(reflection.label)) {
-                context.logger.warn(`The label "${reflection.label}" for ${reflection.getFriendlyFullName()} cannot be referenced with a declaration reference. ` +
+            if (reflection.comment.label &&
+                !/[A-Z_][A-Z0-9_]/.test(reflection.comment.label)) {
+                context.logger.warn(`The label "${reflection.comment.label}" for ${reflection.getFriendlyFullName()} cannot be referenced with a declaration reference. ` +
                     `Labels may only contain A-Z, 0-9, and _, and may not start with a number.`);
             }
             mergeSeeTags(reflection.comment);
@@ -344,22 +335,12 @@ let CommentPlugin = class CommentPlugin extends components_1.ConverterComponent
             return true;
         }
         if (!comment) {
-            // We haven't moved comments from the parent for signatures without a direct
-            // comment, so don't exclude those due to not being documented.
-            if (reflection.kindOf(models_1.ReflectionKind.CallSignature |
-                models_1.ReflectionKind.ConstructorSignature) &&
-                reflection.parent?.comment) {
-                return false;
-            }
             if (this.excludeNotDocumented) {
                 // Don't let excludeNotDocumented remove parameters.
                 if (!(reflection instanceof models_1.DeclarationReflection) &&
                     !(reflection instanceof models_1.SignatureReflection)) {
                     return false;
                 }
-                if (!reflection.kindOf(this.excludeNotDocumentedKinds)) {
-                    return false;
-                }
                 // excludeNotDocumented should hide a module only if it has no visible children
                 if (reflection.kindOf(models_1.ReflectionKind.SomeModule)) {
                     if (!reflection.children) {
@@ -367,6 +348,10 @@ let CommentPlugin = class CommentPlugin extends components_1.ConverterComponent
                     }
                     return reflection.children.every((child) => this.isHidden(child));
                 }
+                // enum members should all be included if the parent enum is documented
+                if (reflection.kind === models_1.ReflectionKind.EnumMember) {
+                    return false;
+                }
                 // signature containers should only be hidden if all their signatures are hidden
                 if (reflection.kindOf(models_1.ReflectionKind.SignatureContainer)) {
                     return reflection
@@ -445,12 +430,6 @@ function moveNestedParamTags(comment, parameter) {
     };
     parameter.type?.visit(visitor);
 }
-function extractLabelTag(comment) {
-    const index = comment.summary.findIndex((part) => part.kind === "inline-tag" && part.tag === "@label");
-    if (index !== -1) {
-        return comment.summary.splice(index, 1)[0].text;
-    }
-}
 function mergeSeeTags(comment) {
     const see = comment.getTags("@see");
     if (see.length < 2)

package/dist/lib/converter/plugins/GroupPlugin.d.ts

@@ -1,4 +1,4 @@
-import { ReflectionKind, DeclarationReflection } from "../../models/reflections/index";
+import { DeclarationReflection } from "../../models/reflections/index";
 import { ReflectionGroup } from "../../models/ReflectionGroup";
 import { ConverterComponent } from "../components";
 /**
@@ -7,23 +7,6 @@ import { ConverterComponent } from "../components";
  * The handler sets the `groups` property of all container reflections.
  */
 export declare class GroupPlugin extends ConverterComponent {
-    /**
-     * Define the singular name of individual reflection kinds.
-     */
-    static SINGULARS: {
-        8: string;
-        16: string;
-    };
-    /**
-     * Define the plural name of individual reflection kinds.
-     */
-    static PLURALS: {
-        128: string;
-        1024: string;
-        8: string;
-        16: string;
-        4194304: string;
-    };
     sortFunction: (reflections: DeclarationReflection[]) => void;
     boosts: Record<string, number>;
     usedBoosts: Set<string>;
@@ -61,25 +44,4 @@ export declare class GroupPlugin extends ConverterComponent {
      * @returns An array containing all children of the given reflection grouped by their kind.
      */
     getReflectionGroups(reflections: DeclarationReflection[]): ReflectionGroup[];
-    /**
-     * Transform the internal typescript kind identifier into a human readable version.
-     *
-     * @param kind  The original typescript kind identifier.
-     * @returns A human readable version of the given typescript kind identifier.
-     */
-    private static getKindString;
-    /**
-     * Return the singular name of a internal typescript kind identifier.
-     *
-     * @param kind The original internal typescript kind identifier.
-     * @returns The singular name of the given internal typescript kind identifier
-     */
-    static getKindSingular(kind: ReflectionKind): string;
-    /**
-     * Return the plural name of a internal typescript kind identifier.
-     *
-     * @param kind The original internal typescript kind identifier.
-     * @returns The plural name of the given internal typescript kind identifier
-     */
-    static getKindPlural(kind: ReflectionKind): string;
 }

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

@@ -5,7 +5,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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 GroupPlugin_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GroupPlugin = void 0;
 const index_1 = require("../../models/reflections/index");
@@ -20,7 +19,7 @@ const models_1 = require("../../models");
  *
  * The handler sets the `groups` property of all container reflections.
  */
-let GroupPlugin = GroupPlugin_1 = class GroupPlugin extends components_1.ConverterComponent {
+let GroupPlugin = class GroupPlugin extends components_1.ConverterComponent {
     constructor() {
         super(...arguments);
         this.usedBoosts = new Set();
@@ -44,7 +43,6 @@ let GroupPlugin = GroupPlugin_1 = class GroupPlugin extends components_1.Convert
      * @param reflection  The reflection that is currently resolved.
      */
     onResolve(_context, reflection) {
-        reflection.kindString = GroupPlugin_1.getKindSingular(reflection.kind);
         if (reflection instanceof index_1.ContainerReflection) {
             this.group(reflection);
         }
@@ -106,7 +104,7 @@ let GroupPlugin = GroupPlugin_1 = class GroupPlugin extends components_1.Convert
         }
         groups.delete("");
         if (groups.size === 0) {
-            groups.add(GroupPlugin_1.getKindPlural(reflection.kind));
+            groups.add(index_1.ReflectionKind.pluralString(reflection.kind));
         }
         for (const group of groups) {
             if (group in this.boosts) {
@@ -139,67 +137,11 @@ let GroupPlugin = GroupPlugin_1 = class GroupPlugin extends components_1.Convert
         });
         return Array.from(groups.values());
     }
-    /**
-     * Transform the internal typescript kind identifier into a human readable version.
-     *
-     * @param kind  The original typescript kind identifier.
-     * @returns A human readable version of the given typescript kind identifier.
-     */
-    static getKindString(kind) {
-        let str = index_1.ReflectionKind[kind];
-        str = str.replace(/(.)([A-Z])/g, (_m, a, b) => a + " " + b.toLowerCase());
-        return str;
-    }
-    /**
-     * Return the singular name of a internal typescript kind identifier.
-     *
-     * @param kind The original internal typescript kind identifier.
-     * @returns The singular name of the given internal typescript kind identifier
-     */
-    static getKindSingular(kind) {
-        if (kind in GroupPlugin_1.SINGULARS) {
-            return GroupPlugin_1.SINGULARS[kind];
-        }
-        else {
-            return GroupPlugin_1.getKindString(kind);
-        }
-    }
-    /**
-     * Return the plural name of a internal typescript kind identifier.
-     *
-     * @param kind The original internal typescript kind identifier.
-     * @returns The plural name of the given internal typescript kind identifier
-     */
-    static getKindPlural(kind) {
-        if (kind in GroupPlugin_1.PLURALS) {
-            return GroupPlugin_1.PLURALS[kind];
-        }
-        else {
-            return this.getKindString(kind) + "s";
-        }
-    }
-};
-/**
- * Define the singular name of individual reflection kinds.
- */
-GroupPlugin.SINGULARS = {
-    [index_1.ReflectionKind.Enum]: "Enumeration",
-    [index_1.ReflectionKind.EnumMember]: "Enumeration Member",
-};
-/**
- * Define the plural name of individual reflection kinds.
- */
-GroupPlugin.PLURALS = {
-    [index_1.ReflectionKind.Class]: "Classes",
-    [index_1.ReflectionKind.Property]: "Properties",
-    [index_1.ReflectionKind.Enum]: "Enumerations",
-    [index_1.ReflectionKind.EnumMember]: "Enumeration Members",
-    [index_1.ReflectionKind.TypeAlias]: "Type Aliases",
 };
 __decorate([
     (0, utils_1.BindOption)("searchGroupBoosts")
 ], GroupPlugin.prototype, "boosts", void 0);
-GroupPlugin = GroupPlugin_1 = __decorate([
+GroupPlugin = __decorate([
     (0, components_1.Component)({ name: "group" })
 ], GroupPlugin);
 exports.GroupPlugin = GroupPlugin;

package/dist/lib/converter/plugins/ImplementsPlugin.d.ts

@@ -12,14 +12,11 @@ export declare class ImplementsPlugin extends ConverterComponent {
     initialize(): void;
     /**
      * Mark all members of the given class to be the implementation of the matching interface member.
-     *
-     * @param context  The context object describing the current state the converter is in.
-     * @param classReflection  The reflection of the classReflection class.
-     * @param interfaceReflection  The reflection of the interfaceReflection interface.
      */
     private analyzeImplements;
     private analyzeInheritance;
     private onResolveEnd;
+    private resolve;
     private tryResolve;
     private doResolve;
     private getExtensionInfo;