typedoc 0.27.4 → 0.27.6

package/README.md

@@ -2,9 +2,6 @@
 
 Documentation generator for TypeScript projects.
 
-[![CI](https://github.com/TypeStrong/typedoc/workflows/CI/badge.svg)](https://github.com/TypeStrong/typedoc/actions)
-[![NPM Version](https://img.shields.io/npm/v/typedoc?color=33cd56&logo=npm)](https://www.npmjs.com/package/typedoc)
-
 ## Documentation
 
 For more detailed documentation, the changelog, and TypeDoc documentation rendered with TypeDoc, see https://typedoc.org.

package/dist/index.d.ts

@@ -1,5 +1,10 @@
 /**
  * @module TypeDoc API
+ *
+ * In addition to the members documented here, TypeDoc exports a `typedoc/debug`
+ * entry point which exports some functions which may be useful during plugin
+ * development or debugging. Exports from that entry point are **not stable**
+ * and may change or be removed at any time.
  */
 export { Application, type ApplicationEvents } from "./lib/application.js";
 export { EventDispatcher } from "./lib/utils/events.js";

package/dist/index.js

@@ -1,5 +1,10 @@
 /**
  * @module TypeDoc API
+ *
+ * In addition to the members documented here, TypeDoc exports a `typedoc/debug`
+ * entry point which exports some functions which may be useful during plugin
+ * development or debugging. Exports from that entry point are **not stable**
+ * and may change or be removed at any time.
  */
 export { Application } from "./lib/application.js";
 export { EventDispatcher } from "./lib/utils/events.js";

package/dist/lib/application.js

@@ -317,9 +317,6 @@ let Application = (() => {
          */
         async convert() {
             const start = Date.now();
-            // We freeze here rather than in the Converter class since TypeDoc's tests reuse the Application
-            // with a few different settings.
-            this.options.freeze();
             this.logger.verbose(`Using TypeScript ${this.getTypeScriptVersion()} from ${this.getTypeScriptPath()}`);
             if (this.entryPointStrategy === EntryPointStrategy.Merge) {
                 return this._merge();
@@ -356,7 +353,6 @@ let Application = (() => {
             return project;
         }
         convertAndWatch(success) {
-            this.options.freeze();
             if (!this.options.getValue("preserveWatchOutput") &&
                 this.logger instanceof ConsoleLogger) {
                 ts.sys.clearScreen?.();

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

@@ -107,17 +107,29 @@ function* lexBlockComment2(file, pos, end, linkTags, checker) {
                 break;
             case "`": {
                 // Markdown's code rules are a royal pain. This could be one of several things.
-                // 1. Inline code: <1-n ticks><text><same number of ticks>
-                // 2. Code block: <3 ticks><language, no ticks>\n<text>\n<3 ticks>\n
+                // 1. Inline code: <1-n ticks><text without multiple consecutive newlines or ticks at start of line><same number of ticks>
+                // 2. Code block: <newline><3+ ticks><language, no ticks>\n<text>\n<3 ticks>\n
                 // 3. Unmatched tick(s), not code, but part of some text.
                 // We don't quite handle #2 correctly yet. PR welcome!
                 braceStartsType = false;
                 let tickCount = 1;
-                let lookahead = pos;
+                let lookahead = pos - 1;
+                let atNewline = true;
+                while (lookahead > 0 && file[lookahead] !== "\n") {
+                    if (/\S/.test(file[lookahead])) {
+                        if (!commentHasStars || file[lookahead] !== "*") {
+                            atNewline = false;
+                            break;
+                        }
+                    }
+                    --lookahead;
+                }
+                lookahead = pos;
                 while (lookahead + 1 < end && file[lookahead + 1] === "`") {
                     tickCount++;
                     lookahead++;
                 }
+                const isCodeBlock = atNewline && tickCount >= 3;
                 let lookaheadStart = pos;
                 const codeText = [];
                 lookahead++;
@@ -125,12 +137,18 @@ function* lexBlockComment2(file, pos, end, linkTags, checker) {
                     if (lookaheadExactlyNTicks(lookahead, tickCount)) {
                         lookahead += tickCount;
                         codeText.push(file.substring(lookaheadStart, lookahead));
-                        yield {
-                            kind: TokenSyntaxKind.Code,
-                            text: codeText.join(""),
-                            pos,
-                        };
-                        pos = lookahead;
+                        const codeTextStr = codeText.join("");
+                        if (isCodeBlock || !/\n\s*\n/.test(codeTextStr)) {
+                            yield {
+                                kind: TokenSyntaxKind.Code,
+                                text: codeTextStr,
+                                pos,
+                            };
+                            pos = lookahead;
+                        }
+                        else {
+                            yield makeToken(TokenSyntaxKind.Text, tickCount);
+                        }
                         break;
                     }
                     else if (file[lookahead] === "`") {
@@ -167,7 +185,7 @@ function* lexBlockComment2(file, pos, end, linkTags, checker) {
                     }
                 }
                 if (lookahead >= end && pos !== lookahead) {
-                    if (tickCount === 3 &&
+                    if (isCodeBlock &&
                         file.substring(pos, end).includes("\n")) {
                         codeText.push(file.substring(lookaheadStart, end));
                         yield {

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

@@ -27,7 +27,8 @@ export interface ComponentPath {
      * How to resolve the `path`
      * - `.` - Navigate via `exports` of symbol
      * - `#` - Navigate via `members` of symbol
-     * - `~` - Navigate via `locals` of symbol
+     * - `~` - Navigate via `locals` of symbol (note: TypeDoc does not support
+     *   locals, see the declaration reference docs)
      */
     navigation: "." | "#" | "~";
     path: string;

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

@@ -300,6 +300,7 @@ export function parseDeclarationReference(source, pos, end) {
     let moduleSource;
     let symbolReference;
     let resolutionStart = "local";
+    let topLevelLocalReference = false;
     const moduleSourceOrSymbolRef = parseModuleSource(source, pos, end);
     if (moduleSourceOrSymbolRef) {
         if (moduleSourceOrSymbolRef[1] < end &&
@@ -308,6 +309,11 @@ export function parseDeclarationReference(source, pos, end) {
             pos = moduleSourceOrSymbolRef[1] + 1;
             resolutionStart = "global";
             moduleSource = moduleSourceOrSymbolRef[0];
+            // We might be referencing a local of a module
+            if (source[pos] === "~") {
+                topLevelLocalReference = true;
+                pos++;
+            }
         }
     }
     else if (source[pos] === "!") {
@@ -317,6 +323,9 @@ export function parseDeclarationReference(source, pos, end) {
     const ref = parseSymbolReference(source, pos, end);
     if (ref) {
         symbolReference = ref[0];
+        if (topLevelLocalReference && symbolReference.path?.length) {
+            symbolReference.path[0].navigation = "~";
+        }
         pos = ref[1];
     }
     if (!moduleSource && !symbolReference)

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

@@ -174,8 +174,14 @@ function resolveKeyword(refl, kw) {
 function resolveSymbolReferencePart(refl, path) {
     let high = [];
     let low = [];
-    if (!(refl instanceof ContainerReflection) ||
-        !refl.childrenIncludingDocuments) {
+    let children;
+    if (refl instanceof ContainerReflection) {
+        children = refl.childrenIncludingDocuments;
+    }
+    if (!children && refl.isDeclaration() && refl.type?.type === "reflection") {
+        children = refl.type.declaration.childrenIncludingDocuments;
+    }
+    if (!children) {
         return { high, low };
     }
     switch (path.navigation) {
@@ -184,16 +190,16 @@ function resolveSymbolReferencePart(refl, path) {
         // so that resolution doesn't behave very poorly with projects using JSDoc style resolution.
         // Also is more consistent with how TypeScript resolves link tags.
         case ".":
-            high = refl.childrenIncludingDocuments.filter((r) => r.name === path.path &&
+            high = children.filter((r) => r.name === path.path &&
                 (r.kindOf(ReflectionKind.SomeExport) || r.flags.isStatic));
-            low = refl.childrenIncludingDocuments.filter((r) => r.name === path.path &&
+            low = children.filter((r) => r.name === path.path &&
                 (!r.kindOf(ReflectionKind.SomeExport) || !r.flags.isStatic));
             break;
         // Resolve via "members", interface children, class instance properties/accessors/methods,
         // enum members, type literal properties
         case "#":
             high =
-                refl.children?.filter((r) => {
+                children?.filter((r) => {
                     return (r.name === path.path &&
                         r.kindOf(ReflectionKind.SomeMember) &&
                         !r.flags.isStatic);
@@ -203,7 +209,7 @@ function resolveSymbolReferencePart(refl, path) {
         // module/namespace exports since TypeDoc doesn't support documenting locals.
         case "~":
             if (refl.kindOf(ReflectionKind.SomeModule | ReflectionKind.Project)) {
-                high = refl.children?.filter((r) => r.name === path.path) || [];
+                high = children?.filter((r) => r.name === path.path) || [];
             }
             break;
     }

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

@@ -65,11 +65,21 @@ function* lexLineComments2(file, pos, end) {
                 // We don't quite handle #2 correctly yet. PR welcome!
                 braceStartsType = false;
                 let tickCount = 1;
-                let lookahead = pos;
+                let lookahead = pos - 1;
+                let atNewline = true;
+                while (lookahead > 0 && file[lookahead] !== "\n") {
+                    if (/\S/.test(file[lookahead])) {
+                        atNewline = false;
+                        break;
+                    }
+                    --lookahead;
+                }
+                lookahead = pos;
                 while (lookahead + 1 < end && file[lookahead + 1] === "`") {
                     tickCount++;
                     lookahead++;
                 }
+                const isCodeBlock = atNewline && tickCount >= 3;
                 let lookaheadStart = pos;
                 const codeText = [];
                 lookahead++;
@@ -77,12 +87,18 @@ function* lexLineComments2(file, pos, end) {
                     if (lookaheadExactlyNTicks(lookahead, tickCount)) {
                         lookahead += tickCount;
                         codeText.push(file.substring(lookaheadStart, lookahead));
-                        yield {
-                            kind: TokenSyntaxKind.Code,
-                            text: codeText.join(""),
-                            pos,
-                        };
-                        pos = lookahead;
+                        const codeTextStr = codeText.join("");
+                        if (isCodeBlock || !/\n\s*\n/.test(codeTextStr)) {
+                            yield {
+                                kind: TokenSyntaxKind.Code,
+                                text: codeTextStr,
+                                pos,
+                            };
+                            pos = lookahead;
+                        }
+                        else {
+                            yield makeToken(TokenSyntaxKind.Text, tickCount);
+                        }
                         break;
                     }
                     else if (file[lookahead] === "`") {

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

@@ -1,7 +1,8 @@
 import ts from "typescript";
-import { DeclarationReflection, Reflection, ReflectionSymbolId, } from "../../models/index.js";
+import { DeclarationReflection, Reflection, ReflectionKind, ReflectionSymbolId, } from "../../models/index.js";
 import { parseDeclarationReference, } from "./declarationReference.js";
 import { resolveDeclarationReference } from "./declarationReferenceResolver.js";
+import { maxElementByScore } from "../../utils/array.js";
 const urlPrefix = /^(http|ftp)s?:\/\//;
 export function resolveLinks(comment, reflection, externalResolver, options) {
     comment.summary = resolvePartLinks(reflection, comment.summary, externalResolver, options);
@@ -45,9 +46,28 @@ function resolveLinkTag(reflection, part, externalResolver, options) {
     const declRef = parseDeclarationReference(part.text, pos, end);
     // Might already know where it should go if useTsLinkResolution is turned on
     if (part.target instanceof ReflectionSymbolId) {
-        const tsTarget = reflection.project.getReflectionFromSymbolId(part.target);
-        if (tsTarget) {
-            target = tsTarget;
+        const tsTargets = reflection.project.getReflectionsFromSymbolId(part.target);
+        if (tsTargets.length) {
+            // Find the target most likely to have a real url in the generated documentation
+            // 1. A direct export (class, interface, variable)
+            // 2. A property of a direct export (class/interface property)
+            // 3. A property of a type of an export (property on type alias)
+            // 4. Whatever the first symbol found was
+            target = maxElementByScore(tsTargets, (r) => {
+                if (r.kindOf(ReflectionKind.SomeExport)) {
+                    return 4;
+                }
+                if (r.kindOf(ReflectionKind.SomeMember) &&
+                    r.parent?.kindOf(ReflectionKind.SomeExport)) {
+                    return 3;
+                }
+                if (r.kindOf(ReflectionKind.SomeMember) &&
+                    r.parent?.kindOf(ReflectionKind.TypeLiteral) &&
+                    r.parent.parent?.kindOf(ReflectionKind.TypeAlias | ReflectionKind.Variable)) {
+                    return 2;
+                }
+                return 1;
+            });
             pos = end;
             defaultDisplayText =
                 part.tsLinkText ||

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

@@ -43,19 +43,14 @@ function* lexCommentString2(file) {
     while (pos < end && /\s/.test(file[end - 1])) {
         end--;
     }
-    let lineStart = true;
     let expectingTag = false;
     for (;;) {
         if (pos >= end) {
             return;
         }
-        if (lineStart) {
-            lineStart = false;
-        }
         switch (file[pos]) {
             case "\n":
                 yield makeToken(TokenSyntaxKind.NewLine, 1);
-                lineStart = true;
                 expectingTag = false;
                 break;
             case "{":
@@ -68,16 +63,26 @@ function* lexCommentString2(file) {
                 break;
             case "`": {
                 // Markdown's code rules are a royal pain. This could be one of several things.
-                // 1. Inline code: <1-n ticks><text><same number of ticks>
-                // 2. Code block: <3 ticks><language, no ticks>\n<text>\n<3 ticks>\n
+                // 1. Inline code: <1-n ticks><text without multiple consecutive newlines or ticks at start of line><same number of ticks>
+                // 2. Code block: <newline><3+ ticks><language, no ticks>\n<text>\n<3 ticks>\n
                 // 3. Unmatched tick(s), not code, but part of some text.
                 // We don't quite handle #2 correctly yet. PR welcome!
                 let tickCount = 1;
-                let lookahead = pos;
+                let lookahead = pos - 1;
+                let atNewline = true;
+                while (lookahead > 0 && file[lookahead] !== "\n") {
+                    if (/\S/.test(file[lookahead])) {
+                        atNewline = false;
+                        break;
+                    }
+                    --lookahead;
+                }
+                lookahead = pos;
                 while (lookahead + 1 < end && file[lookahead + 1] === "`") {
                     tickCount++;
                     lookahead++;
                 }
+                const isCodeBlock = atNewline && tickCount >= 3;
                 let lookaheadStart = pos;
                 const codeText = [];
                 lookahead++;
@@ -85,13 +90,20 @@ function* lexCommentString2(file) {
                     if (lookaheadExactlyNTicks(lookahead, tickCount)) {
                         lookahead += tickCount;
                         codeText.push(file.substring(lookaheadStart, lookahead));
-                        yield {
-                            kind: TokenSyntaxKind.Code,
-                            text: codeText.join(""),
-                            pos,
-                        };
-                        expectingTag = false;
-                        pos = lookahead;
+                        const codeTextStr = codeText.join("");
+                        if (isCodeBlock || !/\n\s*\n/.test(codeTextStr)) {
+                            yield {
+                                kind: TokenSyntaxKind.Code,
+                                text: codeTextStr,
+                                pos,
+                            };
+                            expectingTag = false;
+                            pos = lookahead;
+                        }
+                        else {
+                            yield makeToken(TokenSyntaxKind.Text, tickCount);
+                            expectingTag = false;
+                        }
                         break;
                     }
                     else if (file[lookahead] === "`") {
@@ -114,7 +126,7 @@ function* lexCommentString2(file) {
                     }
                 }
                 if (lookahead >= end && pos !== lookahead) {
-                    if (tickCount === 3 &&
+                    if (isCodeBlock &&
                         file.substring(pos, end).includes("\n")) {
                         codeText.push(file.substring(lookaheadStart, end));
                         yield {

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

@@ -81,6 +81,7 @@ export function textContent(sourcePath, token, i18n, warning, outContent, files,
             addRef(tagLink);
             continue;
         }
+        data.atNewLine = token.text[data.pos] === "\n";
         ++data.pos;
     }
     if (lastPartEnd !== token.text.length) {

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

@@ -10,6 +10,7 @@ import type { CommentStyle, ValidationOptions } from "../utils/options/declarati
 import { type ExternalSymbolResolver, type ExternalResolveResult } from "./comments/linkResolver.js";
 import { type DeclarationReference } from "./comments/declarationReference.js";
 import type { FileRegistry } from "../models/FileRegistry.js";
+import { IncludePlugin } from "./plugins/IncludePlugin.js";
 export interface ConverterEvents {
     begin: [Context];
     end: [Context];
@@ -144,6 +145,8 @@ export declare class Converter extends AbstractComponent<Application, ConverterE
      * @event
      */
     static readonly EVENT_RESOLVE_END: "resolveEnd";
+    /** @internal @hidden */
+    includePlugin: IncludePlugin;
     constructor(owner: Application);
     /**
      * Compile the given source files and create a project reflection for them.

package/dist/lib/converter/converter.js

@@ -255,6 +255,8 @@ let Converter = (() => {
          * @event
          */
         static EVENT_RESOLVE_END = ConverterEvents.RESOLVE_END;
+        /** @internal @hidden */
+        includePlugin;
         constructor(owner) {
             super(owner);
             const userConfiguredSymbolResolver = (ref, refl, _part, symbolId) => {
@@ -294,7 +296,7 @@ let Converter = (() => {
             new PackagePlugin(this);
             new SourcePlugin(this);
             new TypePlugin(this);
-            new IncludePlugin(this);
+            this.includePlugin = new IncludePlugin(this);
             new MergeModuleWithPlugin(this);
         }
         /**

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

@@ -1,4 +1,5 @@
 import { ConverterComponent } from "../components.js";
+import type { CommentDisplayPart, Reflection } from "../../models/index.js";
 import type { Converter } from "../converter.js";
 /**
  * Handles `@include` and `@includeCode` within comments/documents.
@@ -7,5 +8,5 @@ export declare class IncludePlugin extends ConverterComponent {
     get logger(): import("../../utils/loggers.js").Logger;
     constructor(owner: Converter);
     private onCreate;
-    private checkIncludeTagsParts;
+    checkIncludeTagsParts(refl: Reflection, relative: string, parts: CommentDisplayPart[], included?: string[]): void;
 }

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

@@ -155,6 +155,9 @@ let PackagePlugin = (() => {
             if (this.readmeFile && this.readmeContents) {
                 const { content } = this.application.converter.parseRawComment(new MinimalSourceFile(this.readmeContents, this.readmeFile), project.files);
                 project.readme = content;
+                // This isn't ideal, but seems better than figuring out the readme
+                // path over in the include plugin...
+                this.owner.includePlugin.checkIncludeTagsParts(project, Path.dirname(this.readmeFile), content);
             }
             if (this.packageJson) {
                 project.packageName = this.packageJson.name;

package/dist/lib/converter/symbols.js

@@ -501,7 +501,7 @@ function createAlias(target, context, symbol, exportSymbol) {
     if (context.converter.excludeReferences)
         return;
     // We already have this. Create a reference.
-    const ref = new ReferenceReflection(exportSymbol?.name ?? symbol.name, target, context.scope);
+    const ref = new ReferenceReflection(exportSymbol?.name ?? symbol.name, target.isReference() ? target.getTargetReflection() : target, context.scope);
     context.postReflectionCreation(ref, symbol, exportSymbol);
     context.finalizeDeclarationReflection(ref);
 }

package/dist/lib/converter/types.js

@@ -7,7 +7,7 @@ import { ConverterEvents } from "./converter-events.js";
 import { convertIndexSignatures } from "./factories/index-signature.js";
 import { convertParameterNodes, convertTypeParameterNodes, createSignature, } from "./factories/signature.js";
 import { convertSymbol } from "./symbols.js";
-import { isObjectType } from "./utils/nodes.js";
+import { isObjectType, isTypeReference } from "./utils/nodes.js";
 import { removeUndefined } from "./utils/reflections.js";
 const converters = new Map();
 export function loadConverters() {
@@ -490,9 +490,22 @@ const referenceConverter = {
             ];
         }
         else {
-            ref.typeArguments = (type.aliasSymbol
+            // Default type arguments are filled with a reference to the default
+            // type. As TS doesn't support specifying earlier defaults, we know
+            // that this will only filter out type arguments which aren't specified
+            // by the user.
+            let ignoredArgs;
+            if (isTypeReference(type)) {
+                ignoredArgs = type.target.typeParameters
+                    ?.map((p) => p.getDefault())
+                    .filter((x) => !!x);
+            }
+            const args = type.aliasSymbol
                 ? type.aliasTypeArguments
-                : type.typeArguments)?.map((ref) => convertType(context, ref));
+                : type.typeArguments;
+            ref.typeArguments = args
+                ?.filter((ref) => !ignoredArgs?.includes(ref))
+                .map((ref) => convertType(context, ref));
         }
         return ref;
     },

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

@@ -4,3 +4,4 @@ export declare function isNamedNode(node: unknown): node is {
 };
 export declare function getHeritageTypes(declarations: readonly (ts.ClassDeclaration | ts.InterfaceDeclaration)[], kind: ts.SyntaxKind.ImplementsKeyword | ts.SyntaxKind.ExtendsKeyword): ts.ExpressionWithTypeArguments[];
 export declare function isObjectType(type: ts.Type): type is ts.ObjectType;
+export declare function isTypeReference(type: ts.Type): type is ts.TypeReference;

package/dist/lib/converter/utils/nodes.js

@@ -20,3 +20,7 @@ export function getHeritageTypes(declarations, kind) {
 export function isObjectType(type) {
     return typeof type.objectFlags === "number";
 }
+export function isTypeReference(type) {
+    return (isObjectType(type) &&
+        (type.objectFlags & ts.ObjectFlags.Reference) !== 0);
+}

package/dist/lib/debug/debugReflectionLifetimes.d.ts

@@ -0,0 +1,2 @@
+import type { Application } from "../application.js";
+export declare function debugReflectionLifetimes(app: Application): void;

package/dist/lib/debug/debugReflectionLifetimes.js

@@ -0,0 +1,19 @@
+import { ConverterEvents } from "../converter/converter-events.js";
+export function debugReflectionLifetimes(app) {
+    app.converter.on(ConverterEvents.CREATE_PROJECT, logCreate);
+    app.converter.on(ConverterEvents.CREATE_SIGNATURE, logCreate);
+    app.converter.on(ConverterEvents.CREATE_TYPE_PARAMETER, logCreate);
+    app.converter.on(ConverterEvents.CREATE_DECLARATION, logCreate);
+    app.converter.on(ConverterEvents.CREATE_DOCUMENT, logCreate);
+    app.converter.on(ConverterEvents.CREATE_PARAMETER, logCreate);
+    app.converter.on(ConverterEvents.CREATE_PROJECT, (_context, project) => {
+        const oldRemove = project["_removeReflection"];
+        project["_removeReflection"] = function (reflection) {
+            console.log("Remove", reflection.id, reflection.getFullName());
+            return oldRemove.call(this, reflection);
+        };
+    });
+}
+function logCreate(_context, refl) {
+    console.log("Create", refl.variant, refl.id, refl.getFullName());
+}

package/dist/lib/debug/debugRendererUrls.d.ts

@@ -0,0 +1,5 @@
+import type { Application } from "../application.js";
+export declare function debugRendererUrls(app: Application, { json, logs }?: {
+    logs?: true;
+    json?: boolean | undefined;
+}): void;

package/dist/lib/debug/debugRendererUrls.js

@@ -0,0 +1,59 @@
+/* eslint-disable no-console */
+import { join } from "node:path";
+import { Reflection, ReflectionKind, } from "../models/index.js";
+const serializer = {
+    priority: 0,
+    supports(x) {
+        return x instanceof Reflection;
+    },
+    toObject(item, obj) {
+        obj.url = item.url;
+        obj.hasOwnDocument = item.hasOwnDocument;
+        // obj.anchor = item.anchor;
+        delete obj.sources;
+        delete obj.groups;
+        delete obj.categories;
+        delete obj.readme;
+        delete obj.content;
+        obj.kind = ReflectionKind[obj.kind];
+        delete obj.flags;
+        delete obj.defaultValue;
+        delete obj.symbolIdMap;
+        delete obj.files;
+        delete obj.packageName;
+        delete obj.variant;
+        delete obj.extendedTypes;
+        delete obj.inheritedFrom;
+        if (!["reflection", "reference"].includes(obj.type?.type)) {
+            delete obj.type;
+        }
+        if (obj.comment) {
+            obj.comment.summary = obj.comment.summary.filter((part) => part.kind === "inline-tag");
+            obj.comment.blockTags = obj.comment.blockTags?.filter((tag) => {
+                tag.content = tag.content.filter((part) => part.kind === "inline-tag");
+                return tag.content.length;
+            });
+            if (!obj.comment.summary.length &&
+                !obj.comment.blockTags?.length &&
+                !obj.comment.modifierTags) {
+                delete obj.comment;
+            }
+        }
+        return obj;
+    },
+};
+export function debugRendererUrls(app, { json = false, logs = false } = { logs: true }) {
+    app.renderer.postRenderAsyncJobs.push(async (evt) => {
+        if (json) {
+            app.serializer.addSerializer(serializer);
+            await app.generateJson(evt.project, join(evt.outputDirectory, "url_debug.json"));
+            app.serializer.removeSerializer(serializer);
+        }
+        if (logs) {
+            for (const id in evt.project.reflections) {
+                const refl = evt.project.reflections[id];
+                console.log(refl.id, refl.getFullName(), refl.url, refl.hasOwnDocument);
+            }
+        }
+    });
+}

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

@@ -0,0 +1,2 @@
+export { debugRendererUrls } from "./debugRendererUrls.js";
+export { debugReflectionLifetimes } from "./debugReflectionLifetimes.js";

package/dist/lib/debug/index.js

@@ -0,0 +1,2 @@
+export { debugRendererUrls } from "./debugRendererUrls.js";
+export { debugReflectionLifetimes } from "./debugReflectionLifetimes.js";

package/dist/lib/internationalization/internationalization.d.ts

@@ -2,7 +2,6 @@ import type { Application } from "../application.js";
 import { ReflectionKind } from "../models/reflections/kind.js";
 import { ReflectionFlag } from "../models/index.js";
 import { type BuiltinTranslatableStringArgs } from "./translatable.js";
-import translatable from "./locales/en.cjs";
 /**
  * ### What is translatable?
  * TypeDoc includes a lot of literal strings. By convention, messages which are displayed
@@ -75,7 +74,7 @@ export declare class Internationalization {
      * Get the translation of the specified key, replacing placeholders
      * with the arguments specified.
      */
-    translate<T extends keyof typeof translatable>(key: T, ...args: TranslatableStrings[T]): TranslatedString;
+    translate<T extends keyof TranslatableStrings>(key: T, ...args: TranslatableStrings[T]): TranslatedString;
     kindSingularString(kind: ReflectionKind): TranslatedString;
     kindPluralString(kind: ReflectionKind): TranslatedString;
     flagString(flag: ReflectionFlag): TranslatedString;