typedoc 0.28.18 → 0.28.20

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

@@ -1,50 +0,0 @@
-import assert from "assert";
-import { DeclarationReflection, ParameterReflection, ReflectionFlag, ReflectionKind, SignatureReflection, UnionType, } from "../../models/index.js";
-import { ConverterEvents } from "../converter-events.js";
-export function convertIndexSignatures(context, type) {
-    assert(context.scope instanceof DeclarationReflection);
-    // Each declaration should have one SignatureReflection
-    // If we don't have a declaration, the index signature was inferred by TS
-    // and we should make a separate SignatureReflection for each index signature.
-    const seenByDeclaration = new Map();
-    const createdSignatures = [];
-    for (const indexInfo of context.checker.getIndexInfosOfType(type)) {
-        // Check if we've already created an index signature for this type
-        if (indexInfo.declaration &&
-            seenByDeclaration.has(indexInfo.declaration)) {
-            const createdSig = seenByDeclaration.get(indexInfo.declaration);
-            if (createdSig.parameters[0].type?.type !== "union") {
-                createdSig.parameters[0].type = new UnionType([
-                    createdSig.parameters[0].type,
-                ]);
-            }
-            createdSig.parameters[0].type.types.push(context.converter.convertType(context.withScope(createdSig), indexInfo.keyType));
-            // No need to update the return type as it will be the same for all members.
-            continue;
-        }
-        // Otherwise create a new one
-        const index = new SignatureReflection("__index", ReflectionKind.IndexSignature, context.scope);
-        const ic = context.withScope(index);
-        if (indexInfo.isReadonly) {
-            index.setFlag(ReflectionFlag.Readonly);
-        }
-        createdSignatures.push([indexInfo.declaration, index]);
-        if (indexInfo.declaration) {
-            seenByDeclaration.set(indexInfo.declaration, index);
-            index.comment = context.getNodeComment(indexInfo.declaration, 
-            /* moduleComment */ false);
-        }
-        index.parameters = [
-            new ParameterReflection(indexInfo.declaration?.parameters[0].name.getText() ?? "key", ReflectionKind.Parameter, index),
-        ];
-        index.parameters[0].type = context.converter.convertType(ic.withScope(index.parameters[0]), indexInfo.keyType);
-        index.type = context.converter.convertType(ic, indexInfo.type);
-        context.registerReflection(index, indexInfo.declaration?.symbol);
-        context.scope.indexSignatures ||= [];
-        context.scope.indexSignatures.push(index);
-    }
-    // Now that we've created everything, trigger events for them.
-    for (const [declaration, index] of createdSignatures) {
-        context.converter.trigger(ConverterEvents.CREATE_SIGNATURE, context, index, declaration);
-    }
-}

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

