typedoc 0.23.11 → 0.23.14

package/dist/index.d.ts

@@ -3,11 +3,11 @@ export { EventDispatcher, Event } from "./lib/utils/events";
 export { resetReflectionID } from "./lib/models/reflections/abstract";
 export { normalizePath } from "./lib/utils/fs";
 export * from "./lib/models";
-export { Converter, Context, type CommentParserConfig } from "./lib/converter";
+export { Converter, Context, type CommentParserConfig, type DeclarationReference, type SymbolReference, type ComponentPath, type Meaning, type MeaningKeyword, } from "./lib/converter";
 export { Renderer, DefaultTheme, DefaultThemeRenderContext, UrlMapping, Theme, PageEvent, RendererEvent, MarkdownEvent, IndexEvent, } from "./lib/output";
 export type { RenderTemplate, RendererHooks } from "./lib/output";
 export { ArgumentsReader, BindOption, CommentStyle, JSX, LogLevel, Logger, Options, ParameterHint, ParameterType, TSConfigReader, TypeDocReader, EntryPointStrategy, EventHooks, MinimalSourceFile, } from "./lib/utils";
-export type { OptionsReader, TypeDocOptions, TypeDocOptionMap, ValidationOptions, TypeDocOptionValues, KeyToDeclaration, DeclarationOption, DeclarationOptionBase, StringDeclarationOption, NumberDeclarationOption, BooleanDeclarationOption, ArrayDeclarationOption, MixedDeclarationOption, MapDeclarationOption, FlagsDeclarationOption, DeclarationOptionToOptionType, SortStrategy, ParameterTypeToOptionTypeMap, DocumentationEntryPoint, ManuallyValidatedOption, } from "./lib/utils";
+export type { OptionsReader, TypeDocOptions, TypeDocOptionMap, ValidationOptions, TypeDocOptionValues, KeyToDeclaration, DeclarationOption, DeclarationOptionBase, StringDeclarationOption, NumberDeclarationOption, BooleanDeclarationOption, ArrayDeclarationOption, MixedDeclarationOption, ObjectDeclarationOption, MapDeclarationOption, FlagsDeclarationOption, DeclarationOptionToOptionType, SortStrategy, ParameterTypeToOptionTypeMap, DocumentationEntryPoint, ManuallyValidatedOption, } from "./lib/utils";
 export type { EventMap, EventCallback } from "./lib/utils/events";
 export { JSONOutput, Serializer, type SerializerComponent, SerializeEvent, } from "./lib/serialization";
 export type { SerializeEventData } from "./lib/serialization";

package/dist/lib/application-events.d.ts

@@ -0,0 +1,3 @@
+export declare const ApplicationEvents: {
+    BOOTSTRAP_END: string;
+};

package/dist/lib/application-events.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplicationEvents = void 0;
+exports.ApplicationEvents = {
+    BOOTSTRAP_END: "bootstrapEnd",
+};

package/dist/lib/application.d.ts

@@ -46,6 +46,12 @@ export declare class Application extends ChildableComponent<Application, Abstrac
      * The version number of TypeDoc.
      */
     static VERSION: string;
+    /**
+     * Emitted after plugins have been loaded and options have been read, but before they have been frozen.
+     * The listener will be given an instance of {@link Application} and the {@link TypeDocOptions | Partial<TypeDocOptions>}
+     * passed to `bootstrap`.
+     */
+    static readonly EVENT_BOOTSTRAP_END: string;
     /**
      * Create a new TypeDoc application instance.
      *

package/dist/lib/application.js

@@ -24,6 +24,7 @@ const general_1 = require("./utils/general");
 const exports_1 = require("./validation/exports");
 const documentation_1 = require("./validation/documentation");
 const links_1 = require("./validation/links");
+const application_events_1 = require("./application-events");
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const packageInfo = require("../../package.json");
 const supportedVersionMajorMinor = packageInfo.peerDependencies.typescript
@@ -98,6 +99,7 @@ let Application = Application_1 = class Application extends component_1.Childabl
         if ((0, general_1.hasBeenLoadedMultipleTimes)()) {
             this.logger.warn(`TypeDoc has been loaded multiple times. This is commonly caused by plugins which have their own installation of TypeDoc. The loaded paths are:\n\t${(0, general_1.getLoadedPaths)().join("\n\t")}`);
         }
+        this.trigger(application_events_1.ApplicationEvents.BOOTSTRAP_END, this, options);
     }
     /**
      * Return the path to the TypeScript compiler.
@@ -304,6 +306,12 @@ let Application = Application_1 = class Application extends component_1.Childabl
  * The version number of TypeDoc.
  */
 Application.VERSION = packageInfo.version;
+/**
+ * Emitted after plugins have been loaded and options have been read, but before they have been frozen.
+ * The listener will be given an instance of {@link Application} and the {@link TypeDocOptions | Partial<TypeDocOptions>}
+ * passed to `bootstrap`.
+ */
+Application.EVENT_BOOTSTRAP_END = application_events_1.ApplicationEvents.BOOTSTRAP_END;
 __decorate([
     (0, utils_1.BindOption)("logger")
 ], Application.prototype, "loggerType", void 0);

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

@@ -1,4 +1,5 @@
 import { Comment, CommentDisplayPart, Reflection } from "../../models";
 import type { Logger, ValidationOptions } from "../../utils";
-export declare function resolveLinks(comment: Comment, reflection: Reflection, validation: ValidationOptions, logger: Logger): void;
-export declare function resolvePartLinks(reflection: Reflection, parts: readonly CommentDisplayPart[], warn: () => void, validation: ValidationOptions, logger: Logger): CommentDisplayPart[];
+import { DeclarationReference } from "./declarationReference";
+export declare function resolveLinks(comment: Comment, reflection: Reflection, validation: ValidationOptions, logger: Logger, attemptExternalResolve: (ref: DeclarationReference) => string | undefined): void;
+export declare function resolvePartLinks(reflection: Reflection, parts: readonly CommentDisplayPart[], warn: () => void, validation: ValidationOptions, logger: Logger, attemptExternalResolve: (ref: DeclarationReference) => string | undefined): CommentDisplayPart[];

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

