typedoc 0.26.11 → 0.27.0-beta.1

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

@@ -1,151 +1,119 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.discoverFileComments = discoverFileComments;
-exports.discoverNodeComment = discoverNodeComment;
-exports.discoverComment = discoverComment;
-exports.discoverSignatureComment = discoverSignatureComment;
-const typescript_1 = __importDefault(require("typescript"));
-const models_1 = require("../../models");
-const utils_1 = require("../../utils");
-const declaration_1 = require("../../utils/options/declaration");
-const paths_1 = require("../../utils/paths");
-const assert_1 = __importStar(require("assert"));
-const array_1 = require("../../utils/array");
+import ts from "typescript";
+import { ReflectionKind } from "../../models/index.js";
+import { assertNever } from "../../utils/index.js";
+import { CommentStyle } from "../../utils/options/declaration.js";
+import { nicePath } from "../../utils/paths.js";
+import { ok } from "assert";
+import { filter, firstDefined } from "../../utils/array.js";
 const variablePropertyKinds = [
-    typescript_1.default.SyntaxKind.PropertyDeclaration,
-    typescript_1.default.SyntaxKind.PropertySignature,
-    typescript_1.default.SyntaxKind.BinaryExpression,
-    typescript_1.default.SyntaxKind.PropertyAssignment,
-    typescript_1.default.SyntaxKind.ShorthandPropertyAssignment,
+    ts.SyntaxKind.PropertyDeclaration,
+    ts.SyntaxKind.PropertySignature,
+    ts.SyntaxKind.BinaryExpression,
+    ts.SyntaxKind.PropertyAssignment,
+    ts.SyntaxKind.ShorthandPropertyAssignment,
     // class X { constructor(/** Comment */ readonly z: string) }
-    typescript_1.default.SyntaxKind.Parameter,
+    ts.SyntaxKind.Parameter,
     // Variable values
-    typescript_1.default.SyntaxKind.VariableDeclaration,
-    typescript_1.default.SyntaxKind.BindingElement,
-    typescript_1.default.SyntaxKind.ExportAssignment,
-    typescript_1.default.SyntaxKind.PropertyAccessExpression,
+    ts.SyntaxKind.VariableDeclaration,
+    ts.SyntaxKind.BindingElement,
+    ts.SyntaxKind.ExportAssignment,
+    ts.SyntaxKind.PropertyAccessExpression,
 ];
 // Note: This does NOT include JSDoc syntax kinds. This is important!
 // Comments from @typedef and @callback tags are handled specially by
 // the JSDoc converter because we only want part of the comment when
 // getting them.
 const wantedKinds = {
-    [models_1.ReflectionKind.Project]: [
-        typescript_1.default.SyntaxKind.SourceFile,
-        typescript_1.default.SyntaxKind.ModuleDeclaration,
+    [ReflectionKind.Project]: [
+        ts.SyntaxKind.SourceFile,
+        ts.SyntaxKind.ModuleDeclaration,
     ],
-    [models_1.ReflectionKind.Module]: [
-        typescript_1.default.SyntaxKind.SourceFile,
-        typescript_1.default.SyntaxKind.ModuleDeclaration,
+    [ReflectionKind.Module]: [
+        ts.SyntaxKind.SourceFile,
+        ts.SyntaxKind.ModuleDeclaration,
     ],
-    [models_1.ReflectionKind.Namespace]: [
-        typescript_1.default.SyntaxKind.ModuleDeclaration,
-        typescript_1.default.SyntaxKind.SourceFile,
-        typescript_1.default.SyntaxKind.BindingElement,
-        typescript_1.default.SyntaxKind.ExportSpecifier,
-        typescript_1.default.SyntaxKind.NamespaceExport,
+    [ReflectionKind.Namespace]: [
+        ts.SyntaxKind.ModuleDeclaration,
+        ts.SyntaxKind.SourceFile,
+        ts.SyntaxKind.BindingElement,
+        ts.SyntaxKind.ExportSpecifier,
+        ts.SyntaxKind.NamespaceExport,
         // @namespace support
-        typescript_1.default.SyntaxKind.VariableDeclaration,
-        typescript_1.default.SyntaxKind.BindingElement,
-        typescript_1.default.SyntaxKind.ExportAssignment,
-        typescript_1.default.SyntaxKind.PropertyAccessExpression,
-        typescript_1.default.SyntaxKind.PropertyDeclaration,
-        typescript_1.default.SyntaxKind.PropertyAssignment,
-        typescript_1.default.SyntaxKind.ShorthandPropertyAssignment,
+        ts.SyntaxKind.VariableDeclaration,
+        ts.SyntaxKind.BindingElement,
+        ts.SyntaxKind.ExportAssignment,
+        ts.SyntaxKind.PropertyAccessExpression,
+        ts.SyntaxKind.PropertyDeclaration,
+        ts.SyntaxKind.PropertyAssignment,
+        ts.SyntaxKind.ShorthandPropertyAssignment,
     ],
-    [models_1.ReflectionKind.Enum]: [
-        typescript_1.default.SyntaxKind.EnumDeclaration,
-        typescript_1.default.SyntaxKind.VariableDeclaration,
+    [ReflectionKind.Enum]: [
+        ts.SyntaxKind.EnumDeclaration,
+        ts.SyntaxKind.VariableDeclaration,
     ],
-    [models_1.ReflectionKind.EnumMember]: [
-        typescript_1.default.SyntaxKind.EnumMember,
+    [ReflectionKind.EnumMember]: [
+        ts.SyntaxKind.EnumMember,
         // These here so that @enum gets comments
-        typescript_1.default.SyntaxKind.PropertyAssignment,
-        typescript_1.default.SyntaxKind.PropertySignature,
+        ts.SyntaxKind.PropertyAssignment,
+        ts.SyntaxKind.PropertySignature,
     ],
-    [models_1.ReflectionKind.Variable]: variablePropertyKinds,
-    [models_1.ReflectionKind.Function]: [
-        typescript_1.default.SyntaxKind.FunctionDeclaration,
-        typescript_1.default.SyntaxKind.BindingElement,
-        typescript_1.default.SyntaxKind.VariableDeclaration,
-        typescript_1.default.SyntaxKind.ExportAssignment,
-        typescript_1.default.SyntaxKind.PropertyAccessExpression,
-        typescript_1.default.SyntaxKind.PropertyDeclaration,
-        typescript_1.default.SyntaxKind.PropertyAssignment,
-        typescript_1.default.SyntaxKind.ShorthandPropertyAssignment,
+    [ReflectionKind.Variable]: variablePropertyKinds,
+    [ReflectionKind.Function]: [
+        ts.SyntaxKind.FunctionDeclaration,
+        ts.SyntaxKind.BindingElement,
+        ts.SyntaxKind.VariableDeclaration,
+        ts.SyntaxKind.ExportAssignment,
+        ts.SyntaxKind.PropertyAccessExpression,
+        ts.SyntaxKind.PropertyDeclaration,
+        ts.SyntaxKind.PropertyAssignment,
+        ts.SyntaxKind.ShorthandPropertyAssignment,
     ],
-    [models_1.ReflectionKind.Class]: [
-        typescript_1.default.SyntaxKind.ClassDeclaration,
-        typescript_1.default.SyntaxKind.BindingElement,
+    [ReflectionKind.Class]: [
+        ts.SyntaxKind.ClassDeclaration,
+        ts.SyntaxKind.BindingElement,
         // If marked with @class
-        typescript_1.default.SyntaxKind.VariableDeclaration,
-        typescript_1.default.SyntaxKind.ExportAssignment,
-        typescript_1.default.SyntaxKind.FunctionDeclaration,
+        ts.SyntaxKind.VariableDeclaration,
+        ts.SyntaxKind.ExportAssignment,
+        ts.SyntaxKind.FunctionDeclaration,
     ],
-    [models_1.ReflectionKind.Interface]: [
-        typescript_1.default.SyntaxKind.InterfaceDeclaration,
-        typescript_1.default.SyntaxKind.TypeAliasDeclaration,
+    [ReflectionKind.Interface]: [
+        ts.SyntaxKind.InterfaceDeclaration,
+        ts.SyntaxKind.TypeAliasDeclaration,
     ],
-    [models_1.ReflectionKind.Constructor]: [typescript_1.default.SyntaxKind.Constructor],
-    [models_1.ReflectionKind.Property]: variablePropertyKinds,
-    [models_1.ReflectionKind.Method]: [
-        typescript_1.default.SyntaxKind.FunctionDeclaration,
-        typescript_1.default.SyntaxKind.MethodDeclaration,
+    [ReflectionKind.Constructor]: [ts.SyntaxKind.Constructor],
+    [ReflectionKind.Property]: variablePropertyKinds,
+    [ReflectionKind.Method]: [
+        ts.SyntaxKind.FunctionDeclaration,
+        ts.SyntaxKind.MethodDeclaration,
     ],
-    [models_1.ReflectionKind.CallSignature]: [
-        typescript_1.default.SyntaxKind.FunctionDeclaration,
-        typescript_1.default.SyntaxKind.VariableDeclaration,
-        typescript_1.default.SyntaxKind.MethodDeclaration,
-        typescript_1.default.SyntaxKind.MethodDeclaration,
-        typescript_1.default.SyntaxKind.PropertyDeclaration,
-        typescript_1.default.SyntaxKind.PropertySignature,
-        typescript_1.default.SyntaxKind.CallSignature,
+    [ReflectionKind.CallSignature]: [
+        ts.SyntaxKind.FunctionDeclaration,
+        ts.SyntaxKind.VariableDeclaration,
+        ts.SyntaxKind.MethodDeclaration,
+        ts.SyntaxKind.MethodDeclaration,
+        ts.SyntaxKind.PropertyDeclaration,
+        ts.SyntaxKind.PropertySignature,
+        ts.SyntaxKind.CallSignature,
     ],
-    [models_1.ReflectionKind.IndexSignature]: [typescript_1.default.SyntaxKind.IndexSignature],
-    [models_1.ReflectionKind.ConstructorSignature]: [typescript_1.default.SyntaxKind.ConstructSignature],
-    [models_1.ReflectionKind.Parameter]: [typescript_1.default.SyntaxKind.Parameter],
-    [models_1.ReflectionKind.TypeLiteral]: [typescript_1.default.SyntaxKind.TypeLiteral],
-    [models_1.ReflectionKind.TypeParameter]: [typescript_1.default.SyntaxKind.TypeParameter],
-    [models_1.ReflectionKind.Accessor]: [typescript_1.default.SyntaxKind.PropertyDeclaration],
-    [models_1.ReflectionKind.GetSignature]: [typescript_1.default.SyntaxKind.GetAccessor],
-    [models_1.ReflectionKind.SetSignature]: [typescript_1.default.SyntaxKind.SetAccessor],
-    [models_1.ReflectionKind.TypeAlias]: [typescript_1.default.SyntaxKind.TypeAliasDeclaration],
-    [models_1.ReflectionKind.Reference]: [
-        typescript_1.default.SyntaxKind.NamespaceExport,
-        typescript_1.default.SyntaxKind.ExportSpecifier,
+    [ReflectionKind.IndexSignature]: [ts.SyntaxKind.IndexSignature],
+    [ReflectionKind.ConstructorSignature]: [ts.SyntaxKind.ConstructSignature],
+    [ReflectionKind.Parameter]: [ts.SyntaxKind.Parameter],
+    [ReflectionKind.TypeLiteral]: [ts.SyntaxKind.TypeLiteral],
+    [ReflectionKind.TypeParameter]: [ts.SyntaxKind.TypeParameter],
+    [ReflectionKind.Accessor]: [ts.SyntaxKind.PropertyDeclaration],
+    [ReflectionKind.GetSignature]: [ts.SyntaxKind.GetAccessor],
+    [ReflectionKind.SetSignature]: [ts.SyntaxKind.SetAccessor],
+    [ReflectionKind.TypeAlias]: [ts.SyntaxKind.TypeAliasDeclaration],
+    [ReflectionKind.Reference]: [
+        ts.SyntaxKind.NamespaceExport,
+        ts.SyntaxKind.ExportSpecifier,
     ],
     // Non-TS kind, will never have comments.
-    [models_1.ReflectionKind.Document]: [],
+    [ReflectionKind.Document]: [],
 };
-function discoverFileComments(node, commentStyle) {
+export function discoverFileComments(node, commentStyle) {
     const text = node.text;
-    const comments = collectCommentRanges(typescript_1.default.getLeadingCommentRanges(text, node.pos));
+    const comments = collectCommentRanges(ts.getLeadingCommentRanges(text, node.pos));
     const selectedDocComments = comments.filter((ranges) => permittedRange(text, ranges, commentStyle));
     return selectedDocComments.map((ranges) => {
         return {
@@ -156,9 +124,9 @@ function discoverFileComments(node, commentStyle) {
         };
     });
 }
-function discoverNodeComment(node, commentStyle) {
+export function discoverNodeComment(node, commentStyle) {
     const text = node.getSourceFile().text;
-    const comments = collectCommentRanges(typescript_1.default.getLeadingCommentRanges(text, node.pos));
+    const comments = collectCommentRanges(ts.getLeadingCommentRanges(text, node.pos));
     comments.reverse();
     const selectedDocComment = comments.find((ranges) => permittedRange(text, ranges, commentStyle));
     if (selectedDocComment) {
@@ -174,7 +142,7 @@ function checkCommentDeclarations(commentNodes, reverse, commentStyle) {
     const discovered = [];
     for (const { node, inheritedFromParentDeclaration } of commentNodes) {
         const text = node.getSourceFile().text;
-        const comments = collectCommentRanges(typescript_1.default.getLeadingCommentRanges(text, node.pos));
+        const comments = collectCommentRanges(ts.getLeadingCommentRanges(text, node.pos));
         if (reverse) {
             comments.reverse();
         }
@@ -190,22 +158,22 @@ function checkCommentDeclarations(commentNodes, reverse, commentStyle) {
     }
     return discovered;
 }
-function discoverComment(symbol, kind, logger, commentStyle, checker) {
+export function discoverComment(symbol, kind, logger, commentStyle, checker, declarationWarnings) {
     // For a module comment, we want the first one defined in the file,
     // not the last one, since that will apply to the import or declaration.
-    const reverse = !symbol.declarations?.some(typescript_1.default.isSourceFile);
-    const wantedDeclarations = (0, array_1.filter)(symbol.declarations, (decl) => wantedKinds[kind].includes(decl.kind));
+    const reverse = !symbol.declarations?.some(ts.isSourceFile);
+    const wantedDeclarations = filter(symbol.declarations, (decl) => wantedKinds[kind].includes(decl.kind));
     const commentNodes = wantedDeclarations.flatMap((decl) => declarationToCommentNodes(decl, checker));
     // Special behavior here!
     // Signatures and symbols have two distinct discovery methods as of TypeDoc 0.26.
     // This method discovers comments for symbols, and function-likes will only have
     // a symbol comment if there is more than one signature (== more than one declaration)
     // and there is a comment on the implementation signature.
-    if (kind & models_1.ReflectionKind.ContainsCallSignatures) {
+    if (kind & ReflectionKind.ContainsCallSignatures) {
         const canHaveOverloads = wantedDeclarations.some((node) => [
-            typescript_1.default.SyntaxKind.FunctionDeclaration,
-            typescript_1.default.SyntaxKind.MethodDeclaration,
-            typescript_1.default.SyntaxKind.Constructor,
+            ts.SyntaxKind.FunctionDeclaration,
+            ts.SyntaxKind.MethodDeclaration,
+            ts.SyntaxKind.Constructor,
         ].includes(node.kind));
         const isOverloaded = canHaveOverloads && wantedDeclarations.length > 1;
         if (isOverloaded) {
@@ -235,11 +203,13 @@ function discoverComment(symbol, kind, logger, commentStyle, checker) {
             return discovered[0];
         default: {
             if (discovered.filter((n) => !n.inheritedFromParentDeclaration)
-                .length > 1) {
+                .length > 1 &&
+                (declarationWarnings ||
+                    discovered.some((dc) => !dc.file.isDeclarationFile))) {
                 logger.warn(logger.i18n.symbol_0_has_multiple_declarations_with_comment(symbol.name));
                 const locations = discovered.map(({ file, ranges: [{ pos }] }) => {
-                    const path = (0, paths_1.nicePath)(file.fileName);
-                    const line = typescript_1.default.getLineAndCharacterOfPosition(file, pos).line +
+                    const path = nicePath(file.fileName);
+                    const line = ts.getLineAndCharacterOfPosition(file, pos).line +
                         1;
                     return `${path}:${line}`;
                 });
@@ -249,16 +219,16 @@ function discoverComment(symbol, kind, logger, commentStyle, checker) {
         }
     }
 }
-function discoverSignatureComment(declaration, checker, commentStyle) {
+export function discoverSignatureComment(declaration, checker, commentStyle) {
     for (const { node, inheritedFromParentDeclaration, } of declarationToCommentNodes(declaration, checker)) {
-        if (typescript_1.default.isJSDocSignature(node)) {
+        if (ts.isJSDocSignature(node)) {
             const comment = node.parent.parent;
-            (0, assert_1.ok)(typescript_1.default.isJSDoc(comment));
+            ok(ts.isJSDoc(comment));
             return {
                 file: node.getSourceFile(),
                 ranges: [
                     {
-                        kind: typescript_1.default.SyntaxKind.MultiLineCommentTrivia,
+                        kind: ts.SyntaxKind.MultiLineCommentTrivia,
                         pos: comment.pos,
                         end: comment.end,
                     },
@@ -268,7 +238,7 @@ function discoverSignatureComment(declaration, checker, commentStyle) {
             };
         }
         const text = node.getSourceFile().text;
-        const comments = collectCommentRanges(typescript_1.default.getLeadingCommentRanges(text, node.pos));
+        const comments = collectCommentRanges(ts.getLeadingCommentRanges(text, node.pos));
         comments.reverse();
         const comment = comments.find((ranges) => permittedRange(text, ranges, commentStyle));
         if (comment) {
@@ -282,15 +252,15 @@ function discoverSignatureComment(declaration, checker, commentStyle) {
     }
 }
 function findJsDocForComment(node, ranges) {
-    if (ranges[0].kind === typescript_1.default.SyntaxKind.MultiLineCommentTrivia) {
-        const jsDocs = typescript_1.default
+    if (ranges[0].kind === ts.SyntaxKind.MultiLineCommentTrivia) {
+        const jsDocs = ts
             .getJSDocCommentsAndTags(node)
-            .map((doc) => typescript_1.default.findAncestor(doc, typescript_1.default.isJSDoc));
-        if (typescript_1.default.isSourceFile(node)) {
+            .map((doc) => ts.findAncestor(doc, ts.isJSDoc));
+        if (ts.isSourceFile(node)) {
             if (node.statements.length) {
-                jsDocs.push(...typescript_1.default
+                jsDocs.push(...ts
                     .getJSDocCommentsAndTags(node.statements[0])
-                    .map((doc) => typescript_1.default.findAncestor(doc, typescript_1.default.isJSDoc)));
+                    .map((doc) => ts.findAncestor(doc, ts.isJSDoc)));
             }
         }
         return jsDocs.find((doc) => doc.pos === ranges[0].pos);
@@ -310,7 +280,7 @@ function findJsDocForComment(node, ranges) {
  * @return TRUE if the given node is the topmost module declaration, FALSE otherwise.
  */
 function isTopmostModuleDeclaration(node) {
-    return node.getChildren().some(typescript_1.default.isModuleBlock);
+    return node.getChildren().some(ts.isModuleBlock);
 }
 /**
  * Return the root module declaration of the given module declaration.
@@ -323,7 +293,7 @@ function isTopmostModuleDeclaration(node) {
  * ```
  */
 function getRootModuleDeclaration(node) {
-    while (node.parent.kind === typescript_1.default.SyntaxKind.ModuleDeclaration) {
+    while (node.parent.kind === ts.SyntaxKind.ModuleDeclaration) {
         const parent = node.parent;
         if (node.name.pos === parent.name.end + 1) {
             node = parent;
@@ -340,17 +310,17 @@ function declarationToCommentNodeIgnoringParents(node) {
         return node;
     // function foo(x: number)
     //              ^^^^^^^^^
-    if (node.kind === typescript_1.default.SyntaxKind.Parameter) {
+    if (node.kind === ts.SyntaxKind.Parameter) {
         return node;
     }
     // const abc = 123
     //       ^^^
-    if (node.parent.kind === typescript_1.default.SyntaxKind.VariableDeclarationList) {
+    if (node.parent.kind === ts.SyntaxKind.VariableDeclarationList) {
         return node.parent.parent;
     }
     // const a = () => {}
     //           ^^^^^^^^
-    if (node.parent.kind === typescript_1.default.SyntaxKind.VariableDeclaration) {
+    if (node.parent.kind === ts.SyntaxKind.VariableDeclaration) {
         return node.parent.parent.parent;
     }
     // class X { y = () => {} }
@@ -361,13 +331,13 @@ function declarationToCommentNodeIgnoringParents(node) {
     // export default () => {}
     //                ^^^^^^^^
     if ([
-        typescript_1.default.SyntaxKind.PropertyDeclaration,
-        typescript_1.default.SyntaxKind.BinaryExpression,
-        typescript_1.default.SyntaxKind.ExportAssignment,
+        ts.SyntaxKind.PropertyDeclaration,
+        ts.SyntaxKind.BinaryExpression,
+        ts.SyntaxKind.ExportAssignment,
     ].includes(node.parent.kind)) {
         return node.parent;
     }
-    if (typescript_1.default.isModuleDeclaration(node)) {
+    if (ts.isModuleDeclaration(node)) {
         if (!isTopmostModuleDeclaration(node)) {
             return;
         }
@@ -375,10 +345,10 @@ function declarationToCommentNodeIgnoringParents(node) {
             return getRootModuleDeclaration(node);
         }
     }
-    if (node.kind === typescript_1.default.SyntaxKind.ExportSpecifier) {
+    if (node.kind === ts.SyntaxKind.ExportSpecifier) {
         return node.parent.parent;
     }
-    if (typescript_1.default.SyntaxKind.NamespaceExport === node.kind) {
+    if (ts.SyntaxKind.NamespaceExport === node.kind) {
         return node.parent;
     }
 }
@@ -399,13 +369,13 @@ function declarationToCommentNodes(node, checker) {
         },
     ];
     let overloadIndex = undefined;
-    if (typescript_1.default.isMethodDeclaration(node)) {
+    if (ts.isMethodDeclaration(node)) {
         const symbol = checker.getSymbolAtLocation(node.name || node);
         if (symbol) {
             overloadIndex = symbol.declarations
                 ?.filter((d) => d.kind === node.kind)
                 .indexOf(node);
-            (0, assert_1.default)(overloadIndex !== -1, "Should always find declaration");
+            ok(overloadIndex !== -1, "Should always find declaration");
         }
     }
     const seenSymbols = new Set();
@@ -430,17 +400,29 @@ function declarationToCommentNodes(node, checker) {
             inheritedFromParentDeclaration: true,
         });
     }
+    // With overloaded functions/methods, TypeScript will use the comment on the first signature
+    // declaration
+    if ((ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node)) &&
+        node.name) {
+        const symbol = checker.getSymbolAtLocation(node.name);
+        if (symbol && symbol.declarations[0] !== node) {
+            result.push({
+                node: symbol.declarations[0],
+                inheritedFromParentDeclaration: true,
+            });
+        }
+    }
     return result;
 }
 // Lifted from the TS source, with a couple minor modifications
 function findBaseOfDeclaration(checker, declaration, cb) {
-    const classOrInterfaceDeclaration = declaration.parent?.kind === typescript_1.default.SyntaxKind.Constructor
+    const classOrInterfaceDeclaration = declaration.parent?.kind === ts.SyntaxKind.Constructor
         ? declaration.parent.parent
         : declaration.parent;
     if (!classOrInterfaceDeclaration)
         return;
-    const isStaticMember = typescript_1.default.getCombinedModifierFlags(declaration) & typescript_1.default.ModifierFlags.Static;
-    return (0, array_1.firstDefined)(typescript_1.default.getAllSuperTypeNodes(classOrInterfaceDeclaration), (superTypeNode) => {
+    const isStaticMember = ts.getCombinedModifierFlags(declaration) & ts.ModifierFlags.Static;
+    return firstDefined(ts.getAllSuperTypeNodes(classOrInterfaceDeclaration), (superTypeNode) => {
         const baseType = checker.getTypeAtLocation(superTypeNode);
         const type = isStaticMember && baseType.symbol
             ? checker.getTypeOfSymbol(baseType.symbol)
@@ -459,19 +441,19 @@ function collectCommentRanges(ranges) {
     for (const range of ranges || []) {
         collect.push(range);
         switch (range.kind) {
-            case typescript_1.default.SyntaxKind.MultiLineCommentTrivia:
+            case ts.SyntaxKind.MultiLineCommentTrivia:
                 if (collect.length) {
                     result.push(collect);
                     collect = [];
                 }
                 result.push([range]);
                 break;
-            case typescript_1.default.SyntaxKind.SingleLineCommentTrivia:
+            case ts.SyntaxKind.SingleLineCommentTrivia:
                 collect.push(range);
                 break;
             /* istanbul ignore next */
             default:
-                (0, utils_1.assertNever)(range.kind);
+                assertNever(range.kind);
         }
     }
     if (collect.length) {
@@ -481,14 +463,14 @@ function collectCommentRanges(ranges) {
 }
 function permittedRange(text, ranges, commentStyle) {
     switch (commentStyle) {
-        case declaration_1.CommentStyle.All:
+        case CommentStyle.All:
             return true;
-        case declaration_1.CommentStyle.Block:
-            return ranges[0].kind === typescript_1.default.SyntaxKind.MultiLineCommentTrivia;
-        case declaration_1.CommentStyle.Line:
-            return ranges[0].kind === typescript_1.default.SyntaxKind.SingleLineCommentTrivia;
-        case declaration_1.CommentStyle.JSDoc:
-            return (ranges[0].kind === typescript_1.default.SyntaxKind.MultiLineCommentTrivia &&
+        case CommentStyle.Block:
+            return ranges[0].kind === ts.SyntaxKind.MultiLineCommentTrivia;
+        case CommentStyle.Line:
+            return ranges[0].kind === ts.SyntaxKind.SingleLineCommentTrivia;
+        case CommentStyle.JSDoc:
+            return (ranges[0].kind === ts.SyntaxKind.MultiLineCommentTrivia &&
                 text[ranges[0].pos] === "/" &&
                 text[ranges[0].pos + 1] === "*" &&
                 text[ranges[0].pos + 2] === "*");

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

@@ -1,8 +1,8 @@
 import ts from "typescript";
-import { Comment, ReflectionKind } from "../../models";
-import { type Logger } from "../../utils";
-import type { CommentStyle, JsDocCompatibility } from "../../utils/options/declaration";
-import type { FileRegistry } from "../../models/FileRegistry";
+import { Comment, ReflectionKind } from "../../models/index.js";
+import { type Logger } from "../../utils/index.js";
+import type { CommentStyle, JsDocCompatibility } from "../../utils/options/declaration.js";
+import type { FileRegistry } from "../../models/FileRegistry.js";
 export interface CommentParserConfig {
     blockTags: Set<string>;
     inlineTags: Set<string>;