@@ -1,353 +0,0 @@
-import ts from "typescript";
-import assert from "assert";
-import { DeclarationReflection, IntrinsicType, ParameterReflection, PredicateType, ReferenceType, ReflectionFlag, ReflectionKind, SignatureReflection, TypeParameterReflection, VarianceModifier, } from "../../models/index.js";
-import { ConverterEvents } from "../converter-events.js";
-import { convertDefaultValue } from "../convert-expression.js";
-import { removeUndefined } from "../utils/reflections.js";
-export function convertConstructSignatures(context, symbol) {
-    const type = context.checker.getDeclaredTypeOfSymbol(symbol);
-    // These get added as a "constructor" member of this interface. This is a problem... but nobody
-    // has complained yet. We really ought to have a constructSignatures property on the reflection instead.
-    const constructSignatures = context.checker.getSignaturesOfType(type, ts.SignatureKind.Construct);
-    if (constructSignatures.length) {
-        const constructMember = new DeclarationReflection("constructor", ReflectionKind.Constructor, context.scope);
-        context.postReflectionCreation(constructMember, symbol, void 0);
-        context.finalizeDeclarationReflection(constructMember);
-        const constructContext = context.withScope(constructMember);
-        constructSignatures.forEach((sig) => createSignature(constructContext, ReflectionKind.ConstructorSignature, sig, symbol));
-    }
-}
-export function createSignature(context, kind, signature, symbol, declaration) {
-    assert(context.scope instanceof DeclarationReflection);
-    declaration ||= signature.getDeclaration();
-    const sigRef = new SignatureReflection(kind == ReflectionKind.ConstructorSignature
-        ? context.scope.parent.name
-        : context.scope.name, kind, context.scope);
-    // This feels awful, but we need some way to tell if callable signatures on classes
-    // are "static" (e.g. `Foo()`) or not (e.g. `(new Foo())()`)
-    if (context.shouldBeStatic) {
-        sigRef.setFlag(ReflectionFlag.Static);
-    }
-    if (symbol && declaration) {
-        context.project.registerSymbolId(sigRef, context.createSymbolId(symbol, declaration));
-    }
-    let parentReflection = context.scope;
-    if (parentReflection.kindOf(ReflectionKind.TypeLiteral) &&
-        parentReflection.parent instanceof DeclarationReflection) {
-        parentReflection = parentReflection.parent;
-    }
-    if (declaration) {
-        const sigComment = context.getSignatureComment(declaration);
-        if (parentReflection.comment?.discoveryId !== sigComment?.discoveryId) {
-            sigRef.comment = sigComment;
-            if (parentReflection.kindOf(ReflectionKind.MayContainDocuments)) {
-                context.converter.processDocumentTags(sigRef, parentReflection);
-            }
-        }
-    }
-    const sigRefCtx = context.withScope(sigRef);
-    sigRef.typeParameters = convertTypeParameters(sigRefCtx, sigRef, signature.typeParameters);
-    const parameterSymbols = signature.thisParameter
-        ? [signature.thisParameter, ...signature.parameters]
-        : signature.parameters;
-    sigRef.parameters = convertParameters(sigRefCtx, sigRef, parameterSymbols, declaration?.parameters);
-    const predicate = context.checker.getTypePredicateOfSignature(signature);
-    if (predicate) {
-        sigRef.type = convertPredicate(predicate, sigRefCtx);
-    }
-    else if (kind == ReflectionKind.SetSignature) {
-        sigRef.type = new IntrinsicType("void");
-    }
-    else if (declaration?.type?.kind === ts.SyntaxKind.ThisType) {
-        sigRef.type = new IntrinsicType("this");
-    }
-    else {
-        let typeNode = declaration?.type;
-        if (typeNode && ts.isJSDocReturnTag(typeNode)) {
-            typeNode = typeNode.typeExpression?.type;
-        }
-        sigRef.type = context.converter.convertType(sigRefCtx, signature.getReturnType(), typeNode);
-    }
-    context.registerReflection(sigRef, undefined);
-    switch (kind) {
-        case ReflectionKind.GetSignature:
-            context.scope.getSignature = sigRef;
-            break;
-        case ReflectionKind.SetSignature:
-            context.scope.setSignature = sigRef;
-            break;
-        case ReflectionKind.CallSignature:
-        case ReflectionKind.ConstructorSignature:
-            context.scope.signatures ??= [];
-            context.scope.signatures.push(sigRef);
-            break;
-    }
-    context.converter.trigger(ConverterEvents.CREATE_SIGNATURE, context, sigRef, declaration, signature);
-}
-/**
- * Special cased constructor factory for functions tagged with `@class`
- */
-export function createConstructSignatureWithType(context, signature, classType) {
-    assert(context.scope instanceof DeclarationReflection);
-    const declaration = signature.getDeclaration();
-    const sigRef = new SignatureReflection(context.scope.parent.name, ReflectionKind.ConstructorSignature, context.scope);
-    const sigRefCtx = context.withScope(sigRef);
-    if (declaration) {
-        sigRef.comment = context.getSignatureComment(declaration);
-        if (sigRef.comment?.discoveryId === context.scope.parent?.comment?.discoveryId) {
-            delete sigRef.comment;
-        }
-    }
-    const parameterSymbols = signature.thisParameter
-        ? [signature.thisParameter, ...signature.parameters]
-        : [...signature.parameters];
-    // Prevent a `this` parameter from appearing on constructor signature
-    // as TS disallows them on regular classes.
-    if (parameterSymbols[0]?.name === "this") {
-        parameterSymbols.shift();
-    }
-    sigRef.parameters = convertParameters(sigRefCtx, sigRef, parameterSymbols, declaration?.parameters);
-    sigRef.parameters = convertParameters(sigRefCtx, sigRef, parameterSymbols, undefined);
-    // Do NOT convert type parameters here, they go on the class itself in the @class case
-    // See #2914.
-    sigRef.type = ReferenceType.createResolvedReference(context.scope.parent.name, classType, context.project);
-    context.registerReflection(sigRef, undefined);
-    context.scope.signatures ??= [];
-    context.scope.signatures.push(sigRef);
-    context.converter.trigger(ConverterEvents.CREATE_SIGNATURE, context, sigRef, declaration, signature);
-}
-function convertParameters(context, sigRef, parameters, parameterNodes) {
-    // #2698 if `satisfies` is used to imply a this parameter, we might have
-    // more parameters than parameter nodes and need to shift the parameterNode
-    // access index. Very ugly, but it does the job.
-    const parameterNodeOffset = parameterNodes?.length !== parameters.length ? -1 : 0;
-    return parameters.map((param, i) => {
-        const declaration = param.valueDeclaration;
-        assert(!declaration ||
-            ts.isParameter(declaration) ||
-            ts.isJSDocParameterTag(declaration));
-        const paramRefl = new ParameterReflection(/^__\d+$/.test(param.name) ? "__namedParameters" : param.name, ReflectionKind.Parameter, sigRef);
-        if (declaration && ts.isJSDocParameterTag(declaration)) {
-            paramRefl.comment = context.getJsDocComment(declaration);
-        }
-        paramRefl.comment ||= context.getComment(param, paramRefl.kind);
-        context.registerReflection(paramRefl, param);
-        context.converter.trigger(ConverterEvents.CREATE_PARAMETER, context, paramRefl);
-        let type;
-        let typeNode;
-        if (declaration) {
-            type = context.checker.getTypeOfSymbolAtLocation(param, declaration);
-            if (ts.isParameter(declaration)) {
-                typeNode = declaration.type;
-            }
-            else {
-                typeNode = declaration.typeExpression?.type;
-            }
-        }
-        else {
-            type = context.checker.getTypeOfSymbol(param);
-        }
-        if (declaration &&
-            ts.isParameter(declaration) &&
-            declaration.type?.kind === ts.SyntaxKind.ThisType) {
-            paramRefl.type = new IntrinsicType("this");
-        }
-        else if (!type) {
-            paramRefl.type = new IntrinsicType("any");
-        }
-        else {
-            paramRefl.type = context.converter.convertType(context.withScope(paramRefl), type, typeNode);
-        }
-        let isOptional = false;
-        if (declaration) {
-            isOptional = ts.isParameter(declaration)
-                ? !!declaration.questionToken ||
-                    ts
-                        .getJSDocParameterTags(declaration)
-                        .some((tag) => tag.isBracketed)
-                : declaration.isBracketed;
-        }
-        if (isOptional) {
-            paramRefl.type = removeUndefined(paramRefl.type);
-        }
-        paramRefl.defaultValue = convertDefaultValue(parameterNodes?.[i + parameterNodeOffset]);
-        paramRefl.setFlag(ReflectionFlag.Optional, isOptional);
-        // If we have no declaration, then this is an implicitly defined parameter in JS land
-        // because the method body uses `arguments`... which is always a rest argument,
-        // unless it is a this parameter defined with @this in JSDoc.
-        let isRest = param.name !== "this";
-        if (declaration) {
-            isRest = ts.isParameter(declaration)
-                ? !!declaration.dotDotDotToken
-                : !!declaration.typeExpression &&
-                    ts.isJSDocVariadicType(declaration.typeExpression.type);
-        }
-        paramRefl.setFlag(ReflectionFlag.Rest, isRest);
-        checkForDestructuredParameterDefaults(paramRefl, parameterNodes?.[i + parameterNodeOffset]);
-        return paramRefl;
-    });
-}
-export function convertParameterNodes(context, sigRef, parameters) {
-    return parameters.map((param) => {
-        const paramRefl = new ParameterReflection(/__\d+/.test(param.name.getText())
-            ? "__namedParameters"
-            : param.name.getText(), ReflectionKind.Parameter, sigRef);
-        if (ts.isJSDocParameterTag(param)) {
-            paramRefl.comment = context.getJsDocComment(param);
-        }
-        context.registerReflection(paramRefl, context.getSymbolAtLocation(param));
-        context.converter.trigger(ConverterEvents.CREATE_PARAMETER, context, paramRefl);
-        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) {
-            paramRefl.type = removeUndefined(paramRefl.type);
-        }
-        paramRefl.defaultValue = convertDefaultValue(param);
-        paramRefl.setFlag(ReflectionFlag.Optional, isOptional);
-        paramRefl.setFlag(ReflectionFlag.Rest, ts.isParameter(param)
-            ? !!param.dotDotDotToken
-            : !!param.typeExpression &&
-                ts.isJSDocVariadicType(param.typeExpression.type));
-        checkForDestructuredParameterDefaults(paramRefl, param);
-        return paramRefl;
-    });
-}
-function checkForDestructuredParameterDefaults(param, decl) {
-    if (!decl || !ts.isParameter(decl))
-        return;
-    if (param.name !== "__namedParameters")
-        return;
-    if (!ts.isObjectBindingPattern(decl.name))
-        return;
-    if (param.type?.type !== "reflection")
-        return;
-    for (const child of param.type.declaration.children || []) {
-        const tsChild = decl.name.elements.find((el) => (el.propertyName || el.name).getText() === child.name);
-        if (tsChild) {
-            child.defaultValue = convertDefaultValue(tsChild);
-        }
-    }
-}
-export function convertTypeParameters(context, parent, parameters) {
-    return parameters?.map((param) => {
-        const constraintT = param.getConstraint();
-        const defaultT = param.getDefault();
-        // 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 declaration = param
-            .getSymbol()
-            ?.declarations?.find(ts.isTypeParameterDeclaration);
-        const variance = getVariance(declaration?.modifiers);
-        const paramRefl = new 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;
-        // No way to determine this from the type parameter itself, need to go back to the declaration
-        if (declaration?.modifiers?.some((m) => m.kind === ts.SyntaxKind.ConstKeyword)) {
-            paramRefl.flags.setFlag(ReflectionFlag.Const, true);
-        }
-        context.registerReflection(paramRefl, param.getSymbol());
-        context.converter.trigger(ConverterEvents.CREATE_TYPE_PARAMETER, context, paramRefl);
-        return paramRefl;
-    });
-}
-export function convertTypeParameterNodes(context, parameters) {
-    return parameters?.map((param) => createTypeParamReflection(param, context));
-}
-export function createTypeParamReflection(param, context) {
-    const paramRefl = new TypeParameterReflection(param.name.text, context.scope, getVariance(param.modifiers));
-    const paramScope = context.withScope(paramRefl);
-    if (ts.isJSDocTemplateTag(param.parent)) {
-        // With a @template tag, the constraint applies only to the
-        // first type parameter declared.
-        if (param.parent.typeParameters[0].name.text === param.name.text && param.parent.constraint) {
-            paramRefl.type = context.converter.convertType(paramScope, param.parent.constraint);
-        }
-    }
-    else {
-        paramRefl.type = param.constraint
-            ? context.converter.convertType(paramScope, param.constraint)
-            : void 0;
-    }
-    paramRefl.default = param.default
-        ? context.converter.convertType(paramScope, param.default)
-        : void 0;
-    if (param.modifiers?.some((m) => m.kind === ts.SyntaxKind.ConstKeyword)) {
-        paramRefl.flags.setFlag(ReflectionFlag.Const, true);
-    }
-    context.registerReflection(paramRefl, param.symbol);
-    if (ts.isJSDocTemplateTag(param.parent)) {
-        paramRefl.comment = context.getJsDocComment(param.parent);
-    }
-    context.converter.trigger(ConverterEvents.CREATE_TYPE_PARAMETER, context, paramRefl, param);
-    return paramRefl;
-}
-export function convertTemplateParameterNodes(context, nodes) {
-    return nodes?.flatMap((node) => {
-        return node.typeParameters.map((param, index) => {
-            const paramRefl = new TypeParameterReflection(param.name.text, context.scope, getVariance(param.modifiers));
-            const paramScope = context.withScope(paramRefl);
-            paramRefl.type = index || !node.constraint
-                ? void 0
-                : context.converter.convertType(paramScope, node.constraint.type);
-            paramRefl.default = param.default
-                ? context.converter.convertType(paramScope, param.default)
-                : void 0;
-            if (param.modifiers?.some((m) => m.kind === ts.SyntaxKind.ConstKeyword)) {
-                paramRefl.flags.setFlag(ReflectionFlag.Const, true);
-            }
-            context.registerReflection(paramRefl, param.symbol);
-            if (ts.isJSDocTemplateTag(param.parent)) {
-                paramRefl.comment = context.getJsDocComment(param.parent);
-            }
-            context.converter.trigger(ConverterEvents.CREATE_TYPE_PARAMETER, context, paramRefl, param);
-            return paramRefl;
-        });
-    });
-}
-function getVariance(modifiers) {
-    const hasIn = modifiers?.some((mod) => mod.kind === ts.SyntaxKind.InKeyword);
-    const hasOut = modifiers?.some((mod) => mod.kind === ts.SyntaxKind.OutKeyword);
-    if (hasIn && hasOut) {
-        return VarianceModifier.inOut;
-    }
-    if (hasIn) {
-        return VarianceModifier.in;
-    }
-    if (hasOut) {
-        return VarianceModifier.out;
-    }
-}
-function convertPredicate(predicate, context) {
-    let name;
-    switch (predicate.kind) {
-        case ts.TypePredicateKind.This:
-        case ts.TypePredicateKind.AssertsThis:
-            name = "this";
-            break;
-        case ts.TypePredicateKind.Identifier:
-        case ts.TypePredicateKind.AssertsIdentifier:
-            name = predicate.parameterName;
-            break;
-    }
-    let asserts;
-    switch (predicate.kind) {
-        case ts.TypePredicateKind.This:
-        case ts.TypePredicateKind.Identifier:
-            asserts = false;
-            break;
-        case ts.TypePredicateKind.AssertsThis:
-        case ts.TypePredicateKind.AssertsIdentifier:
-            asserts = true;
-            break;
-    }
-    return new PredicateType(name, asserts, predicate.type
-        ? context.converter.convertType(context, predicate.type)
-        : void 0);
-}