@@ -7,7 +7,7 @@ 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) {
+function resolveLinks(comment, reflection, validation, logger, attemptExternalResolve) {
     let warned = false;
     const warn = () => {
         if (!warned) {
@@ -15,20 +15,20 @@ function resolveLinks(comment, reflection, validation, logger) {
             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);
+    comment.summary = resolvePartLinks(reflection, comment.summary, warn, validation, logger, attemptExternalResolve);
     for (const tag of comment.blockTags) {
-        tag.content = resolvePartLinks(reflection, tag.content, warn, validation, logger);
+        tag.content = resolvePartLinks(reflection, tag.content, warn, validation, logger, attemptExternalResolve);
     }
     if (reflection instanceof models_1.DeclarationReflection && reflection.readme) {
-        reflection.readme = resolvePartLinks(reflection, reflection.readme, warn, validation, logger);
+        reflection.readme = resolvePartLinks(reflection, reflection.readme, warn, validation, logger, attemptExternalResolve);
     }
 }
 exports.resolveLinks = resolveLinks;
-function resolvePartLinks(reflection, parts, warn, validation, logger) {
-    return parts.flatMap((part) => processPart(reflection, part, warn, validation, logger));
+function resolvePartLinks(reflection, parts, warn, validation, logger, attemptExternalResolve) {
+    return parts.flatMap((part) => processPart(reflection, part, warn, validation, logger, attemptExternalResolve));
 }
 exports.resolvePartLinks = resolvePartLinks;
-function processPart(reflection, part, warn, validation, logger) {
+function processPart(reflection, part, warn, validation, logger, attemptExternalResolve) {
     if (part.kind === "text" && brackets.test(part.text)) {
         warn();
         return replaceBrackets(reflection, part.text, validation, logger);
@@ -37,7 +37,7 @@ function processPart(reflection, part, warn, validation, logger) {
         if (part.tag === "@link" ||
             part.tag === "@linkcode" ||
             part.tag === "@linkplain") {
-            return resolveLinkTag(reflection, part, (msg) => {
+            return resolveLinkTag(reflection, part, attemptExternalResolve, (msg) => {
                 if (validation.invalidLink) {
                     logger.warn(msg);
                 }
@@ -46,7 +46,7 @@ function processPart(reflection, part, warn, validation, logger) {
     }
     return part;
 }
-function resolveLinkTag(reflection, part, warn) {
+function resolveLinkTag(reflection, part, attemptExternalResolve, warn) {
     let pos = 0;
     const end = part.text.length;
     while (pos < end && ts.isWhiteSpaceLike(part.text.charCodeAt(pos))) {
@@ -56,10 +56,21 @@ function resolveLinkTag(reflection, part, warn) {
     // Try to parse one
     const declRef = (0, declarationReference_1.parseDeclarationReference)(part.text, pos, end);
     let target;
+    let defaultDisplayText;
     if (declRef) {
         // Got one, great! Try to resolve the link
         target = (0, declarationReferenceResolver_1.resolveDeclarationReference)(reflection, declRef[0]);
         pos = declRef[1];
+        if (target) {
+            defaultDisplayText = target.name;
+        }
+        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);
+            }
+        }
     }
     if (!target) {
         if (urlPrefix.test(part.text)) {
@@ -67,13 +78,14 @@ function resolveLinkTag(reflection, part, warn) {
             target =
                 wsIndex === -1 ? part.text : part.text.substring(0, wsIndex);
             pos = target.length;
+            defaultDisplayText = target;
         }
     }
     // If resolution via a declaration reference failed, revert to the legacy "split and check"
     // method... this should go away in 0.24, once people have had a chance to migrate any failing links.
     if (!target) {
         const resolved = legacyResolveLinkTag(reflection, part);
-        if (resolved) {
+        if (resolved.target) {
             warn(`Failed to resolve {@link ${origText}} in ${reflection.getFriendlyFullName()} with declaration references. This link will break in v0.24.`);
         }
         return resolved;
@@ -87,9 +99,7 @@ function resolveLinkTag(reflection, part, warn) {
         pos++;
     }
     part.target = target;
-    part.text =
-        part.text.substring(pos).trim() ||
-            (typeof target === "string" ? target : target.name);
+    part.text = part.text.substring(pos).trim() || defaultDisplayText;
     return part;
 }
 function legacyResolveLinkTag(reflection, part) {

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

@@ -8,25 +8,31 @@ import { MinimalSourceFile } from "../utils";
 import type { DocumentationEntryPoint } from "../utils/entry-point";
 import { CommentParserConfig } from "./comments";
 import type { CommentStyle, ValidationOptions } from "../utils/options/declaration";
+import type { DeclarationReference } from "./comments/declarationReference";
 /**
  * Compiles source files using TypeScript and converts compiler symbols to reflections.
  */
 export declare class Converter extends ChildableComponent<Application, ConverterComponent> {
-    /**
-     * The human readable name of the project. Used within the templates to set the title of the document.
-     */
-    name: string;
+    /** @internal */
     externalPattern: string[];
     private externalPatternCache?;
     private excludeCache?;
+    /** @internal */
     excludeExternals: boolean;
+    /** @internal */
     excludeNotDocumented: boolean;
+    /** @internal */
     excludePrivate: boolean;
+    /** @internal */
     excludeProtected: boolean;
+    /** @internal */
     commentStyle: CommentStyle;
     /** @internal */
     validation: ValidationOptions;
+    /** @internal */
+    externalSymbolLinkMappings: Record<string, Record<string, string>>;
     private _config?;
+    private _externalSymbolResolvers;
     get config(): CommentParserConfig;
     /**
      * General events
@@ -92,6 +98,7 @@ export declare class Converter extends ChildableComponent<Application, Converter
      * @event
      */
     static readonly EVENT_RESOLVE_END: "resolveEnd";
+    constructor(owner: Application);
     /**
      * Compile the given source files and create a project reflection for them.
      */
@@ -111,6 +118,21 @@ export declare class Converter extends ChildableComponent<Application, Converter
      * Parse the given file into a comment. Intended to be used with markdown files.
      */
     parseRawComment(file: MinimalSourceFile): Comment;
+    /**
+     * Adds a new resolver that the theme can use to try to figure out how to link to a symbol declared
+     * by a third-party library which is not included in the documentation.
+     *
+     * The resolver function will be passed a declaration reference which it can attempt to resolve. If
+     * resolution fails, the function should return undefined.
+     *
+     * 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.
+     * @since 0.22.14
+     */
+    addUnknownSymbolResolver(resolver: (ref: DeclarationReference) => string | undefined): void;
+    /** @internal */
+    resolveExternalLink(ref: DeclarationReference): string | undefined;
     resolveLinks(comment: Comment, owner: Reflection): void;
     resolveLinks(parts: readonly CommentDisplayPart[], owner: Reflection): CommentDisplayPart[];
     /**

package/dist/lib/converter/converter.js

@@ -27,6 +27,31 @@ const linkResolver_1 = require("./comments/linkResolver");
  * Compiles source files using TypeScript and converts compiler symbols to reflections.
  */
 let Converter = Converter_1 = class Converter extends component_1.ChildableComponent {
+    constructor(owner) {
+        super(owner);
+        this._externalSymbolResolvers = [];
+        this.addUnknownSymbolResolver((ref) => {
+            // Require global links, matching local ones will likely hide mistakes where the
+            // user meant to link to a local type.
+            if (ref.resolutionStart !== "global" || !ref.symbolReference) {
+                return;
+            }
+            const modLinks = this.externalSymbolLinkMappings[ref.moduleSource ?? "global"];
+            if (typeof modLinks !== "object") {
+                return;
+            }
+            let name = "";
+            if (ref.symbolReference.path) {
+                name += ref.symbolReference.path.map((p) => p.path).join(".");
+            }
+            if (ref.symbolReference.meaning) {
+                name += ":" + ref.symbolReference.meaning;
+            }
+            if (typeof modLinks[name] === "string") {
+                return modLinks[name];
+            }
+        });
+    }
     get config() {
         return this._config || this._buildCommentParserConfig();
     }
@@ -36,7 +61,7 @@ let Converter = Converter_1 = class Converter extends component_1.ChildableCompo
     convert(entryPoints) {
         const programs = entryPoints.map((e) => e.program);
         this.externalPatternCache = void 0;
-        const project = new index_1.ProjectReflection(this.name);
+        const project = new index_1.ProjectReflection(this.application.options.getValue("name"));
         const context = new context_1.Context(this, programs, project);
         this.trigger(Converter_1.EVENT_BEGIN, context);
         this.compile(entryPoints, context);
@@ -67,9 +92,32 @@ let Converter = Converter_1 = class Converter extends component_1.ChildableCompo
     parseRawComment(file) {
         return (0, parser_1.parseComment)((0, rawLexer_1.lexCommentString)(file.text), this.config, file, this.application.logger);
     }
+    /**
+     * Adds a new resolver that the theme can use to try to figure out how to link to a symbol declared
+     * by a third-party library which is not included in the documentation.
+     *
+     * The resolver function will be passed a declaration reference which it can attempt to resolve. If
+     * resolution fails, the function should return undefined.
+     *
+     * 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.
+     * @since 0.22.14
+     */
+    addUnknownSymbolResolver(resolver) {
+        this._externalSymbolResolvers.push(resolver);
+    }
+    /** @internal */
+    resolveExternalLink(ref) {
+        for (const resolver of this._externalSymbolResolvers) {
+            const resolved = resolver(ref);
+            if (resolved)
+                return resolved;
+        }
+    }
     resolveLinks(comment, owner) {
         if (comment instanceof index_1.Comment) {
-            (0, linkResolver_1.resolveLinks)(comment, owner, this.validation, this.owner.logger);
+            (0, linkResolver_1.resolveLinks)(comment, owner, this.validation, this.owner.logger, (ref) => this.resolveExternalLink(ref));
         }
         else {
             let warned = false;
@@ -79,7 +127,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);
+            return (0, linkResolver_1.resolvePartLinks)(owner, comment, warn, this.validation, this.owner.logger, (ref) => this.resolveExternalLink(ref));
         }
     }
     /**
@@ -262,9 +310,6 @@ Converter.EVENT_RESOLVE = converter_events_1.ConverterEvents.RESOLVE;
  * @event
  */
 Converter.EVENT_RESOLVE_END = converter_events_1.ConverterEvents.RESOLVE_END;
-__decorate([
-    (0, utils_1.BindOption)("name")
-], Converter.prototype, "name", void 0);
 __decorate([
     (0, utils_1.BindOption)("externalPattern")
 ], Converter.prototype, "externalPattern", void 0);
@@ -286,6 +331,9 @@ __decorate([
 __decorate([
     (0, utils_1.BindOption)("validation")
 ], Converter.prototype, "validation", void 0);
+__decorate([
+    (0, utils_1.BindOption)("externalSymbolLinkMappings")
+], Converter.prototype, "externalSymbolLinkMappings", void 0);
 Converter = Converter_1 = __decorate([
     (0, component_1.Component)({
         name: "converter",

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

@@ -2,4 +2,5 @@ export { Context } from "./context";
 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";
 import "./plugins/index";

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

@@ -11,6 +11,7 @@ const components_1 = require("../components");
 const converter_events_1 = require("../converter-events");
 const utils_1 = require("../../utils");
 const models_1 = require("../../models");
+const reflections_1 = require("../../utils/reflections");
 /**
  * A plugin that resolves `{@link Foo}` tags.
  */
@@ -35,6 +36,11 @@ let LinkResolverPlugin = class LinkResolverPlugin extends components_1.Converter
         if (context.project.readme) {
             context.project.readme = context.converter.resolveLinks(context.project.readme, context.project);
         }
+        for (const { type } of (0, reflections_1.discoverAllReferenceTypes)(context.project, false)) {
+            if (!type.reflection) {
+                type.externalUrl = context.converter.resolveExternalLink(type.toDeclarationReference());
+            }
+        }
     }
 };
 __decorate([

package/dist/lib/converter/types.js

@@ -348,6 +348,9 @@ const typeLiteralConverter = {
         for (const signature of type.getCallSignatures()) {
             (0, signature_1.createSignature)(rc, models_1.ReflectionKind.CallSignature, signature);
         }
+        for (const signature of type.getConstructSignatures()) {
+            (0, signature_1.createSignature)(rc, models_1.ReflectionKind.ConstructorSignature, signature);
+        }
         (0, index_signature_1.convertIndexSignature)(rc, symbol);
         return new models_1.ReflectionType(reflection);
     },
@@ -364,6 +367,9 @@ const typeLiteralConverter = {
         for (const signature of type.getCallSignatures()) {
             (0, signature_1.createSignature)(context.withScope(reflection), models_1.ReflectionKind.CallSignature, signature);
         }
+        for (const signature of type.getConstructSignatures()) {
+            (0, signature_1.createSignature)(context.withScope(reflection), models_1.ReflectionKind.ConstructorSignature, signature);
+        }
         (0, index_signature_1.convertIndexSignature)(context.withScope(reflection), type.symbol);
         return new models_1.ReflectionType(reflection);
     },

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

@@ -4,9 +4,7 @@ exports.getHeritageTypes = exports.isNamedNode = void 0;
 const ts = require("typescript");
 function isNamedNode(node) {
     const name = node.name;
-    return (!!name &&
-        (ts.isIdentifierOrPrivateIdentifier(name) ||
-            ts.isComputedPropertyName(name)));
+    return !!name && (ts.isMemberName(name) || ts.isComputedPropertyName(name));
 }
 exports.isNamedNode = isNamedNode;
 function getHeritageTypes(declarations, kind) {

package/dist/lib/models/types.d.ts

@@ -4,6 +4,7 @@ import { Reflection } from "./reflections/abstract";
 import type { DeclarationReflection } from "./reflections/declaration";
 import type { ProjectReflection } from "./reflections/project";
 import type { Serializer, JSONOutput } from "../serialization";
+import type { DeclarationReference } from "../converter/comments/declarationReference";
 /**
  * Base class of all type definitions.
  */
@@ -320,6 +321,10 @@ export declare class ReferenceType extends Type {
      * @internal
      */
     getSymbol(): ts.Symbol | undefined;
+    /**
+     * Convert this reference type to a declaration reference used for resolution of external types.
+     */
+    toDeclarationReference(): DeclarationReference;
     /**
      * The fully qualified name of the referenced type, relative to the file it is defined in.
      * This will usually be the same as `name`, unless namespaces are used.
@@ -330,10 +335,15 @@ export declare class ReferenceType extends Type {
      * Will only be set for `ReferenceType`s pointing to a symbol within `node_modules`.
      */
     package?: string;
+    /**
+     * If this reference type refers to a reflection defined by a project not being rendered,
+     * points to the url that this type should be linked to.
+     */
+    externalUrl?: string;
     private _target;
     private _project;
     private constructor();
-    static createResolvedReference(name: string, target: Reflection | number, project: ProjectReflection | null): ReferenceType;
+    static createResolvedReference(name: string, target: Reflection | number, project: ProjectReflection): ReferenceType;
     static createSymbolReference(symbol: ts.Symbol, context: Context, name?: string): ReferenceType;
     /** @internal this is used for type parameters, which don't actually point to something */
     static createBrokenReference(name: string, project: ProjectReflection): ReferenceType;

package/dist/lib/models/types.js

@@ -661,6 +661,20 @@ class ReferenceType extends Type {
         }
         return this._target;
     }
+    /**
+     * Convert this reference type to a declaration reference used for resolution of external types.
+     */
+    toDeclarationReference() {
+        return {
+            resolutionStart: "global",
+            moduleSource: this.package,
+            symbolReference: {
+                path: this.qualifiedName
+                    .split(".")
+                    .map((p) => ({ path: p, navigation: "." })),
+            },
+        };
+    }
     static createResolvedReference(name, target, project) {
         return new ReferenceType(name, target, project, name);
     }
@@ -709,6 +723,7 @@ class ReferenceType extends Type {
             id: this.reflection?.id,
             typeArguments: serializer.toObjectsOptional(this.typeArguments),
             name: this.name,
+            externalUrl: this.externalUrl,
         };
         if (this.package) {
             result.qualifiedName = this.qualifiedName;

package/dist/lib/output/renderer.d.ts

@@ -5,7 +5,6 @@ import { RendererComponent } from "./components";
 import { ChildableComponent } from "../utils/component";
 import { EventHooks } from "../utils";
 import type { Theme as ShikiTheme } from "shiki";
-import { ReferenceType } from "../models";
 import type { JsxElement } from "../utils/jsx.elements";
 import type { DefaultThemeRenderContext } from "./themes/default/DefaultThemeRenderContext";
 /**
@@ -80,7 +79,6 @@ export interface RendererHooks {
  */
 export declare class Renderer extends ChildableComponent<Application, RendererComponent> {
     private themes;
-    private unknownSymbolResolvers;
     /** @event */
     static readonly EVENT_BEGIN_PAGE = "beginPage";
     /** @event */
@@ -125,7 +123,7 @@ export declare class Renderer extends ChildableComponent<Application, RendererCo
      */
     defineTheme(name: string, theme: new (renderer: Renderer) => Theme): void;
     /**
-     * Adds a new resolver that the theme can used to try to figure out how to link to a symbol
+     * Adds a new resolver that the theme can use to try to figure out how to link to a symbol
      * declared by a third-party library which is not included in the documentation.
      * @param packageName the npm package name that this resolver can handle to limit which files it will be tried on.
      *   If the resolver will create links for Node builtin types, it should be set to `@types/node`.
@@ -133,15 +131,11 @@ export declare class Renderer extends ChildableComponent<Application, RendererCo
      * @param resolver a function that will be called to create links for a given symbol name in the registered path.
      *  If the provided name is not contained within the docs, should return `undefined`.
      * @since 0.22.0
+     * @deprecated
+     * Deprecated since v0.23.14, use {@link Converter.addUnknownSymbolResolver | Converter.addUnknownSymbolResolver} instead.
+     * This signature will be removed in 0.24 or possibly 0.25.
      */
     addUnknownSymbolResolver(packageName: string, resolver: (name: string) => string | undefined): void;
-    /**
-     * Marked as internal for now. Using this requires the internal `getSymbol()` method on ReferenceType.
-     * Someday that needs to be fixed so that this can be made public. ReferenceTypes really shouldn't store
-     * symbols so that we don't need to keep the program around forever.
-     * @internal
-     */
-    attemptExternalResolution(type: ReferenceType): string | undefined;
     /**
      * Render the given project reflection to the specified output directory.
      *

package/dist/lib/output/renderer.js

@@ -64,7 +64,6 @@ let Renderer = class Renderer extends component_1.ChildableComponent {
         this.themes = new Map([
             ["default", DefaultTheme_1.DefaultTheme],
         ]);
-        this.unknownSymbolResolvers = new Map();
         /**
          * Hooks which will be called when rendering pages.
          * Note:
@@ -89,7 +88,7 @@ let Renderer = class Renderer extends component_1.ChildableComponent {
         this.themes.set(name, theme);
     }
     /**
-     * Adds a new resolver that the theme can used to try to figure out how to link to a symbol
+     * Adds a new resolver that the theme can use to try to figure out how to link to a symbol
      * declared by a third-party library which is not included in the documentation.
      * @param packageName the npm package name that this resolver can handle to limit which files it will be tried on.
      *   If the resolver will create links for Node builtin types, it should be set to `@types/node`.
@@ -97,32 +96,19 @@ let Renderer = class Renderer extends component_1.ChildableComponent {
      * @param resolver a function that will be called to create links for a given symbol name in the registered path.
      *  If the provided name is not contained within the docs, should return `undefined`.
      * @since 0.22.0
+     * @deprecated
+     * Deprecated since v0.23.14, use {@link Converter.addUnknownSymbolResolver | Converter.addUnknownSymbolResolver} instead.
+     * This signature will be removed in 0.24 or possibly 0.25.
      */
     addUnknownSymbolResolver(packageName, resolver) {
-        const existing = this.unknownSymbolResolvers.get(packageName);
-        if (existing) {
-            existing.push(resolver);
-        }
-        else {
-            this.unknownSymbolResolvers.set(packageName, [resolver]);
-        }
-    }
-    /**
-     * Marked as internal for now. Using this requires the internal `getSymbol()` method on ReferenceType.
-     * Someday that needs to be fixed so that this can be made public. ReferenceTypes really shouldn't store
-     * symbols so that we don't need to keep the program around forever.
-     * @internal
-     */
-    attemptExternalResolution(type) {
-        if (!type.qualifiedName || !type.package) {
-            return;
-        }
-        const resolvers = this.unknownSymbolResolvers.get(type.package);
-        for (const resolver of resolvers || []) {
-            const resolved = resolver(type.qualifiedName);
-            if (resolved)
-                return resolved;
-        }
+        this.owner.converter.addUnknownSymbolResolver((ref) => {
+            const path = ref.symbolReference?.path
+                ?.map((path) => path.path)
+                .join(".");
+            if (ref.moduleSource === packageName && path) {
+                return resolver(path);
+            }
+        });
     }
     /**
      * Render the given project reflection to the specified output directory.

package/dist/lib/output/themes/default/DefaultThemeRenderContext.d.ts

@@ -12,7 +12,12 @@ export declare class DefaultThemeRenderContext {
     relativeURL: (url: string | undefined) => string | undefined;
     urlTo: (reflection: Reflection) => string | undefined;
     markdown: (md: readonly CommentDisplayPart[] | NeverIfInternal<string | undefined>) => string;
-    attemptExternalResolution: (type: ReferenceType) => string | undefined;
+    /**
+     * Using this method will repeat work already done, instead of calling it, use `type.externalUrl`.
+     * @deprecated
+     * Will be removed in 0.24.
+     */
+    attemptExternalResolution: (type: NeverIfInternal<ReferenceType>) => string | undefined;
     reflectionTemplate: (props: import("../..").PageEvent<import("../../../models").ContainerReflection>) => import("../../../utils/jsx.elements").JsxElement;
     indexTemplate: (props: import("../..").PageEvent<import("../../../models").ProjectReflection>) => import("../../../utils/jsx.elements").JsxElement;
     defaultLayout: (props: import("../..").PageEvent<Reflection>) => import("../../../utils/jsx.elements").JsxElement;

package/dist/lib/output/themes/default/DefaultThemeRenderContext.js

@@ -48,8 +48,13 @@ class DefaultThemeRenderContext {
             }
             return md ? this.theme.markedPlugin.parseMarkdown(md) : "";
         };
+        /**
+         * Using this method will repeat work already done, instead of calling it, use `type.externalUrl`.
+         * @deprecated
+         * Will be removed in 0.24.
+         */
         this.attemptExternalResolution = (type) => {
-            return this.theme.owner.attemptExternalResolution(type);
+            return type.externalUrl;
         };
         this.reflectionTemplate = bind(reflection_1.reflectionTemplate, this);
         this.indexTemplate = bind(templates_1.indexTemplate, this);

package/dist/lib/output/themes/default/partials/type.js

@@ -175,14 +175,11 @@ const typeRenderers = {
                 name = renderUniquePath(context, reflection);
             }
         }
+        else if (type.externalUrl) {
+            name = (utils_1.JSX.createElement("a", { href: type.externalUrl, class: "tsd-signature-type external", target: "_blank" }, type.name));
+        }
         else {
-            const externalUrl = context.attemptExternalResolution(type);
-            if (externalUrl) {
-                name = (utils_1.JSX.createElement("a", { href: externalUrl, class: "tsd-signature-type external", target: "_blank" }, type.name));
-            }
-            else {
-                name = utils_1.JSX.createElement("span", { class: "tsd-signature-type" }, type.name);
-            }
+            name = utils_1.JSX.createElement("span", { class: "tsd-signature-type" }, type.name);
         }
         if (type.typeArguments?.length) {
             return (utils_1.JSX.createElement(utils_1.JSX.Fragment, null,

package/dist/lib/serialization/schema.d.ts

@@ -119,7 +119,7 @@ export interface PredicateType extends Type, S<M.PredicateType, "type" | "name"
 }
 export interface QueryType extends Type, S<M.QueryType, "type" | "queryType"> {
 }
-export interface ReferenceType extends Type, S<M.ReferenceType, "type" | "name" | "typeArguments" | "package"> {
+export interface ReferenceType extends Type, S<M.ReferenceType, "type" | "name" | "typeArguments" | "package" | "externalUrl"> {
     id?: number;
     qualifiedName?: string;
 }

package/dist/lib/utils/entry-point.js

@@ -9,6 +9,7 @@ const package_manifest_1 = require("./package-manifest");
 const paths_1 = require("./paths");
 const fs_1 = require("./fs");
 const validation_1 = require("./validation");
+const array_1 = require("./array");
 /**
  * Defines how entry points are interpreted.
  * @enum
@@ -191,6 +192,15 @@ function expandInputFiles(logger, entryPoints, options) {
     });
     return files;
 }
+function deriveRootDir(packageGlobPaths) {
+    const globs = (0, paths_1.createMinimatch)(packageGlobPaths);
+    const rootPaths = globs.flatMap((glob) => (0, array_1.filterMap)(glob.set, (set) => {
+        const stop = set.findIndex((part) => typeof part !== "string");
+        const path = stop === -1 ? set : set.slice(0, stop);
+        return `/${path.join("/")}`;
+    }));
+    return (0, fs_1.getCommonDirectory)(rootPaths);
+}
 /**
  * Expand the provided packages configuration paths, determining the entry points
  * and creating the ts.Programs for any which are found.
@@ -201,9 +211,10 @@ function expandInputFiles(logger, entryPoints, options) {
 function getEntryPointsForPackages(logger, packageGlobPaths, options) {
     const results = [];
     const exclude = (0, paths_1.createMinimatch)(options.getValue("exclude"));
+    const rootDir = deriveRootDir(packageGlobPaths);
     // packages arguments are workspace tree roots, or glob patterns
     // This expands them to leave only leaf packages
-    const expandedPackages = (0, package_manifest_1.expandPackages)(logger, ".", packageGlobPaths, exclude);
+    const expandedPackages = (0, package_manifest_1.expandPackages)(logger, rootDir, packageGlobPaths, exclude);
     for (const packagePath of expandedPackages) {
         const packageJsonPath = (0, path_1.resolve)(packagePath, "package.json");
         const packageJson = (0, package_manifest_1.loadPackageManifest)(logger, packageJsonPath);

package/dist/lib/utils/fs.js

@@ -149,11 +149,7 @@ function glob(pattern, root, options) {
             }
             if (child.isDirectory() && child.name !== "node_modules") {
                 const childPath = dir.concat(child.name);
-                if (mini.set.some((row) => mini.matchOne(
-                // @ts-expect-error childPath really should be an array of strings, not a string.
-                // https://github.com/DefinitelyTyped/DefinitelyTyped/pull/61956
-                childPath, row, 
-                /* partial */ true))) {
+                if (mini.set.some((row) => mini.matchOne(childPath, row, /* partial */ true))) {
                     dirs.push(childPath);
                 }
             }

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

@@ -7,7 +7,7 @@ export { assertNever } from "./general";
 export { CallbackLogger, ConsoleLogger, Logger, LogLevel } from "./loggers";
 export { DefaultMap } from "./map";
 export { ArgumentsReader, BindOption, CommentStyle, Options, ParameterHint, ParameterType, TSConfigReader, TypeDocReader, } from "./options";
-export type { ArrayDeclarationOption, BooleanDeclarationOption, DeclarationOption, DeclarationOptionBase, DeclarationOptionToOptionType, KeyToDeclaration, MapDeclarationOption, MixedDeclarationOption, NumberDeclarationOption, FlagsDeclarationOption, OptionsReader, StringDeclarationOption, TypeDocOptionMap, TypeDocOptions, ValidationOptions, TypeDocOptionValues, ParameterTypeToOptionTypeMap, ManuallyValidatedOption, } from "./options";
+export type { ArrayDeclarationOption, BooleanDeclarationOption, DeclarationOption, DeclarationOptionBase, DeclarationOptionToOptionType, KeyToDeclaration, MapDeclarationOption, MixedDeclarationOption, NumberDeclarationOption, FlagsDeclarationOption, ObjectDeclarationOption, OptionsReader, StringDeclarationOption, TypeDocOptionMap, TypeDocOptions, ValidationOptions, TypeDocOptionValues, ParameterTypeToOptionTypeMap, ManuallyValidatedOption, } from "./options";
 export { discoverPlugins, loadPlugins } from "./plugins";
 export { sortReflections } from "./sort";
 export type { SortStrategy } from "./sort";

package/dist/lib/utils/options/declaration.d.ts

@@ -55,6 +55,7 @@ export interface TypeDocOptionMap {
     excludeInternal: boolean;
     excludePrivate: boolean;
     excludeProtected: boolean;
+    externalSymbolLinkMappings: ManuallyValidatedOption<Record<string, Record<string, string>>>;
     media: string;
     includes: string;
     out: string;
@@ -126,7 +127,7 @@ export declare type ValidationOptions = {
      */
     notExported: boolean;
     /**
-     * If set, TypeDoc will produce warnings about \{&amp;link\} tags which will produce broken links.
+     * If set, TypeDoc will produce warnings about \{\@link\} tags which will produce broken links.
      */
     invalidLink: boolean;
     /**
@@ -137,9 +138,11 @@ export declare type ValidationOptions = {
 /**
  * Converts a given TypeDoc option key to the type of the declaration expected.
  */
-export declare type KeyToDeclaration<K extends keyof TypeDocOptionMap> = TypeDocOptionMap[K] extends boolean ? BooleanDeclarationOption : TypeDocOptionMap[K] extends string ? StringDeclarationOption : TypeDocOptionMap[K] extends number ? NumberDeclarationOption : TypeDocOptionMap[K] extends string[] ? ArrayDeclarationOption : unknown extends TypeDocOptionMap[K] ? MixedDeclarationOption : TypeDocOptionMap[K] extends ManuallyValidatedOption<unknown> ? MixedDeclarationOption & {
+export declare type KeyToDeclaration<K extends keyof TypeDocOptionMap> = TypeDocOptionMap[K] extends boolean ? BooleanDeclarationOption : TypeDocOptionMap[K] extends string ? StringDeclarationOption : TypeDocOptionMap[K] extends number ? NumberDeclarationOption : TypeDocOptionMap[K] extends string[] ? ArrayDeclarationOption : unknown extends TypeDocOptionMap[K] ? MixedDeclarationOption | ObjectDeclarationOption : TypeDocOptionMap[K] extends ManuallyValidatedOption<unknown> ? (MixedDeclarationOption & {
     validate(value: unknown): void;
-} : TypeDocOptionMap[K] extends Record<string, boolean> ? FlagsDeclarationOption<TypeDocOptionMap[K]> : TypeDocOptionMap[K] extends Record<string | number, infer U> ? MapDeclarationOption<U> : never;
+}) | (ObjectDeclarationOption & {
+    validate(value: unknown): void;
+}) : TypeDocOptionMap[K] extends Record<string, boolean> ? FlagsDeclarationOption<TypeDocOptionMap[K]> : TypeDocOptionMap[K] extends Record<string | number, infer U> ? MapDeclarationOption<U> : never;
 export declare enum ParameterHint {
     File = 0,
     Directory = 1
@@ -167,10 +170,14 @@ export declare enum ParameterType {
      * Resolved according to the config directory unless it starts with `**`, after skipping any leading `!` and `#` characters.
      */
     GlobArray = 9,
+    /**
+     * An unopinionated object that preserves default settings unless explicitly overridden
+     */
+    Object = 10,
     /**
      * An object with true/false flags
      */
-    Flags = 10
+    Flags = 11
 }
 export interface DeclarationOptionBase {
     /**
@@ -258,6 +265,18 @@ export interface MixedDeclarationOption extends DeclarationOptionBase {
      */
     validate?: (value: unknown) => void;
 }
+export interface ObjectDeclarationOption extends DeclarationOptionBase {
+    type: ParameterType.Object;
+    /**
+     * If not specified defaults to undefined.
+     */
+    defaultValue?: unknown;
+    /**
+     * An optional validation function that validates a potential value of this option.
+     * The function must throw an Error if the validation fails and should do nothing otherwise.
+     */
+    validate?: (value: unknown) => void;
+}
 export interface MapDeclarationOption<T> extends DeclarationOptionBase {
     type: ParameterType.Map;
     /**
@@ -283,13 +302,14 @@ export interface FlagsDeclarationOption<T extends Record<string, boolean>> exten
      */
     defaults: T;
 }
-export declare type DeclarationOption = StringDeclarationOption | NumberDeclarationOption | BooleanDeclarationOption | MixedDeclarationOption | MapDeclarationOption<unknown> | ArrayDeclarationOption | FlagsDeclarationOption<Record<string, boolean>>;
+export declare type DeclarationOption = StringDeclarationOption | NumberDeclarationOption | BooleanDeclarationOption | MixedDeclarationOption | ObjectDeclarationOption | MapDeclarationOption<unknown> | ArrayDeclarationOption | FlagsDeclarationOption<Record<string, boolean>>;
 export interface ParameterTypeToOptionTypeMap {
     [ParameterType.String]: string;
     [ParameterType.Path]: string;
     [ParameterType.Number]: number;
     [ParameterType.Boolean]: boolean;
     [ParameterType.Mixed]: unknown;
+    [ParameterType.Object]: unknown;
     [ParameterType.Array]: string[];
     [ParameterType.PathArray]: string[];
     [ParameterType.ModuleArray]: string[];
@@ -306,5 +326,5 @@ export declare type DeclarationOptionToOptionType<T extends DeclarationOption> =
  * @param option The option for which the value should be converted.
  * @returns The result of the conversion. Might be the value or an error.
  */
-export declare function convert(value: unknown, option: DeclarationOption, configPath: string): unknown;
+export declare function convert(value: unknown, option: DeclarationOption, configPath: string, oldValue?: unknown): unknown;
 export declare function getDefaultValue(option: DeclarationOption): unknown;

package/dist/lib/utils/options/declaration.js

@@ -47,10 +47,14 @@ var ParameterType;
      * Resolved according to the config directory unless it starts with `**`, after skipping any leading `!` and `#` characters.
      */
     ParameterType[ParameterType["GlobArray"] = 9] = "GlobArray";
+    /**
+     * An unopinionated object that preserves default settings unless explicitly overridden
+     */
+    ParameterType[ParameterType["Object"] = 10] = "Object";
     /**
      * An object with true/false flags
      */
-    ParameterType[ParameterType["Flags"] = 10] = "Flags";
+    ParameterType[ParameterType["Flags"] = 11] = "Flags";
 })(ParameterType = exports.ParameterType || (exports.ParameterType = {}));
 const converters = {
     [ParameterType.String](value, option) {
@@ -146,6 +150,12 @@ const converters = {
         option.validate?.(value);
         return value;
     },
+    [ParameterType.Object](value, option, _configPath, oldValue) {
+        option.validate?.(value);
+        if (typeof oldValue !== "undefined")
+            value = { ...oldValue, ...value };
+        return value;
+    },
     [ParameterType.Flags](value, option) {
         if (typeof value === "boolean") {
             value = Object.fromEntries(Object.keys(option.defaults).map((key) => [key, value]));
@@ -179,9 +189,9 @@ const converters = {
  * @param option The option for which the value should be converted.
  * @returns The result of the conversion. Might be the value or an error.
  */
-function convert(value, option, configPath) {
+function convert(value, option, configPath, oldValue) {
     const _converters = converters;
-    return _converters[option.type ?? ParameterType.String](value, option, configPath);
+    return _converters[option.type ?? ParameterType.String](value, option, configPath, oldValue);
 }
 exports.convert = convert;
 const defaultGetters = {
@@ -209,6 +219,9 @@ const defaultGetters = {
     [ParameterType.Mixed](option) {
         return option.defaultValue;
     },
+    [ParameterType.Object](option) {
+        return option.defaultValue;
+    },
     [ParameterType.Array](option) {
         return option.defaultValue?.slice() ?? [];
     },

package/dist/lib/utils/options/index.d.ts

@@ -2,4 +2,4 @@ export { Options, BindOption } from "./options";
 export type { OptionsReader } from "./options";
 export { ArgumentsReader, TypeDocReader, TSConfigReader } from "./readers";
 export { CommentStyle, EmitStrategy, ParameterType, ParameterHint, } from "./declaration";
-export type { TypeDocOptions, TypeDocOptionMap, ValidationOptions, KeyToDeclaration, DeclarationOption, DeclarationOptionBase, StringDeclarationOption, NumberDeclarationOption, BooleanDeclarationOption, ArrayDeclarationOption, MixedDeclarationOption, MapDeclarationOption, FlagsDeclarationOption, DeclarationOptionToOptionType, TypeDocOptionValues, ParameterTypeToOptionTypeMap, ManuallyValidatedOption, } from "./declaration";
+export type { TypeDocOptions, TypeDocOptionMap, ValidationOptions, KeyToDeclaration, DeclarationOption, DeclarationOptionBase, StringDeclarationOption, NumberDeclarationOption, BooleanDeclarationOption, ArrayDeclarationOption, MixedDeclarationOption, ObjectDeclarationOption, MapDeclarationOption, FlagsDeclarationOption, DeclarationOptionToOptionType, TypeDocOptionValues, ParameterTypeToOptionTypeMap, ManuallyValidatedOption, } from "./declaration";

package/dist/lib/utils/options/options.js

@@ -164,7 +164,10 @@ class Options {
         if (!declaration) {
             throw new Error(`Tried to set an option (${name}) that was not declared.`);
         }
-        const converted = (0, declaration_2.convert)(value, declaration, configPath ?? process.cwd());
+        let oldValue = this._values[declaration.name];
+        if (typeof oldValue === "undefined")
+            oldValue = (0, declaration_2.getDefaultValue)(declaration);
+        const converted = (0, declaration_2.convert)(value, declaration, configPath ?? process.cwd(), oldValue);
         if (declaration.type === declaration_1.ParameterType.Flags) {
             Object.assign(this._values[declaration.name], converted);
         }

package/dist/lib/utils/options/sources/typedoc.js

@@ -89,6 +89,28 @@ function addTypeDocOptions(options) {
         help: "Ignore protected variables and methods.",
         type: declaration_1.ParameterType.Boolean,
     });
+    options.addDeclaration({
+        name: "externalSymbolLinkMappings",
+        help: "Define custom links for symbols not included in the documentation.",
+        type: declaration_1.ParameterType.Mixed,
+        defaultValue: {},
+        validate(value) {
+            const error = "externalSymbolLinkMappings must be a Record<package name, Record<symbol name, link>>";
+            if (!Validation.validate({}, value)) {
+                throw new Error(error);
+            }
+            for (const mappings of Object.values(value)) {
+                if (!Validation.validate({}, mappings)) {
+                    throw new Error(error);
+                }
+                for (const link of Object.values(mappings)) {
+                    if (typeof link !== "string") {
+                        throw new Error(error);
+                    }
+                }
+            }
+        },
+    });
     options.addDeclaration({
         name: "media",
         help: "Specify the location with media files that should be copied to the output directory.",

package/dist/lib/utils/package-manifest.d.ts

@@ -1,5 +1,5 @@
 import type { Logger } from "./loggers";
-import type { IMinimatch } from "minimatch";
+import type { Minimatch } from "minimatch";
 import { additionalProperties, Infer } from "./validation";
 /**
  * Loads a package.json and validates that it is a JSON Object
@@ -20,7 +20,7 @@ export declare function extractTypedocConfigFromPackageManifest(logger: Logger,
  * Given a list of (potentially wildcarded) package paths,
  * return all the actual package folders found.
  */
-export declare function expandPackages(logger: Logger, packageJsonDir: string, workspaces: string[], exclude: IMinimatch[]): string[];
+export declare function expandPackages(logger: Logger, packageJsonDir: string, workspaces: string[], exclude: Minimatch[]): string[];
 export declare const ignorePackage: unique symbol;
 /**
  * Given a package.json, attempt to find the TS file that defines its entry point

package/dist/lib/utils/paths.d.ts

@@ -1,9 +1,9 @@
-import { IMinimatch } from "minimatch";
+import { Minimatch } from "minimatch";
 /**
  * Convert array of glob patterns to array of minimatch instances.
  *
  * Handle a few Windows-Unix path gotchas.
  */
-export declare function createMinimatch(patterns: string[]): IMinimatch[];
-export declare function matchesAny(patterns: readonly IMinimatch[], path: string): boolean;
+export declare function createMinimatch(patterns: string[]): Minimatch[];
+export declare function matchesAny(patterns: readonly Minimatch[], path: string): boolean;
 export declare function nicePath(absPath: string): string;

package/dist/lib/utils/reflections.d.ts

@@ -0,0 +1,5 @@
+import { ProjectReflection, ReferenceType, Reflection } from "../models";
+export declare function discoverAllReferenceTypes(project: ProjectReflection, forExportValidation: boolean): {
+    type: ReferenceType;
+    owner: Reflection;
+}[];

package/dist/lib/utils/reflections.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverAllReferenceTypes = void 0;
+const models_1 = require("../models");
+function discoverAllReferenceTypes(project, forExportValidation) {
+    let current = project;
+    const queue = [];
+    const result = [];
+    const visitor = (0, models_1.makeRecursiveVisitor)({
+        reference(type) {
+            result.push({ type, owner: current });
+        },
+        reflection(type) {
+            queue.push(type.declaration);
+        },
+    });
+    const add = (item) => {
+        if (!item)
+            return;
+        if (item instanceof models_1.Reflection) {
+            queue.push(item);
+        }
+        else {
+            queue.push(...item);
+        }
+    };
+    do {
+        if (current instanceof models_1.ContainerReflection) {
+            add(current.children);
+        }
+        if (current instanceof models_1.DeclarationReflection) {
+            current.type?.visit(visitor);
+            add(current.typeParameters);
+            add(current.signatures);
+            add(current.indexSignature);
+            add(current.getSignature);
+            add(current.setSignature);
+            current.overwrites?.visit(visitor);
+            current.implementedTypes?.forEach((type) => type.visit(visitor));
+            if (!forExportValidation) {
+                current.inheritedFrom?.visit(visitor);
+                current.implementationOf?.visit(visitor);
+                current.extendedTypes?.forEach((t) => t.visit(visitor));
+                current.extendedBy?.forEach((t) => t.visit(visitor));
+                current.implementedBy?.forEach((t) => t.visit(visitor));
+            }
+        }
+        if (current instanceof models_1.SignatureReflection) {
+            add(current.parameters);
+            add(current.typeParameters);
+            current.type?.visit(visitor);
+            current.overwrites?.visit(visitor);
+            if (!forExportValidation) {
+                current.inheritedFrom?.visit(visitor);
+                current.implementationOf?.visit(visitor);
+            }
+        }
+        if (current instanceof models_1.ParameterReflection) {
+            current.type?.visit(visitor);
+        }
+        if (current instanceof models_1.TypeParameterReflection) {
+            current.type?.visit(visitor);
+            current.default?.visit(visitor);
+        }
+    } while ((current = queue.shift()));
+    return result;
+}
+exports.discoverAllReferenceTypes = discoverAllReferenceTypes;

package/dist/lib/validation/exports.d.ts

@@ -1,3 +1,3 @@
-import { ProjectReflection } from "../models";
+import type { ProjectReflection } from "../models";
 import type { Logger } from "../utils";
 export declare function validateExports(project: ProjectReflection, logger: Logger, intentionallyNotExported: readonly string[]): void;

package/dist/lib/validation/exports.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateExports = void 0;
 const ts = require("typescript");
-const models_1 = require("../models");
+const reflections_1 = require("../utils/reflections");
 function makeIntentionallyExportedHelper(intentional, logger) {
     const used = new Set();
     const processed = intentional.map((v) => {
@@ -45,73 +45,21 @@ function makeIntentionallyExportedHelper(intentional, logger) {
     };
 }
 function validateExports(project, logger, intentionallyNotExported) {
-    let current = project;
-    const queue = [];
     const intentional = makeIntentionallyExportedHelper(intentionallyNotExported, logger);
     const warned = new Set();
-    const visitor = (0, models_1.makeRecursiveVisitor)({
-        reference(type) {
-            // If we don't have a symbol, then this was an intentionally broken reference.
-            const symbol = type.getSymbol();
-            if (!type.reflection && symbol) {
-                if ((symbol.flags & ts.SymbolFlags.TypeParameter) === 0 &&
-                    !intentional.has(symbol, type.qualifiedName) &&
-                    !warned.has(symbol)) {
-                    warned.add(symbol);
-                    const decl = symbol.declarations[0];
-                    logger.warn(`${type.qualifiedName} is referenced by ${current.getFullName()} but not included in the documentation.`, decl);
-                }
+    for (const { type, owner } of (0, reflections_1.discoverAllReferenceTypes)(project, true)) {
+        // If we don't have a symbol, then this was an intentionally broken reference.
+        const symbol = type.getSymbol();
+        if (!type.reflection && !type.externalUrl && symbol) {
+            if ((symbol.flags & ts.SymbolFlags.TypeParameter) === 0 &&
+                !intentional.has(symbol, type.qualifiedName) &&
+                !warned.has(symbol)) {
+                warned.add(symbol);
+                const decl = symbol.declarations[0];
+                logger.warn(`${type.qualifiedName} is referenced by ${owner.getFullName()} but not included in the documentation.`, decl);
             }
-        },
-        reflection(type) {
-            queue.push(type.declaration);
-        },
-    });
-    const add = (item) => {
-        if (!item)
-            return;
-        if (item instanceof models_1.Reflection) {
-            queue.push(item);
-        }
-        else {
-            queue.push(...item);
-        }
-    };
-    do {
-        if (current instanceof models_1.ContainerReflection) {
-            add(current.children);
-        }
-        if (current instanceof models_1.DeclarationReflection) {
-            current.type?.visit(visitor);
-            add(current.typeParameters);
-            add(current.signatures);
-            add(current.indexSignature);
-            add(current.getSignature);
-            add(current.setSignature);
-            current.overwrites?.visit(visitor);
-            // Do not check inheritedFrom, it doesn't always make sense to export a base type.
-            // Do not validate implementationOf will always be defined or intentionally broken.
-            // Do not check extendedTypes, it doesn't always make sense to export a base type.
-            // Do not validate extendedBy, guaranteed to all be in the documentation.
-            current.implementedTypes?.forEach((type) => type.visit(visitor));
-            // Do not validate implementedBy, guaranteed to all be in the documentation.
-        }
-        if (current instanceof models_1.SignatureReflection) {
-            add(current.parameters);
-            add(current.typeParameters);
-            current.type?.visit(visitor);
-            current.overwrites?.visit(visitor);
-            // Do not check inheritedFrom, it doesn't always make sense to export a base type.
-            // Do not validate implementationOf will always be defined or intentionally broken.
         }
-        if (current instanceof models_1.ParameterReflection) {
-            current.type?.visit(visitor);
-        }
-        if (current instanceof models_1.TypeParameterReflection) {
-            current.type?.visit(visitor);
-            current.default?.visit(visitor);
-        }
-    } while ((current = queue.shift()));
+    }
     const unusedIntentional = intentional.getUnused();
     if (unusedIntentional.length) {
         logger.warn("The following symbols were marked as intentionally not exported, but were either not referenced in the documentation, or were exported:\n\t" +

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typedoc",
   "description": "Create api documentation for TypeScript projects.",
-  "version": "0.23.11",
+  "version": "0.23.14",
   "homepage": "https://typedoc.org",
   "main": "./dist/index.js",
   "exports": {
@@ -35,15 +35,15 @@
   "devDependencies": {
     "@types/lunr": "^2.3.4",
     "@types/marked": "^4.0.6",
-    "@types/minimatch": "5.1.0",
+    "@types/minimatch": "5.1.2",
     "@types/mocha": "^9.1.1",
     "@types/node": "14",
-    "@typescript-eslint/eslint-plugin": "^5.35.1",
-    "@typescript-eslint/parser": "^5.35.1",
-    "@typestrong/fs-fixture-builder": "github:TypeStrong/fs-fixture-builder#b88cd06fe814614a0d924af9d10d04ff95a551de",
+    "@typescript-eslint/eslint-plugin": "^5.36.1",
+    "@typescript-eslint/parser": "^5.36.1",
+    "@typestrong/fs-fixture-builder": "github:TypeStrong/fs-fixture-builder#5a9486bc66f6e36988106685768396281f6cbc10",
     "c8": "^7.12.0",
-    "esbuild": "^0.15.5",
-    "eslint": "^8.22.0",
+    "esbuild": "^0.15.6",
+    "eslint": "^8.23.0",
     "mocha": "^10.0.0",
     "prettier": "2.7.1",
     "puppeteer": "^13.5.2",

package/static/style.css

@@ -1124,6 +1124,7 @@ ul.tsd-type-parameter-list h5 {
     display: flex;
     justify-content: space-between;
     height: 2.5rem;
+    margin: 0 auto;
 }
 .tsd-page-toolbar .table-cell {
     position: relative;