typedoc 0.24.8 → 0.25.1

package/dist/lib/application.js

@@ -15,11 +15,39 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
+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;
+};
+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 __importStar = (this && this.__importStar) || function (mod) {
     if (mod && mod.__esModule) return mod;
@@ -28,12 +56,26 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var Application_1;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Application = void 0;
+exports.Application = exports.createAppForTesting = void 0;
 const Path = __importStar(require("path"));
 const typescript_1 = __importDefault(require("typescript"));
 const index_1 = require("./converter/index");
@@ -59,6 +101,17 @@ const packageInfo = require("../../package.json");
 const supportedVersionMajorMinor = packageInfo.peerDependencies.typescript
     .split("||")
     .map((version) => version.replace(/^\s*|\.x\s*$/g, ""));
+const DETECTOR = Symbol();
+function createAppForTesting() {
+    // @ts-expect-error private constructor
+    return new Application(DETECTOR);
+}
+exports.createAppForTesting = createAppForTesting;
+const DEFAULT_READERS = [
+    new index_2.TypeDocReader(),
+    new index_2.PackageJsonReader(),
+    new index_2.TSConfigReader(),
+];
 /**
  * The default TypeDoc main application class.
  *
@@ -72,381 +125,436 @@ const supportedVersionMajorMinor = packageInfo.peerDependencies.typescript
  * Both the {@link Converter} and the {@link Renderer} emit a series of events while processing the project.
  * Subscribe to these Events to control the application flow or alter the output.
  */
-let Application = exports.Application = Application_1 = class Application extends component_1.ChildableComponent {
-    /**
-     * Create a new TypeDoc application instance.
-     */
-    constructor() {
-        super(null); // We own ourselves
+let Application = (() => {
+    var _Application_skipErrorChecking_accessor_storage, _Application_entryPointStrategy_accessor_storage, _Application_entryPoints_accessor_storage;
+    let _classDecorators = [(0, component_1.Component)({ name: "application", internal: true })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = component_1.ChildableComponent;
+    let _instanceExtraInitializers = [];
+    let _skipErrorChecking_decorators;
+    let _skipErrorChecking_initializers = [];
+    let _entryPointStrategy_decorators;
+    let _entryPointStrategy_initializers = [];
+    let _entryPoints_decorators;
+    let _entryPoints_initializers = [];
+    var Application = _classThis = class extends _classSuper {
+        /** @internal */
+        get skipErrorChecking() { return __classPrivateFieldGet(this, _Application_skipErrorChecking_accessor_storage, "f"); }
+        set skipErrorChecking(value) { __classPrivateFieldSet(this, _Application_skipErrorChecking_accessor_storage, value, "f"); }
+        /** @internal */
+        get entryPointStrategy() { return __classPrivateFieldGet(this, _Application_entryPointStrategy_accessor_storage, "f"); }
+        set entryPointStrategy(value) { __classPrivateFieldSet(this, _Application_entryPointStrategy_accessor_storage, value, "f"); }
+        /** @internal */
+        get entryPoints() { return __classPrivateFieldGet(this, _Application_entryPoints_accessor_storage, "f"); }
+        set entryPoints(value) { __classPrivateFieldSet(this, _Application_entryPoints_accessor_storage, value, "f"); }
         /**
-         * The serializer used to generate JSON output.
+         * Create a new TypeDoc application instance.
          */
-        this.serializer = new serialization_1.Serializer();
+        constructor(detector) {
+            if (detector !== DETECTOR) {
+                throw new Error("An application handle must be retrieved with Application.bootstrap or Application.bootstrapWithPlugins");
+            }
+            super(null); // We own ourselves
+            /**
+             * The converter used to create the declaration reflections.
+             */
+            this.converter = (__runInitializers(this, _instanceExtraInitializers), void 0);
+            /**
+             * The serializer used to generate JSON output.
+             */
+            this.serializer = new serialization_1.Serializer();
+            /**
+             * The deserializer used to restore previously serialized JSON output.
+             */
+            this.deserializer = new serialization_1.Deserializer(this);
+            /**
+             * The logger that should be used to output messages.
+             */
+            this.logger = new index_2.ConsoleLogger();
+            this.options = new utils_1.Options();
+            _Application_skipErrorChecking_accessor_storage.set(this, __runInitializers(this, _skipErrorChecking_initializers, void 0));
+            _Application_entryPointStrategy_accessor_storage.set(this, __runInitializers(this, _entryPointStrategy_initializers, void 0));
+            _Application_entryPoints_accessor_storage.set(this, __runInitializers(this, _entryPoints_initializers, void 0));
+            this.converter = this.addComponent("converter", index_1.Converter);
+            this.renderer = this.addComponent("renderer", renderer_1.Renderer);
+        }
         /**
-         * The deserializer used to restore previously serialized JSON output.
+         * Initialize TypeDoc, loading plugins if applicable.
          */
-        this.deserializer = new serialization_1.Deserializer(this);
-        this.logger = new index_2.ConsoleLogger();
-        this.options = new utils_1.Options(this.logger);
-        this.converter = this.addComponent("converter", index_1.Converter);
-        this.renderer = this.addComponent("renderer", renderer_1.Renderer);
-    }
-    /**
-     * Initialize TypeDoc, loading plugins if applicable.
-     */
-    async bootstrapWithPlugins(options = {}) {
-        this.options.reset();
-        this.setOptions(options, /* reportErrors */ false);
-        this.options.read(new index_2.Logger());
-        this.logger.level = this.options.getValue("logLevel");
-        await (0, index_2.loadPlugins)(this, this.options.getValue("plugin"));
-        this.bootstrap(options);
-    }
-    /**
-     * Initialize TypeDoc without loading plugins.
-     *
-     * @example
-     * Initialize the application with pretty-printing output disabled.
-     * ```ts
-     * const app = new Application();
-     * app.bootstrap({ pretty: false });
-     * ```
-     *
-     * @param options - Options to set during initialization
-     */
-    bootstrap(options = {}) {
-        this.options.reset();
-        this.setOptions(options, /* reportErrors */ false);
-        this.options.read(this.logger);
-        this.setOptions(options);
-        this.logger.level = this.options.getValue("logLevel");
-        if ((0, general_1.hasBeenLoadedMultipleTimes)()) {
-            this.logger.warn(`TypeDoc has been loaded multiple times. This is commonly caused by plugins which have their own installation of TypeDoc. The loaded paths are:\n\t${(0, general_1.getLoadedPaths)().join("\n\t")}`);
+        static async bootstrapWithPlugins(options = {}, readers = DEFAULT_READERS) {
+            const app = new Application(DETECTOR);
+            readers.forEach((r) => app.options.addReader(r));
+            app.options.reset();
+            app.setOptions(options, /* reportErrors */ false);
+            await app.options.read(new index_2.Logger());
+            app.logger.level = app.options.getValue("logLevel");
+            await (0, index_2.loadPlugins)(app, app.options.getValue("plugin"));
+            await app._bootstrap(options);
+            return app;
         }
-        this.trigger(application_events_1.ApplicationEvents.BOOTSTRAP_END, this);
-    }
-    setOptions(options, reportErrors = true) {
-        for (const [key, val] of Object.entries(options)) {
-            try {
-                this.options.setValue(key, val);
+        /**
+         * Initialize TypeDoc without loading plugins.
+         *
+         * @example
+         * Initialize the application with pretty-printing output disabled.
+         * ```ts
+         * const app = Application.bootstrap({ pretty: false });
+         * ```
+         *
+         * @param options Options to set during initialization
+         * @param readers Option readers to use to discover options from config files.
+         */
+        static async bootstrap(options = {}, readers = DEFAULT_READERS) {
+            const app = new Application(DETECTOR);
+            readers.forEach((r) => app.options.addReader(r));
+            await app._bootstrap(options);
+            return app;
+        }
+        async _bootstrap(options) {
+            this.options.reset();
+            this.setOptions(options, /* reportErrors */ false);
+            await this.options.read(this.logger);
+            this.setOptions(options);
+            this.logger.level = this.options.getValue("logLevel");
+            if ((0, general_1.hasBeenLoadedMultipleTimes)()) {
+                this.logger.warn(`TypeDoc has been loaded multiple times. This is commonly caused by plugins which have their own installation of TypeDoc. The loaded paths are:\n\t${(0, general_1.getLoadedPaths)().join("\n\t")}`);
             }
-            catch (error) {
-                (0, assert_1.ok)(error instanceof Error);
-                if (reportErrors) {
-                    this.logger.error(error.message);
+            this.trigger(application_events_1.ApplicationEvents.BOOTSTRAP_END, this);
+        }
+        setOptions(options, reportErrors = true) {
+            for (const [key, val] of Object.entries(options)) {
+                try {
+                    this.options.setValue(key, val);
+                }
+                catch (error) {
+                    (0, assert_1.ok)(error instanceof Error);
+                    if (reportErrors) {
+                        this.logger.error(error.message);
+                    }
                 }
             }
         }
-    }
-    /**
-     * Return the path to the TypeScript compiler.
-     */
-    getTypeScriptPath() {
-        return (0, paths_1.nicePath)(Path.dirname(require.resolve("typescript")));
-    }
-    getTypeScriptVersion() {
-        return typescript_1.default.version;
-    }
-    /**
-     * 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.
-     */
-    getEntryPoints() {
-        return (0, entry_point_1.getEntryPoints)(this.logger, this.options);
-    }
-    /**
-     * Run the converter for the given set of files and return the generated reflections.
-     *
-     * @returns An instance of ProjectReflection on success, undefined otherwise.
-     */
-    convert() {
-        const start = Date.now();
-        // We freeze here rather than in the Converter class since TypeDoc's tests reuse the Application
-        // with a few different settings.
-        this.options.freeze();
-        this.logger.verbose(`Using TypeScript ${this.getTypeScriptVersion()} from ${this.getTypeScriptPath()}`);
-        if (this.entryPointStrategy === entry_point_1.EntryPointStrategy.Merge) {
-            return this._merge();
-        }
-        if (this.entryPointStrategy === entry_point_1.EntryPointStrategy.Packages) {
-            return this._convertPackages();
+        /**
+         * Return the path to the TypeScript compiler.
+         */
+        getTypeScriptPath() {
+            return (0, paths_1.nicePath)(Path.dirname(require.resolve("typescript")));
         }
-        if (!supportedVersionMajorMinor.some((version) => version == typescript_1.default.versionMajorMinor)) {
-            this.logger.warn(`You are running with an unsupported TypeScript version! If TypeDoc crashes, this is why. TypeDoc supports ${supportedVersionMajorMinor.join(", ")}`);
+        getTypeScriptVersion() {
+            return typescript_1.default.version;
         }
-        const entryPoints = this.getEntryPoints();
-        if (!entryPoints) {
-            // Fatal error already reported.
-            return;
+        /**
+         * 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.
+         */
+        getEntryPoints() {
+            return (0, entry_point_1.getEntryPoints)(this.logger, this.options);
         }
-        const programs = (0, array_1.unique)(entryPoints.map((e) => e.program));
-        this.logger.verbose(`Converting with ${programs.length} programs ${entryPoints.length} entry points`);
-        if (this.skipErrorChecking === false) {
-            const errors = programs.flatMap((program) => typescript_1.default.getPreEmitDiagnostics(program));
-            if (errors.length) {
-                this.logger.diagnostics(errors);
+        /**
+         * Run the converter for the given set of files and return the generated reflections.
+         *
+         * @returns An instance of ProjectReflection on success, undefined otherwise.
+         */
+        async convert() {
+            const start = Date.now();
+            // We freeze here rather than in the Converter class since TypeDoc's tests reuse the Application
+            // with a few different settings.
+            this.options.freeze();
+            this.logger.verbose(`Using TypeScript ${this.getTypeScriptVersion()} from ${this.getTypeScriptPath()}`);
+            if (this.entryPointStrategy === entry_point_1.EntryPointStrategy.Merge) {
+                return this._merge();
+            }
+            if (this.entryPointStrategy === entry_point_1.EntryPointStrategy.Packages) {
+                return this._convertPackages();
+            }
+            if (!supportedVersionMajorMinor.some((version) => version == typescript_1.default.versionMajorMinor)) {
+                this.logger.warn(`You are running with an unsupported TypeScript version! If TypeDoc crashes, this is why. TypeDoc supports ${supportedVersionMajorMinor.join(", ")}`);
+            }
+            const entryPoints = this.getEntryPoints();
+            if (!entryPoints) {
+                // Fatal error already reported.
                 return;
             }
-        }
-        if (this.options.getValue("emit") === "both") {
-            for (const program of programs) {
-                program.emit();
+            const programs = (0, array_1.unique)(entryPoints.map((e) => e.program));
+            this.logger.verbose(`Converting with ${programs.length} programs ${entryPoints.length} entry points`);
+            if (this.skipErrorChecking === false) {
+                const errors = programs.flatMap((program) => typescript_1.default.getPreEmitDiagnostics(program));
+                if (errors.length) {
+                    this.logger.diagnostics(errors);
+                    return;
+                }
             }
+            if (this.options.getValue("emit") === "both") {
+                for (const program of programs) {
+                    program.emit();
+                }
+            }
+            const startConversion = Date.now();
+            this.logger.verbose(`Finished getting entry points in ${Date.now() - start}ms`);
+            const project = this.converter.convert(entryPoints);
+            this.logger.verbose(`Finished conversion in ${Date.now() - startConversion}ms`);
+            return project;
         }
-        const startConversion = Date.now();
-        this.logger.verbose(`Finished getting entry points in ${Date.now() - start}ms`);
-        const project = this.converter.convert(entryPoints);
-        this.logger.verbose(`Finished conversion in ${Date.now() - startConversion}ms`);
-        return project;
-    }
-    convertAndWatch(success) {
-        this.options.freeze();
-        if (!this.options.getValue("preserveWatchOutput") &&
-            this.logger instanceof index_2.ConsoleLogger) {
-            typescript_1.default.sys.clearScreen?.();
-        }
-        this.logger.verbose(`Using TypeScript ${this.getTypeScriptVersion()} from ${this.getTypeScriptPath()}`);
-        if (!supportedVersionMajorMinor.some((version) => version == typescript_1.default.versionMajorMinor)) {
-            this.logger.warn(`You are running with an unsupported TypeScript version! TypeDoc supports ${supportedVersionMajorMinor.join(", ")}`);
-        }
-        if (Object.keys(this.options.getCompilerOptions()).length === 0) {
-            this.logger.warn(`No compiler options set. This likely means that TypeDoc did not find your tsconfig.json. Generated documentation will probably be empty.`);
-        }
-        // Doing this is considerably more complicated, we'd need to manage an array of programs, not convert until all programs
-        // have reported in the first time... just error out for now. I'm not convinced anyone will actually notice.
-        if (this.options.getFileNames().length === 0) {
-            this.logger.error("The provided tsconfig file looks like a solution style tsconfig, which is not supported in watch mode.");
-            return;
-        }
-        // Support for packages mode is currently unimplemented
-        if (this.entryPointStrategy !== entry_point_1.EntryPointStrategy.Resolve &&
-            this.entryPointStrategy !== entry_point_1.EntryPointStrategy.Expand) {
-            this.logger.error("entryPointStrategy must be set to either resolve or expand for watch mode.");
-            return;
-        }
-        const tsconfigFile = (0, tsconfig_1.findTsConfigFile)(this.options.getValue("tsconfig")) ??
-            "tsconfig.json";
-        // We don't want to do it the first time to preserve initial debug status messages. They'll be lost
-        // after the user saves a file, but better than nothing...
-        let firstStatusReport = true;
-        const host = typescript_1.default.createWatchCompilerHost(tsconfigFile, {}, typescript_1.default.sys, typescript_1.default.createEmitAndSemanticDiagnosticsBuilderProgram, (diagnostic) => this.logger.diagnostic(diagnostic), (status, newLine, _options, errorCount) => {
-            if (!firstStatusReport &&
-                errorCount === void 0 &&
-                !this.options.getValue("preserveWatchOutput") &&
+        convertAndWatch(success) {
+            this.options.freeze();
+            if (!this.options.getValue("preserveWatchOutput") &&
                 this.logger instanceof index_2.ConsoleLogger) {
                 typescript_1.default.sys.clearScreen?.();
             }
-            firstStatusReport = false;
-            this.logger.info(typescript_1.default.flattenDiagnosticMessageText(status.messageText, newLine));
-        });
-        let successFinished = true;
-        let currentProgram;
-        const runSuccess = () => {
-            if (!currentProgram) {
+            this.logger.verbose(`Using TypeScript ${this.getTypeScriptVersion()} from ${this.getTypeScriptPath()}`);
+            if (!supportedVersionMajorMinor.some((version) => version == typescript_1.default.versionMajorMinor)) {
+                this.logger.warn(`You are running with an unsupported TypeScript version! TypeDoc supports ${supportedVersionMajorMinor.join(", ")}`);
+            }
+            if (Object.keys(this.options.getCompilerOptions()).length === 0) {
+                this.logger.warn(`No compiler options set. This likely means that TypeDoc did not find your tsconfig.json. Generated documentation will probably be empty.`);
+            }
+            // Doing this is considerably more complicated, we'd need to manage an array of programs, not convert until all programs
+            // have reported in the first time... just error out for now. I'm not convinced anyone will actually notice.
+            if (this.options.getFileNames().length === 0) {
+                this.logger.error("The provided tsconfig file looks like a solution style tsconfig, which is not supported in watch mode.");
+                return;
+            }
+            // Support for packages mode is currently unimplemented
+            if (this.entryPointStrategy !== entry_point_1.EntryPointStrategy.Resolve &&
+                this.entryPointStrategy !== entry_point_1.EntryPointStrategy.Expand) {
+                this.logger.error("entryPointStrategy must be set to either resolve or expand for watch mode.");
                 return;
             }
-            if (successFinished) {
-                if (this.options.getValue("emit") === "both") {
-                    currentProgram.emit();
+            const tsconfigFile = (0, tsconfig_1.findTsConfigFile)(this.options.getValue("tsconfig")) ??
+                "tsconfig.json";
+            // We don't want to do it the first time to preserve initial debug status messages. They'll be lost
+            // after the user saves a file, but better than nothing...
+            let firstStatusReport = true;
+            const host = typescript_1.default.createWatchCompilerHost(tsconfigFile, {}, typescript_1.default.sys, typescript_1.default.createEmitAndSemanticDiagnosticsBuilderProgram, (diagnostic) => this.logger.diagnostic(diagnostic), (status, newLine, _options, errorCount) => {
+                if (!firstStatusReport &&
+                    errorCount === void 0 &&
+                    !this.options.getValue("preserveWatchOutput") &&
+                    this.logger instanceof index_2.ConsoleLogger) {
+                    typescript_1.default.sys.clearScreen?.();
                 }
-                this.logger.resetErrors();
-                this.logger.resetWarnings();
-                const entryPoints = (0, entry_point_1.getWatchEntryPoints)(this.logger, this.options, currentProgram);
-                if (!entryPoints) {
+                firstStatusReport = false;
+                this.logger.info(typescript_1.default.flattenDiagnosticMessageText(status.messageText, newLine));
+            });
+            let successFinished = true;
+            let currentProgram;
+            const runSuccess = () => {
+                if (!currentProgram) {
                     return;
                 }
-                const project = this.converter.convert(entryPoints);
-                currentProgram = undefined;
-                successFinished = false;
-                void success(project).then(() => {
-                    successFinished = true;
+                if (successFinished) {
+                    if (this.options.getValue("emit") === "both") {
+                        currentProgram.emit();
+                    }
+                    this.logger.resetErrors();
+                    this.logger.resetWarnings();
+                    const entryPoints = (0, entry_point_1.getWatchEntryPoints)(this.logger, this.options, currentProgram);
+                    if (!entryPoints) {
+                        return;
+                    }
+                    const project = this.converter.convert(entryPoints);
+                    currentProgram = undefined;
+                    successFinished = false;
+                    void success(project).then(() => {
+                        successFinished = true;
+                        runSuccess();
+                    });
+                }
+            };
+            const origCreateProgram = host.createProgram;
+            host.createProgram = (rootNames, options, host, oldProgram, configDiagnostics, references) => {
+                // If we always do this, we'll get a crash the second time a program is created.
+                if (rootNames !== undefined) {
+                    options = this.options.fixCompilerOptions(options || {});
+                }
+                return origCreateProgram(rootNames, options, host, oldProgram, configDiagnostics, references);
+            };
+            const origAfterProgramCreate = host.afterProgramCreate;
+            host.afterProgramCreate = (program) => {
+                if (typescript_1.default.getPreEmitDiagnostics(program.getProgram()).length === 0) {
+                    currentProgram = program.getProgram();
                     runSuccess();
-                });
+                }
+                origAfterProgramCreate?.(program);
+            };
+            typescript_1.default.createWatchProgram(host);
+        }
+        validate(project) {
+            const checks = this.options.getValue("validation");
+            const start = Date.now();
+            // No point in validating exports when merging. Warnings will have already been emitted when
+            // creating the project jsons that this run merges together.
+            if (checks.notExported &&
+                this.entryPointStrategy !== entry_point_1.EntryPointStrategy.Merge) {
+                (0, exports_1.validateExports)(project, this.logger, this.options.getValue("intentionallyNotExported"));
             }
-        };
-        const origCreateProgram = host.createProgram;
-        host.createProgram = (rootNames, options, host, oldProgram, configDiagnostics, references) => {
-            // If we always do this, we'll get a crash the second time a program is created.
-            if (rootNames !== undefined) {
-                options = this.options.fixCompilerOptions(options || {});
+            if (checks.notDocumented) {
+                (0, documentation_1.validateDocumentation)(project, this.logger, this.options.getValue("requiredToBeDocumented"));
             }
-            return origCreateProgram(rootNames, options, host, oldProgram, configDiagnostics, references);
-        };
-        const origAfterProgramCreate = host.afterProgramCreate;
-        host.afterProgramCreate = (program) => {
-            if (typescript_1.default.getPreEmitDiagnostics(program.getProgram()).length === 0) {
-                currentProgram = program.getProgram();
-                runSuccess();
+            if (checks.invalidLink) {
+                (0, links_1.validateLinks)(project, this.logger);
             }
-            origAfterProgramCreate?.(program);
-        };
-        typescript_1.default.createWatchProgram(host);
-    }
-    validate(project) {
-        const checks = this.options.getValue("validation");
-        const start = Date.now();
-        // No point in validating exports when merging. Warnings will have already been emitted when
-        // creating the project jsons that this run merges together.
-        if (checks.notExported &&
-            this.entryPointStrategy !== entry_point_1.EntryPointStrategy.Merge) {
-            (0, exports_1.validateExports)(project, this.logger, this.options.getValue("intentionallyNotExported"));
-        }
-        if (checks.notDocumented) {
-            (0, documentation_1.validateDocumentation)(project, this.logger, this.options.getValue("requiredToBeDocumented"));
-        }
-        if (checks.invalidLink) {
-            (0, links_1.validateLinks)(project, this.logger);
-        }
-        this.trigger(Application_1.EVENT_VALIDATE_PROJECT, project);
-        this.logger.verbose(`Validation took ${Date.now() - start}ms`);
-    }
-    /**
-     * Render HTML for the given project
-     */
-    async generateDocs(project, out) {
-        const start = Date.now();
-        out = Path.resolve(out);
-        await this.renderer.render(project, out);
-        if (this.logger.hasErrors()) {
-            this.logger.error("Documentation could not be generated due to the errors above.");
+            this.trigger(Application.EVENT_VALIDATE_PROJECT, project);
+            this.logger.verbose(`Validation took ${Date.now() - start}ms`);
         }
-        else {
-            this.logger.info(`Documentation generated at ${(0, paths_1.nicePath)(out)}`);
-            this.logger.verbose(`HTML rendering took ${Date.now() - start}ms`);
-        }
-    }
-    /**
-     * Write the reflections to a json file.
-     *
-     * @param out The path and file name of the target file.
-     * @returns Whether the JSON file could be written successfully.
-     */
-    async generateJson(project, out) {
-        const start = Date.now();
-        out = Path.resolve(out);
-        const ser = this.serializer.projectToObject(project, process.cwd());
-        const space = this.options.getValue("pretty") ? "\t" : "";
-        await (0, index_2.writeFile)(out, JSON.stringify(ser, null, space));
-        this.logger.info(`JSON written to ${(0, paths_1.nicePath)(out)}`);
-        this.logger.verbose(`JSON rendering took ${Date.now() - start}ms`);
-    }
-    /**
-     * Print the version number.
-     */
-    toString() {
-        return [
-            "",
-            `TypeDoc ${Application_1.VERSION}`,
-            `Using TypeScript ${this.getTypeScriptVersion()} from ${this.getTypeScriptPath()}`,
-            "",
-        ].join("\n");
-    }
-    _convertPackages() {
-        if (!this.options.isSet("entryPoints")) {
-            this.logger.error("No entry points provided to packages mode, documentation cannot be generated.");
-            return;
-        }
-        const packageDirs = (0, entry_point_1.getPackageDirectories)(this.logger, this.options, this.options.getValue("entryPoints"));
-        if (packageDirs.length === 0) {
-            this.logger.error("Failed to find any packages, ensure you have provided at least one directory as an entry point containing package.json");
-            return;
-        }
-        const origOptions = this.options;
-        const projects = [];
-        // Generate a json file for each package
-        for (const dir of packageDirs) {
-            this.logger.info(`Converting project at ${(0, paths_1.nicePath)(dir)}`);
-            const opts = origOptions.copyForPackage(dir);
-            // Invalid links should only be reported after everything has been merged.
-            opts.setValue("validation", { invalidLink: false });
-            opts.read(this.logger, dir);
-            if (opts.getValue("entryPointStrategy") ===
-                entry_point_1.EntryPointStrategy.Packages) {
-                this.logger.error(`Project at ${(0, paths_1.nicePath)(dir)} has entryPointStrategy set to packages, but nested packages are not supported.`);
-                continue;
+        /**
+         * Render HTML for the given project
+         */
+        async generateDocs(project, out) {
+            const start = Date.now();
+            out = Path.resolve(out);
+            await this.renderer.render(project, out);
+            if (this.logger.hasErrors()) {
+                this.logger.error("Documentation could not be generated due to the errors above.");
             }
-            this.options = opts;
-            const project = this.convert();
-            if (project) {
-                this.validate(project);
-                projects.push(this.serializer.projectToObject(project, process.cwd()));
+            else {
+                this.logger.info(`Documentation generated at ${(0, paths_1.nicePath)(out)}`);
+                this.logger.verbose(`HTML rendering took ${Date.now() - start}ms`);
             }
-            (0, abstract_1.resetReflectionID)();
         }
-        this.options = origOptions;
-        this.logger.info(`Merging converted projects`);
-        if (projects.length !== packageDirs.length) {
-            this.logger.error("Failed to convert one or more packages, result will not be merged together.");
-            return;
+        /**
+         * Write the reflections to a json file.
+         *
+         * @param out The path and file name of the target file.
+         * @returns Whether the JSON file could be written successfully.
+         */
+        async generateJson(project, out) {
+            const start = Date.now();
+            out = Path.resolve(out);
+            const ser = this.serializer.projectToObject(project, process.cwd());
+            const space = this.options.getValue("pretty") ? "\t" : "";
+            await (0, index_2.writeFile)(out, JSON.stringify(ser, null, space));
+            this.logger.info(`JSON written to ${(0, paths_1.nicePath)(out)}`);
+            this.logger.verbose(`JSON rendering took ${Date.now() - start}ms`);
         }
-        const result = this.deserializer.reviveProjects(this.options.getValue("name") || "Documentation", projects);
-        this.trigger(application_events_1.ApplicationEvents.REVIVE, result);
-        return result;
-    }
-    _merge() {
-        const start = Date.now();
-        if (!this.options.isSet("entryPoints")) {
-            this.logger.error("No entry points provided to merge.");
-            return;
+        /**
+         * Print the version number.
+         */
+        toString() {
+            return [
+                "",
+                `TypeDoc ${Application.VERSION}`,
+                `Using TypeScript ${this.getTypeScriptVersion()} from ${this.getTypeScriptPath()}`,
+                "",
+            ].join("\n");
         }
-        const rootDir = (0, fs_1.deriveRootDir)(this.entryPoints);
-        const entryPoints = this.entryPoints.flatMap((entry) => {
-            const result = (0, fs_1.glob)(entry, rootDir);
-            if (result.length === 0) {
-                this.logger.warn(`The entrypoint glob ${(0, paths_1.nicePath)(entry)} did not match any files.`);
+        async _convertPackages() {
+            if (!this.options.isSet("entryPoints")) {
+                this.logger.error("No entry points provided to packages mode, documentation cannot be generated.");
+                return;
             }
-            else {
-                this.logger.verbose(`Expanded ${(0, paths_1.nicePath)(entry)} to:\n\t${result
-                    .map(paths_1.nicePath)
-                    .join("\n\t")}`);
+            const packageDirs = (0, entry_point_1.getPackageDirectories)(this.logger, this.options, this.options.getValue("entryPoints"));
+            if (packageDirs.length === 0) {
+                this.logger.error("Failed to find any packages, ensure you have provided at least one directory as an entry point containing package.json");
+                return;
             }
-            return result;
-        });
-        const jsonProjects = entryPoints.map((path) => {
-            try {
-                return JSON.parse((0, fs_1.readFile)(path));
+            const origOptions = this.options;
+            const projects = [];
+            // Generate a json file for each package
+            for (const dir of packageDirs) {
+                this.logger.info(`Converting project at ${(0, paths_1.nicePath)(dir)}`);
+                const opts = origOptions.copyForPackage(dir);
+                // Invalid links should only be reported after everything has been merged.
+                opts.setValue("validation", { invalidLink: false });
+                await opts.read(this.logger, dir);
+                if (opts.getValue("entryPointStrategy") ===
+                    entry_point_1.EntryPointStrategy.Packages) {
+                    this.logger.error(`Project at ${(0, paths_1.nicePath)(dir)} has entryPointStrategy set to packages, but nested packages are not supported.`);
+                    continue;
+                }
+                this.options = opts;
+                const project = await this.convert();
+                if (project) {
+                    this.validate(project);
+                    projects.push(this.serializer.projectToObject(project, process.cwd()));
+                }
+                (0, abstract_1.resetReflectionID)();
             }
-            catch {
-                this.logger.error(`Failed to parse file at ${(0, paths_1.nicePath)(path)} as json.`);
-                return null;
+            this.options = origOptions;
+            this.logger.info(`Merging converted projects`);
+            if (projects.length !== packageDirs.length) {
+                this.logger.error("Failed to convert one or more packages, result will not be merged together.");
+                return;
             }
-        });
-        if (this.logger.hasErrors())
-            return;
-        const result = this.deserializer.reviveProjects(this.options.getValue("name"), jsonProjects);
-        this.logger.verbose(`Reviving projects took ${Date.now() - start}ms`);
-        this.trigger(application_events_1.ApplicationEvents.REVIVE, result);
-        return result;
-    }
-};
-/**
- * The version number of TypeDoc.
- */
-Application.VERSION = packageInfo.version;
-/**
- * Emitted after plugins have been loaded and options have been read, but before they have been frozen.
- * The listener will be given an instance of {@link Application}.
- */
-Application.EVENT_BOOTSTRAP_END = application_events_1.ApplicationEvents.BOOTSTRAP_END;
-/**
- * Emitted after a project has been deserialized from JSON.
- * The listener will be given an instance of {@link ProjectReflection}.
- */
-Application.EVENT_PROJECT_REVIVE = application_events_1.ApplicationEvents.REVIVE;
-/**
- * Emitted when validation is being run.
- * The listener will be given an instance of {@link ProjectReflection}.
- */
-Application.EVENT_VALIDATE_PROJECT = application_events_1.ApplicationEvents.VALIDATE_PROJECT;
-__decorate([
-    (0, utils_1.BindOption)("skipErrorChecking")
-], Application.prototype, "skipErrorChecking", void 0);
-__decorate([
-    (0, utils_1.BindOption)("entryPointStrategy")
-], Application.prototype, "entryPointStrategy", void 0);
-__decorate([
-    (0, utils_1.BindOption)("entryPoints")
-], Application.prototype, "entryPoints", void 0);
-exports.Application = Application = Application_1 = __decorate([
-    (0, component_1.Component)({ name: "application", internal: true })
-], Application);
+            const result = this.deserializer.reviveProjects(this.options.getValue("name") || "Documentation", projects);
+            this.trigger(application_events_1.ApplicationEvents.REVIVE, result);
+            return result;
+        }
+        _merge() {
+            const start = Date.now();
+            if (!this.options.isSet("entryPoints")) {
+                this.logger.error("No entry points provided to merge.");
+                return;
+            }
+            const rootDir = (0, fs_1.deriveRootDir)(this.entryPoints);
+            const entryPoints = this.entryPoints.flatMap((entry) => {
+                const result = (0, fs_1.glob)(entry, rootDir);
+                if (result.length === 0) {
+                    this.logger.warn(`The entrypoint glob ${(0, paths_1.nicePath)(entry)} did not match any files.`);
+                }
+                else {
+                    this.logger.verbose(`Expanded ${(0, paths_1.nicePath)(entry)} to:\n\t${result
+                        .map(paths_1.nicePath)
+                        .join("\n\t")}`);
+                }
+                return result;
+            });
+            const jsonProjects = entryPoints.map((path) => {
+                try {
+                    return JSON.parse((0, fs_1.readFile)(path));
+                }
+                catch {
+                    this.logger.error(`Failed to parse file at ${(0, paths_1.nicePath)(path)} as json.`);
+                    return null;
+                }
+            });
+            if (this.logger.hasErrors())
+                return;
+            const result = this.deserializer.reviveProjects(this.options.getValue("name"), jsonProjects);
+            this.logger.verbose(`Reviving projects took ${Date.now() - start}ms`);
+            this.trigger(application_events_1.ApplicationEvents.REVIVE, result);
+            return result;
+        }
+    };
+    _Application_skipErrorChecking_accessor_storage = new WeakMap();
+    _Application_entryPointStrategy_accessor_storage = new WeakMap();
+    _Application_entryPoints_accessor_storage = new WeakMap();
+    __setFunctionName(_classThis, "Application");
+    (() => {
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+        _skipErrorChecking_decorators = [(0, utils_1.Option)("skipErrorChecking")];
+        _entryPointStrategy_decorators = [(0, utils_1.Option)("entryPointStrategy")];
+        _entryPoints_decorators = [(0, utils_1.Option)("entryPoints")];
+        __esDecorate(_classThis, null, _skipErrorChecking_decorators, { kind: "accessor", name: "skipErrorChecking", static: false, private: false, access: { has: obj => "skipErrorChecking" in obj, get: obj => obj.skipErrorChecking, set: (obj, value) => { obj.skipErrorChecking = value; } }, metadata: _metadata }, _skipErrorChecking_initializers, _instanceExtraInitializers);
+        __esDecorate(_classThis, null, _entryPointStrategy_decorators, { kind: "accessor", name: "entryPointStrategy", static: false, private: false, access: { has: obj => "entryPointStrategy" in obj, get: obj => obj.entryPointStrategy, set: (obj, value) => { obj.entryPointStrategy = value; } }, metadata: _metadata }, _entryPointStrategy_initializers, _instanceExtraInitializers);
+        __esDecorate(_classThis, null, _entryPoints_decorators, { kind: "accessor", name: "entryPoints", static: false, private: false, access: { has: obj => "entryPoints" in obj, get: obj => obj.entryPoints, set: (obj, value) => { obj.entryPoints = value; } }, metadata: _metadata }, _entryPoints_initializers, _instanceExtraInitializers);
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        Application = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+    })();
+    /**
+     * The version number of TypeDoc.
+     */
+    _classThis.VERSION = packageInfo.version;
+    /**
+     * Emitted after plugins have been loaded and options have been read, but before they have been frozen.
+     * The listener will be given an instance of {@link Application}.
+     */
+    _classThis.EVENT_BOOTSTRAP_END = application_events_1.ApplicationEvents.BOOTSTRAP_END;
+    /**
+     * Emitted after a project has been deserialized from JSON.
+     * The listener will be given an instance of {@link ProjectReflection}.
+     */
+    _classThis.EVENT_PROJECT_REVIVE = application_events_1.ApplicationEvents.REVIVE;
+    /**
+     * Emitted when validation is being run.
+     * The listener will be given an instance of {@link ProjectReflection}.
+     */
+    _classThis.EVENT_VALIDATE_PROJECT = application_events_1.ApplicationEvents.VALIDATE_PROJECT;
+    (() => {
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return Application = _classThis;
+})();
+exports.Application = Application;