typedoc 0.23.24 → 0.23.26

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

@@ -1,13 +1,16 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolvePartLinks = exports.resolveLinks = void 0;
-const ts = require("typescript");
+const typescript_1 = __importDefault(require("typescript"));
 const models_1 = require("../../models");
 const declarationReference_1 = require("./declarationReference");
 const declarationReferenceResolver_1 = require("./declarationReferenceResolver");
 const urlPrefix = /^(http|ftp)s?:\/\//;
 const brackets = /\[\[(?!include:)([^\]]+)\]\]/g;
-function resolveLinks(comment, reflection, validation, logger, attemptExternalResolve) {
+function resolveLinks(comment, reflection, validation, logger, externalResolver) {
     let warned = false;
     const warn = () => {
         if (!warned) {
@@ -15,20 +18,20 @@ function resolveLinks(comment, reflection, validation, logger, attemptExternalRe
             logger.warn(`${reflection.getFriendlyFullName()}: Comment [[target]] style links are deprecated and will be removed in 0.24`);
         }
     };
-    comment.summary = resolvePartLinks(reflection, comment.summary, warn, validation, logger, attemptExternalResolve);
+    comment.summary = resolvePartLinks(reflection, comment.summary, warn, validation, logger, externalResolver);
     for (const tag of comment.blockTags) {
-        tag.content = resolvePartLinks(reflection, tag.content, warn, validation, logger, attemptExternalResolve);
+        tag.content = resolvePartLinks(reflection, tag.content, warn, validation, logger, externalResolver);
     }
     if (reflection instanceof models_1.DeclarationReflection && reflection.readme) {
-        reflection.readme = resolvePartLinks(reflection, reflection.readme, warn, validation, logger, attemptExternalResolve);
+        reflection.readme = resolvePartLinks(reflection, reflection.readme, warn, validation, logger, externalResolver);
     }
 }
 exports.resolveLinks = resolveLinks;
-function resolvePartLinks(reflection, parts, warn, validation, logger, attemptExternalResolve) {
-    return parts.flatMap((part) => processPart(reflection, part, warn, validation, logger, attemptExternalResolve));
+function resolvePartLinks(reflection, parts, warn, validation, logger, externalResolver) {
+    return parts.flatMap((part) => processPart(reflection, part, warn, validation, logger, externalResolver));
 }
 exports.resolvePartLinks = resolvePartLinks;
-function processPart(reflection, part, warn, validation, logger, attemptExternalResolve) {
+function processPart(reflection, part, warn, validation, logger, externalResolver) {
     if (part.kind === "text" && brackets.test(part.text)) {
         warn();
         return replaceBrackets(reflection, part.text, validation, logger);
@@ -37,7 +40,7 @@ function processPart(reflection, part, warn, validation, logger, attemptExternal
         if (part.tag === "@link" ||
             part.tag === "@linkcode" ||
             part.tag === "@linkplain") {
-            return resolveLinkTag(reflection, part, attemptExternalResolve, (msg) => {
+            return resolveLinkTag(reflection, part, externalResolver, (msg) => {
                 if (validation.invalidLink) {
                     logger.warn(msg);
                 }
@@ -46,17 +49,17 @@ function processPart(reflection, part, warn, validation, logger, attemptExternal
     }
     return part;
 }
-function resolveLinkTag(reflection, part, attemptExternalResolve, warn) {
+function resolveLinkTag(reflection, part, externalResolver, warn) {
     let pos = 0;
     const end = part.text.length;
-    while (pos < end && ts.isWhiteSpaceLike(part.text.charCodeAt(pos))) {
+    while (pos < end && typescript_1.default.isWhiteSpaceLike(part.text.charCodeAt(pos))) {
         pos++;
     }
     const origText = part.text;
     // Try to parse one
     const declRef = (0, declarationReference_1.parseDeclarationReference)(part.text, pos, end);
     let target;
-    let defaultDisplayText;
+    let defaultDisplayText = "";
     if (declRef) {
         // Got one, great! Try to resolve the link
         target = (0, declarationReferenceResolver_1.resolveDeclarationReference)(reflection, declRef[0]);
@@ -66,9 +69,16 @@ function resolveLinkTag(reflection, part, attemptExternalResolve, warn) {
         }
         else {
             // If we didn't find a link, it might be a @link tag to an external symbol, check that next.
-            target = attemptExternalResolve(declRef[0]);
-            if (target) {
-                defaultDisplayText = part.text.substring(0, pos);
+            const externalResolveResult = externalResolver(declRef[0], reflection, part);
+            defaultDisplayText = part.text.substring(0, pos);
+            switch (typeof externalResolveResult) {
+                case "string":
+                    target = externalResolveResult;
+                    break;
+                case "object":
+                    target = externalResolveResult.target;
+                    defaultDisplayText =
+                        externalResolveResult.caption || defaultDisplayText;
             }
         }
     }
@@ -92,14 +102,15 @@ function resolveLinkTag(reflection, part, attemptExternalResolve, warn) {
     }
     // Remaining text after an optional pipe is the link text, so advance
     // until that's consumed.
-    while (pos < end && ts.isWhiteSpaceLike(part.text.charCodeAt(pos))) {
+    while (pos < end && typescript_1.default.isWhiteSpaceLike(part.text.charCodeAt(pos))) {
         pos++;
     }
     if (pos < end && part.text[pos] === "|") {
         pos++;
     }
     part.target = target;
-    part.text = part.text.substring(pos).trim() || defaultDisplayText;
+    part.text =
+        part.text.substring(pos).trim() || defaultDisplayText || part.text;
     return part;
 }
 function legacyResolveLinkTag(reflection, part) {

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

@@ -1,4 +1,4 @@
-import * as ts from "typescript";
+import ts from "typescript";
 import { Reflection, ProjectReflection, DeclarationReflection, ReflectionKind } from "../models/index";
 import type { Converter } from "./converter";
 /**
@@ -46,7 +46,7 @@ export declare class Context {
      */
     constructor(converter: Converter, programs: readonly ts.Program[], project: ProjectReflection, scope?: Context["scope"]);
     /** @internal */
-    get logger(): import("../utils").Logger;
+    get logger(): import("../utils/loggers").Logger;
     /**
      * Return the compiler options.
      */

package/dist/lib/converter/context.js

@@ -1,8 +1,11 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Context = void 0;
 const assert_1 = require("assert");
-const ts = require("typescript");
+const typescript_1 = __importDefault(require("typescript"));
 const index_1 = require("../models/index");
 const nodes_1 = require("./utils/nodes");
 const converter_events_1 = require("./converter-events");
@@ -96,8 +99,8 @@ class Context {
     expectSymbolAtLocation(node) {
         const symbol = this.getSymbolAtLocation(node);
         if (!symbol) {
-            const { line } = ts.getLineAndCharacterOfPosition(node.getSourceFile(), node.pos);
-            throw new Error(`Expected a symbol for node with kind ${ts.SyntaxKind[node.kind]} at ${node.getSourceFile().fileName}:${line + 1}`);
+            const { line } = typescript_1.default.getLineAndCharacterOfPosition(node.getSourceFile(), node.pos);
+            throw new Error(`Expected a symbol for node with kind ${typescript_1.default.SyntaxKind[node.kind]} at ${node.getSourceFile().fileName}:${line + 1}`);
         }
         return symbol;
     }

package/dist/lib/converter/convert-expression.d.ts

@@ -1,4 +1,4 @@
-import * as ts from "typescript";
+import ts from "typescript";
 /**
  * Return the default value of the given node.
  *

package/dist/lib/converter/convert-expression.js

@@ -1,7 +1,10 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertExpression = exports.convertDefaultValue = void 0;
-const ts = require("typescript");
+const typescript_1 = __importDefault(require("typescript"));
 /**
  * Return the default value of the given node.
  *
@@ -20,32 +23,32 @@ function convertDefaultValue(node) {
 exports.convertDefaultValue = convertDefaultValue;
 function convertExpression(expression) {
     switch (expression.kind) {
-        case ts.SyntaxKind.StringLiteral:
-        case ts.SyntaxKind.TrueKeyword:
-        case ts.SyntaxKind.FalseKeyword:
-        case ts.SyntaxKind.NullKeyword:
-        case ts.SyntaxKind.NumericLiteral:
-        case ts.SyntaxKind.PrefixUnaryExpression:
-        case ts.SyntaxKind.Identifier:
+        case typescript_1.default.SyntaxKind.StringLiteral:
+        case typescript_1.default.SyntaxKind.TrueKeyword:
+        case typescript_1.default.SyntaxKind.FalseKeyword:
+        case typescript_1.default.SyntaxKind.NullKeyword:
+        case typescript_1.default.SyntaxKind.NumericLiteral:
+        case typescript_1.default.SyntaxKind.PrefixUnaryExpression:
+        case typescript_1.default.SyntaxKind.Identifier:
             return expression.getText();
     }
-    if (ts.isArrayLiteralExpression(expression) &&
+    if (typescript_1.default.isArrayLiteralExpression(expression) &&
         expression.elements.length === 0) {
         return "[]";
     }
-    if (ts.isObjectLiteralExpression(expression) &&
+    if (typescript_1.default.isObjectLiteralExpression(expression) &&
         expression.properties.length === 0) {
         return "{}";
     }
     // a.b.c.d
-    if (ts.isPropertyAccessExpression(expression)) {
+    if (typescript_1.default.isPropertyAccessExpression(expression)) {
         const parts = [expression.name.getText()];
         let iter = expression.expression;
-        while (ts.isPropertyAccessExpression(iter)) {
+        while (typescript_1.default.isPropertyAccessExpression(iter)) {
             parts.unshift(iter.name.getText());
             iter = iter.expression;
         }
-        if (ts.isIdentifier(iter)) {
+        if (typescript_1.default.isIdentifier(iter)) {
             parts.unshift(iter.text);
             return parts.join(".");
         }

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

@@ -1,4 +1,4 @@
-import * as ts from "typescript";
+import ts from "typescript";
 import type { Application } from "../application";
 import { Comment, CommentDisplayPart, ProjectReflection, Reflection, SomeType } from "../models/index";
 import { Context } from "./context";
@@ -8,6 +8,7 @@ import { MinimalSourceFile } from "../utils";
 import type { DocumentationEntryPoint } from "../utils/entry-point";
 import { CommentParserConfig } from "./comments";
 import type { CommentStyle, ValidationOptions } from "../utils/options/declaration";
+import { ExternalSymbolResolver, ExternalResolveResult } from "./comments/linkResolver";
 import type { DeclarationReference } from "./comments/declarationReference";
 /**
  * Compiles source files using TypeScript and converts compiler symbols to reflections.
@@ -128,12 +129,13 @@ export declare class Converter extends ChildableComponent<Application, Converter
      *
      * Note: This will be used for both references to types declared in node_modules (in which case the
      * reference passed will have the `moduleSource` set and the `symbolReference` will navigate via `.`)
-     * and user defined \{\@link\} tags which cannot be resolved.
+     * and user defined \{\@link\} tags which cannot be resolved. If the link being resolved is inferred
+     * from a type, then no `part` will be passed to the resolver function.
      * @since 0.22.14
      */
-    addUnknownSymbolResolver(resolver: (ref: DeclarationReference) => string | undefined): void;
+    addUnknownSymbolResolver(resolver: ExternalSymbolResolver): void;
     /** @internal */
-    resolveExternalLink(ref: DeclarationReference): string | undefined;
+    resolveExternalLink(ref: DeclarationReference, refl: Reflection, part?: CommentDisplayPart): ExternalResolveResult | string | undefined;
     resolveLinks(comment: Comment, owner: Reflection): void;
     resolveLinks(parts: readonly CommentDisplayPart[], owner: Reflection): CommentDisplayPart[];
     /**

package/dist/lib/converter/converter.js

@@ -5,10 +5,13 @@ 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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 var Converter_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Converter = void 0;
-const ts = require("typescript");
+const typescript_1 = __importDefault(require("typescript"));
 const index_1 = require("../models/index");
 const context_1 = require("./context");
 const components_1 = require("./components");
@@ -104,23 +107,24 @@ let Converter = Converter_1 = class Converter extends component_1.ChildableCompo
      *
      * Note: This will be used for both references to types declared in node_modules (in which case the
      * reference passed will have the `moduleSource` set and the `symbolReference` will navigate via `.`)
-     * and user defined \{\@link\} tags which cannot be resolved.
+     * and user defined \{\@link\} tags which cannot be resolved. If the link being resolved is inferred
+     * from a type, then no `part` will be passed to the resolver function.
      * @since 0.22.14
      */
     addUnknownSymbolResolver(resolver) {
         this._externalSymbolResolvers.push(resolver);
     }
     /** @internal */
-    resolveExternalLink(ref) {
+    resolveExternalLink(ref, refl, part) {
         for (const resolver of this._externalSymbolResolvers) {
-            const resolved = resolver(ref);
+            const resolved = resolver(ref, refl, part);
             if (resolved)
                 return resolved;
         }
     }
     resolveLinks(comment, owner) {
         if (comment instanceof index_1.Comment) {
-            (0, linkResolver_1.resolveLinks)(comment, owner, this.validation, this.owner.logger, (ref) => this.resolveExternalLink(ref));
+            (0, linkResolver_1.resolveLinks)(comment, owner, this.validation, this.owner.logger, (ref, part, refl) => this.resolveExternalLink(ref, part, refl));
         }
         else {
             let warned = false;
@@ -130,7 +134,7 @@ let Converter = Converter_1 = class Converter extends component_1.ChildableCompo
                     this.application.logger.warn(`${owner.name}: Comment [[target]] style links are deprecated and will be removed in 0.24`);
                 }
             };
-            return (0, linkResolver_1.resolvePartLinks)(owner, comment, warn, this.validation, this.owner.logger, (ref) => this.resolveExternalLink(ref));
+            return (0, linkResolver_1.resolvePartLinks)(owner, comment, warn, this.validation, this.owner.logger, (ref, part, refl) => this.resolveExternalLink(ref, part, refl));
         }
     }
     /**
@@ -356,15 +360,15 @@ function getSymbolForModuleLike(context, node) {
     // "globals" file, but this is uncommon enough that I'm skipping it for now.
     const sourceFile = node.getSourceFile();
     const globalSymbols = context.checker
-        .getSymbolsInScope(node, ts.SymbolFlags.ModuleMember)
+        .getSymbolsInScope(node, typescript_1.default.SymbolFlags.ModuleMember)
         .filter((s) => s.getDeclarations()?.some((d) => d.getSourceFile() === sourceFile));
     // Detect declaration files with declare module "foo" as their only export
     // and lift that up one level as the source file symbol
     if (globalSymbols.length === 1 &&
         globalSymbols[0]
             .getDeclarations()
-            ?.every((declaration) => ts.isModuleDeclaration(declaration) &&
-            ts.isStringLiteral(declaration.name))) {
+            ?.every((declaration) => typescript_1.default.isModuleDeclaration(declaration) &&
+            typescript_1.default.isStringLiteral(declaration.name))) {
         return globalSymbols[0];
     }
 }
@@ -379,15 +383,15 @@ function getExports(context, node, symbol) {
         // members of the export= class and as functions if a class is directly exported.
         result = [exportEq].concat(context.checker
             .getExportsOfModule(symbol)
-            .filter((s) => !(0, enum_1.hasAnyFlag)(s.flags, ts.SymbolFlags.Prototype | ts.SymbolFlags.Value)));
+            .filter((s) => !(0, enum_1.hasAnyFlag)(s.flags, typescript_1.default.SymbolFlags.Prototype | typescript_1.default.SymbolFlags.Value)));
     }
     else if (symbol) {
         result = context.checker
             .getExportsOfModule(symbol)
-            .filter((s) => !(0, enum_1.hasAllFlags)(s.flags, ts.SymbolFlags.Prototype));
+            .filter((s) => !(0, enum_1.hasAllFlags)(s.flags, typescript_1.default.SymbolFlags.Prototype));
         if (result.length === 0) {
-            const globalDecl = node.statements.find((s) => ts.isModuleDeclaration(s) &&
-                s.flags & ts.NodeFlags.GlobalAugmentation);
+            const globalDecl = node.statements.find((s) => typescript_1.default.isModuleDeclaration(s) &&
+                s.flags & typescript_1.default.NodeFlags.GlobalAugmentation);
             if (globalDecl) {
                 const globalSymbol = context.getSymbolAtLocation(globalDecl);
                 if (globalSymbol) {
@@ -402,7 +406,7 @@ function getExports(context, node, symbol) {
         // Global file with no inferred top level symbol, get all symbols declared in this file.
         const sourceFile = node.getSourceFile();
         result = context.checker
-            .getSymbolsInScope(node, ts.SymbolFlags.ModuleMember)
+            .getSymbolsInScope(node, typescript_1.default.SymbolFlags.ModuleMember)
             .filter((s) => s
             .getDeclarations()
             ?.some((d) => d.getSourceFile() === sourceFile));

package/dist/lib/converter/factories/index-signature.d.ts

@@ -1,3 +1,3 @@
-import * as ts from "typescript";
+import ts from "typescript";
 import type { Context } from "../context";
 export declare function convertIndexSignature(context: Context, symbol: ts.Symbol): void;

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

@@ -1,21 +1,24 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertIndexSignature = void 0;
-const assert = require("assert");
-const ts = require("typescript");
+const assert_1 = __importDefault(require("assert"));
+const typescript_1 = __importDefault(require("typescript"));
 const models_1 = require("../../models");
 const converter_events_1 = require("../converter-events");
 function convertIndexSignature(context, symbol) {
-    assert(context.scope instanceof models_1.DeclarationReflection);
+    (0, assert_1.default)(context.scope instanceof models_1.DeclarationReflection);
     const indexSymbol = symbol.members?.get("__index");
     if (indexSymbol) {
         // Right now TypeDoc models don't have a way to distinguish between string
         // and number index signatures... { [x: string]: 1 | 2; [x: number]: 2 }
         // will be misrepresented.
         const indexDeclaration = indexSymbol.getDeclarations()?.[0];
-        assert(indexDeclaration && ts.isIndexSignatureDeclaration(indexDeclaration));
+        (0, assert_1.default)(indexDeclaration && typescript_1.default.isIndexSignatureDeclaration(indexDeclaration));
         const param = indexDeclaration.parameters[0];
-        assert(param && ts.isParameter(param));
+        (0, assert_1.default)(param && typescript_1.default.isParameter(param));
         const index = new models_1.SignatureReflection("__index", models_1.ReflectionKind.IndexSignature, context.scope);
         index.parameters = [
             new models_1.ParameterReflection(param.name.getText(), models_1.ReflectionKind.Parameter, index),

package/dist/lib/converter/factories/signature.d.ts

@@ -1,4 +1,4 @@
-import * as ts from "typescript";
+import ts from "typescript";
 import { ParameterReflection, ReflectionKind, SignatureReflection, TypeParameterReflection } from "../../models";
 import type { Context } from "../context";
 export declare function createSignature(context: Context, kind: ReflectionKind.CallSignature | ReflectionKind.ConstructorSignature | ReflectionKind.GetSignature | ReflectionKind.SetSignature, signature: ts.Signature, declaration?: ts.SignatureDeclaration | ts.JSDocSignature): void;

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

@@ -1,8 +1,11 @@
 "use strict";
+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 ts = require("typescript");
-const assert = require("assert");
+const typescript_1 = __importDefault(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");
@@ -10,7 +13,7 @@ const reflections_1 = require("../utils/reflections");
 const comments_1 = require("../comments");
 function createSignature(context, kind, signature, declaration) {
     var _a;
-    assert(context.scope instanceof models_1.DeclarationReflection);
+    (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}`
@@ -42,7 +45,7 @@ function createSignature(context, kind, signature, declaration) {
         sigRef.type = new models_1.IntrinsicType("void");
     }
     else {
-        sigRef.type = context.converter.convertType(context.withScope(sigRef), (declaration?.kind === ts.SyntaxKind.FunctionDeclaration &&
+        sigRef.type = context.converter.convertType(context.withScope(sigRef), (declaration?.kind === typescript_1.default.SyntaxKind.FunctionDeclaration &&
             declaration.type) ||
             signature.getReturnType());
     }
@@ -66,11 +69,11 @@ exports.createSignature = createSignature;
 function convertParameters(context, sigRef, parameters, parameterNodes) {
     return parameters.map((param, i) => {
         const declaration = param.valueDeclaration;
-        assert(!declaration ||
-            ts.isParameter(declaration) ||
-            ts.isJSDocParameterTag(declaration));
+        (0, assert_1.default)(!declaration ||
+            typescript_1.default.isParameter(declaration) ||
+            typescript_1.default.isJSDocParameterTag(declaration));
         const paramRefl = new models_1.ParameterReflection(/__\d+/.test(param.name) ? "__namedParameters" : param.name, models_1.ReflectionKind.Parameter, sigRef);
-        if (declaration && ts.isJSDocParameterTag(declaration)) {
+        if (declaration && typescript_1.default.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));
@@ -86,9 +89,9 @@ function convertParameters(context, sigRef, parameters, parameterNodes) {
         paramRefl.type = context.converter.convertType(context.withScope(paramRefl), type);
         let isOptional = false;
         if (declaration) {
-            isOptional = ts.isParameter(declaration)
+            isOptional = typescript_1.default.isParameter(declaration)
                 ? !!declaration.questionToken ||
-                    ts
+                    typescript_1.default
                         .getJSDocParameterTags(declaration)
                         .some((tag) => tag.isBracketed)
                 : declaration.isBracketed;
@@ -102,10 +105,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 = ts.isParameter(declaration)
+            isRest = typescript_1.default.isParameter(declaration)
                 ? !!declaration.dotDotDotToken
                 : !!declaration.typeExpression &&
-                    ts.isJSDocVariadicType(declaration.typeExpression.type);
+                    typescript_1.default.isJSDocVariadicType(declaration.typeExpression.type);
         }
         paramRefl.setFlag(models_1.ReflectionFlag.Rest, isRest);
         return paramRefl;
@@ -116,13 +119,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 (ts.isJSDocParameterTag(param)) {
+        if (typescript_1.default.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), ts.isParameter(param) ? param.type : param.typeExpression?.type);
-        const isOptional = ts.isParameter(param)
+        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)
             ? !!param.questionToken
             : param.isBracketed;
         if (isOptional) {
@@ -130,10 +133,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, ts.isParameter(param)
+        paramRefl.setFlag(models_1.ReflectionFlag.Rest, typescript_1.default.isParameter(param)
             ? !!param.dotDotDotToken
             : !!param.typeExpression &&
-                ts.isJSDocVariadicType(param.typeExpression.type));
+                typescript_1.default.isJSDocVariadicType(param.typeExpression.type));
         return paramRefl;
     });
 }
@@ -150,7 +153,7 @@ function convertTypeParameters(context, parent, parameters) {
             : 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(ts.isTypeParameterDeclaration)
+        const variance = getVariance(param.getSymbol()?.declarations?.find(typescript_1.default.isTypeParameterDeclaration)
             ?.modifiers);
         const paramRefl = new models_1.TypeParameterReflection(param.symbol.name, constraint, defaultType, parent, variance);
         context.registerReflection(paramRefl, param.getSymbol());
@@ -171,7 +174,7 @@ function createTypeParamReflection(param, context) {
         : void 0;
     const paramRefl = new models_1.TypeParameterReflection(param.name.text, constraint, defaultType, context.scope, getVariance(param.modifiers));
     context.registerReflection(paramRefl, param.symbol);
-    if (ts.isJSDocTemplateTag(param.parent)) {
+    if (typescript_1.default.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);
@@ -179,8 +182,8 @@ function createTypeParamReflection(param, context) {
 }
 exports.createTypeParamReflection = createTypeParamReflection;
 function getVariance(modifiers) {
-    const hasIn = modifiers?.some((mod) => mod.kind === ts.SyntaxKind.InKeyword);
-    const hasOut = modifiers?.some((mod) => mod.kind === ts.SyntaxKind.OutKeyword);
+    const hasIn = modifiers?.some((mod) => mod.kind === typescript_1.default.SyntaxKind.InKeyword);
+    const hasOut = modifiers?.some((mod) => mod.kind === typescript_1.default.SyntaxKind.OutKeyword);
     if (hasIn && hasOut) {
         return models_1.VarianceModifier.inOut;
     }
@@ -194,23 +197,23 @@ function getVariance(modifiers) {
 function convertPredicate(predicate, context) {
     let name;
     switch (predicate.kind) {
-        case ts.TypePredicateKind.This:
-        case ts.TypePredicateKind.AssertsThis:
+        case typescript_1.default.TypePredicateKind.This:
+        case typescript_1.default.TypePredicateKind.AssertsThis:
             name = "this";
             break;
-        case ts.TypePredicateKind.Identifier:
-        case ts.TypePredicateKind.AssertsIdentifier:
+        case typescript_1.default.TypePredicateKind.Identifier:
+        case typescript_1.default.TypePredicateKind.AssertsIdentifier:
             name = predicate.parameterName;
             break;
     }
     let asserts;
     switch (predicate.kind) {
-        case ts.TypePredicateKind.This:
-        case ts.TypePredicateKind.Identifier:
+        case typescript_1.default.TypePredicateKind.This:
+        case typescript_1.default.TypePredicateKind.Identifier:
             asserts = false;
             break;
-        case ts.TypePredicateKind.AssertsThis:
-        case ts.TypePredicateKind.AssertsIdentifier:
+        case typescript_1.default.TypePredicateKind.AssertsThis:
+        case typescript_1.default.TypePredicateKind.AssertsIdentifier:
             asserts = true;
             break;
     }

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

@@ -3,4 +3,5 @@ export { Converter } from "./converter";
 export type { CommentParserConfig } from "./comments/index";
 export { convertDefaultValue, convertExpression } from "./convert-expression";
 export type { DeclarationReference, SymbolReference, ComponentPath, Meaning, MeaningKeyword, } from "./comments/declarationReference";
+export type { ExternalSymbolResolver, ExternalResolveResult, } from "./comments/linkResolver";
 import "./plugins/index";

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

@@ -1,4 +1,4 @@
-import * as ts from "typescript";
+import 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;