typedoc 0.27.0-beta.0 → 0.27.0-beta.2

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

@@ -102,7 +102,12 @@ export function renderName(refl) {
     }
     return wbr(refl.name);
 }
+// This is cached to avoid slowness with large projects.
+const rootsCache = new WeakMap();
 export function getHierarchyRoots(project) {
+    const cached = rootsCache.get(project);
+    if (cached)
+        return cached;
     const allClasses = project.getReflectionsByKind(ReflectionKind.ClassOrInterface);
     const roots = allClasses.filter((refl) => {
         // If nobody extends this class, there's no possible hierarchy to display.
@@ -122,7 +127,9 @@ export function getHierarchyRoots(project) {
             },
         }));
     });
-    return roots.sort((a, b) => a.name.localeCompare(b.name));
+    const result = roots.sort((a, b) => a.name.localeCompare(b.name));
+    rootsCache.set(project, result);
+    return result;
 }
 export function getMemberSections(parent, childFilter = () => true) {
     if (parent.categories?.length) {

package/dist/lib/utils/entry-point.d.ts

@@ -36,7 +36,7 @@ export interface DocumentEntryPoint {
     displayName: string;
     path: string;
 }
-export declare function inferEntryPoints(logger: Logger, options: Options): Promise<DocumentationEntryPoint[]>;
+export declare function inferEntryPoints(logger: Logger, options: Options): DocumentationEntryPoint[];
 export declare function getEntryPoints(logger: Logger, options: Options): DocumentationEntryPoint[] | undefined;
 /**
  * Document entry points are markdown documents that the user has requested we include in the project with

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

@@ -1,12 +1,10 @@
-import { dirname, join, relative, resolve } from "path";
+import { join, relative, resolve } from "path";
 import ts from "typescript";
 import * as FS from "fs";
 import { expandPackages } from "./package-manifest.js";
 import { createMinimatch, matchesAny, nicePath, normalizePath, } from "./paths.js";
-import { deriveRootDir, discoverPackageJson, getCommonDirectory, glob, isDir, } from "./fs.js";
+import { deriveRootDir, discoverPackageJson, getCommonDirectory, glob, inferPackageEntryPointPaths, isDir, } from "./fs.js";
 import { assertNever } from "./general.js";
-import { resolveAllExports } from "resolve-import/resolve-all-exports";
-import { fileURLToPath } from "url";
 /**
  * Defines how entry points are interpreted.
  * @enum
@@ -32,32 +30,13 @@ export const EntryPointStrategy = {
      */
     Merge: "merge",
 };
-export async function inferEntryPoints(logger, options) {
+export function inferEntryPoints(logger, options) {
     const packageJson = discoverPackageJson(process.cwd());
     if (!packageJson) {
         logger.warn(logger.i18n.no_entry_points_provided());
         return [];
     }
-    const entries = await resolveAllExports(packageJson.file, {
-        conditions: ["typedoc", "import", "node"],
-    });
-    const pathEntries = Object.entries(entries).map(([k, v]) => {
-        if (typeof v === "object") {
-            return [k, fileURLToPath(v)];
-        }
-        return [k, v];
-    });
-    // resolveAllExports doesn't create a fake export for "main"
-    // so do that here if we don't have any exports.
-    if (pathEntries.length === 0) {
-        if ("main" in packageJson.content &&
-            typeof packageJson.content["main"] === "string") {
-            pathEntries.push([
-                ".",
-                resolve(dirname(packageJson.file), packageJson.content["main"]),
-            ]);
-        }
-    }
+    const pathEntries = inferPackageEntryPointPaths(packageJson.file);
     const entryPoints = [];
     const programs = getEntryPrograms(pathEntries.map((p) => p[1]), logger, options);
     // See also: addInferredDeclarationMapPaths in ReflectionSymbolId

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

@@ -35,6 +35,15 @@ export declare function writeFile(fileName: string, data: string): Promise<void>
  */
 export declare function copy(src: string, dest: string): Promise<void>;
 export declare function copySync(src: string, dest: string): void;
+export interface DiscoverFilesController {
+    shouldRecurse(childPath: string[]): boolean;
+    matches(path: string): boolean;
+    /** Defaults to false */
+    matchDirectories?: boolean;
+    /** Defaults to false */
+    followSymlinks?: boolean;
+}
+export declare function discoverFiles(rootDir: string, controller: DiscoverFilesController): string[];
 /**
  * Simpler version of `glob.sync` that only covers our use cases, always ignoring node_modules.
  */
@@ -61,3 +70,4 @@ export declare function discoverPackageJson(dir: string): {
     };
 } | undefined;
 export declare function findPackageForPath(sourcePath: string): string | undefined;
+export declare function inferPackageEntryPointPaths(packagePath: string): [importPath: string, resolvedPath: string][];

package/dist/lib/utils/fs.js

@@ -5,6 +5,8 @@ import { dirname, join, relative, resolve } from "path";
 import { optional, validate } from "./validation.js";
 import { createMinimatch, normalizePath } from "./paths.js";
 import { filterMap } from "./array.js";
+import { escapeRegExp } from "./general.js";
+import { ok } from "assert";
 export function isFile(file) {
     try {
         return fs.statSync(file).isFile();
@@ -144,33 +146,24 @@ export function copySync(src, dest) {
         // Do nothing for FIFO, special devices.
     }
 }
-/**
- * Simpler version of `glob.sync` that only covers our use cases, always ignoring node_modules.
- */
-export function glob(pattern, root, options = {}) {
+// cache of fs.realpathSync results to avoid extra I/O
+const realpathCache = new Map();
+export function discoverFiles(rootDir, controller) {
     const result = [];
-    const mini = new Minimatch(normalizePath(pattern));
-    const dirs = [normalizePath(root).split("/")];
+    const dirs = [normalizePath(rootDir).split("/")];
     // cache of real paths to avoid infinite recursion
     const symlinkTargetsSeen = new Set();
-    // cache of fs.realpathSync results to avoid extra I/O
-    const realpathCache = new Map();
-    const { includeDirectories = false, followSymlinks = false } = options;
-    // if we _specifically asked_ for something in node_modules, fine, otherwise ignore it
-    // to avoid globs like '**/*.ts' finding all the .d.ts files in node_modules.
-    // however, if the pattern is something like `!**/node_modules/**`, this will also
-    // cause node_modules to be considered, though it will be discarded by minimatch.
-    const shouldIncludeNodeModules = pattern.includes("node_modules");
+    const { matchDirectories = false, followSymlinks = false } = controller;
     let dir = dirs.shift();
     const handleFile = (path) => {
         const childPath = [...dir, path].join("/");
-        if (mini.match(childPath)) {
+        if (controller.matches(childPath)) {
             result.push(childPath);
         }
     };
     const handleDirectory = (path) => {
         const childPath = [...dir, path];
-        if (mini.set.some((row) => mini.matchOne(childPath, row, /* partial */ true))) {
+        if (controller.shouldRecurse(childPath)) {
             dirs.push(childPath);
         }
     };
@@ -212,7 +205,7 @@ export function glob(pattern, root, options = {}) {
         }
     };
     while (dir) {
-        if (includeDirectories && mini.match(dir.join("/"))) {
+        if (matchDirectories && controller.matches(dir.join("/"))) {
             result.push(dir.join("/"));
         }
         for (const child of fs.readdirSync(dir.join("/"), {
@@ -222,9 +215,7 @@ export function glob(pattern, root, options = {}) {
                 handleFile(child.name);
             }
             else if (child.isDirectory()) {
-                if (shouldIncludeNodeModules || child.name !== "node_modules") {
-                    handleDirectory(child.name);
-                }
+                handleDirectory(child.name);
             }
             else if (followSymlinks && child.isSymbolicLink()) {
                 handleSymlink(child.name);
@@ -234,6 +225,32 @@ export function glob(pattern, root, options = {}) {
     }
     return result;
 }
+/**
+ * Simpler version of `glob.sync` that only covers our use cases, always ignoring node_modules.
+ */
+export function glob(pattern, root, options = {}) {
+    const mini = new Minimatch(normalizePath(pattern));
+    const shouldIncludeNodeModules = pattern.includes("node_modules");
+    const controller = {
+        matches(path) {
+            return mini.match(path);
+        },
+        shouldRecurse(childPath) {
+            // if we _specifically asked_ for something in node_modules, fine, otherwise ignore it
+            // to avoid globs like '**/*.ts' finding all the .d.ts files in node_modules.
+            // however, if the pattern is something like `!**/node_modules/**`, this will also
+            // cause node_modules to be considered, though it will be discarded by minimatch.
+            if (childPath[childPath.length - 1] === "node_modules" &&
+                !shouldIncludeNodeModules) {
+                return false;
+            }
+            return mini.set.some((row) => mini.matchOne(childPath, row, /* partial */ true));
+        },
+        matchDirectories: options.includeDirectories,
+        followSymlinks: options.followSymlinks,
+    };
+    return discoverFiles(root, controller);
+}
 export function hasTsExtension(path) {
     return /\.[cm]?ts$|\.tsx$/.test(path);
 }
@@ -311,3 +328,100 @@ export function findPackageForPath(sourcePath) {
         return packageJson.content.name;
     }
 }
+export function inferPackageEntryPointPaths(packagePath) {
+    const packageDir = dirname(packagePath);
+    const packageJson = JSON.parse(readFile(packagePath));
+    const exports = packageJson.exports;
+    if (typeof exports === "string") {
+        return resolveExport(packageDir, ".", exports, false);
+    }
+    if (!exports || typeof exports !== "object") {
+        if (typeof packageJson.main === "string") {
+            return [[".", resolve(packageDir, packageJson.main)]];
+        }
+        return [];
+    }
+    const results = [];
+    if (Array.isArray(exports)) {
+        results.push(...resolveExport(packageDir, ".", exports, true));
+    }
+    else {
+        for (const [importPath, exp] of Object.entries(exports)) {
+            results.push(...resolveExport(packageDir, importPath, exp, false));
+        }
+    }
+    return results;
+}
+function resolveExport(packageDir, name, exportDeclaration, validatePath) {
+    if (typeof exportDeclaration === "string") {
+        return resolveStarredExport(packageDir, name, exportDeclaration, validatePath);
+    }
+    if (Array.isArray(exportDeclaration)) {
+        for (const item of exportDeclaration) {
+            const result = resolveExport(packageDir, name, item, true);
+            if (result.length) {
+                return result;
+            }
+        }
+        return [];
+    }
+    const EXPORT_CONDITIONS = ["typedoc", "types", "import", "node", "default"];
+    for (const cond in exportDeclaration) {
+        if (EXPORT_CONDITIONS.includes(cond)) {
+            return resolveExport(packageDir, name, exportDeclaration[cond], false);
+        }
+    }
+    // No recognized export condition
+    return [];
+}
+function isWildcardName(name) {
+    let starCount = 0;
+    for (let i = 0; i < name.length; ++i) {
+        if (name[i] === "*") {
+            ++starCount;
+        }
+    }
+    return starCount === 1;
+}
+function resolveStarredExport(packageDir, name, exportDeclaration, validatePath) {
+    // Wildcards only do something if there is exactly one star in the name
+    // If there isn't any star in the destination, all entries map to one file
+    // so don't bother enumerating possible files.
+    if (isWildcardName(name) && exportDeclaration.includes("*")) {
+        // Construct a pattern which we can use to determine if a wildcard matches
+        // This will look something like: /^/app\/package\/(.*).js$/
+        // The destination may have multiple wildcards, in which case they should
+        // contain the same text, so we replace "*" with backreferences for all
+        // but the first occurrence.
+        let first = true;
+        const matcher = new RegExp("^" +
+            escapeRegExp(normalizePath(packageDir) +
+                "/" +
+                exportDeclaration.replace(/^\.\//, "")).replaceAll("\\*", () => {
+                if (first) {
+                    first = false;
+                    return "(.*)";
+                }
+                return "\\1";
+            }) +
+            "$");
+        const matchedFiles = discoverFiles(packageDir, {
+            matches(path) {
+                return matcher.test(path);
+            },
+            shouldRecurse(path) {
+                return path[path.length - 1] !== "node_modules";
+            },
+        });
+        return matchedFiles.flatMap((path) => {
+            const starContent = path.match(matcher);
+            ok(starContent, "impossible, discoverFiles uses matcher");
+            return [[name.replace("*", starContent[1]), path]];
+        });
+    }
+    const exportPath = resolve(packageDir, exportDeclaration);
+    if (validatePath && !fs.existsSync(exportPath)) {
+        return [];
+    }
+    return [[name, exportPath]];
+}

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

@@ -39,6 +39,7 @@ export type Chars<T extends string> = T extends `${infer C}${infer R}` ? C | Cha
  * Utility to help type checking ensure that there is no uncovered case.
  */
 export declare function assertNever(x: never): never;
+export declare function escapeRegExp(s: string): string;
 export declare function editDistance(s: string, t: string): number;
 export declare function getSimilarValues(values: Iterable<string>, compareTo: string): string[];
 export declare function NonEnumerable(_cls: unknown, context: ClassFieldDecoratorContext): void;

package/dist/lib/utils/general.js

@@ -8,6 +8,10 @@ import { DefaultMap } from "./map.js";
 export function assertNever(x) {
     throw new Error(`Expected handling to cover all possible cases, but it didn't cover: ${Util.inspect(x)}`);
 }
+// From MDN
+export function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); // $& means the whole matched string
+}
 // Based on https://en.wikipedia.org/wiki/Levenshtein_distance#Iterative_with_two_matrix_rows
 // Slightly modified for improved match results for options
 export function editDistance(s, t) {

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

@@ -1,6 +1,5 @@
-import type { BundledLanguage, BundledTheme } from "shiki" with { "resolution-mode": "import" };
-export declare function loadShikiMetadata(): Promise<void>;
-export declare function loadHighlighter(lightTheme: BundledTheme, darkTheme: BundledTheme, langs: BundledLanguage[]): Promise<void>;
+import * as shiki from "@gerrit0/mini-shiki";
+export declare function loadHighlighter(lightTheme: shiki.BundledTheme, darkTheme: shiki.BundledTheme, langs: shiki.BundledLanguage[]): Promise<void>;
 export declare function isSupportedLanguage(lang: string): boolean;
 export declare function getSupportedLanguages(): string[];
 export declare function getSupportedLanguagesWithoutAliases(): string[];

package/dist/lib/utils/highlighter.js

@@ -1,31 +1,24 @@
-import { ok as assert, ok } from "assert";
+import * as shiki from "@gerrit0/mini-shiki";
 import * as JSX from "./jsx.js";
 import { unique } from "./array.js";
+import assert from "assert";
 const aliases = new Map();
-let supportedLanguagesWithoutAliases = [];
-let supportedLanguages = [];
-let supportedThemes = [];
-const plaintextLanguages = ["txt", "text"];
-export async function loadShikiMetadata() {
-    if (aliases.size)
-        return;
-    const shiki = await import("shiki");
-    for (const lang of shiki.bundledLanguagesInfo) {
-        for (const alias of lang.aliases || []) {
-            aliases.set(alias, lang.id);
-        }
+for (const lang of shiki.bundledLanguagesInfo) {
+    for (const alias of lang.aliases || []) {
+        aliases.set(alias, lang.id);
     }
-    supportedLanguages = unique([
-        ...plaintextLanguages,
-        ...aliases.keys(),
-        ...shiki.bundledLanguagesInfo.map((lang) => lang.id),
-    ]).sort();
-    supportedLanguagesWithoutAliases = unique([
-        ...plaintextLanguages,
-        ...shiki.bundledLanguagesInfo.map((lang) => lang.id),
-    ]);
-    supportedThemes = Object.keys(shiki.bundledThemes);
 }
+const plaintextLanguages = ["txt", "text"];
+const supportedLanguagesWithoutAliases = unique([
+    ...plaintextLanguages,
+    ...shiki.bundledLanguagesInfo.map((lang) => lang.id),
+]);
+const supportedLanguages = unique([
+    ...plaintextLanguages,
+    ...aliases.keys(),
+    ...shiki.bundledLanguagesInfo.map((lang) => lang.id),
+]).sort();
+const supportedThemes = Object.keys(shiki.bundledThemes);
 class DoubleHighlighter {
     highlighter;
     light;
@@ -40,7 +33,7 @@ class DoubleHighlighter {
         return this.highlighter.getLoadedLanguages().includes(lang);
     }
     highlight(code, lang) {
-        const tokens = this.highlighter.codeToTokensWithThemes(code, {
+        const tokens = shiki.codeToTokensWithThemes(this.highlighter, code, {
             themes: { light: this.light, dark: this.dark },
             lang: lang,
         });
@@ -101,27 +94,32 @@ class DoubleHighlighter {
         return scheme;
     }
 }
+let shikiEngine;
 let highlighter;
 export async function loadHighlighter(lightTheme, darkTheme, langs) {
     if (highlighter)
         return;
-    const shiki = await import("shiki");
-    const hl = await shiki.createHighlighter({ themes: [lightTheme, darkTheme], langs });
+    if (!shikiEngine) {
+        await shiki.loadBuiltinWasm();
+        shikiEngine = await shiki.createOnigurumaEngine();
+    }
+    const hl = await shiki.createShikiInternal({
+        engine: shikiEngine,
+        themes: [shiki.bundledThemes[lightTheme], shiki.bundledThemes[darkTheme]],
+        langs: langs.map((lang) => shiki.bundledLanguages[lang]),
+    });
     highlighter = new DoubleHighlighter(hl, lightTheme, darkTheme);
 }
 export function isSupportedLanguage(lang) {
     return getSupportedLanguages().includes(lang);
 }
 export function getSupportedLanguages() {
-    ok(supportedLanguages.length > 0, "loadShikiMetadata has not been called");
     return supportedLanguages;
 }
 export function getSupportedLanguagesWithoutAliases() {
-    ok(supportedLanguagesWithoutAliases.length > 0, "loadShikiMetadata has not been called");
-    return supportedLanguages;
+    return supportedLanguagesWithoutAliases;
 }
 export function getSupportedThemes() {
-    ok(supportedThemes.length > 0, "loadShikiMetadata has not been called");
     return supportedThemes;
 }
 export function isLoadedLanguage(lang) {

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

@@ -14,7 +14,6 @@
  * @module
  */
 import type { IntrinsicElements, JsxElement, JsxChildren, JsxComponent } from "./jsx.elements.js";
-import { JsxFragment as Fragment } from "./jsx.elements.js";
 export type { JsxElement as Element, JsxChildren as Children, JsxComponent, } from "./jsx.elements.js";
 export { JsxFragment as Fragment } from "./jsx.elements.js";
 /**
@@ -41,7 +40,7 @@ export declare namespace JSX {
  * @param props
  * @param children
  */
-export declare function createElement(tag: typeof Fragment | string | JsxComponent<any>, props: object | null, ...children: JsxChildren[]): JsxElement;
+export declare function createElement(tag: string | JsxComponent<any>, props: object | null, ...children: JsxChildren[]): JsxElement;
 export declare function setRenderSettings(options: {
     pretty: boolean;
 }): void;

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

@@ -123,7 +123,7 @@ export interface IntrinsicElements {
     use: JsxUseElementProps;
     text: JsxTextElementProps;
 }
-export declare const JsxFragment: unique symbol;
+export declare function JsxFragment(): never;
 export type JsxComponent<P> = (props: P) => JsxElement | null | undefined;
 export interface JsxElement {
     tag: typeof JsxFragment | string | JsxComponent<any>;

package/dist/lib/utils/jsx.elements.js

@@ -1 +1,3 @@
-export const JsxFragment = Symbol();
+export function JsxFragment() {
+    throw new Error("Should never be called");
+}

package/dist/lib/utils/jsx.js

@@ -14,7 +14,7 @@
  * @module
  */
 import { escapeHtml } from "./html.js";
-import { JsxFragment as Fragment } from "./jsx.elements.js";
+import { JsxFragment } from "./jsx.elements.js";
 export { JsxFragment as Fragment } from "./jsx.elements.js";
 /**
  * Used to inject HTML directly into the document.
@@ -75,57 +75,52 @@ export function renderElement(element) {
         return "";
     }
     const { tag, props, children } = element;
+    let html = "";
     if (typeof tag === "function") {
         if (tag === Raw) {
             return String(props.html);
         }
+        if (tag === JsxFragment) {
+            renderChildren(children);
+            return html;
+        }
         return renderElement(tag(Object.assign({ children }, props)));
     }
-    let html = "";
-    if (tag !== Fragment) {
-        if (blockElements.has(tag) && renderPretty && html) {
-            html += "\n";
-        }
-        html += "<";
-        html += tag;
-        for (const [key, val] of Object.entries(props ?? {})) {
-            if (val == null)
-                continue;
-            if (typeof val == "boolean") {
-                if (val) {
-                    html += " ";
-                    html += key;
-                }
-            }
-            else {
+    if (blockElements.has(tag) && renderPretty && html) {
+        html += "\n";
+    }
+    html += "<";
+    html += tag;
+    for (const [key, val] of Object.entries(props ?? {})) {
+        if (val == null)
+            continue;
+        if (typeof val == "boolean") {
+            if (val) {
                 html += " ";
                 html += key;
-                html += '="';
-                html += (typeof val === "string" ? val : JSON.stringify(val)).replaceAll('"', "&quot;");
-                html += '"';
             }
         }
+        else {
+            html += " ";
+            html += key;
+            html += '="';
+            html += (typeof val === "string" ? val : JSON.stringify(val)).replaceAll('"', "&quot;");
+            html += '"';
+        }
     }
-    let hasChildren = false;
     if (children.length) {
-        hasChildren = true;
-        if (tag !== Fragment)
-            html += ">";
+        html += ">";
         renderChildren(children);
+        html += "</";
+        html += tag;
+        html += ">";
     }
-    if (tag !== Fragment) {
-        if (!hasChildren) {
-            if (voidElements.has(tag)) {
-                html += "/>";
-            }
-            else {
-                html += "></";
-                html += tag;
-                html += ">";
-            }
+    else {
+        if (voidElements.has(tag)) {
+            html += "/>";
         }
         else {
-            html += "</";
+            html += "></";
             html += tag;
             html += ">";
         }
@@ -157,19 +152,21 @@ export function renderElementToText(element) {
         return "";
     }
     const { tag, props, children } = element;
+    let html = "";
     if (typeof tag === "function") {
         if (tag === Raw) {
             return String(props.html);
         }
+        if (tag === JsxFragment) {
+            renderChildren(children);
+            return html;
+        }
         return renderElementToText(tag(Object.assign({ children }, props)));
     }
     else if (tag === "br") {
         return "\n";
     }
-    let html = "";
-    if (children.length) {
-        renderChildren(children);
-    }
+    renderChildren(children);
     return html;
     function renderChildren(children) {
         for (const child of children) {

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

@@ -1,4 +1,4 @@
-import type { BundledTheme as ShikiTheme } from "shiki" with { "resolution-mode": "import" };
+import type { BundledTheme as ShikiTheme } from "@gerrit0/mini-shiki";
 import type { LogLevel } from "../loggers.js";
 import type { SortStrategy } from "../sort.js";
 import type { EntryPointStrategy } from "../entry-point.js";
@@ -97,6 +97,7 @@ export interface TypeDocOptionMap {
     readme: string;
     outputs: ManuallyValidatedOption<Array<OutputSpecification>>;
     out: string;
+    html: string;
     json: string;
     pretty: boolean;
     emit: typeof EmitStrategy;
@@ -160,6 +161,7 @@ export interface TypeDocOptionMap {
     sluggerConfiguration: {
         lowercase: boolean;
     };
+    includeHierarchySummary: boolean;
     visibilityFilters: ManuallyValidatedOption<{
         protected?: boolean;
         private?: boolean;

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

@@ -1,4 +1,4 @@
-import type { BundledLanguage } from "shiki" with { "resolution-mode": "import" };
+import type { BundledLanguage } from "@gerrit0/mini-shiki";
 import type { EnumKeys } from "../enum.js";
 import type { ReflectionKind } from "../../models/index.js";
 /**

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

@@ -231,12 +231,18 @@ export function addTypeDocOptions(options) {
     });
     options.addDeclaration({
         name: "out",
-        outputShortcut: "html",
         help: (i18n) => i18n.help_out(),
         type: ParameterType.Path,
         hint: ParameterHint.Directory,
         defaultValue: "./docs",
     });
+    options.addDeclaration({
+        name: "html",
+        outputShortcut: "html",
+        help: (i18n) => i18n.help_html(),
+        type: ParameterType.Path,
+        hint: ParameterHint.Directory,
+    });
     options.addDeclaration({
         name: "json",
         outputShortcut: "json",
@@ -538,6 +544,12 @@ export function addTypeDocOptions(options) {
             lowercase: true,
         },
     });
+    options.addDeclaration({
+        name: "includeHierarchySummary",
+        help: (i18n) => i18n.help_includeHierarchySummary(),
+        type: ParameterType.Boolean,
+        defaultValue: true,
+    });
     options.addDeclaration({
         name: "visibilityFilters",
         help: (i18n) => i18n.help_visibilityFilters(),