typedoc 0.26.11 → 0.27.0-beta.1

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

@@ -1,361 +1,295 @@
-"use strict";
-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 });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImplementsPlugin = void 0;
-const typescript_1 = __importDefault(require("typescript"));
-const application_events_1 = require("../../application-events");
-const index_1 = require("../../models/reflections/index");
-const types_1 = require("../../models/types");
-const array_1 = require("../../utils/array");
-const components_1 = require("../components");
-const converter_1 = require("../converter");
-const utils_1 = require("../../utils");
+import ts from "typescript";
+import { ApplicationEvents } from "../../application-events.js";
+import { DeclarationReflection, ReflectionFlag, ReflectionKind, SignatureReflection, } from "../../models/reflections/index.js";
+import { ReferenceType, ReflectionType, } from "../../models/types.js";
+import { filterMap, zip } from "../../utils/array.js";
+import { ConverterComponent } from "../components.js";
+import { getHumanName } from "../../utils/index.js";
+import { ConverterEvents } from "../converter-events.js";
 /**
  * A plugin that detects interface implementations of functions and
  * properties on classes and links them.
  */
-let ImplementsPlugin = (() => {
-    let _classDecorators = [(0, components_1.Component)({ name: "implements" })];
-    let _classDescriptor;
-    let _classExtraInitializers = [];
-    let _classThis;
-    let _classSuper = components_1.ConverterComponent;
-    var ImplementsPlugin = _classThis = class extends _classSuper {
-        constructor() {
-            super(...arguments);
-            this.resolved = new WeakSet();
-            this.postponed = new WeakMap();
-            this.revivingSerialized = false;
-        }
-        /**
-         * Create a new ImplementsPlugin instance.
-         */
-        initialize() {
-            this.owner.on(converter_1.Converter.EVENT_RESOLVE_END, this.onResolveEnd.bind(this));
-            this.owner.on(converter_1.Converter.EVENT_CREATE_DECLARATION, this.onDeclaration.bind(this), -1000);
-            this.owner.on(converter_1.Converter.EVENT_CREATE_SIGNATURE, this.onSignature.bind(this), 1000);
-            this.application.on(application_events_1.ApplicationEvents.REVIVE, this.onRevive.bind(this));
+export class ImplementsPlugin extends ConverterComponent {
+    resolved = new WeakSet();
+    postponed = new WeakMap();
+    revivingSerialized = false;
+    constructor(owner) {
+        super(owner);
+        this.owner.on(ConverterEvents.RESOLVE_END, this.onResolveEnd.bind(this));
+        this.owner.on(ConverterEvents.CREATE_DECLARATION, this.onDeclaration.bind(this), -1000);
+        this.owner.on(ConverterEvents.CREATE_SIGNATURE, this.onSignature.bind(this), 1000);
+        this.application.on(ApplicationEvents.REVIVE, this.onRevive.bind(this));
+    }
+    /**
+     * Mark all members of the given class to be the implementation of the matching interface member.
+     */
+    analyzeImplements(project, classReflection, interfaceReflection) {
+        this.handleInheritedComments(classReflection, interfaceReflection);
+        if (!interfaceReflection.children) {
+            return;
         }
-        /**
-         * Mark all members of the given class to be the implementation of the matching interface member.
-         */
-        analyzeImplements(project, classReflection, interfaceReflection) {
-            this.handleInheritedComments(classReflection, interfaceReflection);
-            if (!interfaceReflection.children) {
+        interfaceReflection.children.forEach((interfaceMember) => {
+            const classMember = findMatchingMember(interfaceMember, classReflection);
+            if (!classMember) {
                 return;
             }
-            interfaceReflection.children.forEach((interfaceMember) => {
-                const classMember = findMatchingMember(interfaceMember, classReflection);
-                if (!classMember) {
-                    return;
-                }
-                const interfaceMemberName = interfaceReflection.name + "." + interfaceMember.name;
-                classMember.implementationOf =
-                    types_1.ReferenceType.createResolvedReference(interfaceMemberName, interfaceMember, project);
-                const intSigs = interfaceMember.signatures ||
-                    interfaceMember.type?.visit({
-                        reflection: (r) => r.declaration.signatures,
-                    });
-                const clsSigs = classMember.signatures ||
-                    classMember.type?.visit({
-                        reflection: (r) => r.declaration.signatures,
-                    });
-                if (intSigs && clsSigs) {
-                    for (const [clsSig, intSig] of (0, array_1.zip)(clsSigs, intSigs)) {
-                        if (clsSig.implementationOf) {
-                            const target = intSig.parent.kindOf(index_1.ReflectionKind.FunctionOrMethod)
-                                ? intSig
-                                : intSig.parent.parent;
-                            clsSig.implementationOf =
-                                types_1.ReferenceType.createResolvedReference(clsSig.implementationOf.name, target, project);
-                        }
+            const interfaceMemberName = interfaceReflection.name + "." + interfaceMember.name;
+            classMember.implementationOf =
+                ReferenceType.createResolvedReference(interfaceMemberName, interfaceMember, project);
+            const intSigs = interfaceMember.signatures ||
+                interfaceMember.type?.visit({
+                    reflection: (r) => r.declaration.signatures,
+                });
+            const clsSigs = classMember.signatures ||
+                classMember.type?.visit({
+                    reflection: (r) => r.declaration.signatures,
+                });
+            if (intSigs && clsSigs) {
+                for (const [clsSig, intSig] of zip(clsSigs, intSigs)) {
+                    if (clsSig.implementationOf) {
+                        const target = intSig.parent.kindOf(ReflectionKind.FunctionOrMethod)
+                            ? intSig
+                            : intSig.parent.parent;
+                        clsSig.implementationOf =
+                            ReferenceType.createResolvedReference(clsSig.implementationOf.name, target, project);
                     }
                 }
-                this.handleInheritedComments(classMember, interfaceMember);
-            });
-        }
-        analyzeInheritance(project, reflection) {
-            const extendedTypes = (0, array_1.filterMap)(reflection.extendedTypes ?? [], (type) => {
-                return type instanceof types_1.ReferenceType &&
-                    type.reflection instanceof index_1.DeclarationReflection
-                    ? type
-                    : void 0;
-            });
-            for (const parent of extendedTypes) {
-                this.handleInheritedComments(reflection, parent.reflection);
-                for (const parentMember of parent.reflection.children ?? []) {
-                    const child = findMatchingMember(parentMember, reflection);
-                    if (child) {
-                        const key = child.overwrites
-                            ? "overwrites"
-                            : "inheritedFrom";
-                        for (const [childSig, parentSig] of (0, array_1.zip)(child.signatures ?? [], parentMember.signatures ?? [])) {
-                            childSig[key] = types_1.ReferenceType.createResolvedReference(`${parent.name}.${parentMember.name}`, parentSig, project);
-                        }
-                        child[key] = types_1.ReferenceType.createResolvedReference(`${parent.name}.${parentMember.name}`, parentMember, project);
-                        this.handleInheritedComments(child, parentMember);
+            }
+            this.handleInheritedComments(classMember, interfaceMember);
+        });
+    }
+    analyzeInheritance(project, reflection) {
+        const extendedTypes = filterMap(reflection.extendedTypes ?? [], (type) => {
+            return type instanceof ReferenceType &&
+                type.reflection instanceof DeclarationReflection
+                ? type
+                : void 0;
+        });
+        for (const parent of extendedTypes) {
+            this.handleInheritedComments(reflection, parent.reflection);
+            for (const parentMember of parent.reflection.children ?? []) {
+                const child = findMatchingMember(parentMember, reflection);
+                if (child) {
+                    const key = child.overwrites
+                        ? "overwrites"
+                        : "inheritedFrom";
+                    for (const [childSig, parentSig] of zip(child.signatures ?? [], parentMember.signatures ?? [])) {
+                        childSig[key] = ReferenceType.createResolvedReference(`${parent.name}.${parentMember.name}`, parentSig, project);
                     }
+                    child[key] = ReferenceType.createResolvedReference(`${parent.name}.${parentMember.name}`, parentMember, project);
+                    this.handleInheritedComments(child, parentMember);
                 }
             }
         }
-        onResolveEnd(context) {
-            this.resolve(context.project);
+    }
+    onResolveEnd(context) {
+        this.resolve(context.project);
+    }
+    onRevive(project) {
+        this.revivingSerialized = true;
+        this.resolve(project);
+        this.revivingSerialized = false;
+    }
+    resolve(project) {
+        for (const id in project.reflections) {
+            const refl = project.reflections[id];
+            if (refl instanceof DeclarationReflection) {
+                this.tryResolve(project, refl);
+            }
         }
-        onRevive(project) {
-            this.revivingSerialized = true;
-            this.resolve(project);
-            this.revivingSerialized = false;
+    }
+    tryResolve(project, reflection) {
+        const requirements = filterMap([
+            ...(reflection.implementedTypes ?? []),
+            ...(reflection.extendedTypes ?? []),
+        ], (type) => {
+            return type instanceof ReferenceType ? type.reflection : void 0;
+        });
+        if (requirements.every((req) => this.resolved.has(req))) {
+            this.doResolve(project, reflection);
+            this.resolved.add(reflection);
+            for (const refl of this.postponed.get(reflection) ?? []) {
+                this.tryResolve(project, refl);
+            }
+            this.postponed.delete(reflection);
         }
-        resolve(project) {
-            for (const id in project.reflections) {
-                const refl = project.reflections[id];
-                if (refl instanceof index_1.DeclarationReflection) {
-                    this.tryResolve(project, refl);
-                }
+        else {
+            for (const req of requirements) {
+                const future = this.postponed.get(req) ?? new Set();
+                future.add(reflection);
+                this.postponed.set(req, future);
             }
         }
-        tryResolve(project, reflection) {
-            const requirements = (0, array_1.filterMap)([
-                ...(reflection.implementedTypes ?? []),
-                ...(reflection.extendedTypes ?? []),
-            ], (type) => {
-                return type instanceof types_1.ReferenceType ? type.reflection : void 0;
-            });
-            if (requirements.every((req) => this.resolved.has(req))) {
-                this.doResolve(project, reflection);
-                this.resolved.add(reflection);
-                for (const refl of this.postponed.get(reflection) ?? []) {
-                    this.tryResolve(project, refl);
+    }
+    doResolve(project, reflection) {
+        if (reflection.kindOf(ReflectionKind.Class) &&
+            reflection.implementedTypes) {
+            reflection.implementedTypes.forEach((type) => {
+                if (!(type instanceof ReferenceType)) {
+                    return;
                 }
-                this.postponed.delete(reflection);
-            }
-            else {
-                for (const req of requirements) {
-                    const future = this.postponed.get(req) ?? new Set();
-                    future.add(reflection);
-                    this.postponed.set(req, future);
+                if (type.reflection &&
+                    type.reflection.kindOf(ReflectionKind.ClassOrInterface)) {
+                    this.analyzeImplements(project, reflection, type.reflection);
                 }
-            }
+            });
         }
-        doResolve(project, reflection) {
-            if (reflection.kindOf(index_1.ReflectionKind.Class) &&
-                reflection.implementedTypes) {
-                reflection.implementedTypes.forEach((type) => {
-                    if (!(type instanceof types_1.ReferenceType)) {
-                        return;
-                    }
-                    if (type.reflection &&
-                        type.reflection.kindOf(index_1.ReflectionKind.ClassOrInterface)) {
-                        this.analyzeImplements(project, reflection, type.reflection);
-                    }
-                });
-            }
-            if (reflection.kindOf(index_1.ReflectionKind.ClassOrInterface) &&
-                reflection.extendedTypes) {
-                this.analyzeInheritance(project, reflection);
-            }
+        if (reflection.kindOf(ReflectionKind.ClassOrInterface) &&
+            reflection.extendedTypes) {
+            this.analyzeInheritance(project, reflection);
         }
-        getExtensionInfo(context, reflection) {
-            if (!reflection || !reflection.kindOf(index_1.ReflectionKind.Inheritable)) {
-                return;
-            }
-            // Need this because we re-use reflections for type literals.
-            if (!reflection.parent?.kindOf(index_1.ReflectionKind.ClassOrInterface)) {
-                return;
-            }
-            const symbol = context.project.getSymbolFromReflection(reflection.parent);
-            if (!symbol) {
-                return;
-            }
-            const declaration = symbol
-                .getDeclarations()
-                ?.find((n) => typescript_1.default.isClassDeclaration(n) || typescript_1.default.isInterfaceDeclaration(n));
-            if (!declaration) {
-                return;
-            }
-            return { symbol, declaration };
+    }
+    getExtensionInfo(context, reflection) {
+        if (!reflection || !reflection.kindOf(ReflectionKind.Inheritable)) {
+            return;
         }
-        onSignature(context, reflection) {
-            this.onDeclaration(context, reflection.parent);
+        // Need this because we re-use reflections for type literals.
+        if (!reflection.parent?.kindOf(ReflectionKind.ClassOrInterface)) {
+            return;
         }
-        /**
-         * Responsible for setting the {@link DeclarationReflection.inheritedFrom},
-         * {@link DeclarationReflection.overwrites}, and {@link DeclarationReflection.implementationOf}
-         * properties on the provided reflection temporarily, these links will be replaced
-         * during the resolve step with links which actually point to the right place.
-         */
-        onDeclaration(context, reflection) {
-            const info = this.getExtensionInfo(context, reflection);
-            if (!info) {
-                return;
-            }
-            if (reflection.kind === index_1.ReflectionKind.Constructor) {
-                const ctor = info.declaration.members.find(typescript_1.default.isConstructorDeclaration);
-                constructorInheritance(context, reflection, info.declaration, ctor);
-                return;
-            }
-            const childType = reflection.flags.isStatic
-                ? context.checker.getTypeOfSymbolAtLocation(info.symbol, info.declaration)
-                : context.checker.getDeclaredTypeOfSymbol(info.symbol);
-            const property = findProperty(reflection, childType);
-            if (!property) {
-                // We're probably broken... but I don't think this should be fatal.
-                context.logger.warn(`Failed to retrieve${reflection.flags.isStatic ? " static" : ""} member "${reflection.escapedName ?? reflection.name}" of "${reflection.parent?.name}" for inheritance analysis. Please report a bug.`);
-                return;
+        const symbol = context.project.getSymbolFromReflection(reflection.parent);
+        if (!symbol) {
+            return;
+        }
+        const declaration = symbol
+            .getDeclarations()
+            ?.find((n) => ts.isClassDeclaration(n) || ts.isInterfaceDeclaration(n));
+        if (!declaration) {
+            return;
+        }
+        return { symbol, declaration };
+    }
+    onSignature(context, reflection) {
+        this.onDeclaration(context, reflection.parent);
+    }
+    /**
+     * Responsible for setting the {@link DeclarationReflection.inheritedFrom},
+     * {@link DeclarationReflection.overwrites}, and {@link DeclarationReflection.implementationOf}
+     * properties on the provided reflection temporarily, these links will be replaced
+     * during the resolve step with links which actually point to the right place.
+     */
+    onDeclaration(context, reflection) {
+        const info = this.getExtensionInfo(context, reflection);
+        if (!info) {
+            return;
+        }
+        if (reflection.kind === ReflectionKind.Constructor) {
+            const ctor = info.declaration.members.find(ts.isConstructorDeclaration);
+            constructorInheritance(context, reflection, info.declaration, ctor);
+            return;
+        }
+        const childType = reflection.flags.isStatic
+            ? context.checker.getTypeOfSymbolAtLocation(info.symbol, info.declaration)
+            : context.checker.getDeclaredTypeOfSymbol(info.symbol);
+        const property = findProperty(reflection, childType);
+        if (!property) {
+            // We're probably broken... but I don't think this should be fatal.
+            context.logger.warn(`Failed to retrieve${reflection.flags.isStatic ? " static" : ""} member "${reflection.escapedName ?? reflection.name}" of "${reflection.parent?.name}" for inheritance analysis. Please report a bug.`);
+            return;
+        }
+        // Need to check both extends and implements clauses.
+        out: for (const clause of info.declaration.heritageClauses ?? []) {
+            // No point checking implemented types for static members, they won't exist.
+            if (reflection.flags.isStatic &&
+                clause.token === ts.SyntaxKind.ImplementsKeyword) {
+                continue;
             }
-            // Need to check both extends and implements clauses.
-            out: for (const clause of info.declaration.heritageClauses ?? []) {
-                // No point checking implemented types for static members, they won't exist.
-                if (reflection.flags.isStatic &&
-                    clause.token === typescript_1.default.SyntaxKind.ImplementsKeyword) {
-                    continue;
-                }
-                for (const expr of clause.types) {
-                    const parentType = context.checker.getTypeAtLocation(reflection.flags.isStatic ? expr.expression : expr);
-                    const parentProperty = findProperty(reflection, parentType);
-                    if (parentProperty) {
-                        const isInherit = property
-                            .getDeclarations()
-                            ?.some((d) => d.parent !== info.declaration) ??
-                            true;
-                        createLink(context, reflection, clause, expr, parentProperty, isInherit);
-                        // Can't always break because we need to also set `implementationOf` if we
-                        // inherit from a base class and also implement an interface.
-                        if (clause.token === typescript_1.default.SyntaxKind.ImplementsKeyword) {
-                            break out;
-                        }
+            for (const expr of clause.types) {
+                const parentType = context.checker.getTypeAtLocation(reflection.flags.isStatic ? expr.expression : expr);
+                const parentProperty = findProperty(reflection, parentType);
+                if (parentProperty) {
+                    const isInherit = property
+                        .getDeclarations()
+                        ?.some((d) => d.parent !== info.declaration) ??
+                        true;
+                    createLink(context, reflection, clause, expr, parentProperty, isInherit);
+                    // Can't always break because we need to also set `implementationOf` if we
+                    // inherit from a base class and also implement an interface.
+                    if (clause.token === ts.SyntaxKind.ImplementsKeyword) {
+                        break out;
                     }
                 }
             }
         }
-        /**
-         * Responsible for copying comments from "parent" reflections defined
-         * in either a base class or implemented interface to the child class.
-         */
-        handleInheritedComments(child, parent) {
-            this.copyComment(child, parent);
-            if (parent.kindOf(index_1.ReflectionKind.Property) &&
-                child.kindOf(index_1.ReflectionKind.Accessor)) {
-                if (child.getSignature) {
-                    this.copyComment(child.getSignature, parent);
-                    child.getSignature.implementationOf = child.implementationOf;
-                }
-                if (child.setSignature) {
-                    this.copyComment(child.setSignature, parent);
-                    child.setSignature.implementationOf = child.implementationOf;
-                }
+    }
+    /**
+     * Responsible for copying comments from "parent" reflections defined
+     * in either a base class or implemented interface to the child class.
+     */
+    handleInheritedComments(child, parent) {
+        this.copyComment(child, parent);
+        if (parent.kindOf(ReflectionKind.Property) &&
+            child.kindOf(ReflectionKind.Accessor)) {
+            if (child.getSignature) {
+                this.copyComment(child.getSignature, parent);
+                child.getSignature.implementationOf = child.implementationOf;
             }
-            if (parent.kindOf(index_1.ReflectionKind.Accessor) &&
-                child.kindOf(index_1.ReflectionKind.Accessor)) {
-                if (parent.getSignature && child.getSignature) {
-                    this.copyComment(child.getSignature, parent.getSignature);
-                }
-                if (parent.setSignature && child.setSignature) {
-                    this.copyComment(child.setSignature, parent.setSignature);
-                }
+            if (child.setSignature) {
+                this.copyComment(child.setSignature, parent);
+                child.setSignature.implementationOf = child.implementationOf;
             }
-            if (parent.kindOf(index_1.ReflectionKind.FunctionOrMethod) &&
-                parent.signatures &&
-                child.signatures) {
-                for (const [cs, ps] of (0, array_1.zip)(child.signatures, parent.signatures)) {
-                    this.copyComment(cs, ps);
-                }
+        }
+        if (parent.kindOf(ReflectionKind.Accessor) &&
+            child.kindOf(ReflectionKind.Accessor)) {
+            if (parent.getSignature && child.getSignature) {
+                this.copyComment(child.getSignature, parent.getSignature);
             }
-            else if (parent.kindOf(index_1.ReflectionKind.Property) &&
-                parent.type instanceof types_1.ReflectionType &&
-                parent.type.declaration.signatures &&
-                child.signatures) {
-                for (const [cs, ps] of (0, array_1.zip)(child.signatures, parent.type.declaration.signatures)) {
-                    this.copyComment(cs, ps);
-                }
+            if (parent.setSignature && child.setSignature) {
+                this.copyComment(child.setSignature, parent.setSignature);
             }
         }
-        /**
-         * Copy the comment of the source reflection to the target reflection with a JSDoc style copy
-         * function. The TSDoc copy function is in the InheritDocPlugin.
-         */
-        copyComment(target, source) {
-            if (!shouldCopyComment(target, source, this.revivingSerialized)) {
-                return;
+        if (parent.kindOf(ReflectionKind.FunctionOrMethod) &&
+            parent.signatures &&
+            child.signatures) {
+            for (const [cs, ps] of zip(child.signatures, parent.signatures)) {
+                this.copyComment(cs, ps);
             }
-            target.comment = source.comment.clone();
-            if (target instanceof index_1.DeclarationReflection &&
-                source instanceof index_1.DeclarationReflection) {
-                for (const [tt, ts] of (0, array_1.zip)(target.typeParameters || [], source.typeParameters || [])) {
-                    this.copyComment(tt, ts);
-                }
+        }
+        else if (parent.kindOf(ReflectionKind.Property) &&
+            parent.type instanceof ReflectionType &&
+            parent.type.declaration.signatures &&
+            child.signatures) {
+            for (const [cs, ps] of zip(child.signatures, parent.type.declaration.signatures)) {
+                this.copyComment(cs, ps);
             }
-            if (target instanceof index_1.SignatureReflection &&
-                source instanceof index_1.SignatureReflection) {
-                for (const [tt, ts] of (0, array_1.zip)(target.typeParameters || [], source.typeParameters || [])) {
-                    this.copyComment(tt, ts);
-                }
-                for (const [pt, ps] of (0, array_1.zip)(target.parameters || [], source.parameters || [])) {
-                    this.copyComment(pt, ps);
-                }
+        }
+    }
+    /**
+     * Copy the comment of the source reflection to the target reflection with a JSDoc style copy
+     * function. The TSDoc copy function is in the InheritDocPlugin.
+     */
+    copyComment(target, source) {
+        if (!shouldCopyComment(target, source, this.revivingSerialized)) {
+            return;
+        }
+        target.comment = source.comment.clone();
+        if (target instanceof DeclarationReflection &&
+            source instanceof DeclarationReflection) {
+            for (const [tt, ts] of zip(target.typeParameters || [], source.typeParameters || [])) {
+                this.copyComment(tt, ts);
             }
         }
-    };
-    __setFunctionName(_classThis, "ImplementsPlugin");
-    (() => {
-        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);
-        ImplementsPlugin = _classThis = _classDescriptor.value;
-        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-        __runInitializers(_classThis, _classExtraInitializers);
-    })();
-    return ImplementsPlugin = _classThis;
-})();
-exports.ImplementsPlugin = ImplementsPlugin;
+        if (target instanceof SignatureReflection &&
+            source instanceof SignatureReflection) {
+            for (const [tt, ts] of zip(target.typeParameters || [], source.typeParameters || [])) {
+                this.copyComment(tt, ts);
+            }
+            for (const [pt, ps] of zip(target.parameters || [], source.parameters || [])) {
+                this.copyComment(pt, ps);
+            }
+        }
+    }
+}
 function constructorInheritance(context, reflection, childDecl, constructorDecl) {
-    const extendsClause = childDecl.heritageClauses?.find((cl) => cl.token === typescript_1.default.SyntaxKind.ExtendsKeyword);
+    const extendsClause = childDecl.heritageClauses?.find((cl) => cl.token === ts.SyntaxKind.ExtendsKeyword);
     if (!extendsClause)
         return;
     const name = `${extendsClause.types[0].getText()}.constructor`;
     const key = constructorDecl ? "overwrites" : "inheritedFrom";
-    reflection[key] ??= types_1.ReferenceType.createBrokenReference(name, context.project);
+    reflection[key] ??= ReferenceType.createBrokenReference(name, context.project);
     for (const sig of reflection.signatures ?? []) {
-        sig[key] ??= types_1.ReferenceType.createBrokenReference(name, context.project);
+        sig[key] ??= ReferenceType.createBrokenReference(name, context.project);
     }
 }
 function findProperty(reflection, parent) {
@@ -367,7 +301,7 @@ function findProperty(reflection, parent) {
 }
 function createLink(context, reflection, clause, expr, symbol, isInherit) {
     const project = context.project;
-    const name = `${expr.expression.getText()}.${(0, utils_1.getHumanName)(symbol.name)}`;
+    const name = `${expr.expression.getText()}.${getHumanName(symbol.name)}`;
     link(reflection);
     link(reflection.getSignature);
     link(reflection.setSignature);
@@ -384,16 +318,16 @@ function createLink(context, reflection, clause, expr, symbol, isInherit) {
     function link(target) {
         if (!target)
             return;
-        if (clause.token === typescript_1.default.SyntaxKind.ImplementsKeyword) {
-            target.implementationOf ??= types_1.ReferenceType.createBrokenReference(name, project);
+        if (clause.token === ts.SyntaxKind.ImplementsKeyword) {
+            target.implementationOf ??= ReferenceType.createBrokenReference(name, project);
             return;
         }
         if (isInherit) {
-            target.setFlag(index_1.ReflectionFlag.Inherited);
-            target.inheritedFrom ??= types_1.ReferenceType.createBrokenReference(name, project);
+            target.setFlag(ReflectionFlag.Inherited);
+            target.inheritedFrom ??= ReferenceType.createBrokenReference(name, project);
         }
         else {
-            target.overwrites ??= types_1.ReferenceType.createBrokenReference(name, project);
+            target.overwrites ??= ReferenceType.createBrokenReference(name, project);
         }
     }
 }