@depup/typedoc 0.28.17-depup.0

package/dist/lib/output/plugins/JavascriptIndexPlugin.js

@@ -0,0 +1,222 @@
+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] = _;
+        }
+    }
+    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);
+    }
+    return useValue ? value : void 0;
+};
+import * as Path from "path";
+import lunr from "lunr";
+import { Reflection } from "../../models/index.js";
+import { RendererComponent } from "../components.js";
+import { IndexEvent, RendererEvent } from "../events.js";
+import { Option, writeFile } from "../../utils/index.js";
+import { DefaultTheme } from "../themes/default/DefaultTheme.js";
+import { GroupPlugin } from "../../converter/plugins/GroupPlugin.js";
+import { CategoryPlugin } from "../../converter/plugins/CategoryPlugin.js";
+import { compressJson } from "../../utils/compress.js";
+import { i18n } from "#utils";
+/**
+ * A plugin that exports an index of the project to a javascript file.
+ *
+ * The resulting javascript file can be used to build a simple search function.
+ */
+let JavascriptIndexPlugin = (() => {
+    let _classSuper = RendererComponent;
+    let _searchComments_decorators;
+    let _searchComments_initializers = [];
+    let _searchComments_extraInitializers = [];
+    let _searchDocuments_decorators;
+    let _searchDocuments_initializers = [];
+    let _searchDocuments_extraInitializers = [];
+    let _searchGroupBoosts_decorators;
+    let _searchGroupBoosts_initializers = [];
+    let _searchGroupBoosts_extraInitializers = [];
+    let _searchCategoryBoosts_decorators;
+    let _searchCategoryBoosts_initializers = [];
+    let _searchCategoryBoosts_extraInitializers = [];
+    let _groupReferencesByType_decorators;
+    let _groupReferencesByType_initializers = [];
+    let _groupReferencesByType_extraInitializers = [];
+    return class JavascriptIndexPlugin extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _searchComments_decorators = [Option("searchInComments")];
+            _searchDocuments_decorators = [Option("searchInDocuments")];
+            _searchGroupBoosts_decorators = [Option("searchGroupBoosts")];
+            _searchCategoryBoosts_decorators = [Option("searchCategoryBoosts")];
+            _groupReferencesByType_decorators = [Option("groupReferencesByType")];
+            __esDecorate(this, null, _searchComments_decorators, { kind: "accessor", name: "searchComments", static: false, private: false, access: { has: obj => "searchComments" in obj, get: obj => obj.searchComments, set: (obj, value) => { obj.searchComments = value; } }, metadata: _metadata }, _searchComments_initializers, _searchComments_extraInitializers);
+            __esDecorate(this, null, _searchDocuments_decorators, { kind: "accessor", name: "searchDocuments", static: false, private: false, access: { has: obj => "searchDocuments" in obj, get: obj => obj.searchDocuments, set: (obj, value) => { obj.searchDocuments = value; } }, metadata: _metadata }, _searchDocuments_initializers, _searchDocuments_extraInitializers);
+            __esDecorate(this, null, _searchGroupBoosts_decorators, { kind: "accessor", name: "searchGroupBoosts", static: false, private: false, access: { has: obj => "searchGroupBoosts" in obj, get: obj => obj.searchGroupBoosts, set: (obj, value) => { obj.searchGroupBoosts = value; } }, metadata: _metadata }, _searchGroupBoosts_initializers, _searchGroupBoosts_extraInitializers);
+            __esDecorate(this, null, _searchCategoryBoosts_decorators, { kind: "accessor", name: "searchCategoryBoosts", static: false, private: false, access: { has: obj => "searchCategoryBoosts" in obj, get: obj => obj.searchCategoryBoosts, set: (obj, value) => { obj.searchCategoryBoosts = value; } }, metadata: _metadata }, _searchCategoryBoosts_initializers, _searchCategoryBoosts_extraInitializers);
+            __esDecorate(this, null, _groupReferencesByType_decorators, { kind: "accessor", name: "groupReferencesByType", static: false, private: false, access: { has: obj => "groupReferencesByType" in obj, get: obj => obj.groupReferencesByType, set: (obj, value) => { obj.groupReferencesByType = value; } }, metadata: _metadata }, _groupReferencesByType_initializers, _groupReferencesByType_extraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        #searchComments_accessor_storage = __runInitializers(this, _searchComments_initializers, void 0);
+        get searchComments() { return this.#searchComments_accessor_storage; }
+        set searchComments(value) { this.#searchComments_accessor_storage = value; }
+        #searchDocuments_accessor_storage = (__runInitializers(this, _searchComments_extraInitializers), __runInitializers(this, _searchDocuments_initializers, void 0));
+        get searchDocuments() { return this.#searchDocuments_accessor_storage; }
+        set searchDocuments(value) { this.#searchDocuments_accessor_storage = value; }
+        #searchGroupBoosts_accessor_storage = (__runInitializers(this, _searchDocuments_extraInitializers), __runInitializers(this, _searchGroupBoosts_initializers, void 0));
+        get searchGroupBoosts() { return this.#searchGroupBoosts_accessor_storage; }
+        set searchGroupBoosts(value) { this.#searchGroupBoosts_accessor_storage = value; }
+        #searchCategoryBoosts_accessor_storage = (__runInitializers(this, _searchGroupBoosts_extraInitializers), __runInitializers(this, _searchCategoryBoosts_initializers, void 0));
+        get searchCategoryBoosts() { return this.#searchCategoryBoosts_accessor_storage; }
+        set searchCategoryBoosts(value) { this.#searchCategoryBoosts_accessor_storage = value; }
+        #groupReferencesByType_accessor_storage = (__runInitializers(this, _searchCategoryBoosts_extraInitializers), __runInitializers(this, _groupReferencesByType_initializers, void 0));
+        get groupReferencesByType() { return this.#groupReferencesByType_accessor_storage; }
+        set groupReferencesByType(value) { this.#groupReferencesByType_accessor_storage = value; }
+        unusedGroupBoosts = (__runInitializers(this, _groupReferencesByType_extraInitializers), new Set());
+        unusedCatBoosts = new Set();
+        constructor(owner) {
+            super(owner);
+            this.owner.on(RendererEvent.BEGIN, this.onRendererBegin.bind(this));
+        }
+        onRendererBegin(_event) {
+            this.unusedGroupBoosts = new Set(Object.keys(this.searchGroupBoosts));
+            this.unusedCatBoosts = new Set(Object.keys(this.searchCategoryBoosts));
+            if (!(this.owner.theme instanceof DefaultTheme)) {
+                return;
+            }
+            this.owner.preRenderAsyncJobs.push((event) => this.buildSearchIndex(event));
+        }
+        async buildSearchIndex(event) {
+            const theme = this.owner.theme;
+            const rows = [];
+            const initialSearchResults = this.owner
+                .router.getLinkTargets()
+                .filter((refl) => refl instanceof Reflection &&
+                (refl.isDeclaration() || refl.isDocument()) &&
+                refl.name &&
+                !refl.flags.isExternal);
+            const indexEvent = new IndexEvent(initialSearchResults);
+            this.owner.trigger(IndexEvent.PREPARE_INDEX, indexEvent);
+            const builder = new lunr.Builder();
+            builder.pipeline.add(lunr.trimmer);
+            builder.ref("id");
+            for (const [key, boost] of Object.entries(indexEvent.searchFieldWeights)) {
+                builder.field(key, { boost });
+            }
+            for (const reflection of indexEvent.searchResults) {
+                const boost = this.getBoost(reflection);
+                if (boost <= 0) {
+                    continue;
+                }
+                let parent = reflection.parent;
+                if (parent?.isProject()) {
+                    parent = undefined;
+                }
+                const row = {
+                    kind: reflection.kind,
+                    name: reflection.name,
+                    url: theme.router.getFullUrl(reflection),
+                    classes: theme.getReflectionClasses(reflection),
+                };
+                const icon = theme.getReflectionIcon(reflection);
+                if (icon !== reflection.kind) {
+                    row.icon = icon;
+                }
+                if (parent) {
+                    row.parent = parent.getFullName();
+                }
+                builder.add({
+                    name: reflection.name,
+                    comment: this.getCommentSearchText(reflection),
+                    document: this.getDocumentSearchText(reflection),
+                    ...indexEvent.searchFields[rows.length],
+                    id: rows.length,
+                }, { boost });
+                rows.push(row);
+            }
+            const index = builder.build();
+            const jsonFileName = Path.join(event.outputDirectory, "assets", "search.js");
+            const data = {
+                rows,
+                index,
+            };
+            await writeFile(jsonFileName, `window.searchData = "${await compressJson(data)}";`);
+            if (this.unusedGroupBoosts.size &&
+                this.application.options.isSet("searchGroupBoosts")) {
+                this.application.logger.warn(i18n.not_all_search_group_boosts_used_0(Array.from(this.unusedGroupBoosts).join("\n\t")));
+            }
+            if (this.unusedCatBoosts.size &&
+                this.application.options.isSet("searchCategoryBoosts")) {
+                this.application.logger.warn(i18n.not_all_search_category_boosts_used_0(Array.from(this.unusedCatBoosts).join("\n\t")));
+            }
+        }
+        getBoost(refl) {
+            let boost = refl.relevanceBoost ?? 1;
+            for (const group of GroupPlugin.getGroups(refl, this.groupReferencesByType)) {
+                boost *= this.searchGroupBoosts[group] ?? 1;
+                this.unusedGroupBoosts.delete(group);
+            }
+            for (const cat of CategoryPlugin.getCategories(refl)) {
+                boost *= this.searchCategoryBoosts[cat] ?? 1;
+                this.unusedCatBoosts.delete(cat);
+            }
+            return boost;
+        }
+        getCommentSearchText(reflection) {
+            if (!this.searchComments)
+                return;
+            const comments = [];
+            if (reflection.comment)
+                comments.push(reflection.comment);
+            if (reflection.isDeclaration()) {
+                reflection.signatures?.forEach((s) => s.comment && comments.push(s.comment));
+                if (reflection.getSignature?.comment) {
+                    comments.push(reflection.getSignature.comment);
+                }
+                if (reflection.setSignature?.comment) {
+                    comments.push(reflection.setSignature.comment);
+                }
+            }
+            if (!comments.length) {
+                return;
+            }
+            return comments
+                .flatMap((c) => {
+                return [...c.summary, ...c.blockTags.flatMap((t) => t.content)];
+            })
+                .map((part) => part.text)
+                .join("\n");
+        }
+        getDocumentSearchText(reflection) {
+            if (!this.searchDocuments)
+                return;
+            if (reflection.isDocument()) {
+                return reflection.content.flatMap((c) => c.text).join("\n");
+            }
+        }
+    };
+})();
+export { JavascriptIndexPlugin };

package/dist/lib/output/plugins/NavigationPlugin.d.ts

@@ -0,0 +1,7 @@
+import { RendererComponent } from "../components.js";
+import type { Renderer } from "../index.js";
+export declare class NavigationPlugin extends RendererComponent {
+    constructor(owner: Renderer);
+    private onRendererBegin;
+    private buildNavigationIndex;
+}

package/dist/lib/output/plugins/NavigationPlugin.js

@@ -0,0 +1,23 @@
+import * as Path from "path";
+import { RendererComponent } from "../components.js";
+import { RendererEvent } from "../events.js";
+import { writeFile } from "../../utils/index.js";
+import { DefaultTheme } from "../themes/default/DefaultTheme.js";
+import { compressJson } from "../../utils/compress.js";
+export class NavigationPlugin extends RendererComponent {
+    constructor(owner) {
+        super(owner);
+        this.owner.on(RendererEvent.BEGIN, this.onRendererBegin.bind(this));
+    }
+    onRendererBegin(_event) {
+        if (!(this.owner.theme instanceof DefaultTheme)) {
+            return;
+        }
+        this.owner.preRenderAsyncJobs.push((event) => this.buildNavigationIndex(event));
+    }
+    async buildNavigationIndex(event) {
+        const navigationJs = Path.join(event.outputDirectory, "assets", "navigation.js");
+        const nav = this.owner.theme.getNavigation(event.project);
+        await writeFile(navigationJs, `window.navigationData = "${await compressJson(nav)}"`);
+    }
+}

package/dist/lib/output/plugins/SitemapPlugin.d.ts

@@ -0,0 +1,8 @@
+import { RendererComponent } from "../components.js";
+import type { Renderer } from "../index.js";
+export declare class SitemapPlugin extends RendererComponent {
+    private get hostedBaseUrl();
+    constructor(owner: Renderer);
+    private onRendererBegin;
+    private buildSitemap;
+}

package/dist/lib/output/plugins/SitemapPlugin.js

@@ -0,0 +1,82 @@
+import Path from "path";
+import { RendererComponent } from "../components.js";
+import { RendererEvent } from "../events.js";
+import { DefaultTheme } from "../themes/default/DefaultTheme.js";
+import { writeFile } from "#node-utils";
+import { escapeHtml, JSX } from "#utils";
+export class SitemapPlugin extends RendererComponent {
+    get hostedBaseUrl() {
+        const url = this.application.options.getValue("hostedBaseUrl");
+        return !url || url.endsWith("/") ? url : url + "/";
+    }
+    constructor(owner) {
+        super(owner);
+        this.owner.on(RendererEvent.BEGIN, this.onRendererBegin.bind(this));
+    }
+    onRendererBegin(_event) {
+        if (!(this.owner.theme instanceof DefaultTheme)) {
+            return;
+        }
+        if (!this.hostedBaseUrl) {
+            return;
+        }
+        this.owner.hooks.on("head.begin", (context) => {
+            if (context.page.url === "index.html") {
+                return {
+                    tag: "link",
+                    props: { rel: "canonical", href: this.hostedBaseUrl },
+                    children: [],
+                };
+            }
+            return { tag: JSX.Fragment, props: null, children: [] };
+        });
+        this.owner.preRenderAsyncJobs.push((event) => this.buildSitemap(event));
+    }
+    async buildSitemap(event) {
+        // cSpell:words lastmod urlset
+        const sitemapXml = Path.join(event.outputDirectory, "sitemap.xml");
+        const lastmod = new Date(this.owner.renderStartTime).toISOString();
+        const urls = event.pages.map((page) => {
+            return {
+                tag: "url",
+                children: [
+                    {
+                        tag: "loc",
+                        children: new URL(page.url, this.hostedBaseUrl).toString(),
+                    },
+                    {
+                        tag: "lastmod",
+                        children: lastmod,
+                    },
+                ],
+            };
+        });
+        const sitemap = `<?xml version="1.0" encoding="UTF-8"?>\n` +
+            stringifyXml({
+                tag: "urlset",
+                attr: { xmlns: "http://www.sitemaps.org/schemas/sitemap/0.9" },
+                children: urls,
+            }) +
+            "\n";
+        await writeFile(sitemapXml, sitemap);
+    }
+}
+function stringifyXml(xml, indent = 0) {
+    const parts = ["\t".repeat(indent), "<", xml.tag];
+    for (const [key, val] of Object.entries(xml.attr || {})) {
+        parts.push(" ", key, '="', escapeHtml(val), '"');
+    }
+    parts.push(">");
+    if (typeof xml.children === "string") {
+        parts.push(escapeHtml(xml.children));
+    }
+    else {
+        for (const child of xml.children) {
+            parts.push("\n");
+            parts.push(stringifyXml(child, indent + 1));
+        }
+        parts.push("\n", "\t".repeat(indent));
+    }
+    parts.push("</", xml.tag, ">");
+    return parts.join("");
+}

package/dist/lib/output/plugins/index.d.ts

@@ -0,0 +1,7 @@
+export { MarkedPlugin } from "../themes/MarkedPlugin.js";
+export { AssetsPlugin } from "./AssetsPlugin.js";
+export { HierarchyPlugin } from "./HierarchyPlugin.js";
+export { IconsPlugin } from "./IconsPlugin.js";
+export { JavascriptIndexPlugin } from "./JavascriptIndexPlugin.js";
+export { NavigationPlugin } from "./NavigationPlugin.js";
+export { SitemapPlugin } from "./SitemapPlugin.js";

package/dist/lib/output/plugins/index.js

@@ -0,0 +1,7 @@
+export { MarkedPlugin } from "../themes/MarkedPlugin.js";
+export { AssetsPlugin } from "./AssetsPlugin.js";
+export { HierarchyPlugin } from "./HierarchyPlugin.js";
+export { IconsPlugin } from "./IconsPlugin.js";
+export { JavascriptIndexPlugin } from "./JavascriptIndexPlugin.js";
+export { NavigationPlugin } from "./NavigationPlugin.js";
+export { SitemapPlugin } from "./SitemapPlugin.js";

package/dist/lib/output/renderer.d.ts

@@ -0,0 +1,227 @@
+import type { Application } from "../application.js";
+import type { Theme } from "./theme.js";
+import { IndexEvent, type MarkdownEvent, PageEvent, RendererEvent } from "./events.js";
+import type { ProjectReflection } from "../models/ProjectReflection.js";
+import { AbstractComponent } from "../utils/index.js";
+import type { Comment, Reflection } from "../models/index.js";
+import type { DefaultThemeRenderContext } from "./themes/default/DefaultThemeRenderContext.js";
+import { EventHooks, JSX } from "#utils";
+import { MarkedPlugin } from "./plugins/index.js";
+import { type Router } from "./router.js";
+/**
+ * Describes the hooks available to inject output in the default theme.
+ * If the available hooks don't let you put something where you'd like, please open an issue!
+ */
+export interface RendererHooks {
+    /**
+     * Applied immediately after the opening `<head>` tag.
+     */
+    "head.begin": [DefaultThemeRenderContext];
+    /**
+     * Applied immediately before the closing `</head>` tag.
+     */
+    "head.end": [DefaultThemeRenderContext];
+    /**
+     * Applied immediately after the opening `<body>` tag.
+     */
+    "body.begin": [DefaultThemeRenderContext];
+    /**
+     * Applied immediately before the closing `</body>` tag.
+     */
+    "body.end": [DefaultThemeRenderContext];
+    /**
+     * Applied immediately before the main template.
+     */
+    "content.begin": [DefaultThemeRenderContext];
+    /**
+     * Applied immediately after the main template.
+     */
+    "content.end": [DefaultThemeRenderContext];
+    /**
+     * Applied immediately before calling `context.sidebar`.
+     */
+    "sidebar.begin": [DefaultThemeRenderContext];
+    /**
+     * Applied immediately after calling `context.sidebar`.
+     */
+    "sidebar.end": [DefaultThemeRenderContext];
+    /**
+     * Applied immediately before calling `context.pageSidebar`.
+     */
+    "pageSidebar.begin": [DefaultThemeRenderContext];
+    /**
+     * Applied immediately after calling `context.pageSidebar`.
+     */
+    "pageSidebar.end": [DefaultThemeRenderContext];
+    /**
+     * Applied immediately before the "Generated by TypeDoc" link in the footer.
+     */
+    "footer.begin": [DefaultThemeRenderContext];
+    /**
+     * Applied immediately after the "Generated by TypeDoc" link in the footer.
+     */
+    "footer.end": [DefaultThemeRenderContext];
+    /**
+     * Applied immediately before a comment's tags are rendered.
+     *
+     * This may be used to set {@link Models.CommentTag.skipRendering} on any tags which
+     * should not be rendered.
+     */
+    "comment.beforeTags": [DefaultThemeRenderContext, Comment, Reflection];
+    /**
+     * Applied immediately after a comment's tags are rendered.
+     *
+     * This may be used to set {@link Models.CommentTag.skipRendering} on any tags which
+     * should not be rendered as this hook is called before the tags are actually
+     * rendered.
+     */
+    "comment.afterTags": [DefaultThemeRenderContext, Comment, Reflection];
+}
+export interface RendererEvents {
+    beginRender: [RendererEvent];
+    beginPage: [PageEvent];
+    endPage: [PageEvent];
+    endRender: [RendererEvent];
+    parseMarkdown: [MarkdownEvent];
+    prepareIndex: [IndexEvent];
+}
+/**
+ * The renderer processes a {@link ProjectReflection} using a {@link Theme} instance and writes
+ * the emitted html documents to a output directory. You can specify which theme should be used
+ * using the `--theme <name>` command line argument.
+ *
+ * {@link Renderer} is a subclass of {@link EventDispatcher} and triggers a series of events while
+ * a project is being processed. You can listen to these events to control the flow or manipulate
+ * the output.
+ *
+ *  * {@link Renderer.EVENT_BEGIN}<br>
+ *    Triggered before the renderer starts rendering a project. The listener receives
+ *    an instance of {@link RendererEvent}.
+ *
+ *    * {@link Renderer.EVENT_BEGIN_PAGE}<br>
+ *      Triggered before a document will be rendered. The listener receives an instance of
+ *      {@link PageEvent}.
+ *
+ *    * {@link Renderer.EVENT_END_PAGE}<br>
+ *      Triggered after a document has been rendered, just before it is written to disc. The
+ *      listener receives an instance of {@link PageEvent}.
+ *
+ *  * {@link Renderer.EVENT_END}<br>
+ *    Triggered after the renderer has written all documents. The listener receives
+ *    an instance of {@link RendererEvent}.
+ *
+ * * {@link Renderer.EVENT_PREPARE_INDEX}<br>
+ *    Triggered when the JavascriptIndexPlugin is preparing the search index. Listeners receive
+ *    an instance of {@link IndexEvent}.
+ *
+ * @summary Writes HTML output from TypeDoc's models
+ * @group None
+ */
+export declare class Renderer extends AbstractComponent<Application, RendererEvents> {
+    private routers;
+    private themes;
+    /** @event */
+    static readonly EVENT_BEGIN_PAGE = "beginPage";
+    /** @event */
+    static readonly EVENT_END_PAGE = "endPage";
+    /** @event */
+    static readonly EVENT_BEGIN = "beginRender";
+    /** @event */
+    static readonly EVENT_END = "endRender";
+    /** @event */
+    static readonly EVENT_PREPARE_INDEX = "prepareIndex";
+    /**
+     * A list of async jobs which must be completed *before* rendering output.
+     * They will be called after {@link RendererEvent.BEGIN} has fired, but before any files have been written.
+     *
+     * This may be used by plugins to register work that must be done to prepare output files. For example: asynchronously
+     * transform markdown to HTML.
+     *
+     * Note: This array is cleared after calling the contained functions on each {@link Renderer.render} call.
+     */
+    preRenderAsyncJobs: Array<(output: RendererEvent) => Promise<void>>;
+    /**
+     * A list of async jobs which must be completed after rendering output files but before generation is considered successful.
+     * These functions will be called after all documents have been written to the filesystem.
+     *
+     * This may be used by plugins to register work that must be done to finalize output files. For example: asynchronously
+     * generating an image referenced in a render hook.
+     *
+     * Note: This array is cleared after calling the contained functions on each {@link Renderer.render} call.
+     */
+    postRenderAsyncJobs: Array<(output: RendererEvent) => Promise<void>>;
+    /**
+     * The theme that is used to render the documentation.
+     */
+    theme?: Theme;
+    /**
+     * The router which is used to determine the pages to render and
+     * how to link between pages.
+     */
+    router?: Router;
+    /**
+     * Hooks which will be called when rendering pages.
+     * Note:
+     * - Hooks added during output will be discarded at the end of rendering.
+     * - Hooks added during a page render will be discarded at the end of that page's render.
+     *
+     * See {@link RendererHooks} for a description of each available hook, and when it will be called.
+     */
+    hooks: EventHooks<RendererHooks, JSX.Element>;
+    /** @internal */
+    private accessor themeName;
+    /** @internal */
+    private accessor routerName;
+    private accessor cleanOutputDir;
+    private accessor cname;
+    private accessor githubPages;
+    /** @internal */
+    accessor cacheBust: boolean;
+    private accessor pretty;
+    renderStartTime: number;
+    markedPlugin: MarkedPlugin;
+    constructor(owner: Application);
+    /**
+     * Define a new theme that can be used to render output.
+     * This API will likely be changing at some point, to allow more easily overriding parts of the theme without
+     * requiring additional boilerplate.
+     * @param name
+     * @param theme
+     */
+    defineTheme(name: string, theme: new (renderer: Renderer) => Theme): void;
+    /** @internal intended for test usage only */
+    removeTheme(name: string): void;
+    /**
+     * Define a new router that can be used to determine the output structure.
+     * @param name
+     * @param router
+     */
+    defineRouter(name: string, router: new (app: Application) => Router): void;
+    /** @internal intended for test usage only */
+    removeRouter(name: string): void;
+    /**
+     * Render the given project reflection to the specified output directory.
+     *
+     * @param project  The project that should be rendered.
+     * @param outputDirectory  The path of the directory the documentation should be rendered to.
+     */
+    render(project: ProjectReflection, outputDirectory: string): Promise<void>;
+    private runPreRenderJobs;
+    /**
+     * Render a single page.
+     *
+     * @param page An event describing the current page.
+     * @return TRUE if the page has been saved to disc, otherwise FALSE.
+     */
+    private renderDocument;
+    private prepareRouter;
+    private prepareTheme;
+    /**
+     * Prepare the output directory. If the directory does not exist, it will be
+     * created. If the directory exists, it will be emptied.
+     *
+     * @param directory  The path to the directory that should be prepared.
+     * @returns TRUE if the directory could be prepared, otherwise FALSE.
+     */
+    private prepareOutputDirectory;
+}