typedoc 0.28.11 → 0.28.13

package/dist/lib/models/types.js

@@ -833,8 +833,10 @@ let ReferenceType = (() => {
          * later during conversion.
          * @internal
          */
-        static createBrokenReference(name, project) {
-            return new ReferenceType(name, -1, project, name);
+        static createBrokenReference(name, project, packageName) {
+            const ref = new ReferenceType(name, -1, project, name);
+            ref.package = packageName;
+            return ref;
         }
         getTypeString() {
             const name = this.reflection ? this.reflection.name : this.name;

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

@@ -240,7 +240,17 @@ let MarkedPlugin = (() => {
                                 const refl = page.project.files.resolve(part.target, page.model.project);
                                 let url;
                                 if (typeof refl === "object") {
-                                    url = context.urlTo(refl);
+                                    // #3006, this is an unfortunate heuristic. If there is a relative link to the project
+                                    // the user probably created it by linking to the directory of the project or to
+                                    // the project's readme. Since the readme doesn't get its own reflection, we can't
+                                    // reliably disambiguate this and instead will arbitrarily decide to reference the
+                                    // root index page in this case.
+                                    if (refl.isProject()) {
+                                        url = context.relativeURL("./");
+                                    }
+                                    else {
+                                        url = context.urlTo(refl);
+                                    }
                                 }
                                 else {
                                     const fileName = page.project.files.getName(part.target);

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

@@ -48,20 +48,21 @@ export function commentTags(context, props) {
         ? props.comment.blockTags.filter((tag) => tag.tag !== "@returns" && !tag.skipRendering && !skippedTags.includes(tag.tag))
         : props.comment.blockTags.filter((tag) => !tag.skipRendering && !skippedTags.includes(tag.tag));
     skipSave.forEach((skip, i) => (props.comment.blockTags[i].skipRendering = skip));
+    const tagsContents = tags.map((item) => {
+        const name = item.name
+            ? `${translateTagName(item.tag)}: ${item.name}`
+            : translateTagName(item.tag);
+        const anchor = context.slugger.slug(name);
+        return (JSX.createElement(JSX.Fragment, null,
+            JSX.createElement("div", { class: `tsd-tag-${item.tag.substring(1)}` },
+                JSX.createElement("h4", { class: "tsd-anchor-link", id: anchor },
+                    name,
+                    anchorIcon(context, anchor)),
+                JSX.createElement(JSX.Raw, { html: context.markdown(item.content) }))));
+    });
     return (JSX.createElement(JSX.Fragment, null,
         beforeTags,
-        JSX.createElement("div", { class: "tsd-comment tsd-typography" }, tags.map((item) => {
-            const name = item.name
-                ? `${translateTagName(item.tag)}: ${item.name}`
-                : translateTagName(item.tag);
-            const anchor = context.slugger.slug(name);
-            return (JSX.createElement(JSX.Fragment, null,
-                JSX.createElement("div", { class: `tsd-tag-${item.tag.substring(1)}` },
-                    JSX.createElement("h4", { class: "tsd-anchor-link", id: anchor },
-                        name,
-                        anchorIcon(context, anchor)),
-                    JSX.createElement(JSX.Raw, { html: context.markdown(item.content) }))));
-        })),
+        tagsContents.length > 0 && (JSX.createElement("div", { class: "tsd-comment tsd-typography" }, tagsContents)),
         afterTags));
 }
 export function reflectionFlags(context, props) {

package/dist/lib/output/themes/default/partials/member.declaration.js

@@ -9,7 +9,7 @@ function shouldRenderDefaultValue(props) {
     /** Fix for #2717. If type is the same as value the default value is omitted */
     if (props.type && props.type.type === "literal") {
         const reflectionTypeString = props.type.toString();
-        if (reflectionTypeString === defaultValue.toString()) {
+        if (reflectionTypeString === defaultValue) {
             return false;
         }
     }

package/dist/lib/output/themes/default/partials/member.signature.body.js

@@ -11,7 +11,7 @@ export function memberSignatureBody(context, props, { hideSources = false } = {}
             JSX.createElement("ul", { class: "tsd-parameter-list" }, props.parameters.map((item) => (JSX.createElement("li", null,
                 JSX.createElement("span", null,
                     context.reflectionFlags(item),
-                    !!item.flags.isRest && JSX.createElement("span", { class: "tsd-signature-symbol" }, "..."),
+                    item.flags.isRest && JSX.createElement("span", { class: "tsd-signature-symbol" }, "..."),
                     JSX.createElement("span", { class: "tsd-kind-parameter" }, item.name),
                     ": ",
                     context.type(item.type),

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

@@ -5,7 +5,7 @@ import { anchorIcon } from "./anchor-icon.js";
 export function moduleReflection(context, mod) {
     const sections = getMemberSections(mod);
     return (JSX.createElement(JSX.Fragment, null,
-        mod.hasComment() && (JSX.createElement("section", { class: "tsd-panel tsd-comment" },
+        mod.hasComment(context.options.getValue("notRenderedTags")) && (JSX.createElement("section", { class: "tsd-panel tsd-comment" },
             context.commentSummary(mod),
             context.commentTags(mod))),
         mod.isDeclaration() && mod.kind === ReflectionKind.Module && !!mod.readme?.length && (JSX.createElement("section", { class: "tsd-panel tsd-typography" },

package/dist/lib/output/themes/default/partials/typeAndParent.d.ts

@@ -1,4 +1,4 @@
 import type { DefaultThemeRenderContext } from "../DefaultThemeRenderContext.js";
-import { type Type } from "../../../../models/index.js";
+import { type Type } from "#models";
 import { JSX } from "#utils";
 export declare const typeAndParent: (context: DefaultThemeRenderContext, props: Type) => JSX.Element;

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

@@ -1,4 +1,4 @@
-import { ArrayType, ReferenceType, SignatureReflection } from "../../../../models/index.js";
+import { ArrayType, ReferenceType, SignatureReflection } from "#models";
 import { JSX } from "#utils";
 export const typeAndParent = (context, props) => {
     if (props instanceof ArrayType) {
@@ -6,13 +6,23 @@ export const typeAndParent = (context, props) => {
             context.typeAndParent(props.elementType),
             "[]"));
     }
-    if (props instanceof ReferenceType && props.reflection) {
-        const refl = props.reflection instanceof SignatureReflection ? props.reflection.parent : props.reflection;
-        const parent = refl.parent;
-        return (JSX.createElement(JSX.Fragment, null,
-            JSX.createElement("a", { href: context.urlTo(parent) }, parent.name),
-            ".",
-            JSX.createElement("a", { href: context.urlTo(refl) }, refl.name)));
+    if (props instanceof ReferenceType) {
+        if (props.reflection) {
+            const refl = props.reflection instanceof SignatureReflection ? props.reflection.parent : props.reflection;
+            const parent = refl.parent;
+            return (JSX.createElement(JSX.Fragment, null,
+                JSX.createElement("a", { href: context.urlTo(parent) }, parent.name),
+                ".",
+                JSX.createElement("a", { href: context.urlTo(refl) }, refl.name)));
+        }
+        else if (props.externalUrl) {
+            if (props.externalUrl === "#") {
+                return JSX.createElement(JSX.Fragment, null, props.toString());
+            }
+            else {
+                return JSX.createElement("a", { href: props.externalUrl, class: "external", target: "_blank" }, props.name);
+            }
+        }
     }
     return JSX.createElement(JSX.Fragment, null, props.toString());
 };

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

@@ -2,19 +2,20 @@ import { Comment, Reflection, ReflectionKind, } from "../../../../models/index.j
 import { assert, i18n, JSX } from "#utils";
 import { classNames, getKindClass } from "../../lib.js";
 import { anchorTargetIfPresent } from "./anchor-icon.js";
-function renderingTypeDetailsIsUseful(container, type) {
+function renderingTypeDetailsIsUseful(container, type, notRenderedTags) {
     const isUsefulVisitor = {
         array(type) {
-            return renderingTypeDetailsIsUseful(container, type.elementType);
+            return renderingTypeDetailsIsUseful(container, type.elementType, notRenderedTags);
         },
         intersection(type) {
-            return type.types.some(t => renderingTypeDetailsIsUseful(container, t));
+            return type.types.some(t => renderingTypeDetailsIsUseful(container, t, notRenderedTags));
         },
         union(type) {
-            return !!type.elementSummaries || type.types.some(t => renderingTypeDetailsIsUseful(container, t));
+            return !!type.elementSummaries ||
+                type.types.some(t => renderingTypeDetailsIsUseful(container, t, notRenderedTags));
         },
         reflection(type) {
-            return renderingChildIsUseful(type.declaration);
+            return renderingChildIsUseful(type.declaration, notRenderedTags);
         },
         reference(type) {
             return shouldExpandReference(container, type);
@@ -24,7 +25,7 @@ function renderingTypeDetailsIsUseful(container, type) {
 }
 export function typeDeclaration(context, reflectionOwningType, type) {
     assert(reflectionOwningType instanceof Reflection, "typeDeclaration(reflectionOwningType, type) called incorrectly");
-    if (renderingTypeDetailsIsUseful(reflectionOwningType, type)) {
+    if (renderingTypeDetailsIsUseful(reflectionOwningType, type, context.options.getValue("notRenderedTags"))) {
         return (JSX.createElement("div", { class: "tsd-type-declaration" },
             JSX.createElement("h4", null, i18n.theme_type_declaration()),
             context.typeDetails(reflectionOwningType, type, true)));
@@ -135,7 +136,7 @@ export function typeDetailsImpl(context, reflectionOwningType, type, renderAncho
 }
 export function typeDetailsIfUseful(context, reflectionOwningType, type) {
     assert(reflectionOwningType instanceof Reflection, "typeDetailsIfUseful(reflectionOwningType, type) called incorrectly");
-    if (type && renderingTypeDetailsIsUseful(reflectionOwningType, type)) {
+    if (type && renderingTypeDetailsIsUseful(reflectionOwningType, type, context.options.getValue("notRenderedTags"))) {
         return context.typeDetails(reflectionOwningType, type, false);
     }
 }
@@ -177,10 +178,10 @@ function renderChild(context, child, renderAnchors, highlight) {
     if (child.signatures) {
         return (JSX.createElement("li", { class: "tsd-parameter" },
             JSX.createElement("h5", { id: anchorTargetIfPresent(context, child) },
-                !!child.flags.isRest && JSX.createElement("span", { class: "tsd-signature-symbol" }, "..."),
+                child.flags.isRest && JSX.createElement("span", { class: "tsd-signature-symbol" }, "..."),
                 JSX.createElement("span", { class: getKindClass(child) }, child.name),
                 JSX.createElement("span", { class: "tsd-signature-symbol" },
-                    !!child.flags.isOptional && "?",
+                    child.flags.isOptional && "?",
                     ":"),
                 " function"),
             context.memberSignatures(child)));
@@ -195,17 +196,18 @@ function renderChild(context, child, renderAnchors, highlight) {
     }
     // standard type
     if (child.type) {
+        const notRenderedTags = context.options.getValue("notRenderedTags");
         return (JSX.createElement("li", { class: "tsd-parameter" },
             JSX.createElement("h5", { id: anchorTargetIfPresent(context, child) },
                 context.reflectionFlags(child),
-                !!child.flags.isRest && JSX.createElement("span", { class: "tsd-signature-symbol" }, "..."),
+                child.flags.isRest && JSX.createElement("span", { class: "tsd-signature-symbol" }, "..."),
                 JSX.createElement("span", { class: getKindClass(child) }, child.name),
                 JSX.createElement("span", { class: "tsd-signature-symbol" },
-                    !!child.flags.isOptional && "?",
+                    child.flags.isOptional && "?",
                     ": "),
                 context.type(child.type)),
             highlightOrComment(child),
-            child.getProperties().some(renderingChildIsUseful) && (JSX.createElement("ul", { class: "tsd-parameters" }, child.getProperties().map((c) => renderChild(context, c, renderAnchors))))));
+            child.getProperties().some(prop => renderingChildIsUseful(prop, notRenderedTags)) && (JSX.createElement("ul", { class: "tsd-parameters" }, child.getProperties().map((c) => renderChild(context, c, renderAnchors))))));
     }
     // getter/setter
     return (JSX.createElement(JSX.Fragment, null,
@@ -254,7 +256,7 @@ function renderIndexSignature(context, index) {
         context.commentTags(index),
         context.typeDeclaration(index, index.type)));
 }
-function renderingChildIsUseful(refl) {
+function renderingChildIsUseful(refl, notRenderedTags) {
     // Object types directly under a variable/type alias will always be considered useful.
     // This probably isn't ideal, but it is an easy thing to check when assigning URLs
     // in the default theme, so we'll make the assumption that those properties ought to always
@@ -265,18 +267,18 @@ function renderingChildIsUseful(refl) {
         refl.parent.type?.type === "reflection") {
         return true;
     }
-    if (renderingThisChildIsUseful(refl)) {
+    if (renderingThisChildIsUseful(refl, notRenderedTags)) {
         return true;
     }
-    return refl.getProperties().some(renderingThisChildIsUseful);
+    return refl.getProperties().some(prop => renderingThisChildIsUseful(prop, notRenderedTags));
 }
-function renderingThisChildIsUseful(refl) {
-    if (refl.hasComment())
+function renderingThisChildIsUseful(refl, notRenderedTags) {
+    if (refl.hasComment(notRenderedTags))
         return true;
     const declaration = refl.type?.type === "reflection" ? refl.type.declaration : refl;
-    if (declaration.hasComment())
+    if (declaration.hasComment(notRenderedTags))
         return true;
     return declaration.getAllSignatures().some((sig) => {
-        return sig.hasComment() || sig.parameters?.some((p) => p.hasComment());
+        return sig.hasComment(notRenderedTags) || sig.parameters?.some((p) => p.hasComment(notRenderedTags));
     });
 }

package/dist/lib/output/themes/default/templates/reflection.js

@@ -12,7 +12,7 @@ export function reflectionTemplate(context, props) {
         return context.moduleReflection(props.model);
     }
     return (JSX.createElement(JSX.Fragment, null,
-        props.model.hasComment() && (JSX.createElement("section", { class: "tsd-panel tsd-comment" },
+        props.model.hasComment(context.options.getValue("notRenderedTags")) && (JSX.createElement("section", { class: "tsd-panel tsd-comment" },
             context.commentSummary(props.model),
             context.commentTags(props.model))),
         context.reflectionPreview(props.model),

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

@@ -49,8 +49,8 @@ export declare class Deserializer {
         registry: FileRegistry;
         alwaysCreateEntryPointModule: boolean;
     }): ProjectReflection;
-    revive<T, U extends Deserializable<T>>(source: NonNullable<T>, creator: (obj: T) => U): U;
-    revive<T, U extends Deserializable<T>>(source: T | undefined, creator: (obj: T) => U): U | undefined;
+    revive<T extends object, U extends Deserializable<T>>(source: NonNullable<T>, creator: (obj: T) => U): U;
+    revive<T extends object, U extends Deserializable<T>>(source: T | undefined, creator: (obj: T) => U): U | undefined;
     reviveMany<T, U extends Deserializable<T>>(sourceArray: T[], creator: (obj: T) => U): U[];
     reviveMany<T, U extends Deserializable<T>>(sourceArray: T[] | undefined, creator: (obj: T) => U): U[] | undefined;
     reviveType<T extends JSONOutput.SomeType>(obj: T): TypeKindMap[T["type"]];

package/dist/lib/serialization/deserializer.js

@@ -58,7 +58,7 @@ export class Deserializer {
             return new IntrinsicType(obj.name);
         },
         literal(obj) {
-            if (obj.value && typeof obj.value === "object") {
+            if (typeof obj.value === "object" && obj.value != null) {
                 return new LiteralType(BigInt(`${obj.value.negative ? "-" : ""}${obj.value.value}`));
             }
             return new LiteralType(obj.value);

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

@@ -29,7 +29,7 @@
  * @module
  */
 import type * as M from "#models";
-import type { IfInternal, NormalizedPath } from "#utils";
+import type { IfInternal, NormalizedPath, TagString } from "#utils";
 export declare const SCHEMA_VERSION = "2.0";
 /**
  * Describes the mapping from Model types to the corresponding JSON output type.
@@ -223,7 +223,7 @@ export interface ReflectionFlags extends Partial<S<M.ReflectionFlags, BoolKeys<M
 /** @category Comments */
 export interface Comment extends Partial<S<M.Comment, "blockTags" | "label">> {
     summary: CommentDisplayPart[];
-    modifierTags?: `@${string}`[];
+    modifierTags?: TagString[];
 }
 /** @category Comments */
 export interface CommentTag extends S<M.CommentTag, "tag" | "name"> {
@@ -247,7 +247,7 @@ export type CommentDisplayPart = {
  */
 export interface InlineTagDisplayPart {
     kind: "inline-tag";
-    tag: `@${string}`;
+    tag: TagString;
     text: string;
     target?: string | ReflectionId | ReflectionSymbolId;
     tsLinkText?: string;

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

@@ -2,6 +2,8 @@ import { type FileId, FileRegistry } from "../models/FileRegistry.js";
 import type { Deserializer, JSONOutput } from "#serialization";
 import { type NormalizedPath } from "#utils";
 export declare class ValidatingFileRegistry extends FileRegistry {
+    basePath: NormalizedPath;
+    constructor(basePath?: NormalizedPath);
     register(sourcePath: NormalizedPath, relativePath: NormalizedPath): {
         target: FileId;
         anchor: string | undefined;

package/dist/lib/utils/ValidatingFileRegistry.js

@@ -2,14 +2,29 @@ import { FileRegistry } from "../models/FileRegistry.js";
 import { i18n, NormalizedPathUtils } from "#utils";
 import { existsSync } from "fs";
 export class ValidatingFileRegistry extends FileRegistry {
+    basePath;
+    constructor(basePath = "") {
+        super();
+        this.basePath = basePath;
+    }
     register(sourcePath, relativePath) {
-        const absolute = NormalizedPathUtils.resolve(NormalizedPathUtils.dirname(sourcePath), relativePath);
-        const absoluteWithoutAnchor = absolute.replace(/#.*/, "");
+        let absolute = NormalizedPathUtils.resolve(NormalizedPathUtils.dirname(sourcePath), relativePath);
+        let absoluteWithoutAnchor = absolute.replace(/#.*/, "");
         // Note: We allow paths to directories to be registered here, but the AssetsPlugin will not
         // copy them to the output path. This is so that we can link to directories and associate them
         // with reflections in packages mode.
         if (!existsSync(absoluteWithoutAnchor)) {
-            return;
+            // If the relative path didn't exist normally, also check the path relative to the assetBasePath option
+            if (this.basePath != "") {
+                absolute = NormalizedPathUtils.resolve(this.basePath, relativePath);
+                absoluteWithoutAnchor = absolute.replace(/#.*/, "");
+                if (!existsSync(absoluteWithoutAnchor)) {
+                    return;
+                }
+            }
+            else {
+                return;
+            }
         }
         return this.registerAbsolute(absolute);
     }

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

@@ -124,7 +124,7 @@ export function getDocumentEntryPoints(logger, options) {
     // that have at some point or another been used for markdown: https://superuser.com/a/285878
     const supportedFileRegex = /\.(md|markdown)$/;
     const expanded = expandInputFiles(logger, docPaths, options, supportedFileRegex);
-    const baseDir = options.getValue("basePath") || getCommonDirectory(expanded);
+    const baseDir = options.getValue("displayBasePath") || options.getValue("basePath") || getCommonDirectory(expanded);
     return expanded.map((path) => {
         return {
             displayName: relative(baseDir, path).replace(/\.[^.]+$/, ""),
@@ -184,7 +184,8 @@ function getModuleName(fileName, baseDir) {
  * This is in contrast with the package-oriented `getEntryPointsForPackages`
  */
 function getEntryPointsForPaths(logger, inputFiles, options, programs = getEntryPrograms(inputFiles, logger, options)) {
-    const baseDir = options.getValue("basePath") || getCommonDirectory(inputFiles);
+    const baseDir = options.getValue("displayBasePath") || options.getValue("basePath") ||
+        getCommonDirectory(inputFiles);
     const entryPoints = [];
     let expandSuggestion = true;
     entryLoop: for (const fileOrDir of inputFiles.map(normalizePath)) {

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

@@ -2,7 +2,7 @@ import type { BundledTheme as ShikiTheme } from "@gerrit0/mini-shiki";
 import type { SortStrategy } from "../sort.js";
 import type { EntryPointStrategy } from "../entry-point.js";
 import type { ReflectionKind } from "../../models/kind.js";
-import { type GlobString, type LogLevel, type NeverIfInternal, type NormalizedPath, type NormalizedPathOrModule, type NormalizedPathOrModuleOrFunction } from "#utils";
+import { type GlobString, type LogLevel, type NeverIfInternal, type NormalizedPath, type NormalizedPathOrModule, type NormalizedPathOrModuleOrFunction, type TagString } from "#utils";
 import type { TranslationProxy } from "../../internationalization/internationalization.js";
 import type { Application } from "../../application.js";
 /** @enum */
@@ -108,6 +108,7 @@ export interface TypeDocOptionMap {
     gitRevision: string;
     gitRemote: string;
     readme: string;
+    basePath: NormalizedPath;
     outputs: ManuallyValidatedOption<Array<OutputSpecification>>;
     out: NormalizedPath;
     html: NormalizedPath;
@@ -145,7 +146,7 @@ export interface TypeDocOptionMap {
      * strictly typed here.
      */
     markdownItLoader: ManuallyValidatedOption<(parser: any) => void>;
-    basePath: NormalizedPath;
+    displayBasePath: NormalizedPath;
     cname: string;
     favicon: NormalizedPath;
     githubPages: boolean;
@@ -182,7 +183,7 @@ export interface TypeDocOptionMap {
         private?: boolean;
         inherited?: boolean;
         external?: boolean;
-        [tag: `@${string}`]: boolean;
+        [tag: TagString]: boolean;
     }>;
     searchCategoryBoosts: ManuallyValidatedOption<Record<string, number>>;
     searchGroupBoosts: ManuallyValidatedOption<Record<string, number>>;
@@ -192,13 +193,13 @@ export interface TypeDocOptionMap {
     preserveLinkText: boolean;
     jsDocCompatibility: JsDocCompatibility;
     suppressCommentWarningsInDeclarationFiles: boolean;
-    blockTags: `@${string}`[];
-    inlineTags: `@${string}`[];
-    modifierTags: `@${string}`[];
-    excludeTags: `@${string}`[];
-    notRenderedTags: `@${string}`[];
+    blockTags: TagString[];
+    inlineTags: TagString[];
+    modifierTags: TagString[];
+    excludeTags: TagString[];
+    notRenderedTags: TagString[];
     externalSymbolLinkMappings: ManuallyValidatedOption<Record<string, Record<string, string>>>;
-    cascadedModifierTags: `@${string}`[];
+    cascadedModifierTags: TagString[];
     categorizeByGroup: boolean;
     groupReferencesByType: boolean;
     defaultCategory: string;

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

@@ -3,15 +3,15 @@
  * @module
  */
 import type { BundledLanguage } from "@gerrit0/mini-shiki";
-import type { EnumKeys } from "#utils";
+import type { EnumKeys, TagString } from "#utils";
 import type { ReflectionKind } from "../../models/index.js";
 export declare const excludeNotDocumentedKinds: readonly EnumKeys<typeof ReflectionKind>[];
-export declare const excludeTags: readonly `@${string}`[];
-export declare const blockTags: readonly `@${string}`[];
-export declare const inlineTags: readonly `@${string}`[];
-export declare const modifierTags: readonly `@${string}`[];
-export declare const cascadedModifierTags: readonly `@${string}`[];
-export declare const notRenderedTags: readonly `@${string}`[];
+export declare const excludeTags: readonly TagString[];
+export declare const blockTags: readonly TagString[];
+export declare const inlineTags: readonly TagString[];
+export declare const modifierTags: readonly TagString[];
+export declare const cascadedModifierTags: readonly TagString[];
+export declare const notRenderedTags: readonly TagString[];
 export declare const highlightLanguages: readonly BundledLanguage[];
 export declare const ignoredHighlightLanguages: readonly string[];
 export declare const sort: readonly string[];

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

@@ -59,7 +59,7 @@ export class ArgumentsReader {
                 }
                 else if (decl.type === ParameterType.Boolean ||
                     decl.type === ParameterType.Flags) {
-                    const value = String(this.args[index]).toLowerCase();
+                    const value = String(this.args.at(index)).toLowerCase();
                     if (value === "true" || value === "false") {
                         trySet(decl.name, value === "true");
                     }
@@ -87,7 +87,7 @@ export class ArgumentsReader {
                 const decl = options.getDeclaration(actualName);
                 if (decl && decl.type === ParameterType.Flags) {
                     const flagName = name.split(".", 2)[1];
-                    const value = String(this.args[index]).toLowerCase();
+                    const value = String(this.args.at(index)).toLowerCase();
                     if (value === "true" || value === "false") {
                         trySet(decl.name, { [flagName]: value === "true" });
                     }

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

@@ -16,9 +16,7 @@ function makeTagArrayValidator(name) {
 }
 // For convenience, added in the same order as they are documented on the website.
 export function addTypeDocOptions(options) {
-    ///////////////////////////
-    // Configuration Options //
-    ///////////////////////////
+    // MARK: Configuration Options
     options.addDeclaration({
         type: ParameterType.Path,
         name: "options",
@@ -84,9 +82,7 @@ export function addTypeDocOptions(options) {
             }
         },
     });
-    ///////////////////////////
-    ////// Input Options //////
-    ///////////////////////////
+    // MARK: Input Options
     options.addDeclaration({
         name: "entryPoints",
         help: () => i18n.help_entryPoints(),
@@ -202,9 +198,17 @@ export function addTypeDocOptions(options) {
             }
         },
     });
-    ///////////////////////////
-    ///// Output Options //////
-    ///////////////////////////
+    options.addDeclaration({
+        name: "readme",
+        help: () => i18n.help_readme(),
+        type: ParameterType.Path,
+    });
+    options.addDeclaration({
+        name: "basePath",
+        help: () => i18n.help_basePath(),
+        type: ParameterType.Path,
+    });
+    // MARK: Output Options
     options.addDeclaration({
         name: "outputs",
         help: () => i18n.help_out(),
@@ -396,13 +400,8 @@ export function addTypeDocOptions(options) {
         type: ParameterType.Boolean,
     });
     options.addDeclaration({
-        name: "basePath",
-        help: () => i18n.help_basePath(),
-        type: ParameterType.Path,
-    });
-    options.addDeclaration({
-        name: "readme",
-        help: () => i18n.help_readme(),
+        name: "displayBasePath",
+        help: () => i18n.help_displayBasePath(),
         type: ParameterType.Path,
     });
     options.addDeclaration({
@@ -574,7 +573,7 @@ export function addTypeDocOptions(options) {
         },
         validate(value) {
             const knownKeys = ["protected", "private", "inherited", "external"];
-            if (!value || typeof value !== "object") {
+            if (typeof value !== "object" || !value) {
                 throw new Error(i18n.option_0_must_be_an_object("visibilityFilters"));
             }
             for (const [key, val] of Object.entries(value)) {
@@ -622,9 +621,7 @@ export function addTypeDocOptions(options) {
         help: () => i18n.help_useFirstParagraphOfCommentAsSummary(),
         type: ParameterType.Boolean,
     });
-    ///////////////////////////
-    ///// Comment Options /////
-    ///////////////////////////
+    // MARK: Comment Options
     options.addDeclaration({
         name: "jsDocCompatibility",
         help: () => i18n.help_jsDocCompatibility(),
@@ -703,9 +700,7 @@ export function addTypeDocOptions(options) {
         defaultValue: OptionDefaults.cascadedModifierTags,
         validate: makeTagArrayValidator("cascadedModifierTags"),
     });
-    ///////////////////////////
-    // Organization Options ///
-    ///////////////////////////
+    // MARK: Organization Options
     options.addDeclaration({
         name: "categorizeByGroup",
         help: () => i18n.help_categorizeByGroup(),
@@ -764,9 +759,7 @@ export function addTypeDocOptions(options) {
             }
         },
     });
-    ///////////////////////////
-    ///// General Options /////
-    ///////////////////////////
+    // MARK: General Options
     options.addDeclaration({
         name: "watch",
         help: () => i18n.help_watch(),

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

@@ -1,4 +1,5 @@
 import type { TranslationProxy } from "../internationalization/internationalization.js";
+import type { TagString } from "./validation.js";
 declare const TranslatedString: unique symbol;
 export type TranslatedString = string & {
     [TranslatedString]: true;
@@ -13,5 +14,5 @@ export declare function setTranslations(t: Record<string, string>): void;
  */
 export declare function addTranslations(t: Record<string, string>): void;
 export declare const i18n: TranslationProxy;
-export declare function translateTagName(tag: `@${string}`): TranslatedString;
+export declare function translateTagName(tag: TagString): TranslatedString;
 export {};

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

@@ -13,3 +13,4 @@ export * from "./path.js";
 export * from "./set.js";
 export * from "./string.js";
 export * as Validation from "./validation.js";
+export type { TagString } from "./validation.js";

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

@@ -28,5 +28,6 @@ export type Schema = typeof String | typeof Number | typeof Boolean | readonly s
  */
 export declare function validate<T extends Schema>(schema: T, obj: unknown): obj is Infer<T>;
 export declare function optional<T extends Schema>(x: T): Optional<T>;
-export declare function isTagString(x: unknown): x is `@${string}`;
+export type TagString = `@${string}`;
+export declare function isTagString(x: unknown): x is TagString;
 export {};