typedoc 0.26.11 → 0.27.0-beta.0

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

@@ -1,67 +1,66 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefaultTheme = exports.Slugger = void 0;
-const theme_1 = require("../../theme");
-const models_1 = require("../../../models");
-const UrlMapping_1 = require("../../models/UrlMapping");
-const DefaultThemeRenderContext_1 = require("./DefaultThemeRenderContext");
-const utils_1 = require("../../../utils");
-const lib_1 = require("../lib");
-const icon_1 = require("./partials/icon");
-/**
- * Responsible for getting a unique anchor for elements within a page.
- */
-class Slugger {
-    constructor() {
-        this.seen = new Map();
-    }
-    serialize(value) {
-        // Extracted from marked@4.3.0
-        return (value
-            .toLowerCase()
-            .trim()
-            // remove html tags
-            .replace(/<[!/a-z].*?>/gi, "")
-            // remove unwanted chars
-            .replace(/[\u2000-\u206F\u2E00-\u2E7F\\'!"#$%&()*+,./:;<=>?@[\]^`{|}~]/g, "")
-            .replace(/\s/g, "-"));
-    }
-    slug(value) {
-        const originalSlug = this.serialize(value);
-        let slug = originalSlug;
-        let count = 0;
-        if (this.seen.has(slug)) {
-            count = this.seen.get(originalSlug);
-            do {
-                count++;
-                slug = `${originalSlug}-${count}`;
-            } while (this.seen.has(slug));
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
         }
-        this.seen.set(originalSlug, count);
-        this.seen.set(slug, 0);
-        return slug;
-    }
-}
-exports.Slugger = Slugger;
-/**
- * Default theme implementation of TypeDoc. If a theme does not provide a custom
- * {@link Theme} implementation, this theme class will be used.
- */
-class DefaultTheme extends theme_1.Theme {
-    getRenderContext(pageEvent) {
-        return new DefaultThemeRenderContext_1.DefaultThemeRenderContext(this, pageEvent, this.application.options);
     }
-    getReflectionClasses(reflection) {
-        const filters = this.application.options.getValue("visibilityFilters");
-        return getReflectionClasses(reflection, filters);
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
     }
-    /**
-     * Create a new DefaultTheme instance.
-     *
-     * @param renderer  The renderer this theme is attached to.
-     */
-    constructor(renderer) {
-        super(renderer);
+    return useValue ? value : void 0;
+};
+import { Theme } from "../../theme.js";
+import { ReflectionKind, ProjectReflection, DeclarationReflection, SignatureReflection, ReflectionCategory, ReflectionGroup, TypeParameterReflection, ReferenceReflection, } from "../../../models/index.js";
+import { UrlMapping } from "../../models/UrlMapping.js";
+import { DefaultThemeRenderContext } from "./DefaultThemeRenderContext.js";
+import { filterMap, JSX, Option } from "../../../utils/index.js";
+import { classNames, getDisplayName, getHierarchyRoots, toStyleClass } from "../lib.js";
+import { icons } from "./partials/icon.js";
+import { Slugger } from "./Slugger.js";
+import { createNormalizedUrl } from "../../../utils/html.js";
+let DefaultTheme = (() => {
+    let _classSuper = Theme;
+    let _sluggerConfiguration_decorators;
+    let _sluggerConfiguration_initializers = [];
+    let _sluggerConfiguration_extraInitializers = [];
+    return class DefaultTheme extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _sluggerConfiguration_decorators = [Option("sluggerConfiguration")];
+            __esDecorate(this, null, _sluggerConfiguration_decorators, { kind: "accessor", name: "sluggerConfiguration", static: false, private: false, access: { has: obj => "sluggerConfiguration" in obj, get: obj => obj.sluggerConfiguration, set: (obj, value) => { obj.sluggerConfiguration = value; } }, metadata: _metadata }, _sluggerConfiguration_initializers, _sluggerConfiguration_extraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        // Note: This will always contain lowercased names to avoid issues with
+        // case-insensitive file systems.
+        usedFileNames = new Set();
+        #sluggerConfiguration_accessor_storage = __runInitializers(this, _sluggerConfiguration_initializers, void 0);
+        get sluggerConfiguration() { return this.#sluggerConfiguration_accessor_storage; }
+        set sluggerConfiguration(value) { this.#sluggerConfiguration_accessor_storage = value; }
+        /** @internal */
+        markedPlugin = __runInitializers(this, _sluggerConfiguration_extraInitializers);
         /**
          * The icons which will actually be rendered. The source of truth lives on the theme, and
          * the {@link DefaultThemeRenderContext.icons} member will produce references to these.
@@ -75,324 +74,349 @@ class DefaultTheme extends theme_1.Theme {
          * the icons used within the page, however TypeDoc currently assumes that all icons are svg
          * elements, so custom themes must also use svg elements.
          */
-        this.icons = { ...icon_1.icons };
-        this.documentTemplate = (pageEvent) => {
+        icons = { ...icons };
+        getRenderContext(pageEvent) {
+            return new DefaultThemeRenderContext(this, pageEvent, this.application.options);
+        }
+        documentTemplate = (pageEvent) => {
             return this.getRenderContext(pageEvent).documentTemplate(pageEvent);
         };
-        this.reflectionTemplate = (pageEvent) => {
+        reflectionTemplate = (pageEvent) => {
             return this.getRenderContext(pageEvent).reflectionTemplate(pageEvent);
         };
-        this.indexTemplate = (pageEvent) => {
+        indexTemplate = (pageEvent) => {
             return this.getRenderContext(pageEvent).indexTemplate(pageEvent);
         };
-        this.hierarchyTemplate = (pageEvent) => {
+        hierarchyTemplate = (pageEvent) => {
             return this.getRenderContext(pageEvent).hierarchyTemplate(pageEvent);
         };
-        this.defaultLayoutTemplate = (pageEvent, template) => {
+        defaultLayoutTemplate = (pageEvent, template) => {
             return this.getRenderContext(pageEvent).defaultLayout(template, pageEvent);
         };
+        getReflectionClasses(reflection) {
+            const filters = this.application.options.getValue("visibilityFilters");
+            return getReflectionClasses(reflection, filters);
+        }
         /**
          * Mappings of reflections kinds to templates used by this theme.
          */
-        this.mappings = [
+        mappings = [
             {
-                kind: [models_1.ReflectionKind.Class],
+                kind: [ReflectionKind.Class],
                 directory: "classes",
                 template: this.reflectionTemplate,
             },
             {
-                kind: [models_1.ReflectionKind.Interface],
+                kind: [ReflectionKind.Interface],
                 directory: "interfaces",
                 template: this.reflectionTemplate,
             },
             {
-                kind: [models_1.ReflectionKind.Enum],
+                kind: [ReflectionKind.Enum],
                 directory: "enums",
                 template: this.reflectionTemplate,
             },
             {
-                kind: [models_1.ReflectionKind.Namespace, models_1.ReflectionKind.Module],
+                kind: [ReflectionKind.Namespace, ReflectionKind.Module],
                 directory: "modules",
                 template: this.reflectionTemplate,
             },
             {
-                kind: [models_1.ReflectionKind.TypeAlias],
+                kind: [ReflectionKind.TypeAlias],
                 directory: "types",
                 template: this.reflectionTemplate,
             },
             {
-                kind: [models_1.ReflectionKind.Function],
+                kind: [ReflectionKind.Function],
                 directory: "functions",
                 template: this.reflectionTemplate,
             },
             {
-                kind: [models_1.ReflectionKind.Variable],
+                kind: [ReflectionKind.Variable],
                 directory: "variables",
                 template: this.reflectionTemplate,
             },
             {
-                kind: [models_1.ReflectionKind.Document],
+                kind: [ReflectionKind.Document],
                 directory: "documents",
                 template: this.documentTemplate,
             },
         ];
-        this.sluggers = new Map();
-        this.markedPlugin = renderer.getComponent("marked");
-    }
-    /**
-     * Map the models of the given project to the desired output files.
-     *
-     * @param project  The project whose urls should be generated.
-     * @returns        A list of {@link UrlMapping} instances defining which models
-     *                 should be rendered to which files.
-     */
-    getUrls(project) {
-        const urls = [];
-        this.sluggers.set(project, new Slugger());
-        if (!project.readme?.length) {
-            project.url = "index.html";
-            urls.push(new UrlMapping_1.UrlMapping("index.html", project, this.reflectionTemplate));
-        }
-        else {
-            project.url = "modules.html";
-            urls.push(new UrlMapping_1.UrlMapping("modules.html", project, this.reflectionTemplate));
-            urls.push(new UrlMapping_1.UrlMapping("index.html", project, this.indexTemplate));
-        }
-        if ((0, lib_1.getHierarchyRoots)(project).length) {
-            urls.push(new UrlMapping_1.UrlMapping("hierarchy.html", project, this.hierarchyTemplate));
+        static URL_PREFIX = /^(http|ftp)s?:\/\//;
+        /**
+         * Create a new DefaultTheme instance.
+         *
+         * @param renderer  The renderer this theme is attached to.
+         */
+        constructor(renderer) {
+            super(renderer);
+            this.markedPlugin = renderer.markedPlugin;
         }
-        project.childrenIncludingDocuments?.forEach((child) => this.buildUrls(child, urls));
-        return urls;
-    }
-    /**
-     * Return a url for the given reflection.
-     *
-     * @param reflection  The reflection the url should be generated for.
-     * @param relative    The parent reflection the url generation should stop on.
-     * @param separator   The separator used to generate the url.
-     * @returns           The generated url.
-     */
-    static getUrl(reflection, relative, separator = ".") {
-        let url = reflection.getAlias();
-        if (reflection.parent && reflection.parent !== relative && !(reflection.parent instanceof models_1.ProjectReflection)) {
-            url = DefaultTheme.getUrl(reflection.parent, relative, separator) + separator + url;
+        /**
+         * Map the models of the given project to the desired output files.
+         *
+         * @param project  The project whose urls should be generated.
+         * @returns        A list of {@link UrlMapping} instances defining which models
+         *                 should be rendered to which files.
+         */
+        getUrls(project) {
+            this.usedFileNames = new Set();
+            const urls = [];
+            this.setSlugger(project, new Slugger(this.sluggerConfiguration));
+            if (!project.readme?.length) {
+                project.url = "index.html";
+                urls.push(new UrlMapping("index.html", project, this.reflectionTemplate));
+            }
+            else {
+                project.url = "modules.html";
+                urls.push(new UrlMapping("modules.html", project, this.reflectionTemplate));
+                urls.push(new UrlMapping("index.html", project, this.indexTemplate));
+            }
+            if (getHierarchyRoots(project).length) {
+                urls.push(new UrlMapping("hierarchy.html", project, this.hierarchyTemplate));
+            }
+            project.childrenIncludingDocuments?.forEach((child) => this.buildUrls(child, urls));
+            return urls;
         }
-        return url;
-    }
-    /**
-     * Return the template mapping for the given reflection.
-     *
-     * @param reflection  The reflection whose mapping should be resolved.
-     * @returns           The found mapping or undefined if no mapping could be found.
-     */
-    getMapping(reflection) {
-        return this.mappings.find((mapping) => reflection.kindOf(mapping.kind));
-    }
-    /**
-     * Build the url for the the given reflection and all of its children.
-     *
-     * @param reflection  The reflection the url should be created for.
-     * @param urls        The array the url should be appended to.
-     * @returns           The altered urls array.
-     */
-    buildUrls(reflection, urls) {
-        const mapping = this.getMapping(reflection);
-        if (mapping) {
-            if (!reflection.url || !DefaultTheme.URL_PREFIX.test(reflection.url)) {
-                const url = [mapping.directory, DefaultTheme.getUrl(reflection) + ".html"].join("/");
-                urls.push(new UrlMapping_1.UrlMapping(url, reflection, mapping.template));
-                this.sluggers.set(reflection, new Slugger());
-                reflection.url = url;
-                reflection.hasOwnDocument = true;
+        /**
+         * @param reflection  The reflection the url should be generated for.
+         */
+        getFileName(reflection) {
+            const parts = [createNormalizedUrl(reflection.name)];
+            while (reflection.parent && !reflection.parent.isProject()) {
+                reflection = reflection.parent;
+                parts.unshift(createNormalizedUrl(reflection.name));
             }
-            reflection.traverse((child) => {
-                if (child.isDeclaration() || child.isDocument()) {
-                    this.buildUrls(child, urls);
+            const baseName = parts.join(".");
+            const lowerBaseName = baseName.toLocaleLowerCase();
+            if (this.usedFileNames.has(lowerBaseName)) {
+                let index = 1;
+                while (this.usedFileNames.has(`${lowerBaseName}-${index}`)) {
+                    ++index;
                 }
-                else {
-                    DefaultTheme.applyAnchorUrl(child, reflection);
+                this.usedFileNames.add(`${lowerBaseName}-${index}`);
+                return `${baseName}-${index}.html`;
+            }
+            this.usedFileNames.add(lowerBaseName);
+            return `${baseName}.html`;
+        }
+        /**
+         * Return the template mapping for the given reflection.
+         *
+         * @param reflection  The reflection whose mapping should be resolved.
+         * @returns           The found mapping or undefined if no mapping could be found.
+         */
+        getMapping(reflection) {
+            return this.mappings.find((mapping) => reflection.kindOf(mapping.kind));
+        }
+        /**
+         * Build the url for the the given reflection and all of its children.
+         *
+         * @param reflection  The reflection the url should be created for.
+         * @param urls        The array the url should be appended to.
+         * @returns           The altered urls array.
+         */
+        buildUrls(reflection, urls) {
+            const mapping = this.getMapping(reflection);
+            if (mapping) {
+                if (!reflection.url || !DefaultTheme.URL_PREFIX.test(reflection.url)) {
+                    const url = [mapping.directory, this.getFileName(reflection)].join("/");
+                    urls.push(new UrlMapping(url, reflection, mapping.template));
+                    this.setSlugger(reflection, new Slugger(this.sluggerConfiguration));
+                    reflection.url = url;
+                    reflection.hasOwnDocument = true;
                 }
-                return true;
-            });
+                reflection.traverse((child) => {
+                    if (child.isDeclaration() || child.isDocument()) {
+                        this.buildUrls(child, urls);
+                    }
+                    else {
+                        this.applyAnchorUrl(child, reflection);
+                    }
+                    return true;
+                });
+            }
+            else if (reflection.parent) {
+                this.applyAnchorUrl(reflection, reflection.parent);
+            }
+            return urls;
         }
-        else if (reflection.parent) {
-            DefaultTheme.applyAnchorUrl(reflection, reflection.parent);
+        render(page, template) {
+            const templateOutput = this.defaultLayoutTemplate(page, template);
+            return "<!DOCTYPE html>" + JSX.renderElement(templateOutput) + "\n";
         }
-        return urls;
-    }
-    render(page, template) {
-        const templateOutput = this.defaultLayoutTemplate(page, template);
-        return "<!DOCTYPE html>" + utils_1.JSX.renderElement(templateOutput) + "\n";
-    }
-    /**
-     * If implementing a custom theme, it is recommended to override {@link buildNavigation} instead.
-     */
-    getNavigation(project) {
-        // This is ok because currently TypeDoc wipes out the theme after each render.
-        // Might need to change in the future, but it's fine for now.
-        if (this._navigationCache) {
-            return this._navigationCache;
+        _navigationCache;
+        /**
+         * If implementing a custom theme, it is recommended to override {@link buildNavigation} instead.
+         */
+        getNavigation(project) {
+            // This is ok because currently TypeDoc wipes out the theme after each render.
+            // Might need to change in the future, but it's fine for now.
+            if (this._navigationCache) {
+                return this._navigationCache;
+            }
+            return (this._navigationCache = this.buildNavigation(project));
         }
-        return (this._navigationCache = this.buildNavigation(project));
-    }
-    buildNavigation(project) {
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
-        const theme = this;
-        const opts = this.application.options.getValue("navigation");
-        const leaves = this.application.options.getValue("navigationLeaves");
-        return getNavigationElements(project) || [];
-        function toNavigation(element) {
-            const children = getNavigationElements(element);
-            if (element instanceof models_1.ReflectionCategory || element instanceof models_1.ReflectionGroup) {
-                if (!children?.length) {
+        buildNavigation(project) {
+            // eslint-disable-next-line @typescript-eslint/no-this-alias
+            const theme = this;
+            const opts = this.application.options.getValue("navigation");
+            const leaves = this.application.options.getValue("navigationLeaves");
+            return getNavigationElements(project) || [];
+            function toNavigation(element) {
+                if (opts.excludeReferences && element instanceof ReferenceReflection) {
                     return;
                 }
+                const children = getNavigationElements(element);
+                if (element instanceof ReflectionCategory || element instanceof ReflectionGroup) {
+                    if (!children?.length) {
+                        return;
+                    }
+                    return {
+                        text: element.title,
+                        children,
+                    };
+                }
                 return {
-                    text: element.title,
-                    children,
+                    text: getDisplayName(element),
+                    path: element.url,
+                    kind: element.kind & ReflectionKind.Project ? undefined : element.kind,
+                    class: classNames({ deprecated: element.isDeprecated() }, theme.getReflectionClasses(element)),
+                    children: children?.length ? children : undefined,
                 };
             }
-            if (opts.excludeReferences && element instanceof models_1.ReferenceReflection) {
-                return;
-            }
-            return {
-                text: (0, lib_1.getDisplayName)(element),
-                path: element.url,
-                kind: element.kind,
-                class: (0, lib_1.classNames)({ deprecated: element.isDeprecated() }, theme.getReflectionClasses(element)),
-                children: children?.length ? children : undefined,
-            };
-        }
-        function getNavigationElements(parent) {
-            if (parent instanceof models_1.ReflectionCategory) {
-                return (0, utils_1.filterMap)(parent.children, toNavigation);
-            }
-            if (parent instanceof models_1.ReflectionGroup) {
-                if (shouldShowCategories(parent.owningReflection, opts) && parent.categories) {
-                    return (0, utils_1.filterMap)(parent.categories, toNavigation);
+            function getNavigationElements(parent) {
+                if (parent instanceof ReflectionCategory) {
+                    return filterMap(parent.children, toNavigation);
                 }
-                return (0, utils_1.filterMap)(parent.children, toNavigation);
-            }
-            if (leaves.includes(parent.getFullName())) {
-                return;
-            }
-            if (!parent.kindOf(models_1.ReflectionKind.MayContainDocuments)) {
-                return;
-            }
-            if (parent.isDocument()) {
-                return (0, utils_1.filterMap)(parent.children, toNavigation);
-            }
-            if (!parent.kindOf(models_1.ReflectionKind.SomeModule | models_1.ReflectionKind.Project)) {
-                // Tricky: Non-module children don't show up in the navigation pane,
-                //   but any documents added by them should.
-                return (0, utils_1.filterMap)(parent.documents, toNavigation);
-            }
-            if (parent.categories && shouldShowCategories(parent, opts)) {
-                return filterMapWithNoneCollection(parent.categories);
-            }
-            if (parent.groups && shouldShowGroups(parent, opts)) {
-                return filterMapWithNoneCollection(parent.groups);
-            }
-            if (opts.includeFolders && parent.childrenIncludingDocuments?.some((child) => child.name.includes("/"))) {
-                return deriveModuleFolders(parent.childrenIncludingDocuments);
+                if (parent instanceof ReflectionGroup) {
+                    if (shouldShowCategories(parent.owningReflection, opts) && parent.categories) {
+                        return filterMap(parent.categories, toNavigation);
+                    }
+                    return filterMap(parent.children, toNavigation);
+                }
+                if (leaves.includes(parent.getFullName())) {
+                    return;
+                }
+                if (!parent.kindOf(ReflectionKind.MayContainDocuments)) {
+                    return;
+                }
+                if (parent.isDocument()) {
+                    return filterMap(parent.children, toNavigation);
+                }
+                if (!parent.kindOf(ReflectionKind.SomeModule | ReflectionKind.Project)) {
+                    // Tricky: Non-module children don't show up in the navigation pane,
+                    //   but any documents added by them should.
+                    return filterMap(parent.documents, toNavigation);
+                }
+                if (parent.categories && shouldShowCategories(parent, opts)) {
+                    return filterMapWithNoneCollection(parent.categories);
+                }
+                if (parent.groups && shouldShowGroups(parent, opts)) {
+                    return filterMapWithNoneCollection(parent.groups);
+                }
+                if (opts.includeFolders && parent.childrenIncludingDocuments?.some((child) => child.name.includes("/"))) {
+                    return deriveModuleFolders(parent.childrenIncludingDocuments);
+                }
+                return filterMap(parent.childrenIncludingDocuments, toNavigation);
             }
-            return (0, utils_1.filterMap)(parent.childrenIncludingDocuments, toNavigation);
-        }
-        function filterMapWithNoneCollection(reflection) {
-            const none = reflection.find((x) => x.title.toLocaleLowerCase() === "none");
-            const others = reflection.filter((x) => x.title.toLocaleLowerCase() !== "none");
-            const mappedOthers = (0, utils_1.filterMap)(others, toNavigation);
-            if (none) {
-                const noneMappedChildren = (0, utils_1.filterMap)(none.children, toNavigation);
-                return [...noneMappedChildren, ...mappedOthers];
+            function filterMapWithNoneCollection(reflection) {
+                const none = reflection.find((x) => x.title.toLocaleLowerCase() === "none");
+                const others = reflection.filter((x) => x.title.toLocaleLowerCase() !== "none");
+                const mappedOthers = filterMap(others, toNavigation);
+                if (none) {
+                    const noneMappedChildren = filterMap(none.children, toNavigation);
+                    return [...noneMappedChildren, ...mappedOthers];
+                }
+                return mappedOthers;
             }
-            return mappedOthers;
-        }
-        function deriveModuleFolders(children) {
-            const result = [];
-            const resolveOrCreateParents = (path, root = result) => {
-                if (path.length > 1) {
-                    const inner = root.find((el) => el.text === path[0]);
-                    if (inner) {
-                        inner.children ||= [];
-                        return resolveOrCreateParents(path.slice(1), inner.children);
+            function deriveModuleFolders(children) {
+                const result = [];
+                const resolveOrCreateParents = (path, root = result) => {
+                    if (path.length > 1) {
+                        const inner = root.find((el) => el.text === path[0]);
+                        if (inner) {
+                            inner.children ||= [];
+                            return resolveOrCreateParents(path.slice(1), inner.children);
+                        }
+                        else {
+                            root.push({
+                                text: path[0],
+                                children: [],
+                            });
+                            return resolveOrCreateParents(path.slice(1), root[root.length - 1].children);
+                        }
                     }
-                    else {
-                        root.push({
-                            text: path[0],
-                            children: [],
-                        });
-                        return resolveOrCreateParents(path.slice(1), root[root.length - 1].children);
+                    return root;
+                };
+                // Note: This might end up putting a module within another module if we document
+                // both foo/index.ts and foo/bar.ts.
+                for (const child of children.filter((c) => c.hasOwnDocument)) {
+                    const nav = toNavigation(child);
+                    if (nav) {
+                        const parts = child.name.split("/");
+                        const collection = resolveOrCreateParents(parts);
+                        nav.text = parts[parts.length - 1];
+                        collection.push(nav);
                     }
                 }
-                return root;
-            };
-            // Note: This might end up putting a module within another module if we document
-            // both foo/index.ts and foo/bar.ts.
-            for (const child of children.filter((c) => c.hasOwnDocument)) {
-                const nav = toNavigation(child);
-                if (nav) {
-                    const parts = child.name.split("/");
-                    const collection = resolveOrCreateParents(parts);
-                    nav.text = parts[parts.length - 1];
-                    collection.push(nav);
+                // Now merge single-possible-paths together so we don't have folders in our navigation
+                // which contain only another single folder.
+                if (opts.compactFolders) {
+                    const queue = [...result];
+                    while (queue.length) {
+                        const review = queue.shift();
+                        queue.push(...(review.children || []));
+                        if (review.kind || review.path)
+                            continue;
+                        if (review.children?.length === 1) {
+                            const copyFrom = review.children[0];
+                            const fullName = `${review.text}/${copyFrom.text}`;
+                            delete review.children;
+                            Object.assign(review, copyFrom);
+                            review.text = fullName;
+                            queue.push(review);
+                        }
+                    }
                 }
+                return result;
+            }
+        }
+        /**
+         * Generate an anchor url for the given reflection and all of its children.
+         *
+         * @param reflection  The reflection an anchor url should be created for.
+         * @param container   The nearest reflection having an own document.
+         */
+        applyAnchorUrl(reflection, container) {
+            if (!(reflection instanceof DeclarationReflection) &&
+                !(reflection instanceof SignatureReflection) &&
+                !(reflection instanceof TypeParameterReflection)) {
+                return;
             }
-            // Now merge single-possible-paths together so we don't have folders in our navigation
-            // which contain only another single folder.
-            if (opts.compactFolders) {
-                const queue = [...result];
-                while (queue.length) {
-                    const review = queue.shift();
-                    queue.push(...(review.children || []));
-                    if (review.kind || review.path)
-                        continue;
-                    if (review.children?.length === 1) {
-                        const copyFrom = review.children[0];
-                        const fullName = `${review.text}/${copyFrom.text}`;
-                        delete review.children;
-                        Object.assign(review, copyFrom);
-                        review.text = fullName;
-                        queue.push(review);
+            if (!reflection.url || !DefaultTheme.URL_PREFIX.test(reflection.url)) {
+                let refl = reflection;
+                const parts = [refl.name];
+                while (refl.parent && refl.parent !== container && !(reflection.parent instanceof ProjectReflection)) {
+                    refl = refl.parent;
+                    // Avoid duplicate names for signatures
+                    if (parts[0] !== refl.name) {
+                        parts.unshift(refl.name);
                     }
                 }
+                const anchor = this.getSlugger(reflection).slug(parts.join("."));
+                reflection.url = container.url + "#" + anchor;
+                reflection.anchor = anchor;
+                reflection.hasOwnDocument = false;
             }
-            return result;
-        }
-    }
-    getSlugger(reflection) {
-        if (this.sluggers.has(reflection)) {
-            return this.sluggers.get(reflection);
-        }
-        // A slugger should always be defined at least for the project
-        return this.getSlugger(reflection.parent);
-    }
-    /**
-     * Generate an anchor url for the given reflection and all of its children.
-     *
-     * @param reflection  The reflection an anchor url should be created for.
-     * @param container   The nearest reflection having an own document.
-     */
-    static applyAnchorUrl(reflection, container) {
-        if (!(reflection instanceof models_1.DeclarationReflection) &&
-            !(reflection instanceof models_1.SignatureReflection) &&
-            !(reflection instanceof models_1.TypeParameterReflection)) {
-            return;
-        }
-        if (!reflection.url || !DefaultTheme.URL_PREFIX.test(reflection.url)) {
-            const anchor = DefaultTheme.getUrl(reflection, container, ".");
-            reflection.url = container.url + "#" + anchor;
-            reflection.anchor = anchor;
-            reflection.hasOwnDocument = false;
+            reflection.traverse((child) => {
+                this.applyAnchorUrl(child, container);
+                return true;
+            });
         }
-        reflection.traverse((child) => {
-            DefaultTheme.applyAnchorUrl(child, container);
-            return true;
-        });
-    }
-}
-exports.DefaultTheme = DefaultTheme;
-DefaultTheme.URL_PREFIX = /^(http|ftp)s?:\/\//;
+    };
+})();
+export { DefaultTheme };
 function getReflectionClasses(reflection, filters) {
     const classes = [];
     // Filter classes should match up with the settings function in
@@ -421,12 +445,12 @@ function getReflectionClasses(reflection, filters) {
         else if (key.startsWith("@")) {
             if (key === "@deprecated") {
                 if (reflection.isDeprecated()) {
-                    classes.push((0, lib_1.toStyleClass)(`tsd-is-${key.substring(1)}`));
+                    classes.push(toStyleClass(`tsd-is-${key.substring(1)}`));
                 }
             }
             else if (reflection.comment?.hasModifier(key) ||
                 reflection.comment?.getTag(key)) {
-                classes.push((0, lib_1.toStyleClass)(`tsd-is-${key.substring(1)}`));
+                classes.push(toStyleClass(`tsd-is-${key.substring(1)}`));
             }
         }
     }