typedoc 0.27.0-beta.1 → 0.27.0

package/dist/lib/application.d.ts

@@ -125,7 +125,7 @@ export declare class Application extends AbstractComponent<Application, Applicat
      */
     getTypeScriptPath(): string;
     getTypeScriptVersion(): string;
-    getEntryPoints(): Promise<DocumentationEntryPoint[] | undefined>;
+    getEntryPoints(): DocumentationEntryPoint[] | undefined;
     /**
      * Gets the entry points to be documented according to the current `entryPoints` and `entryPointStrategy` options.
      * May return undefined if entry points fail to be expanded.

package/dist/lib/application.js

@@ -52,7 +52,6 @@ import { findTsConfigFile } from "./utils/tsconfig.js";
 import { deriveRootDir, glob, readFile } from "./utils/fs.js";
 import { addInferredDeclarationMapPaths } from "./models/reflections/ReflectionSymbolId.js";
 import { Internationalization, } from "./internationalization/internationalization.js";
-import { loadShikiMetadata } from "./utils/highlighter.js";
 import { ValidatingFileRegistry, FileRegistry } from "./models/FileRegistry.js";
 import { readFileSync } from "fs";
 import { fileURLToPath } from "url";
@@ -215,7 +214,6 @@ let Application = (() => {
          * Initialize TypeDoc, loading plugins if applicable.
          */
         static async bootstrapWithPlugins(options = {}, readers = DEFAULT_READERS) {
-            await loadShikiMetadata();
             const app = new Application(DETECTOR);
             readers.forEach((r) => app.options.addReader(r));
             app.options.reset();
@@ -239,7 +237,6 @@ let Application = (() => {
          * @param readers Option readers to use to discover options from config files.
          */
         static async bootstrap(options = {}, readers = DEFAULT_READERS) {
-            await loadShikiMetadata();
             const app = new Application(DETECTOR);
             readers.forEach((r) => app.options.addReader(r));
             await app._bootstrap(options);
@@ -300,7 +297,7 @@ let Application = (() => {
         getTypeScriptVersion() {
             return ts.version;
         }
-        async getEntryPoints() {
+        getEntryPoints() {
             if (this.options.isSet("entryPoints")) {
                 return this.getDefinedEntryPoints();
             }
@@ -333,7 +330,7 @@ let Application = (() => {
             if (!supportedVersionMajorMinor.some((version) => version == ts.versionMajorMinor)) {
                 this.logger.warn(this.i18n.unsupported_ts_version_0(supportedVersionMajorMinor.join(", ")));
             }
-            const entryPoints = await this.getEntryPoints();
+            const entryPoints = this.getEntryPoints();
             if (!entryPoints) {
                 // Fatal error already reported.
                 return;

package/dist/lib/converter/symbols.js

@@ -169,7 +169,15 @@ function convertNamespace(context, symbol, exportSymbol) {
         reflection = existingReflection;
     }
     else {
-        reflection = context.createDeclarationReflection(ReflectionKind.Namespace, symbol, exportSymbol);
+        let kind = ReflectionKind.Namespace;
+        let nameOverride;
+        // #2778 - always treat declare module "foo" as a module, not a namespace
+        const declareModule = symbol.declarations?.find((mod) => ts.isModuleDeclaration(mod) && ts.isStringLiteral(mod.name));
+        if (declareModule) {
+            kind = ReflectionKind.Module;
+            nameOverride = declareModule.name.text;
+        }
+        reflection = context.createDeclarationReflection(kind, symbol, exportSymbol, nameOverride);
         context.finalizeDeclarationReflection(reflection);
     }
     convertSymbols(context.withScope(reflection), context.checker

package/dist/lib/converter/types.js

@@ -231,8 +231,7 @@ const importType = {
     kind: [ts.SyntaxKind.ImportType],
     convert(context, node) {
         const name = node.qualifier?.getText() ?? "__module";
-        const symbol = context.checker.getSymbolAtLocation(node);
-        assert(symbol, "Missing symbol when converting import type node");
+        const symbol = context.expectSymbolAtLocation(node.qualifier || node);
         return ReferenceType.createSymbolReference(context.resolveAliasedSymbol(symbol), context, name);
     },
     convertType(context, type) {

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

@@ -189,6 +189,7 @@ module.exports = localeUtils.buildIncompleteTranslation({
     help_headings: "确定标题是否需要被渲染",
     help_sluggerConfiguration: "确定渲染的 HTML 中锚点的确定方式",
     help_navigation: "确定导航侧边栏的组织方式",
+    help_includeHierarchySummary: "如果设置，反射的层级一览将被渲染至概述页面。默认为 `true`",
     help_visibilityFilters: "根据修饰符标签指定内置过滤器和附加过滤器的默认可见性",
     help_searchCategoryBoosts: "配置搜索以提高所选类别的相关性",
     help_searchGroupBoosts: "配置搜索以增强所选种类（例如“类别”）的相关性",
@@ -316,6 +317,8 @@ module.exports = localeUtils.buildIncompleteTranslation({
     theme_type_declaration: "类型声明",
     theme_index: "索引",
     theme_hierarchy: "层级",
+    theme_hierarchy_summary: "层级一览",
+    theme_hierarchy_view_summary: "查看层级一览",
     theme_implemented_by: "实现于",
     theme_defined_in: "定义于",
     theme_implementation_of: "实现了",
@@ -339,6 +342,8 @@ module.exports = localeUtils.buildIncompleteTranslation({
     theme_copy: "复制",
     theme_copied: "已复制！",
     theme_normally_hidden: "由于您的过滤器设置，该成员已被隐藏。",
+    theme_hierarchy_expand: "展开",
+    theme_hierarchy_collapse: "折叠",
     tag_defaultValue: "默认值",
     tag_deprecated: "已被弃用",
     tag_example: "示例",

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

@@ -184,6 +184,7 @@ declare const _default: {
     help_headings: string;
     help_sluggerConfiguration: string;
     help_navigation: string;
+    help_includeHierarchySummary: string;
     help_visibilityFilters: string;
     help_searchCategoryBoosts: string;
     help_searchGroupBoosts: string;
@@ -311,6 +312,8 @@ declare const _default: {
     theme_type_declaration: string;
     theme_index: string;
     theme_hierarchy: string;
+    theme_hierarchy_summary: string;
+    theme_hierarchy_view_summary: string;
     theme_implemented_by: string;
     theme_defined_in: string;
     theme_implementation_of: string;
@@ -334,6 +337,8 @@ declare const _default: {
     theme_copy: string;
     theme_copied: string;
     theme_normally_hidden: string;
+    theme_hierarchy_expand: string;
+    theme_hierarchy_collapse: string;
     tag_defaultValue: string;
     tag_deprecated: string;
     tag_example: string;

package/dist/lib/output/themes/MarkedPlugin.d.ts

@@ -1,6 +1,6 @@
 import { ContextAwareRendererComponent } from "../components.js";
 import { MarkdownEvent, RendererEvent, type PageEvent } from "../events.js";
-import type { BundledTheme } from "shiki" with { "resolution-mode": "import" };
+import type { BundledTheme } from "@gerrit0/mini-shiki";
 import type { DefaultThemeRenderContext, Renderer } from "../index.js";
 import { type CommentDisplayPart } from "../../models/index.js";
 /**

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,9 +39,11 @@ 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;
+export declare const TYPEDOC_ROOT: string;
 export declare function hasBeenLoadedMultipleTimes(): boolean;
 export declare function getLoadedPaths(): string[];
 export {};

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) {
@@ -59,6 +63,8 @@ export function NonEnumerable(_cls, context) {
         });
     });
 }
+// transform /abs/path/to/typedoc/dist/lib/utils/general -> /abs/path/to/typedoc
+export const TYPEDOC_ROOT = dirname(dirname(dirname(dirname(url.fileURLToPath(import.meta.url)))));
 /**
  * This is a hack to make it possible to detect and warn about installation setups
  * which result in TypeDoc being installed multiple times. If TypeDoc has been loaded
@@ -69,8 +75,7 @@ const pathSymbol = Symbol.for("typedoc_paths");
 const g = globalThis;
 g[loadSymbol] = (g[loadSymbol] || 0) + 1;
 g[pathSymbol] ||= [];
-// transform /abs/path/to/typedoc/dist/lib/utils/general -> /abs/path/to/typedoc
-g[pathSymbol].push(dirname(dirname(dirname(dirname(url.fileURLToPath(import.meta.url))))));
+g[pathSymbol].push(TYPEDOC_ROOT);
 export function hasBeenLoadedMultipleTimes() {
     return g[loadSymbol] !== 1;
 }

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/index.d.ts

@@ -5,7 +5,7 @@ export { EventDispatcher } from "./events.js";
 export { isFile, copy, copySync, getCommonDirectory, readFile, writeFile, writeFileSync, discoverInParentDir, discoverPackageJson, } from "./fs.js";
 export { normalizePath } from "./paths.js";
 export type { IfInternal, NeverIfInternal, Chars } from "./general.js";
-export { assertNever } from "./general.js";
+export { assertNever, TYPEDOC_ROOT } from "./general.js";
 export { ConsoleLogger, Logger, LogLevel } from "./loggers.js";
 export { DefaultMap } from "./map.js";
 export { ArgumentsReader, Option, CommentStyle, Options, PackageJsonReader, ParameterHint, ParameterType, TSConfigReader, TypeDocReader, OptionDefaults, } from "./options/index.js";

package/dist/lib/utils/index.js

@@ -4,7 +4,7 @@ export * from "./enum.js";
 export { EventDispatcher } from "./events.js";
 export { isFile, copy, copySync, getCommonDirectory, readFile, writeFile, writeFileSync, discoverInParentDir, discoverPackageJson, } from "./fs.js";
 export { normalizePath } from "./paths.js";
-export { assertNever } from "./general.js";
+export { assertNever, TYPEDOC_ROOT } from "./general.js";
 export { ConsoleLogger, Logger, LogLevel } from "./loggers.js";
 export { DefaultMap } from "./map.js";
 export { ArgumentsReader, Option, CommentStyle, Options, PackageJsonReader, ParameterHint, ParameterType, TSConfigReader, TypeDocReader, OptionDefaults, } from "./options/index.js";

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";

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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typedoc",
   "description": "Create api documentation for TypeScript projects.",
-  "version": "0.27.0-beta.1",
+  "version": "0.27.0",
   "homepage": "https://typedoc.org",
   "type": "module",
   "exports": {
@@ -25,11 +25,10 @@
     "node": ">= 18"
   },
   "dependencies": {
+    "@gerrit0/mini-shiki": "^1.23.2",
     "lunr": "^2.3.9",
     "markdown-it": "^14.1.0",
-    "minimatch": "^10.0.1",
-    "resolve-import": "^1.4.6",
-    "shiki": "^1.23.1",
+    "minimatch": "^9.0.5",
     "yaml": "^2.6.1"
   },
   "peerDependencies": {