package/dist/lib/converter/factories/symbol-id.js

@@ -1,50 +0,0 @@
-import { ReflectionSymbolId } from "#models";
-import { findPackageForPath, getQualifiedName, normalizePath, resolveDeclarationMaps } from "#node-utils";
-import {} from "#utils";
-import { relative } from "node:path";
-import ts from "typescript";
-let transientCount = 0;
-const transientIds = new WeakMap();
-// Don't use this directly, use Context.createSymbolId instead.
-export function createSymbolIdImpl(symbol, declaration) {
-    declaration ??= symbol.declarations?.[0];
-    const tsSource = declaration?.getSourceFile().fileName ?? "";
-    const sourceFileName = resolveDeclarationMaps(tsSource);
-    let packageName;
-    let packagePath;
-    const packageInfo = findPackageForPath(tsSource);
-    if (packageInfo) {
-        let packageDir;
-        [packageName, packageDir] = packageInfo;
-        packagePath = normalizePath(relative(packageDir, sourceFileName));
-    }
-    else {
-        packageName = ReflectionSymbolId.UNKNOWN_PACKAGE;
-        packagePath = normalizePath(sourceFileName);
-    }
-    let qualifiedName;
-    if (symbol.declarations?.some(ts.isSourceFile)) {
-        qualifiedName = "";
-    }
-    else {
-        qualifiedName = getQualifiedName(symbol, symbol.name);
-    }
-    const pos = declaration?.getStart() ?? Infinity;
-    // Transient symbols may need to be tagged as such to disambiguate between references
-    // to generic classes/interfaces/aliases. However esModuleInterop can also introduce
-    // transient symbols for modules, which we don't want to catch here.
-    let transientId = NaN;
-    if ((symbol.flags & ts.SymbolFlags.Transient) && declaration?.kind !== ts.SyntaxKind.SourceFile) {
-        transientId = transientIds.get(symbol) ?? ++transientCount;
-        transientIds.set(symbol, transientId);
-    }
-    const id = new ReflectionSymbolId({
-        packageName,
-        packagePath,
-        qualifiedName,
-    });
-    id.pos = pos;
-    id.transientId = transientId;
-    id.fileName = normalizePath(sourceFileName);
-    return id;
-}

