typedoc 0.28.0-beta.1 → 0.28.0-beta.2

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

@@ -1,57 +1,98 @@
-import { ReflectionKind, } from "../../../../models/index.js";
-import { i18n, JSX } from "#utils";
+import { Comment, Reflection, ReflectionKind, } from "../../../../models/index.js";
+import { assert, i18n, JSX } from "#utils";
 import { classNames, getKindClass } from "../../lib.js";
-import { anchorLinkIfPresent } from "./anchor-icon.js";
-const isUsefulVisitor = {
-    array(type) {
-        return renderingTypeDetailsIsUseful(type.elementType);
-    },
-    intersection(type) {
-        return type.types.some(renderingTypeDetailsIsUseful);
-    },
-    union(type) {
-        return !!type.elementSummaries || type.types.some(renderingTypeDetailsIsUseful);
-    },
-    reflection(type) {
-        return renderingChildIsUseful(type.declaration);
-    },
-    reference(type) {
-        return shouldExpandReference(type);
-    },
-};
-function renderingTypeDetailsIsUseful(type) {
+import { anchorTargetIfPresent } from "./anchor-icon.js";
+function renderingTypeDetailsIsUseful(container, type) {
+    const isUsefulVisitor = {
+        array(type) {
+            return renderingTypeDetailsIsUseful(container, type.elementType);
+        },
+        intersection(type) {
+            return type.types.some(t => renderingTypeDetailsIsUseful(container, t));
+        },
+        union(type) {
+            return !!type.elementSummaries || type.types.some(t => renderingTypeDetailsIsUseful(container, t));
+        },
+        reflection(type) {
+            return renderingChildIsUseful(type.declaration);
+        },
+        reference(type) {
+            return shouldExpandReference(container, type);
+        },
+    };
     return type.visit(isUsefulVisitor) ?? false;
 }
-export function typeDeclaration(context, type) {
-    if (renderingTypeDetailsIsUseful(type)) {
+export function typeDeclaration(context, reflectionOwningType, type) {
+    assert(reflectionOwningType instanceof Reflection, "typeDeclaration(reflectionOwningType, type) called incorrectly");
+    if (renderingTypeDetailsIsUseful(reflectionOwningType, type)) {
         return (JSX.createElement("div", { class: "tsd-type-declaration" },
             JSX.createElement("h4", null, i18n.theme_type_declaration()),
-            context.typeDetails(type, true)));
+            context.typeDetails(reflectionOwningType, type, true)));
     }
     return null;
 }
+const expandTypeCache = new WeakMap();
+function getExpandTypeInfo(refl) {
+    const cache = expandTypeCache.get(refl);
+    if (cache)
+        return cache;
+    const expandType = new Set();
+    const preventExpand = new Set();
+    if (!refl.isProject()) {
+        const info = getExpandTypeInfo(refl.parent);
+        for (const item of info.expandType) {
+            expandType.add(item);
+        }
+        for (const item of info.preventExpand) {
+            preventExpand.add(item);
+        }
+    }
+    for (const tag of refl.comment?.blockTags || []) {
+        if (tag.tag === "@expandType") {
+            const name = Comment.combineDisplayParts(tag.content);
+            expandType.add(name);
+            preventExpand.delete(name);
+        }
+        else if (tag.tag === "@preventExpand") {
+            const name = Comment.combineDisplayParts(tag.content);
+            preventExpand.add(name);
+            expandType.delete(name);
+        }
+    }
+    expandTypeCache.set(refl, { expandType, preventExpand });
+    return { expandType, preventExpand };
+}
 const expanded = new Set();
-function shouldExpandReference(reference) {
+function shouldExpandReference(container, reference) {
     const target = reference.reflection;
-    if (reference.highlightedProperties) {
-        return !target || expanded.has(target) === false;
+    if (!target) {
+        // If it doesn't exist, expand only if there are specific properties
+        // which the user annotated. Assume they know what they're doing.
+        return reference.highlightedProperties !== undefined;
     }
-    if (!target?.kindOf(ReflectionKind.TypeAlias | ReflectionKind.Interface))
+    // Prevent expansion of non-types
+    if (!target.kindOf(ReflectionKind.TypeAlias | ReflectionKind.Interface))
         return false;
-    if (!target.comment?.hasModifier("@expand"))
+    // Prevent recursive expand
+    if (expanded.has(target))
         return false;
-    return expanded.has(target) === false;
+    const info = getExpandTypeInfo(container);
+    // Expand if the user explicitly requested it with @param or @expand
+    if (reference.highlightedProperties || target.comment?.hasModifier("@expand") || info.expandType.has(target.name)) {
+        return !info.preventExpand.has(target.name);
+    }
+    return false;
 }
-export function typeDetails(context, type, renderAnchors) {
-    return typeDetailsImpl(context, type, renderAnchors);
+export function typeDetails(context, reflectionOwningType, type, renderAnchors) {
+    return typeDetailsImpl(context, reflectionOwningType, type, renderAnchors);
 }
-export function typeDetailsImpl(context, type, renderAnchors, highlighted) {
+export function typeDetailsImpl(context, reflectionOwningType, type, renderAnchors, highlighted) {
     const result = type.visit({
         array(type) {
-            return context.typeDetails(type.elementType, renderAnchors);
+            return context.typeDetails(reflectionOwningType, type.elementType, renderAnchors);
         },
         intersection(type) {
-            return type.types.map((t) => context.typeDetails(t, renderAnchors));
+            return type.types.map((t) => context.typeDetails(reflectionOwningType, t, renderAnchors));
         },
         union(type) {
             const result = [];
@@ -59,7 +100,7 @@ export function typeDetailsImpl(context, type, renderAnchors, highlighted) {
                 result.push(JSX.createElement("li", null,
                     context.type(type.types[i]),
                     context.displayParts(type.elementSummaries?.[i]),
-                    context.typeDetailsIfUseful(type.types[i])));
+                    context.typeDetailsIfUseful(reflectionOwningType, type.types[i])));
             }
             return JSX.createElement("ul", null, result);
         },
@@ -71,7 +112,7 @@ export function typeDetailsImpl(context, type, renderAnchors, highlighted) {
             return declarationDetails(context, declaration, renderAnchors);
         },
         reference(reference) {
-            if (shouldExpandReference(reference)) {
+            if (shouldExpandReference(reflectionOwningType, reference)) {
                 const target = reference.reflection;
                 if (!target?.isDeclaration()) {
                     return highlightedPropertyDetails(context, reference.highlightedProperties);
@@ -79,7 +120,7 @@ export function typeDetailsImpl(context, type, renderAnchors, highlighted) {
                 // Ensure we don't go into an infinite loop here
                 expanded.add(target);
                 const details = target.type
-                    ? context.typeDetails(target.type, renderAnchors)
+                    ? context.typeDetails(reflectionOwningType, target.type, renderAnchors)
                     : declarationDetails(context, target, renderAnchors);
                 expanded.delete(target);
                 return details;
@@ -92,9 +133,10 @@ export function typeDetailsImpl(context, type, renderAnchors, highlighted) {
     }
     return result;
 }
-export function typeDetailsIfUseful(context, type) {
-    if (type && renderingTypeDetailsIsUseful(type)) {
-        return context.typeDetails(type, false);
+export function typeDetailsIfUseful(context, reflectionOwningType, type) {
+    assert(reflectionOwningType instanceof Reflection, "typeDetailsIfUseful(reflectionOwningType, type) called incorrectly");
+    if (type && renderingTypeDetailsIsUseful(reflectionOwningType, type)) {
+        return context.typeDetails(reflectionOwningType, type, false);
     }
 }
 function highlightedPropertyDetails(context, highlighted) {
@@ -134,14 +176,13 @@ function declarationDetails(context, declaration, renderAnchors) {
 function renderChild(context, child, renderAnchors, highlight) {
     if (child.signatures) {
         return (JSX.createElement("li", { class: "tsd-parameter" },
-            JSX.createElement("h5", null,
+            JSX.createElement("h5", { id: anchorTargetIfPresent(context, child) },
                 !!child.flags.isRest && JSX.createElement("span", { class: "tsd-signature-symbol" }, "..."),
                 JSX.createElement("span", { class: getKindClass(child) }, child.name),
-                anchorLinkIfPresent(context, child),
                 JSX.createElement("span", { class: "tsd-signature-symbol" },
                     !!child.flags.isOptional && "?",
                     ":"),
-                "function"),
+                " function"),
             context.memberSignatures(child)));
     }
     function highlightOrComment(refl) {
@@ -155,11 +196,10 @@ function renderChild(context, child, renderAnchors, highlight) {
     // standard type
     if (child.type) {
         return (JSX.createElement("li", { class: "tsd-parameter" },
-            JSX.createElement("h5", null,
+            JSX.createElement("h5", { id: anchorTargetIfPresent(context, child) },
                 context.reflectionFlags(child),
                 !!child.flags.isRest && JSX.createElement("span", { class: "tsd-signature-symbol" }, "..."),
                 JSX.createElement("span", { class: getKindClass(child) }, child.name),
-                anchorLinkIfPresent(context, child),
                 JSX.createElement("span", { class: "tsd-signature-symbol" },
                     !!child.flags.isOptional && "?",
                     ": "),
@@ -170,43 +210,49 @@ function renderChild(context, child, renderAnchors, highlight) {
     // getter/setter
     return (JSX.createElement(JSX.Fragment, null,
         child.getSignature && (JSX.createElement("li", { class: "tsd-parameter" },
-            JSX.createElement("h5", null,
+            JSX.createElement("h5", { id: anchorTargetIfPresent(context, child) },
                 context.reflectionFlags(child.getSignature),
                 JSX.createElement("span", { class: "tsd-signature-keyword" }, "get"),
+                " ",
                 JSX.createElement("span", { class: getKindClass(child) }, child.name),
-                anchorLinkIfPresent(context, child),
                 JSX.createElement("span", { class: "tsd-signature-symbol" }, "():"),
+                " ",
                 context.type(child.getSignature.type)),
             highlightOrComment(child.getSignature))),
         child.setSignature && (JSX.createElement("li", { class: "tsd-parameter" },
-            JSX.createElement("h5", null,
+            JSX.createElement("h5", { id: !child.getSignature ? anchorTargetIfPresent(context, child) : undefined },
                 context.reflectionFlags(child.setSignature),
                 JSX.createElement("span", { class: "tsd-signature-keyword" }, "set"),
+                " ",
                 JSX.createElement("span", { class: getKindClass(child) }, child.name),
-                !child.getSignature && anchorLinkIfPresent(context, child),
                 JSX.createElement("span", { class: "tsd-signature-symbol" }, "("),
                 child.setSignature.parameters?.map((item) => (JSX.createElement(JSX.Fragment, null,
                     item.name,
                     JSX.createElement("span", { class: "tsd-signature-symbol" }, ":"),
+                    " ",
                     context.type(item.type)))),
                 JSX.createElement("span", { class: "tsd-signature-symbol" }, "):"),
+                " ",
                 context.type(child.setSignature.type)),
             highlightOrComment(child.setSignature)))));
 }
 function renderIndexSignature(context, index) {
     return (JSX.createElement("li", { class: "tsd-parameter-index-signature" },
         JSX.createElement("h5", null,
-            index.flags.isReadonly && JSX.createElement("span", { class: "tsd-signature-keyword" }, "readonly"),
+            index.flags.isReadonly && (JSX.createElement(JSX.Fragment, null,
+                JSX.createElement("span", { class: "tsd-signature-keyword" }, "readonly"),
+                " ")),
             JSX.createElement("span", { class: "tsd-signature-symbol" }, "["),
             index.parameters.map((item) => (JSX.createElement(JSX.Fragment, null,
                 JSX.createElement("span", { class: getKindClass(item) }, item.name),
                 ": ",
                 context.type(item.type)))),
-            JSX.createElement("span", { class: "tsd-signature-symbol" }, "]: "),
+            JSX.createElement("span", { class: "tsd-signature-symbol" }, "]:"),
+            " ",
             context.type(index.type)),
         context.commentSummary(index),
         context.commentTags(index),
-        context.typeDeclaration(index.type)));
+        context.typeDeclaration(index, index.type)));
 }
 function renderingChildIsUseful(refl) {
     // Object types directly under a variable/type alias will always be considered useful.

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

@@ -1,12 +1,11 @@
 import { i18n, JSX } from "#utils";
-import { anchorLinkIfPresent } from "./anchor-icon.js";
+import { anchorTargetIfPresent } from "./anchor-icon.js";
 export function typeParameters(context, typeParameters) {
     return (JSX.createElement(JSX.Fragment, null,
         JSX.createElement("section", { class: "tsd-panel" },
             JSX.createElement("h4", null, i18n.kind_plural_type_parameter()),
             JSX.createElement("ul", { class: "tsd-type-parameter-list" }, typeParameters.map((item) => (JSX.createElement("li", null,
-                JSX.createElement("span", null,
-                    anchorLinkIfPresent(context, item),
+                JSX.createElement("span", { id: anchorTargetIfPresent(context, item) },
                     item.flags.isConst && (JSX.createElement(JSX.Fragment, null,
                         JSX.createElement("span", { class: "tsd-signature-keyword" }, "const"),
                         " ")),

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

@@ -1,11 +1,10 @@
 import { i18n, JSX } from "#utils";
 import { getHierarchyRoots } from "../../lib.js";
-import { anchorLink } from "../partials/anchor-icon.js";
 function fullHierarchy(context, root, seen) {
     if (seen.has(root)) {
         return (JSX.createElement("li", { "data-refl": root.id },
             JSX.createElement("a", { href: context.urlTo(root) },
-                context.icons[root.kind](),
+                context.reflectionIcon(root),
                 root.name)));
     }
     seen.add(root);
@@ -18,10 +17,9 @@ function fullHierarchy(context, root, seen) {
     // Note: We don't use root.anchor for the anchor, because those are built on a per page basis.
     // And classes/interfaces get their own page, so all the anchors will be empty anyways.
     // Full name should be safe here, since this list only includes classes/interfaces.
-    return (JSX.createElement("li", { "data-refl": root.id },
-        anchorLink(root.getFullName()),
+    return (JSX.createElement("li", { "data-refl": root.id, id: root.getFullName() },
         JSX.createElement("a", { href: context.urlTo(root) },
-            context.icons[root.kind](),
+            context.reflectionIcon(root),
             root.name),
         children.length && JSX.createElement("ul", null, children)));
 }

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

@@ -3,7 +3,8 @@ import { DeclarationReflection, ReflectionKind, } from "../../../../models/index
 import { i18n, JSX } from "#utils";
 export function reflectionTemplate(context, props) {
     if (props.model.kindOf(ReflectionKind.TypeAlias | ReflectionKind.Variable) &&
-        props.model instanceof DeclarationReflection) {
+        props.model instanceof DeclarationReflection &&
+        props.model.type) {
         return context.memberDeclaration(props.model);
     }
     if (props.model.kindOf(ReflectionKind.ExportContainer) &&
@@ -35,15 +36,18 @@ export function reflectionTemplate(context, props) {
 function renderIndexSignature(context, index) {
     return (JSX.createElement("li", { class: classNames({ "tsd-index-signature": true }, context.getReflectionClasses(index)) },
         JSX.createElement("div", { class: "tsd-signature" },
-            index.flags.isReadonly && JSX.createElement("span", { class: "tsd-signature-keyword" }, "readonly"),
+            index.flags.isReadonly && (JSX.createElement(JSX.Fragment, null,
+                JSX.createElement("span", { class: "tsd-signature-keyword" }, "readonly"),
+                " ")),
             JSX.createElement("span", { class: "tsd-signature-symbol" }, "["),
             index.parameters.map((item) => (JSX.createElement(JSX.Fragment, null,
                 JSX.createElement("span", { class: getKindClass(item) }, item.name),
                 ": ",
                 context.type(item.type)))),
             JSX.createElement("span", { class: "tsd-signature-symbol" }, "]:"),
+            " ",
             context.type(index.type)),
         context.commentSummary(index),
         context.commentTags(index),
-        context.typeDetailsIfUseful(index.type)));
+        context.typeDetailsIfUseful(index, index.type)));
 }

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

@@ -75,19 +75,23 @@ export function renderTypeParametersSignature(context, typeParameters) {
         return (JSX.createElement(JSX.Fragment, null,
             JSX.createElement("span", { class: "tsd-signature-symbol" }, "<"),
             join(JSX.createElement("span", { class: "tsd-signature-symbol" }, ", "), typeParameters, (item) => (JSX.createElement(JSX.Fragment, null,
-                item.flags.isConst && JSX.createElement("span", { class: "tsd-signature-keyword" }, "const"),
-                item.varianceModifier ? `${item.varianceModifier} ` : "",
+                (item.flags.isConst || item.varianceModifier) && (JSX.createElement("span", { class: "tsd-signature-keyword" },
+                    item.flags.isConst && "const ",
+                    item.varianceModifier && `${item.varianceModifier} `)),
                 JSX.createElement("a", { class: "tsd-signature-type tsd-kind-type-parameter", href: context.urlTo(item) }, item.name)))),
             JSX.createElement("span", { class: "tsd-signature-symbol" }, ">")));
     }
     return (JSX.createElement(JSX.Fragment, null,
         JSX.createElement("span", { class: "tsd-signature-symbol" }, "<"),
         join(JSX.createElement("span", { class: "tsd-signature-symbol" }, ", "), typeParameters, (item) => (JSX.createElement(JSX.Fragment, null,
-            item.flags.isConst && "const ",
-            item.varianceModifier ? `${item.varianceModifier} ` : "",
+            (item.flags.isConst || item.varianceModifier) && (JSX.createElement("span", { class: "tsd-signature-keyword" },
+                item.flags.isConst && "const ",
+                item.varianceModifier && `${item.varianceModifier} `)),
             JSX.createElement("span", { class: "tsd-signature-type tsd-kind-type-parameter" }, item.name),
             !!item.type && (JSX.createElement(JSX.Fragment, null,
+                " ",
                 JSX.createElement("span", { class: "tsd-signature-keyword" }, "extends"),
+                " ",
                 context.type(item.type)))))),
         JSX.createElement("span", { class: "tsd-signature-symbol" }, ">")));
 }

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

@@ -1,4 +1,5 @@
 import * as shiki from "@gerrit0/mini-shiki";
+export declare function loadTestHighlighter(): void;
 export declare function loadHighlighter(lightTheme: shiki.BundledTheme, darkTheme: shiki.BundledTheme, langs: shiki.BundledLanguage[], ignoredLangs: string[] | undefined): Promise<void>;
 export declare function isSupportedLanguage(lang: string): boolean;
 export declare function getSupportedLanguages(): string[];

package/dist/lib/utils/highlighter.js

@@ -14,7 +14,7 @@ const supportedLanguages = unique([
     ...shiki.bundledLanguagesInfo.map((lang) => lang.id),
 ]).sort();
 const supportedThemes = Object.keys(shiki.bundledThemes);
-class DoubleHighlighter {
+class ShikiHighlighter {
     highlighter;
     light;
     dark;
@@ -89,9 +89,23 @@ class DoubleHighlighter {
         return scheme;
     }
 }
+class TestHighlighter {
+    supports() {
+        return true;
+    }
+    highlight(code) {
+        return code;
+    }
+    getStyles() {
+        return "";
+    }
+}
 let shikiEngine;
 let highlighter;
 let ignoredLanguages;
+export function loadTestHighlighter() {
+    highlighter = new TestHighlighter();
+}
 export async function loadHighlighter(lightTheme, darkTheme, langs, ignoredLangs) {
     if (highlighter)
         return;
@@ -105,7 +119,7 @@ export async function loadHighlighter(lightTheme, darkTheme, langs, ignoredLangs
         themes: [shiki.bundledThemes[lightTheme], shiki.bundledThemes[darkTheme]],
         langs: langs.map((lang) => shiki.bundledLanguages[lang]),
     });
-    highlighter = new DoubleHighlighter(hl, lightTheme, darkTheme);
+    highlighter = new ShikiHighlighter(hl, lightTheme, darkTheme);
 }
 export function isSupportedLanguage(lang) {
     return ignoredLanguages?.includes(lang) || getSupportedLanguages().includes(lang);

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

@@ -9,6 +9,7 @@ export { loadPlugins } from "./plugins.js";
 export { getSortFunction } from "./sort.js";
 export type { SortStrategy } from "./sort.js";
 export * from "./entry-point.js";
+export * from "./highlighter.js";
 export * from "./html.js";
 export * from "./tsconfig.js";
 export * from "./tsutils.js";

package/dist/lib/utils/index.js

@@ -7,6 +7,7 @@ export * from "./paths.js";
 export { loadPlugins } from "./plugins.js";
 export { getSortFunction } from "./sort.js";
 export * from "./entry-point.js";
+export * from "./highlighter.js";
 export * from "./html.js";
 export * from "./tsconfig.js";
 export * from "./tsutils.js";

package/dist/lib/utils/options/defaults.js

@@ -42,6 +42,8 @@ export const notRenderedTags = [
     "@hideCategories",
     "@hideGroups",
     "@expand",
+    "@preventExpand",
+    "@expandType",
     "@summary",
     "@group",
     "@groupDescription",

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

@@ -1,5 +1,5 @@
 export declare const tsdocBlockTags: readonly ["@defaultValue", "@deprecated", "@example", "@param", "@privateRemarks", "@remarks", "@returns", "@see", "@throws", "@typeParam"];
-export declare const blockTags: readonly ["@defaultValue", "@deprecated", "@example", "@param", "@privateRemarks", "@remarks", "@returns", "@see", "@throws", "@typeParam", "@author", "@callback", "@category", "@categoryDescription", "@default", "@document", "@extends", "@augments", "@yields", "@group", "@groupDescription", "@import", "@inheritDoc", "@jsx", "@license", "@module", "@mergeModuleWith", "@prop", "@property", "@return", "@satisfies", "@since", "@template", "@type", "@typedef", "@summary"];
+export declare const blockTags: readonly ["@defaultValue", "@deprecated", "@example", "@param", "@privateRemarks", "@remarks", "@returns", "@see", "@throws", "@typeParam", "@author", "@callback", "@category", "@categoryDescription", "@default", "@document", "@extends", "@augments", "@yields", "@group", "@groupDescription", "@import", "@inheritDoc", "@jsx", "@license", "@module", "@mergeModuleWith", "@prop", "@property", "@return", "@satisfies", "@since", "@template", "@type", "@typedef", "@summary", "@preventInline", "@inlineType", "@preventExpand", "@expandType"];
 export declare const tsdocInlineTags: readonly ["@link", "@inheritDoc", "@label"];
 export declare const inlineTags: readonly ["@link", "@inheritDoc", "@label", "@linkcode", "@linkplain", "@include", "@includeCode"];
 export declare const tsdocModifierTags: readonly ["@alpha", "@beta", "@eventProperty", "@experimental", "@internal", "@override", "@packageDocumentation", "@public", "@readonly", "@sealed", "@virtual"];

package/dist/lib/utils/options/tsdoc-defaults.js

@@ -39,6 +39,10 @@ export const blockTags = [
     "@type",
     "@typedef",
     "@summary",
+    "@preventInline",
+    "@inlineType",
+    "@preventExpand",
+    "@expandType",
 ];
 export const tsdocInlineTags = ["@link", "@inheritDoc", "@label"];
 export const inlineTags = [

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

@@ -122,6 +122,7 @@ export interface IntrinsicElements {
     line: JsxLineElementProps;
     use: JsxUseElementProps;
     text: JsxTextElementProps;
+    image: JsxImageElementProps;
 }
 export declare function JsxFragment(): never;
 export type JsxComponent<P> = (props: P) => JsxElement | null | undefined;
@@ -930,3 +931,18 @@ export interface JsxTextElementProps extends JsxSvgCoreProps, JsxSvgStyleProps,
     x?: string | number;
     y?: string | number;
 }
+/**
+ * Properties permitted on the `<image>` element.
+ *
+ * Reference: https://developer.mozilla.org/en-US/docs/Web/SVG/Element/image
+ */
+export interface JsxImageElementProps extends JsxSvgCoreProps {
+    x?: string | number;
+    y?: string | number;
+    width?: string | number;
+    height?: string | number;
+    href: string;
+    preserveAspectRatio?: string;
+    crossorigin?: "anonymous" | "use-credentials";
+    decoding?: "async" | "sync" | "auto";
+}

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

@@ -78,7 +78,10 @@ export var NormalizedPathUtils;
         const parts = path.split("/");
         let canRemoveDotDot = false;
         for (let i = 0; i < parts.length; /* inside loop */) {
-            if (parts[i] == "..") {
+            if (parts[i] == "." && i + 1 != parts.length) {
+                parts.splice(i, 1);
+            }
+            else if (parts[i] == "..") {
                 if (canRemoveDotDot) {
                     if (i - 1 === 0 && /\w:/i.test(parts[0])) {
                         parts.splice(i, 1);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typedoc",
   "description": "Create api documentation for TypeScript projects.",
-  "version": "0.28.0-beta.1",
+  "version": "0.28.0-beta.2",
   "homepage": "https://typedoc.org",
   "type": "module",
   "exports": {