typedoc 0.28.6 → 0.28.8

package/dist/index.d.ts

@@ -41,7 +41,7 @@ export type { Icons, NavigationElement, PageDefinition, PageHeading, RendererEve
 export { Outputs } from "./lib/output/output.js";
 export { ArgumentsReader, CommentStyle, EntryPointStrategy, normalizePath, Option, OptionDefaults, Options, PackageJsonReader, ParameterHint, ParameterType, TSConfigReader, TypeDocReader, ValidatingFileRegistry, } from "./lib/utils/index.js";
 export type { ArrayDeclarationOption, BooleanDeclarationOption, DeclarationOption, DeclarationOptionBase, DeclarationOptionToOptionType, DocumentationEntryPoint, FancyConsoleLogger, FlagsDeclarationOption, JsDocCompatibility, KeyToDeclaration, ManuallyValidatedOption, MapDeclarationOption, MixedDeclarationOption, NumberDeclarationOption, ObjectDeclarationOption, OptionsReader, OutputSpecification, ParameterTypeToOptionTypeMap, SortStrategy, StringDeclarationOption, TypeDocOptionMap, TypeDocOptions, TypeDocOptionValues, ValidationOptions, } from "./lib/utils/index.js";
-export { type ComponentPath, ConsoleLogger, type DeclarationReference, type EnumKeys, EventDispatcher, EventHooks, type GlobString, i18n, JSX, Logger, LogLevel, type Meaning, type MeaningKeyword, type MinimalNode, MinimalSourceFile, type NormalizedPath, type NormalizedPathOrModule, type SymbolReference, type TranslatedString, translateTagName, } from "#utils";
+export { type ComponentPath, ConsoleLogger, type DeclarationReference, type EnumKeys, EventDispatcher, EventHooks, type GlobString, i18n, JSX, Logger, LogLevel, type Meaning, type MeaningKeyword, type MinimalNode, MinimalSourceFile, type NormalizedPath, type NormalizedPathOrModule, type NormalizedPathOrModuleOrFunction, type SymbolReference, type TranslatedString, translateTagName, } from "#utils";
 export { type Deserializable, Deserializer, type DeserializerComponent, JSONOutput, SerializeEvent, Serializer, type SerializerComponent, type SerializerEvents, } from "./lib/serialization/index.js";
 export * as Internationalization from "./lib/internationalization/index.js";
 export type { TranslatableStrings } from "./lib/internationalization/internationalization.js";

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

@@ -1,3 +1,4 @@
 import ts from "typescript";
 import { type Token } from "./lexer.js";
-export declare function lexBlockComment(file: string, pos?: number, end?: number, jsDoc?: ts.JSDoc | undefined, checker?: ts.TypeChecker | undefined): Generator<Token, undefined, undefined>;
+import type { Context } from "../context.js";
+export declare function lexBlockComment(file: string, pos?: number, end?: number, createSymbolId?: Context["createSymbolId"], jsDoc?: ts.JSDoc | undefined, checker?: ts.TypeChecker | undefined): Generator<Token, undefined, undefined>;

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

@@ -1,11 +1,12 @@
 import ts from "typescript";
 import { TokenSyntaxKind } from "./lexer.js";
 import { resolveAliasedSymbol } from "../utils/symbols.js";
-import { createSymbolId } from "../factories/symbol-id.js";
-export function* lexBlockComment(file, pos = 0, end = file.length, jsDoc = undefined, checker = undefined) {
+export function* lexBlockComment(file, pos = 0, end = file.length, createSymbolId = () => {
+    throw new Error("unreachable");
+}, jsDoc = undefined, checker = undefined) {
     // Wrapper around our real lex function to collapse adjacent text tokens.
     let textToken;
-    for (const token of lexBlockComment2(file, pos, end, getLinkTags(jsDoc), checker)) {
+    for (const token of lexBlockComment2(file, pos, end, getLinkTags(jsDoc), checker, createSymbolId)) {
         if (token.kind === TokenSyntaxKind.Text) {
             if (textToken) {
                 textToken.text += token.text;
@@ -53,7 +54,7 @@ function getLinkTags(jsDoc) {
     }
     return result;
 }
-function* lexBlockComment2(file, pos, end, linkTags, checker) {
+function* lexBlockComment2(file, pos, end, linkTags, checker, createSymbolId) {
     pos += 2; // Leading '/*'
     end -= 2; // Trailing '*/'
     if (pos < end && file[pos] === "*") {
@@ -208,7 +209,7 @@ function* lexBlockComment2(file, pos, end, linkTags, checker) {
                 }
                 if (lookahead !== pos + 1) {
                     while (lookahead < end &&
-                        /[a-z0-9]/i.test(file[lookahead])) {
+                        /[a-z0-9-]/i.test(file[lookahead])) {
                         lookahead++;
                     }
                 }

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

@@ -78,6 +78,7 @@ const wantedKinds = {
     [ReflectionKind.Interface]: [
         ts.SyntaxKind.InterfaceDeclaration,
         ts.SyntaxKind.TypeAliasDeclaration,
+        ts.SyntaxKind.ClassDeclaration, // type only exports
     ],
     [ReflectionKind.Constructor]: [ts.SyntaxKind.Constructor],
     [ReflectionKind.Property]: variablePropertyKinds,
@@ -102,7 +103,12 @@ const wantedKinds = {
     [ReflectionKind.Accessor]: [ts.SyntaxKind.PropertyDeclaration],
     [ReflectionKind.GetSignature]: [ts.SyntaxKind.GetAccessor],
     [ReflectionKind.SetSignature]: [ts.SyntaxKind.SetAccessor],
-    [ReflectionKind.TypeAlias]: [ts.SyntaxKind.TypeAliasDeclaration],
+    [ReflectionKind.TypeAlias]: [
+        ts.SyntaxKind.TypeAliasDeclaration,
+        ts.SyntaxKind.FunctionDeclaration, // type only exports
+        // Intentionally not included to avoid comments being copied for variable/alias combos
+        // ts.SyntaxKind.VariableDeclaration,
+    ],
     [ReflectionKind.Reference]: [
         ts.SyntaxKind.NamespaceExport,
         ts.SyntaxKind.ExportSpecifier,

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

@@ -3,6 +3,7 @@ import { Comment, ReflectionKind } from "../../models/index.js";
 import type { CommentStyle, JsDocCompatibility } from "../../utils/options/declaration.js";
 import type { FileRegistry } from "../../models/FileRegistry.js";
 import { type Logger } from "#utils";
+import type { Context } from "../context.js";
 export interface CommentParserConfig {
     blockTags: Set<string>;
     inlineTags: Set<string>;
@@ -12,9 +13,23 @@ export interface CommentParserConfig {
     useTsLinkResolution: boolean;
     commentStyle: CommentStyle;
 }
+export interface CommentContext {
+    config: CommentParserConfig;
+    logger: Logger;
+    checker: ts.TypeChecker;
+    files: FileRegistry;
+    createSymbolId: Context["createSymbolId"];
+}
+export interface CommentContextOptionalChecker {
+    config: CommentParserConfig;
+    logger: Logger;
+    checker?: ts.TypeChecker | undefined;
+    files: FileRegistry;
+    createSymbolId: Context["createSymbolId"];
+}
 export declare function clearCommentCache(): void;
-export declare function getComment(symbol: ts.Symbol, kind: ReflectionKind, config: CommentParserConfig, logger: Logger, checker: ts.TypeChecker, files: FileRegistry): Comment | undefined;
-export declare function getNodeComment(node: ts.Node, moduleComment: boolean, config: CommentParserConfig, logger: Logger, checker: ts.TypeChecker | undefined, files: FileRegistry): Comment | undefined;
-export declare function getFileComment(file: ts.SourceFile, config: CommentParserConfig, logger: Logger, checker: ts.TypeChecker | undefined, files: FileRegistry): Comment | undefined;
-export declare function getSignatureComment(declaration: ts.SignatureDeclaration | ts.JSDocSignature, config: CommentParserConfig, logger: Logger, checker: ts.TypeChecker, files: FileRegistry): Comment | undefined;
-export declare function getJsDocComment(declaration: ts.JSDocPropertyLikeTag | ts.JSDocCallbackTag | ts.JSDocTypedefTag | ts.JSDocTemplateTag | ts.JSDocEnumTag, config: CommentParserConfig, logger: Logger, checker: ts.TypeChecker | undefined, files: FileRegistry): Comment | undefined;
+export declare function getComment(symbol: ts.Symbol, kind: ReflectionKind, context: CommentContext): Comment | undefined;
+export declare function getNodeComment(node: ts.Node, moduleComment: boolean, context: CommentContext): Comment | undefined;
+export declare function getFileComment(file: ts.SourceFile, context: CommentContext): Comment | undefined;
+export declare function getSignatureComment(declaration: ts.SignatureDeclaration | ts.JSDocSignature, context: CommentContext): Comment | undefined;
+export declare function getJsDocComment(declaration: ts.JSDocPropertyLikeTag | ts.JSDocCallbackTag | ts.JSDocTypedefTag | ts.JSDocTemplateTag | ts.JSDocEnumTag, context: CommentContext): Comment | undefined;

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

@@ -21,7 +21,7 @@ export function clearCommentCache() {
     commentCache = new WeakMap();
     commentDiscoveryId = 0;
 }
-function getCommentWithCache(discovered, config, logger, checker, files) {
+function getCommentWithCache(discovered, context) {
     if (!discovered)
         return;
     const { file, ranges, jsDoc } = discovered;
@@ -34,10 +34,10 @@ function getCommentWithCache(discovered, config, logger, checker, files) {
     let comment;
     switch (ranges[0].kind) {
         case ts.SyntaxKind.MultiLineCommentTrivia:
-            comment = parseComment(lexBlockComment(file.text, ranges[0].pos, ranges[0].end, jsDoc, checker), config, file, logger, files);
+            comment = parseComment(lexBlockComment(file.text, ranges[0].pos, ranges[0].end, context.createSymbolId, jsDoc, context.checker), file, context);
             break;
         case ts.SyntaxKind.SingleLineCommentTrivia:
-            comment = parseComment(lexLineComments(file.text, ranges), config, file, logger, files);
+            comment = parseComment(lexLineComments(file.text, ranges), file, context);
             break;
         default:
             assertNever(ranges[0].kind);
@@ -48,8 +48,11 @@ function getCommentWithCache(discovered, config, logger, checker, files) {
     commentCache.set(file, cache);
     return comment.clone();
 }
-function getCommentImpl(commentSource, config, logger, moduleComment, checker, files) {
-    const comment = getCommentWithCache(commentSource, config, logger, config.useTsLinkResolution ? checker : undefined, files);
+function getCommentImpl(commentSource, moduleComment, context) {
+    const comment = getCommentWithCache(commentSource, {
+        ...context,
+        checker: context.config.useTsLinkResolution ? context.checker : undefined,
+    });
     if (comment?.getTag("@import") || comment?.getTag("@license")) {
         return;
     }
@@ -70,15 +73,15 @@ function getCommentImpl(commentSource, config, logger, moduleComment, checker, f
     }
     return comment;
 }
-export function getComment(symbol, kind, config, logger, checker, files) {
+export function getComment(symbol, kind, context) {
     const declarations = symbol.declarations || [];
     if (declarations.length &&
         declarations.every((d) => jsDocCommentKinds.includes(d.kind))) {
-        return getJsDocComment(declarations[0], config, logger, checker, files);
+        return getJsDocComment(declarations[0], context);
     }
     const sf = declarations.find(ts.isSourceFile);
     if (sf) {
-        return getFileComment(sf, config, logger, checker, files);
+        return getFileComment(sf, context);
     }
     const isModule = declarations.some((decl) => {
         if (ts.isModuleDeclaration(decl) && ts.isStringLiteral(decl.name)) {
@@ -86,18 +89,18 @@ export function getComment(symbol, kind, config, logger, checker, files) {
         }
         return false;
     });
-    const comment = getCommentImpl(discoverComment(symbol, kind, logger, config.commentStyle, checker, !config.suppressCommentWarningsInDeclarationFiles), config, logger, isModule, checker, files);
+    const comment = getCommentImpl(discoverComment(symbol, kind, context.logger, context.config.commentStyle, context.checker, !context.config.suppressCommentWarningsInDeclarationFiles), isModule, context);
     if (!comment && kind === ReflectionKind.Property) {
-        return getConstructorParamPropertyComment(symbol, config, logger, checker, files);
+        return getConstructorParamPropertyComment(symbol, context);
     }
     return comment;
 }
-export function getNodeComment(node, moduleComment, config, logger, checker, files) {
-    return getCommentImpl(discoverNodeComment(node, config.commentStyle), config, logger, moduleComment, checker, files);
+export function getNodeComment(node, moduleComment, context) {
+    return getCommentImpl(discoverNodeComment(node, context.config.commentStyle), moduleComment, context);
 }
-export function getFileComment(file, config, logger, checker, files) {
-    for (const commentSource of discoverFileComments(file, config.commentStyle)) {
-        const comment = getCommentWithCache(commentSource, config, logger, config.useTsLinkResolution ? checker : undefined, files);
+export function getFileComment(file, context) {
+    for (const commentSource of discoverFileComments(file, context.config.commentStyle)) {
+        const comment = getCommentWithCache(commentSource, context);
         if (comment?.getTag("@license") || comment?.getTag("@import")) {
             continue;
         }
@@ -108,12 +111,12 @@ export function getFileComment(file, config, logger, checker, files) {
         return;
     }
 }
-function getConstructorParamPropertyComment(symbol, config, logger, checker, files) {
+function getConstructorParamPropertyComment(symbol, context) {
     const decl = symbol.declarations?.find(ts.isParameter);
     if (!decl)
         return;
     const ctor = decl.parent;
-    const comment = getSignatureComment(ctor, config, logger, checker, files);
+    const comment = getSignatureComment(ctor, context);
     const paramTag = comment?.getIdentifiedTag(symbol.name, "@param");
     if (paramTag) {
         const result = new Comment(paramTag.content);
@@ -121,10 +124,10 @@ function getConstructorParamPropertyComment(symbol, config, logger, checker, fil
         return result;
     }
 }
-export function getSignatureComment(declaration, config, logger, checker, files) {
-    return getCommentImpl(discoverSignatureComment(declaration, checker, config.commentStyle), config, logger, false, checker, files);
+export function getSignatureComment(declaration, context) {
+    return getCommentImpl(discoverSignatureComment(declaration, context.checker, context.config.commentStyle), false, context);
 }
-export function getJsDocComment(declaration, config, logger, checker, files) {
+export function getJsDocComment(declaration, context) {
     const file = declaration.getSourceFile();
     // First, get the whole comment. We know we'll need all of it.
     let parent = declaration.parent;
@@ -143,7 +146,7 @@ export function getJsDocComment(declaration, config, logger, checker, files) {
         ],
         jsDoc: parent,
         inheritedFromParentDeclaration: false,
-    }, config, logger, config.useTsLinkResolution ? checker : undefined, files);
+    }, context);
     // And pull out the tag we actually care about.
     if (ts.isJSDocEnumTag(declaration)) {
         const result = new Comment(comment.getTag("@enum")?.content);
@@ -156,7 +159,7 @@ export function getJsDocComment(declaration, config, logger, checker, files) {
         // We could just put the same comment on everything, but due to how comment parsing works,
         // we'd have to search for any @template with a name starting with the first type parameter's name
         // which feels horribly hacky.
-        logger.warn(i18n.multiple_type_parameters_on_template_tag_unsupported(), declaration);
+        context.logger.warn(i18n.multiple_type_parameters_on_template_tag_unsupported(), declaration);
         return;
     }
     let name;
@@ -176,7 +179,7 @@ export function getJsDocComment(declaration, config, logger, checker, files) {
         // was a comment attached. If there wasn't, then don't error about failing to find
         // a tag because this is unsupported.
         if (!ts.isJSDocTemplateTag(declaration)) {
-            logger.error(i18n.failed_to_find_jsdoc_tag_for_name_0(name), declaration);
+            context.logger.error(i18n.failed_to_find_jsdoc_tag_for_name_0(name), declaration);
         }
     }
     else {

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

@@ -145,7 +145,7 @@ function* lexLineComments2(file, pos, end) {
                 }
                 if (lookahead !== pos + 1) {
                     while (lookahead < end &&
-                        /[a-z0-9]/i.test(file[lookahead])) {
+                        /[a-z0-9-]/i.test(file[lookahead])) {
                         lookahead++;
                     }
                 }

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

@@ -1,4 +1,4 @@
-import { type Comment, type CommentDisplayPart, Reflection, ReflectionSymbolId } from "../../models/index.js";
+import { type CommentDisplayPart, Reflection, ReflectionSymbolId } from "../../models/index.js";
 import { type DeclarationReference } from "#utils";
 export type ExternalResolveResult = {
     target: string;
@@ -16,5 +16,5 @@ export type ExternalSymbolResolver = (ref: DeclarationReference, refl: Reflectio
 export type LinkResolverOptions = {
     preserveLinkText: boolean;
 };
-export declare function resolveLinks(comment: Comment, reflection: Reflection, externalResolver: ExternalSymbolResolver, options: LinkResolverOptions): void;
+export declare function resolveLinks(reflection: Reflection, externalResolver: ExternalSymbolResolver, options: LinkResolverOptions): void;
 export declare function resolvePartLinks(reflection: Reflection, parts: readonly CommentDisplayPart[], externalResolver: ExternalSymbolResolver, options: LinkResolverOptions): CommentDisplayPart[];

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

@@ -1,19 +1,62 @@
 import ts from "typescript";
-import { DeclarationReflection, Reflection, ReflectionKind, ReflectionSymbolId, } from "../../models/index.js";
+import { makeRecursiveVisitor, Reflection, ReflectionKind, ReflectionSymbolId, } from "../../models/index.js";
 import { resolveDeclarationReference } from "./declarationReferenceResolver.js";
 import { maxElementByScore, parseDeclarationReference } from "#utils";
 const urlPrefix = /^(http|ftp)s?:\/\//;
-export function resolveLinks(comment, reflection, externalResolver, options) {
-    comment.summary = resolvePartLinks(reflection, comment.summary, externalResolver, options);
-    for (const tag of comment.blockTags) {
-        tag.content = resolvePartLinks(reflection, tag.content, externalResolver, options);
+export function resolveLinks(reflection, externalResolver, options) {
+    if (reflection.comment) {
+        reflection.comment.summary = resolvePartLinks(reflection, reflection.comment.summary, externalResolver, options);
+        for (const tag of reflection.comment.blockTags) {
+            tag.content = resolvePartLinks(reflection, tag.content, externalResolver, options);
+        }
     }
-    if (reflection instanceof DeclarationReflection && reflection.readme) {
+    if ((reflection.isDeclaration() || reflection.isProject()) && reflection.readme) {
         reflection.readme = resolvePartLinks(reflection, reflection.readme, externalResolver, options);
     }
+    if (reflection.isDeclaration()) {
+        reflection.type?.visit(makeRecursiveVisitor({
+            union: (type) => {
+                type.elementSummaries = type.elementSummaries?.map((parts) => resolvePartLinks(reflection, parts, externalResolver, options));
+            },
+        }));
+    }
     if (reflection.isDocument()) {
         reflection.content = resolvePartLinks(reflection, reflection.content, externalResolver, options);
     }
+    if (reflection.isParameter() &&
+        reflection.type?.type === "reference" &&
+        reflection.type.highlightedProperties) {
+        const resolved = new Map(Array.from(reflection.type.highlightedProperties, ([name, parts]) => {
+            return [
+                name,
+                resolvePartLinks(reflection, parts, externalResolver, options),
+            ];
+        }));
+        reflection.type.highlightedProperties = resolved;
+    }
+    if (reflection.isContainer()) {
+        if (reflection.groups) {
+            for (const group of reflection.groups) {
+                if (group.description) {
+                    group.description = resolvePartLinks(reflection, group.description, externalResolver, options);
+                }
+                if (group.categories) {
+                    for (const cat of group.categories) {
+                        if (cat.description) {
+                            cat.description = resolvePartLinks(reflection, cat.description, externalResolver, options);
+                        }
+                    }
+                }
+            }
+        }
+        if (reflection.categories) {
+            for (const cat of reflection.categories) {
+                if (cat.description) {
+                    cat.description = resolvePartLinks(reflection, cat.description, externalResolver, options);
+                }
+            }
+        }
+    }
 }
 export function resolvePartLinks(reflection, parts, externalResolver, options) {
     return parts.flatMap((part) => processPart(reflection, part, externalResolver, options));
@@ -48,10 +91,10 @@ function resolveLinkTag(reflection, part, externalResolver, options) {
         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
+            // 4. A direct export (class, interface, variable)
+            // 3. A property of a direct export (class/interface property)
+            // 2. A property of a type of an export (property on type alias)
+            // 1. Whatever the first symbol found was
             target = maxElementByScore(tsTargets, (r) => {
                 if (r.kindOf(ReflectionKind.SomeExport)) {
                     return 4;

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

@@ -1,10 +1,10 @@
-import type { CommentParserConfig } from "./index.js";
+import type { CommentContextOptionalChecker, CommentParserConfig } from "./index.js";
 import { Comment, type CommentDisplayPart } from "../../models/index.js";
 import type { MinimalSourceFile } from "#utils";
 import { type Token } from "./lexer.js";
 import { FileRegistry } from "../../models/FileRegistry.js";
 import { type Logger } from "#utils";
-export declare function parseComment(tokens: Generator<Token, undefined, undefined>, config: CommentParserConfig, file: MinimalSourceFile, logger: Logger, files: FileRegistry): Comment;
+export declare function parseComment(tokens: Generator<Token, undefined, undefined>, file: MinimalSourceFile, context: CommentContextOptionalChecker): Comment;
 /**
  * Intended for parsing markdown documents. This only parses code blocks and
  * inline tags outside of code blocks, everything else is text.

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

@@ -40,24 +40,24 @@ function makeLookaheadGenerator(gen) {
         },
     };
 }
-export function parseComment(tokens, config, file, logger, files) {
+export function parseComment(tokens, file, context) {
     const lexer = makeLookaheadGenerator(tokens);
     const tok = lexer.done() || lexer.peek();
     const comment = new Comment();
     comment.sourcePath = file.fileName;
-    comment.summary = blockContent(comment, lexer, config, i18n, warningImpl, files);
+    comment.summary = blockContent(comment, lexer, context.config, i18n, warningImpl, context.files);
     while (!lexer.done()) {
-        comment.blockTags.push(blockTag(comment, lexer, config, i18n, warningImpl, files));
+        comment.blockTags.push(blockTag(comment, lexer, context.config, i18n, warningImpl, context.files));
     }
     const tok2 = tok;
-    postProcessComment(comment, i18n, () => `${nicePath(file.fileName)}:${file.getLineAndCharacterOfPosition(tok2.pos).line + 1}`, (message) => logger.warn(message));
+    postProcessComment(comment, i18n, () => `${nicePath(file.fileName)}:${file.getLineAndCharacterOfPosition(tok2.pos).line + 1}`, (message) => context.logger.warn(message));
     return comment;
     function warningImpl(message, token) {
-        if (config.suppressCommentWarningsInDeclarationFiles &&
+        if (context.config.suppressCommentWarningsInDeclarationFiles &&
             hasDeclarationFileExtension(file.fileName)) {
             return;
         }
-        logger.warn(message, token.pos, file);
+        context.logger.warn(message, token.pos, file);
     }
 }
 /**

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

@@ -151,7 +151,7 @@ function* lexCommentString2(file) {
                 }
                 if (lookahead !== pos + 1) {
                     while (lookahead < end &&
-                        /[a-z0-9]/i.test(file[lookahead])) {
+                        /[a-z0-9-]/i.test(file[lookahead])) {
                         lookahead++;
                     }
                 }

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

@@ -85,9 +85,11 @@ export function textContent(sourcePath, token, i18n, warning, outContent, files,
             addRef(reference);
             continue;
         }
-        const tagLink = checkTagLink(data);
-        if (tagLink) {
-            addRef(tagLink);
+        const tagLinks = checkTagLink(data);
+        if (tagLinks.length) {
+            for (const tagLink of tagLinks) {
+                addRef(tagLink);
+            }
             continue;
         }
         const atNewLine = token.text[data.pos] === "\n";
@@ -221,39 +223,111 @@ function checkReference(data) {
     }
 }
 /**
- * Looks for `<a href="./relative">` and `<img src="./relative">`
+ * Looks for `<a href="./relative">`, `<img src="./relative">`, and `<source srcset="./relative">`
  */
 function checkTagLink(data) {
     const { pos, token } = data;
     if (token.text.startsWith("<img ", pos)) {
         data.pos += 4;
-        return checkAttribute(data, "src");
+        return checkAttributes(data, {
+            src: checkAttributeDirectPath,
+            srcset: checkAttributeSrcSet,
+        });
+    }
+    if (token.text.startsWith("<link ", pos)) {
+        data.pos += 4;
+        return checkAttributes(data, {
+            imagesrcset: checkAttributeSrcSet,
+        });
     }
     if (token.text.startsWith("<a ", pos)) {
         data.pos += 3;
-        return checkAttribute(data, "href");
+        return checkAttributes(data, { href: checkAttributeDirectPath });
     }
+    if (token.text.startsWith("<source ", pos)) {
+        data.pos += 8;
+        return checkAttributes(data, {
+            src: checkAttributeDirectPath,
+            srcset: checkAttributeSrcSet,
+        });
+    }
+    return [];
 }
-function checkAttribute(data, attr) {
+function checkAttributes(data, attributes) {
+    const links = [];
     const parser = new HtmlAttributeParser(data.token.text, data.pos);
     while (parser.state !== ParserState.END) {
         if (parser.state === ParserState.BeforeAttributeValue &&
-            parser.currentAttributeName === attr) {
+            Object.prototype.hasOwnProperty.call(attributes, parser.currentAttributeName)) {
             parser.step();
-            if (isRelativePath(parser.currentAttributeValue)) {
-                data.pos = parser.pos;
-                const { target, anchor } = data.files.register(data.sourcePath, parser.currentAttributeValue) || { target: undefined, anchor: undefined };
-                return {
-                    pos: parser.currentAttributeValueStart,
-                    end: parser.currentAttributeValueEnd,
-                    target,
-                    targetAnchor: anchor,
-                };
-            }
-            return;
+            links.push(...attributes[parser.currentAttributeName](data, parser.currentAttributeValue, parser.currentAttributeValueStart, parser.currentAttributeValueEnd));
         }
         parser.step();
     }
+    return links;
+}
+function checkAttributeDirectPath(data, text, pos, end) {
+    if (isRelativePath(text.trim())) {
+        const { target, anchor } = data.files.register(data.sourcePath, text.trim()) || { target: undefined, anchor: undefined };
+        return [{
+                pos,
+                end,
+                target,
+                targetAnchor: anchor,
+            }];
+    }
+    return [];
+}
+// See https://html.spec.whatwg.org/multipage/images.html#srcset-attribute
+function checkAttributeSrcSet(data, text, pos, _end) {
+    const result = [];
+    let textPos = 0;
+    parseImageCandidate();
+    while (textPos < text.length && text[textPos] == ",") {
+        ++textPos;
+        parseImageCandidate();
+    }
+    return result;
+    function parseImageCandidate() {
+        // 1. Zero or more ASCII whitespace
+        while (textPos < text.length && /[\t\r\f\n ]/.test(text[textPos]))
+            ++textPos;
+        // 2. A valid non-empty URL that does not start or end with a comma
+        // TypeDoc: We don't exactly match this, PR welcome! For now, just permit anything
+        // that's not whitespace or a comma
+        const url = text.slice(textPos).match(/^[^\t\r\f\n ,]+/);
+        if (url && isRelativePath(url[0])) {
+            const { target, anchor } = data.files.register(data.sourcePath, url[0]) || { target: undefined, anchor: undefined };
+            result.push({
+                pos: pos + textPos,
+                end: pos + textPos + url[0].length,
+                target,
+                targetAnchor: anchor,
+            });
+        }
+        textPos += url ? url[0].length : 0;
+        // 3. Zero or more ASCII whitespace
+        while (textPos < text.length && /[\t\r\f\n ]/.test(text[textPos]))
+            ++textPos;
+        // 4. Zero or one of the following:
+        {
+            // A width descriptor, consisting of: ASCII whitespace, a valid non-negative integer giving
+            // a number greater than zero representing the width descriptor value, and a U+0077 LATIN
+            // SMALL LETTER W character.
+            const w = text.slice(textPos).match(/^\+?\d+\s*w/);
+            textPos += w ? w[0].length : 0;
+            // A pixel density descriptor, consisting of: ASCII whitespace, a valid floating-point number
+            // giving a number greater than zero representing the pixel density descriptor value, and a
+            // U+0078 LATIN SMALL LETTER X character.
+            if (!w) {
+                const x = text.slice(textPos).match(/^\+?\d+(\.\d+)?([eE][+-]\d+)?\s*x/);
+                textPos += x ? x[0].length : 0;
+            }
+        }
+        // 5. Zero or more ASCII whitespace
+        while (textPos < text.length && /[\t\r\f\n ]/.test(text[textPos]))
+            ++textPos;
+    }
 }
 function isRelativePath(link) {
     // Lots of edge cases encoded right here!

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

@@ -67,6 +67,15 @@ export declare class Context {
      * This is available on Context so that it can be monkey-patched by typedoc-plugin-missing-exports
      */
     createSymbolReference(symbol: ts.Symbol, context: Context, name?: string): ReferenceType;
+    /**
+     * Create a stable {@link ReflectionSymbolId} for the provided symbol,
+     * optionally targeting a specific declaration.
+     *
+     * @privateRemarks
+     * This is available on Context so that it can be monkey-patched by typedoc-plugin-missing-exports
+     * It might also turn out to be generally useful for other plugin users.
+     */
+    createSymbolId(symbol: ts.Symbol, declaration?: ts.Declaration): import("../models/ReflectionSymbolId.js").ReflectionSymbolId;
     addChild(reflection: DeclarationReflection | DocumentReflection): void;
     shouldIgnore(symbol: ts.Symbol): boolean;
     /**
@@ -81,6 +90,7 @@ export declare class Context {
     getSymbolFromReflection(reflection: Reflection): ts.Symbol | undefined;
     /** @internal */
     setActiveProgram(program: ts.Program | undefined): void;
+    private createCommentContext;
     getComment(symbol: ts.Symbol, kind: ReflectionKind): Comment | undefined;
     getNodeComment(node: ts.Node, moduleComment: boolean): Comment | undefined;
     getFileComment(node: ts.SourceFile): Comment | undefined;