package/dist/lib/converter/index.js

@@ -1,3 +0,0 @@
-export { Context } from "./context.js";
-export { convertDefaultValue, convertExpression } from "./convert-expression.js";
-export { Converter } from "./converter.js";

package/dist/lib/converter/jsdoc.js

@@ -1,135 +0,0 @@
-// Converter functions for JSDoc defined types
-// @typedef
-// @callback
-import { ok } from "assert";
-import ts from "typescript";
-import { DeclarationReflection, IntrinsicType, ReflectionKind, ReflectionType, SignatureReflection, } from "../models/index.js";
-import { ConverterEvents } from "./converter-events.js";
-import { convertConstructSignatures, convertParameterNodes, convertTemplateParameterNodes, createSignature, } from "./factories/signature.js";
-import { i18n } from "#utils";
-import { convertIndexSignatures } from "./factories/index-signature.js";
-// This is almost convertTypeAliasAsInterface, but unfortunately needs to be separate
-// due to type parameters being different in JSDoc comments
-function convertJsDocAliasAsInterface(context, symbol, exportSymbol, declaration) {
-    const reflection = context.createDeclarationReflection(ReflectionKind.Interface, symbol, exportSymbol);
-    context.finalizeDeclarationReflection(reflection);
-    const rc = context.withScope(reflection);
-    const type = context.checker.getTypeAtLocation(declaration);
-    if (type.getFlags() & ts.TypeFlags.Union) {
-        context.logger.warn(i18n.converting_union_as_interface(), declaration);
-    }
-    // Interfaces have properties
-    for (const prop of type.getProperties()) {
-        context.converter.convertSymbol(rc, prop);
-    }
-    // And type parameters
-    convertTemplateParameters(rc, declaration.parent);
-    // And maybe call signatures
-    context.checker
-        .getSignaturesOfType(type, ts.SignatureKind.Call)
-        .forEach((sig) => createSignature(rc, ReflectionKind.CallSignature, sig, symbol));
-    // And maybe constructor signatures
-    convertConstructSignatures(rc, symbol);
-    // And finally, index signatures
-    convertIndexSignatures(rc, type);
-}
-export function convertJsDocAlias(context, symbol, declaration, exportSymbol) {
-    if (declaration.typeExpression &&
-        ts.isJSDocTypeLiteral(declaration.typeExpression)) {
-        convertJsDocInterface(context, declaration, symbol, exportSymbol);
-        return;
-    }
-    const comment = context.getJsDocComment(declaration);
-    if (comment?.hasModifier("@interface")) {
-        return convertJsDocAliasAsInterface(context, symbol, exportSymbol, declaration);
-    }
-    // If the typedef tag is just referring to another type-space symbol, with no type parameters
-    // or appropriate forwarding type parameters, then we treat it as a re-export instead of creating
-    // a type alias with an import type.
-    const aliasedSymbol = getTypedefReExportTarget(context, declaration);
-    if (aliasedSymbol) {
-        context.converter.convertSymbol(context, aliasedSymbol, exportSymbol ?? symbol);
-        return;
-    }
-    const reflection = context.createDeclarationReflection(ReflectionKind.TypeAlias, symbol, exportSymbol);
-    reflection.comment = comment;
-    reflection.type = context.converter.convertType(context.withScope(reflection), declaration.typeExpression?.type);
-    convertTemplateParameters(context.withScope(reflection), declaration.parent);
-    context.finalizeDeclarationReflection(reflection);
-}
-export function convertJsDocCallback(context, symbol, declaration, exportSymbol) {
-    const alias = context.createDeclarationReflection(ReflectionKind.TypeAlias, symbol, exportSymbol);
-    alias.comment = context.getJsDocComment(declaration);
-    context.finalizeDeclarationReflection(alias);
-    const ac = context.withScope(alias);
-    alias.type = convertJsDocSignature(ac, declaration.typeExpression);
-    convertTemplateParameters(ac, declaration.parent);
-}
-function convertJsDocInterface(context, declaration, symbol, exportSymbol) {
-    const reflection = context.createDeclarationReflection(ReflectionKind.Interface, symbol, exportSymbol);
-    reflection.comment = context.getJsDocComment(declaration);
-    context.finalizeDeclarationReflection(reflection);
-    const rc = context.withScope(reflection);
-    const type = context.checker.getDeclaredTypeOfSymbol(symbol);
-    for (const s of type.getProperties()) {
-        context.converter.convertSymbol(rc, s);
-    }
-    convertTemplateParameters(rc, declaration.parent);
-}
-function convertJsDocSignature(context, node) {
-    const symbol = context.getSymbolAtLocation(node) ?? node.symbol;
-    const type = context.getTypeAtLocation(node);
-    if (!symbol || !type) {
-        return new IntrinsicType("Function");
-    }
-    const reflection = new DeclarationReflection("__type", ReflectionKind.TypeLiteral, context.scope);
-    const rc = context.withScope(reflection);
-    context.registerReflection(reflection, symbol);
-    context.converter.trigger(ConverterEvents.CREATE_DECLARATION, context, reflection);
-    const signature = new SignatureReflection("__type", ReflectionKind.CallSignature, reflection);
-    context.project.registerSymbolId(signature, context.createSymbolId(symbol, node));
-    context.registerReflection(signature, void 0);
-    const signatureCtx = rc.withScope(signature);
-    reflection.signatures = [signature];
-    signature.type = context.converter.convertType(signatureCtx, node.type?.typeExpression?.type);
-    signature.parameters = convertParameterNodes(signatureCtx, signature, node.parameters);
-    signature.typeParameters = convertTemplateParameterNodes(context.withScope(reflection), node.typeParameters);
-    return new ReflectionType(reflection);
-}
-function convertTemplateParameters(context, node) {
-    ok(context.scope instanceof DeclarationReflection);
-    context.scope.typeParameters = convertTemplateParameterNodes(context, node.tags?.filter(ts.isJSDocTemplateTag));
-}
-function getTypedefReExportTarget(context, declaration) {
-    const typeExpression = declaration.typeExpression;
-    if (!ts.isJSDocTypedefTag(declaration) ||
-        !typeExpression ||
-        ts.isJSDocTypeLiteral(typeExpression) ||
-        !ts.isImportTypeNode(typeExpression.type) ||
-        !typeExpression.type.qualifier ||
-        !ts.isIdentifier(typeExpression.type.qualifier)) {
-        return;
-    }
-    const targetSymbol = context.expectSymbolAtLocation(typeExpression.type.qualifier);
-    const decl = targetSymbol.declarations?.[0];
-    if (!decl ||
-        !(ts.isTypeAliasDeclaration(decl) ||
-            ts.isInterfaceDeclaration(decl) ||
-            ts.isJSDocTypedefTag(decl) ||
-            ts.isJSDocCallbackTag(decl))) {
-        return;
-    }
-    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) => !ts.isTypeReferenceNode(arg) ||
-            !ts.isIdentifier(arg.typeName) ||
-            arg.typeArguments ||
-            localParams[i]?.name.text !== arg.typeName.text)) {
-        return;
-    }
-    return targetSymbol;
-}