typedoc 0.28.15 → 0.28.16

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

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

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

@@ -4,7 +4,7 @@ import { lexBlockComment } from "./blockLexer.js";
 import { discoverComment, discoverFileComments, discoverNodeComment, discoverSignatureComment, } from "./discovery.js";
 import { lexLineComments } from "./lineLexer.js";
 import { parseComment } from "./parser.js";
-import { assertNever, i18n } from "#utils";
+import { assertNever, i18n, Logger, setUnion } from "#utils";
 const jsDocCommentKinds = [
     ts.SyntaxKind.JSDocPropertyTag,
     ts.SyntaxKind.JSDocCallbackTag,
@@ -21,16 +21,10 @@ export function clearCommentCache() {
     commentCache = new WeakMap();
     commentDiscoveryId = 0;
 }
-function getCommentWithCache(discovered, context) {
+function getCommentIgnoringCacheNoDiscoveryId(discovered, context) {
     if (!discovered)
         return;
     const { file, ranges, jsDoc } = discovered;
-    const cache = commentCache.get(file) || new Map();
-    if (cache.has(ranges[0].pos)) {
-        const clone = cache.get(ranges[0].pos).clone();
-        clone.inheritedFromParentDeclaration = discovered.inheritedFromParentDeclaration;
-        return clone;
-    }
     let comment;
     switch (ranges[0].kind) {
         case ts.SyntaxKind.MultiLineCommentTrivia:
@@ -42,8 +36,23 @@ function getCommentWithCache(discovered, context) {
         default:
             assertNever(ranges[0].kind);
     }
-    comment.discoveryId = ++commentDiscoveryId;
     comment.inheritedFromParentDeclaration = discovered.inheritedFromParentDeclaration;
+    return comment;
+}
+function getCommentWithCache(discovered, context) {
+    if (!discovered)
+        return;
+    const { file, ranges } = discovered;
+    const cache = commentCache.get(file) || new Map();
+    if (cache.has(ranges[0].pos)) {
+        const clone = cache.get(ranges[0].pos).clone();
+        clone.inheritedFromParentDeclaration = discovered.inheritedFromParentDeclaration;
+        return clone;
+    }
+    const comment = getCommentIgnoringCacheNoDiscoveryId(discovered, context);
+    if (!comment)
+        return;
+    comment.discoveryId = ++commentDiscoveryId;
     cache.set(ranges[0].pos, comment);
     commentCache.set(file, cache);
     return comment.clone();
@@ -99,14 +108,24 @@ export function getNodeComment(node, moduleComment, context) {
     return getCommentImpl(discoverNodeComment(node, context.config.commentStyle), moduleComment, context);
 }
 export function getFileComment(file, context) {
+    const quietContext = {
+        ...context,
+        logger: new Logger(),
+    };
     for (const commentSource of discoverFileComments(file, context.config.commentStyle)) {
-        const comment = getCommentWithCache(commentSource, context);
+        // First parse the comment without adding the parse to the cache
+        // and without logging any messages. If we end up not using this as
+        // a file comment we want to avoid parsing it with warnings here as
+        // it might be associated with a JSDoc parse which has special
+        // handling to allow modifier tags to be specified as {@mod}
+        // and if it gets added to the cache here we'll get unwanted warnings
+        const comment = getCommentIgnoringCacheNoDiscoveryId(commentSource, quietContext);
         if (comment?.getTag("@license") || comment?.getTag("@import")) {
             continue;
         }
         if (comment?.getTag("@module") ||
             comment?.hasModifier("@packageDocumentation")) {
-            return comment;
+            return getCommentWithCache(commentSource, context);
         }
         return;
     }
@@ -127,6 +146,33 @@ function getConstructorParamPropertyComment(symbol, context) {
 export function getSignatureComment(declaration, context) {
     return getCommentImpl(discoverSignatureComment(declaration, context.checker, context.config.commentStyle), false, context);
 }
+function buildJsDocCommentFromParts(declaration, parts, sourceComment, context) {
+    if (!parts) {
+        return undefined;
+    }
+    const comment = new Comment(Comment.cloneDisplayParts(parts));
+    comment.sourcePath = sourceComment.sourcePath;
+    for (let i = 0; i < comment.summary.length;) {
+        const part = comment.summary[i];
+        if (part.kind === "inline-tag" &&
+            !part.text.trim() &&
+            context.config.modifierTags.has(part.tag)) {
+            comment.modifierTags.add(part.tag);
+            comment.summary.splice(i, 1);
+        }
+        else if (part.kind === "inline-tag" &&
+            part.text.trim() &&
+            context.config.modifierTags.has(part.tag) &&
+            !context.config.inlineTags.has(part.tag)) {
+            context.logger.warn(i18n.inline_tag_0_not_parsed_as_modifier_tag_1(part.tag, part.text.trim()), declaration);
+            ++i;
+        }
+        else {
+            ++i;
+        }
+    }
+    return comment;
+}
 export function getJsDocComment(declaration, context) {
     const file = declaration.getSourceFile();
     // First, get the whole comment. We know we'll need all of it.
@@ -134,6 +180,15 @@ export function getJsDocComment(declaration, context) {
     while (!ts.isJSDoc(parent)) {
         parent = parent.parent;
     }
+    // Build a custom context to allow modifier tags to be written as inline
+    // tags as otherwise there's no way to specify them here #2916 #3050
+    const contextWithInline = {
+        ...context,
+        config: {
+            ...context.config,
+            inlineTags: setUnion(context.config.inlineTags, context.config.modifierTags),
+        },
+    };
     // Then parse it.
     const comment = getCommentWithCache({
         file,
@@ -146,12 +201,10 @@ export function getJsDocComment(declaration, context) {
         ],
         jsDoc: parent,
         inheritedFromParentDeclaration: false,
-    }, context);
+    }, contextWithInline);
     // And pull out the tag we actually care about.
     if (ts.isJSDocEnumTag(declaration)) {
-        const result = new Comment(comment.getTag("@enum")?.content);
-        result.sourcePath = comment.sourcePath;
-        return result;
+        return buildJsDocCommentFromParts(declaration, comment.getTag("@enum")?.content, comment, context);
     }
     if (ts.isJSDocTemplateTag(declaration) &&
         declaration.comment &&
@@ -183,8 +236,6 @@ export function getJsDocComment(declaration, context) {
         }
     }
     else {
-        const result = new Comment(Comment.cloneDisplayParts(tag.content));
-        result.sourcePath = comment.sourcePath;
-        return result;
+        return buildJsDocCommentFromParts(declaration, tag.content, comment, context);
     }
 }

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

@@ -1,6 +1,7 @@
 import ts from "typescript";
 import { ParameterReflection, type Reflection, ReflectionKind, SignatureReflection, TypeParameterReflection } from "../../models/index.js";
 import type { Context } from "../context.js";
+export declare function convertConstructSignatures(context: Context, symbol: ts.Symbol): void;
 export declare function createSignature(context: Context, kind: ReflectionKind.CallSignature | ReflectionKind.ConstructorSignature | ReflectionKind.GetSignature | ReflectionKind.SetSignature, signature: ts.Signature, symbol: ts.Symbol | undefined, declaration?: ts.SignatureDeclaration | ts.JSDocSignature): void;
 /**
  * Special cased constructor factory for functions tagged with `@class`

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

@@ -4,6 +4,19 @@ import { DeclarationReflection, IntrinsicType, ParameterReflection, PredicateTyp
 import { ConverterEvents } from "../converter-events.js";
 import { convertDefaultValue } from "../convert-expression.js";
 import { removeUndefined } from "../utils/reflections.js";
+export function convertConstructSignatures(context, symbol) {
+    const type = context.checker.getDeclaredTypeOfSymbol(symbol);
+    // These get added as a "constructor" member of this interface. This is a problem... but nobody
+    // has complained yet. We really ought to have a constructSignatures property on the reflection instead.
+    const constructSignatures = context.checker.getSignaturesOfType(type, ts.SignatureKind.Construct);
+    if (constructSignatures.length) {
+        const constructMember = new DeclarationReflection("constructor", ReflectionKind.Constructor, context.scope);
+        context.postReflectionCreation(constructMember, symbol, void 0);
+        context.finalizeDeclarationReflection(constructMember);
+        const constructContext = context.withScope(constructMember);
+        constructSignatures.forEach((sig) => createSignature(constructContext, ReflectionKind.ConstructorSignature, sig, symbol));
+    }
+}
 export function createSignature(context, kind, signature, symbol, declaration) {
     assert(context.scope instanceof DeclarationReflection);
     declaration ||= signature.getDeclaration();

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

@@ -1,4 +1,4 @@
 import ts from "typescript";
 import type { Context } from "./context.js";
-export declare function convertJsDocAlias(context: Context, symbol: ts.Symbol, declaration: ts.JSDocTypedefTag | ts.JSDocEnumTag, exportSymbol?: ts.Symbol): void;
+export declare function convertJsDocAlias(context: Context, symbol: ts.Symbol, declaration: ts.JSDocTypedefTag | ts.JSDocEnumTag, exportSymbol?: ts.Symbol): undefined;
 export declare function convertJsDocCallback(context: Context, symbol: ts.Symbol, declaration: ts.JSDocCallbackTag, exportSymbol?: ts.Symbol): void;

package/dist/lib/converter/jsdoc.js

@@ -5,13 +5,44 @@ import { ok } from "assert";
 import ts from "typescript";
 import { DeclarationReflection, IntrinsicType, ReflectionKind, ReflectionType, SignatureReflection, } from "../models/index.js";
 import { ConverterEvents } from "./converter-events.js";
-import { convertParameterNodes, convertTemplateParameterNodes } from "./factories/signature.js";
+import { convertConstructSignatures, convertParameterNodes, convertTemplateParameterNodes, createSignature, } from "./factories/signature.js";
+import { i18n } from "#utils";
+import { convertIndexSignatures } from "./factories/index-signature.js";
+// This is almost convertTypeAliasAsInterface, but unfortunately needs to be separate
+// due to type parameters being different in JSDoc comments
+function convertJsDocAliasAsInterface(context, symbol, exportSymbol, declaration) {
+    const reflection = context.createDeclarationReflection(ReflectionKind.Interface, symbol, exportSymbol);
+    context.finalizeDeclarationReflection(reflection);
+    const rc = context.withScope(reflection);
+    const type = context.checker.getTypeAtLocation(declaration);
+    if (type.getFlags() & ts.TypeFlags.Union) {
+        context.logger.warn(i18n.converting_union_as_interface(), declaration);
+    }
+    // Interfaces have properties
+    for (const prop of type.getProperties()) {
+        context.converter.convertSymbol(rc, prop);
+    }
+    // And type parameters
+    convertTemplateParameters(rc, declaration.parent);
+    // And maybe call signatures
+    context.checker
+        .getSignaturesOfType(type, ts.SignatureKind.Call)
+        .forEach((sig) => createSignature(rc, ReflectionKind.CallSignature, sig, symbol));
+    // And maybe constructor signatures
+    convertConstructSignatures(rc, symbol);
+    // And finally, index signatures
+    convertIndexSignatures(rc, type);
+}
 export function convertJsDocAlias(context, symbol, declaration, exportSymbol) {
     if (declaration.typeExpression &&
         ts.isJSDocTypeLiteral(declaration.typeExpression)) {
         convertJsDocInterface(context, declaration, symbol, exportSymbol);
         return;
     }
+    const comment = context.getJsDocComment(declaration);
+    if (comment?.hasModifier("@interface")) {
+        return convertJsDocAliasAsInterface(context, symbol, exportSymbol, declaration);
+    }
     // If the typedef tag is just referring to another type-space symbol, with no type parameters
     // or appropriate forwarding type parameters, then we treat it as a re-export instead of creating
     // a type alias with an import type.
@@ -21,7 +52,7 @@ export function convertJsDocAlias(context, symbol, declaration, exportSymbol) {
         return;
     }
     const reflection = context.createDeclarationReflection(ReflectionKind.TypeAlias, symbol, exportSymbol);
-    reflection.comment = context.getJsDocComment(declaration);
+    reflection.comment = comment;
     reflection.type = context.converter.convertType(context.withScope(reflection), declaration.typeExpression?.type);
     convertTemplateParameters(context.withScope(reflection), declaration.parent);
     context.finalizeDeclarationReflection(reflection);

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

@@ -14,6 +14,7 @@ export declare class ImplementsPlugin extends ConverterComponent {
      */
     private analyzeImplements;
     private analyzeInheritance;
+    private cleanUpImplements;
     private onResolveEnd;
     private onRevive;
     private resolve;

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

@@ -95,10 +95,6 @@ export class ImplementsPlugin extends ConverterComponent {
         // serialization/deserialization, might point to an unexpected location. (See the mixin
         // converter tests, I suspect this might actually be an indication of something else slightly
         // broken there, but don't want to spend more time with this right now.)
-        // #2982/#3007, even more unfortunately, we only want to keep the link if it is pointing
-        // to a reflection which will receive a link during rendering, we pick this based on it being
-        // the type of member we expect to point to.
-        const isValidRef = (ref) => !!ref.reflection?.parent?.kindOf(ReflectionKind.ClassOrInterface | ReflectionKind.Method | ReflectionKind.Constructor);
         for (const child of reflection.children || []) {
             if (child.inheritedFrom && !isValidRef(child.inheritedFrom)) {
                 child.inheritedFrom = ReferenceType.createBrokenReference(child.inheritedFrom.name, project, child.inheritedFrom.package);
@@ -116,6 +112,19 @@ export class ImplementsPlugin extends ConverterComponent {
             }
         }
     }
+    cleanUpImplements(project, reflection) {
+        // #3052, the same problem as #2978 applies for implements
+        for (const child of reflection.children || []) {
+            if (child.implementationOf && !isValidRef(child.implementationOf)) {
+                child.implementationOf = ReferenceType.createBrokenReference(child.implementationOf.name, project, child.implementationOf.package);
+            }
+            for (const childSig of child.getAllSignatures()) {
+                if (childSig.implementationOf && !isValidRef(childSig.implementationOf)) {
+                    childSig.implementationOf = ReferenceType.createBrokenReference(childSig.implementationOf.name, project, childSig.implementationOf.package);
+                }
+            }
+        }
+    }
     onResolveEnd(context) {
         this.resolve(context.project);
     }
@@ -184,6 +193,10 @@ export class ImplementsPlugin extends ConverterComponent {
             reflection.extendedTypes) {
             this.analyzeInheritance(project, reflection);
         }
+        if (reflection.kindOf(ReflectionKind.ClassOrInterface) &&
+            (reflection.extendedTypes || reflection.implementedTypes)) {
+            this.cleanUpImplements(project, reflection);
+        }
     }
     getExtensionInfo(context, reflection) {
         if (!reflection || !reflection.kindOf(ReflectionKind.Inheritable)) {
@@ -417,3 +430,9 @@ function findMatchingMember(toMatch, container) {
     return container.children?.find((child) => child.name == toMatch.name &&
         child.flags.isStatic === toMatch.flags.isStatic);
 }
+// #2982/#3007 unfortunately, we only want to keep the link if it is pointing
+// to a reflection which will receive a link during rendering, we pick this based on it being
+// the type of member we expect to point to.
+function isValidRef(ref) {
+    return !!ref.reflection?.parent?.kindOf(ReflectionKind.ClassOrInterface | ReflectionKind.Method | ReflectionKind.Constructor);
+}

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

@@ -246,5 +246,9 @@ regionTagREsByExt["php"] = regionTagREsByExt["cs"];
 regionTagREsByExt["ps1"] = regionTagREsByExt["cs"];
 regionTagREsByExt["py"] = regionTagREsByExt["cs"];
 regionTagREsByExt["js"] = regionTagREsByExt["ts"];
+regionTagREsByExt["mjs"] = regionTagREsByExt["ts"];
 regionTagREsByExt["mts"] = regionTagREsByExt["ts"];
+regionTagREsByExt["cjs"] = regionTagREsByExt["ts"];
 regionTagREsByExt["cts"] = regionTagREsByExt["ts"];
+regionTagREsByExt["jsx"] = regionTagREsByExt["ts"];
+regionTagREsByExt["tsx"] = regionTagREsByExt["ts"];

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

@@ -33,7 +33,7 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     return useValue ? value : void 0;
 };
 import ts from "typescript";
-import { DeclarationReflection, SignatureReflection } from "../../models/index.js";
+import { DeclarationReflection, ReflectionKind, SignatureReflection } from "../../models/index.js";
 import { ConverterComponent } from "../components.js";
 import { getCommonDirectory, normalizePath, Option } from "../../utils/index.js";
 import { isNamedNode } from "../utils/nodes.js";
@@ -120,7 +120,7 @@ let SourcePlugin = (() => {
          * @param reflection  The reflection that is currently processed.
          */
         onDeclaration(context, reflection) {
-            if (this.disableSources)
+            if (this.disableSources || reflection.kindOf(ReflectionKind.TypeLiteral))
                 return;
             const symbol = context.getSymbolFromReflection(reflection);
             for (const node of symbol?.declarations || []) {
@@ -139,7 +139,7 @@ let SourcePlugin = (() => {
             }
         }
         onSignature(_context, reflection, sig) {
-            if (this.disableSources || !sig)
+            if (this.disableSources || !sig || reflection.parent.kindOf(ReflectionKind.TypeLiteral))
                 return;
             const sourceFile = sig.getSourceFile();
             const fileName = normalizePath(sourceFile.fileName);

package/dist/lib/converter/symbols.js

@@ -4,7 +4,7 @@ import { DeclarationReflection, IntrinsicType, LiteralType, ReferenceReflection,
 import { getEnumFlags, hasAllFlags, hasAnyFlag, i18n, removeFlag } from "#utils";
 import { convertDefaultValue } from "./convert-expression.js";
 import { convertIndexSignatures } from "./factories/index-signature.js";
-import { convertTypeParameters, createConstructSignatureWithType, createSignature, createTypeParamReflection, } from "./factories/signature.js";
+import { convertConstructSignatures, convertTypeParameters, createConstructSignatureWithType, createSignature, createTypeParamReflection, } from "./factories/signature.js";
 import { convertJsDocAlias, convertJsDocCallback } from "./jsdoc.js";
 import { getHeritageTypes } from "./utils/nodes.js";
 import { removeUndefined } from "./utils/reflections.js";
@@ -522,19 +522,6 @@ function convertConstructor(context, symbol) {
         createSignature(reflectionContext, ReflectionKind.ConstructorSignature, sig, symbol);
     }
 }
-function convertConstructSignatures(context, symbol) {
-    const type = context.checker.getDeclaredTypeOfSymbol(symbol);
-    // These get added as a "constructor" member of this interface. This is a problem... but nobody
-    // has complained yet. We really ought to have a constructSignatures property on the reflection instead.
-    const constructSignatures = context.checker.getSignaturesOfType(type, ts.SignatureKind.Construct);
-    if (constructSignatures.length) {
-        const constructMember = new DeclarationReflection("constructor", ReflectionKind.Constructor, context.scope);
-        context.postReflectionCreation(constructMember, symbol, void 0);
-        context.finalizeDeclarationReflection(constructMember);
-        const constructContext = context.withScope(constructMember);
-        constructSignatures.forEach((sig) => createSignature(constructContext, ReflectionKind.ConstructorSignature, sig, symbol));
-    }
-}
 function convertAlias(context, symbol, exportSymbol) {
     // If this is a namespace marked as a primary export or directly within one
     // marked as a primary export then we should convert it immediately rather than deferring

package/dist/lib/internationalization/locales/en.cjs

@@ -37,6 +37,7 @@ module.exports = {
     comments_for_0_are_declared_at_1: `The comments for {0} are declared at:\n\t{1}`,
     // comments/parser.ts
     multiple_type_parameters_on_template_tag_unsupported: `TypeDoc does not support multiple type parameters defined in a single @template tag with a comment`,
+    inline_tag_0_not_parsed_as_modifier_tag_1: `The inline tag {0} was likely intended to be a modifier tag but was not parsed as one due to including content "{1}"`,
     failed_to_find_jsdoc_tag_for_name_0: `Failed to find JSDoc tag for {0} after parsing comment, please file a bug report`,
     relative_path_0_is_not_a_file_and_will_not_be_copied_to_output: `The relative path {0} is not a file and will not be copied to the output directory`,
     inline_inheritdoc_should_not_appear_in_block_tag_in_comment_at_0: "An inline @inheritDoc tag should not appear within a block tag as it will not be processed in comment at {0}",

package/dist/lib/internationalization/locales/en.d.cts

@@ -33,6 +33,7 @@ declare const _default: {
     readonly symbol_0_has_multiple_declarations_with_comment: "{0} has multiple declarations with a comment. An arbitrary comment will be used";
     readonly comments_for_0_are_declared_at_1: "The comments for {0} are declared at:\n\t{1}";
     readonly multiple_type_parameters_on_template_tag_unsupported: "TypeDoc does not support multiple type parameters defined in a single @template tag with a comment";
+    readonly inline_tag_0_not_parsed_as_modifier_tag_1: "The inline tag {0} was likely intended to be a modifier tag but was not parsed as one due to including content \"{1}\"";
     readonly failed_to_find_jsdoc_tag_for_name_0: "Failed to find JSDoc tag for {0} after parsing comment, please file a bug report";
     readonly relative_path_0_is_not_a_file_and_will_not_be_copied_to_output: "The relative path {0} is not a file and will not be copied to the output directory";
     readonly inline_inheritdoc_should_not_appear_in_block_tag_in_comment_at_0: "An inline @inheritDoc tag should not appear within a block tag as it will not be processed in comment at {0}";

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

@@ -128,7 +128,7 @@ export declare class Comment {
      */
     static combineDisplayParts(parts: readonly CommentDisplayPart[] | undefined): string;
     /**
-     * Helper utility to clone {@link Comment.summary} or {@link CommentTag.content}
+     * Helper utility to clone {@link Comment#summary} or {@link CommentTag#content}
      */
     static cloneDisplayParts(parts: readonly CommentDisplayPart[]): CommentDisplayPart[];
     static serializeDisplayParts(parts: CommentDisplayPart[]): JSONOutput.CommentDisplayPart[];

package/dist/lib/models/Comment.js

@@ -159,7 +159,7 @@ let Comment = (() => {
             return result;
         }
         /**
-         * Helper utility to clone {@link Comment.summary} or {@link CommentTag.content}
+         * Helper utility to clone {@link Comment#summary} or {@link CommentTag#content}
          */
         static cloneDisplayParts(parts) {
             return parts.map((p) => ({ ...p }));

package/dist/lib/output/themes/MarkedPlugin.js

@@ -330,8 +330,12 @@ let MarkedPlugin = (() => {
             githubAlertMarkdownPlugin(this.parser);
             const loader = this.application.options.getValue("markdownItLoader");
             loader(this.parser);
+            function defaultRender(tokens, idx, options, _env, self) {
+                return self.renderToken(tokens, idx, options);
+            }
             // Add anchor links for headings in readme, and add them to the "On this page" section
-            this.parser.renderer.rules["heading_open"] = (tokens, idx) => {
+            const headingOpenRenderer = this.parser.renderer.rules["heading_open"] || defaultRender;
+            this.parser.renderer.rules["heading_open"] = (tokens, idx, options, env, self) => {
                 const token = tokens[idx];
                 const content = getTokenTextContent(tokens[idx + 1]);
                 const level = token.markup.length;
@@ -342,14 +346,16 @@ let MarkedPlugin = (() => {
                     text: content,
                     level,
                 });
-                return `<${token.tag} id="${slug}" class="tsd-anchor-link">`;
+                token.attrSet("id", slug);
+                token.attrSet("class", "tsd-anchor-link");
+                return headingOpenRenderer(tokens, idx, options, env, self);
             };
-            this.parser.renderer.rules["heading_close"] = (tokens, idx) => {
-                return `${JSX.renderElement(anchorIcon(this.renderContext, this.lastHeaderSlug))}</${tokens[idx].tag}>`;
+            const headingCloseRenderer = this.parser.renderer.rules["heading_close"] || defaultRender;
+            this.parser.renderer.rules["heading_close"] = (...args) => {
+                return `${JSX.renderElement(anchorIcon(this.renderContext, this.lastHeaderSlug))}${headingCloseRenderer(...args)}`;
             };
-            // Rewrite anchor links inline in a readme file to links targeting the `md:` prefixed anchors
-            // that TypeDoc creates.
-            this.parser.renderer.rules["link_open"] = (tokens, idx, options, _env, self) => {
+            const linkOpenRenderer = this.parser.renderer.rules["link_open"] || defaultRender;
+            this.parser.renderer.rules["link_open"] = (tokens, idx, options, env, self) => {
                 const token = tokens[idx];
                 const href = token.attrGet("href");
                 if (href) {
@@ -367,8 +373,9 @@ let MarkedPlugin = (() => {
                     }
                     token.attrSet("href", href);
                 }
-                return self.renderToken(tokens, idx, options);
+                return linkOpenRenderer(tokens, idx, options, env, self);
             };
+            // Don't need custom rendering here as this is a TypeDoc-provided rule name
             this.parser.renderer.rules["alert_open"] = (tokens, idx) => {
                 const icon = this.renderContext.icons[tokens[idx].attrGet("icon")];
                 const iconHtml = JSX.renderElement(icon());

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

@@ -6,7 +6,7 @@ import { i18n, JSX } from "#utils";
 const kindIcon = (letterPath, color, label, circular = false) => (JSX.createElement("svg", { class: "tsd-kind-icon", viewBox: "0 0 24 24", "aria-label": label },
     JSX.createElement("rect", { fill: "var(--color-icon-background)", stroke: color, "stroke-width": "1.5", x: "1", y: "1", width: "22", height: "22", rx: circular ? "12" : "6" }),
     letterPath));
-const textIcon = (letter, color, label, circular = false) => kindIcon(JSX.createElement("text", { fill: "var(--color-icon-text)", x: "50%", y: "50%", "dominant-baseline": "central", "text-anchor": "middle" }, letter), color, label, circular);
+const textIcon = (letter, color, label, circular = false) => kindIcon(JSX.createElement("text", { fill: "var(--color-icon-text)", x: "50%", y: "50%", dy: "0.35em", "text-anchor": "middle" }, letter), color, label, circular);
 export function buildRefIcons(icons, context) {
     const refs = {};
     for (const [name, builder] of Object.entries(icons)) {

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

@@ -54,7 +54,7 @@ export function inferEntryPoints(logger, options, programs) {
     for (const [name, path] of pathEntries) {
         // Strip leading ./ from the display name
         const displayName = name.replace(/^\.\/?/, "");
-        const targetPath = jsToTsSource.get(path) || resolveDeclarationMaps(path) || path;
+        const targetPath = jsToTsSource.get(normalizePath(path)) || resolveDeclarationMaps(path) || path;
         const program = programs.find((p) => p.getSourceFile(targetPath));
         if (program) {
             entryPoints.push({

package/dist/lib/utils-common/jsx.elements.d.ts

@@ -771,6 +771,7 @@ export interface JsxSvgPresentationProps {
     direction?: "ltr" | "rtl";
     display?: string;
     "dominant-baseline"?: "auto" | "text-bottom" | "alphabetic" | "ideographic" | "middle" | "central" | "mathematical" | "hanging" | "text-top";
+    dy?: string;
     fill?: string;
     "fill-opacity"?: number;
     "fill-rule"?: "nonzero" | "evenodd";

package/dist/lib/utils-common/set.d.ts

@@ -1,2 +1,3 @@
 export declare function setIntersection<T>(a: Iterable<T>, b: Set<T>): Set<T>;
 export declare function setDifference<T>(a: Iterable<T>, b: Iterable<T>): Set<T>;
+export declare function setUnion<T>(a: Iterable<T>, b: Iterable<T>): Set<T>;

package/dist/lib/utils-common/set.js

@@ -14,3 +14,10 @@ export function setDifference(a, b) {
     }
     return result;
 }
+export function setUnion(a, b) {
+    const result = new Set(a);
+    for (const elem of b) {
+        result.add(elem);
+    }
+    return result;
+}

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "typedoc",
   "description": "Create api documentation for TypeScript projects.",
-  "version": "0.28.15",
+  "version": "0.28.16",
   "homepage": "https://typedoc.org",
   "type": "module",
   "exports": {
     ".": "./dist/index.js",
     "./tsdoc.json": "./tsdoc.json",
+    "./typedoc-config.schema.json": "./typedoc-config.schema.json",
     "./package.json": "./package.json",
     "./models": "./dist/lib/models/index.js",
     "./browser": "./dist/browser-utils.js",
@@ -67,7 +68,8 @@
     "!/dist/test",
     "/LICENSE",
     "/static",
-    "/tsdoc.json"
+    "/tsdoc.json",
+    "/typedoc-config.schema.json"
   ],
   "keywords": [
     "typescript",
@@ -121,7 +123,7 @@
     "build:tsc": "tsc --project .",
     "build:themes": "node scripts/build_themes.js",
     "build:locales": "node scripts/build_browser_translations.js",
-    "build:prod": "pnpm build:prod:tsc && pnpm build:locales && pnpm build:themes",
+    "build:prod": "pnpm build:prod:tsc && pnpm build:locales && pnpm build:themes && node scripts/generate_options_schema.js typedoc-config.schema.json",
     "build:prod:tsc": "tsc --project . --sourceMap false --declarationMap false",
     "lint": "eslint . --max-warnings 0 && dprint check"
   }