typedoc 0.26.11 → 0.27.0-beta.0

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

@@ -1,9 +1,9 @@
 import type * as ts from "typescript";
-import type { NeverIfInternal } from "..";
-import type { Application } from "../../..";
-import type { Logger } from "../loggers";
-import { type DeclarationOption, type KeyToDeclaration, type TypeDocOptionMap, type TypeDocOptions, type TypeDocOptionValues } from "./declaration";
-import type { TranslationProxy } from "../../internationalization/internationalization";
+import type { NeverIfInternal } from "../index.js";
+import type { Application } from "../../../index.js";
+import type { Logger } from "../loggers.js";
+import { type DeclarationOption, type KeyToDeclaration, type TypeDocOptionMap, type TypeDocOptions, type TypeDocOptionValues } from "./declaration.js";
+import type { TranslationProxy } from "../../internationalization/internationalization.js";
 /**
  * Describes an option reader that discovers user configuration and converts it to the
  * TypeDoc format.
@@ -60,6 +60,9 @@ export interface OptionsReader {
  * 3. tsconfig-json (200) - Last config file reader, cannot specify the typedoc.json file to read.
  * 4. argv (300) - Read argv again since any options set there should override those set in config
  *    files.
+ *
+ * @group Common
+ * @summary Contains all of TypeDoc's option declarations & values
  */
 export declare class Options {
     private _readers;

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

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Options = void 0;
-exports.Option = Option;
-const declaration_1 = require("./declaration");
-const map_1 = require("../map");
-const array_1 = require("../array");
-const declaration_2 = require("./declaration");
-const sources_1 = require("./sources");
-const help_1 = require("./help");
+import { resolve } from "path";
+import { ParameterType } from "./declaration.js";
+import { insertOrderSorted, unique } from "../array.js";
+import { convert, getDefaultValue, } from "./declaration.js";
+import { addTypeDocOptions } from "./sources/index.js";
+import { getOptionsHelp } from "./help.js";
+import { getSimilarValues } from "../general.js";
 const optionSnapshots = new WeakMap();
 /**
  * Maintains a collection of option declarations split into TypeDoc options
@@ -28,18 +25,26 @@ const optionSnapshots = new WeakMap();
  * 3. tsconfig-json (200) - Last config file reader, cannot specify the typedoc.json file to read.
  * 4. argv (300) - Read argv again since any options set there should override those set in config
  *    files.
+ *
+ * @group Common
+ * @summary Contains all of TypeDoc's option declarations & values
  */
-class Options {
+export class Options {
+    _readers = [];
+    _declarations = new Map();
+    _values = {};
+    _setOptions = new Set();
+    _compilerOptions = {};
+    _fileNames = [];
+    _projectReferences = [];
+    _i18n;
+    /**
+     * In packages mode, the directory of the package being converted.
+     */
+    packageDir;
     constructor(i18n) {
-        this._readers = [];
-        this._declarations = new Map();
-        this._values = {};
-        this._setOptions = new Set();
-        this._compilerOptions = {};
-        this._fileNames = [];
-        this._projectReferences = [];
         this._i18n = i18n;
-        (0, sources_1.addTypeDocOptions)(this);
+        addTypeDocOptions(this);
     }
     /**
      * Clones the options, intended for use in packages mode.
@@ -94,12 +99,12 @@ class Options {
             if (!declaration) {
                 throw new Error(`Cannot reset an option (${name}) which has not been declared.`);
             }
-            this._values[declaration.name] = (0, declaration_2.getDefaultValue)(declaration);
+            this._values[declaration.name] = getDefaultValue(declaration);
             this._setOptions.delete(declaration.name);
         }
         else {
             for (const declaration of this.getDeclarations()) {
-                this._values[declaration.name] = (0, declaration_2.getDefaultValue)(declaration);
+                this._values[declaration.name] = getDefaultValue(declaration);
             }
             this._setOptions.clear();
             this._compilerOptions = {};
@@ -112,7 +117,7 @@ class Options {
      * @param reader
      */
     addReader(reader) {
-        (0, array_1.insertOrderSorted)(this._readers, reader);
+        insertOrderSorted(this._readers, reader);
     }
     async read(logger, cwd = process.cwd()) {
         for (const reader of this._readers) {
@@ -127,7 +132,7 @@ class Options {
         else {
             this._declarations.set(declaration.name, declaration);
         }
-        this._values[declaration.name] = (0, declaration_2.getDefaultValue)(declaration);
+        this._values[declaration.name] = getDefaultValue(declaration);
     }
     /**
      * Gets a declaration by one of its names.
@@ -140,7 +145,7 @@ class Options {
      * Gets all declared options.
      */
     getDeclarations() {
-        return (0, array_1.unique)(this._declarations.values());
+        return unique(this._declarations.values());
     }
     isSet(name) {
         if (!this._declarations.has(name)) {
@@ -172,12 +177,23 @@ class Options {
             throw new Error(this._i18n.unknown_option_0_you_may_have_meant_1(name, nearNames.join("\n\t")));
         }
         let oldValue = this._values[declaration.name];
-        if (typeof oldValue === "undefined")
-            oldValue = (0, declaration_2.getDefaultValue)(declaration);
-        const converted = (0, declaration_2.convert)(value, declaration, this._i18n, configPath ?? process.cwd(), oldValue);
-        if (declaration.type === declaration_1.ParameterType.Flags) {
+        if (typeof oldValue === "undefined") {
+            oldValue = getDefaultValue(declaration);
+        }
+        const converted = convert(value, declaration, this._i18n, configPath ?? process.cwd(), oldValue);
+        if (declaration.type === ParameterType.Flags) {
             this._values[declaration.name] = Object.assign({}, this._values[declaration.name], converted);
         }
+        else if (declaration.name === "outputs") {
+            // This is very unfortunate... there's probably some smarter way to define options
+            // so that this can be done intelligently via the convert function.
+            this._values[declaration.name] = converted.map((c) => {
+                return {
+                    ...c,
+                    path: resolve(configPath ?? process.cwd(), c.path),
+                };
+            });
+        }
         else {
             this._values[declaration.name] = converted;
         }
@@ -237,33 +253,21 @@ class Options {
      * Discover similar option names to the given name, for use in error reporting.
      */
     getSimilarOptions(missingName) {
-        const results = new map_1.DefaultMap(() => []);
-        let lowest = Infinity;
-        for (const name of this._declarations.keys()) {
-            const distance = editDistance(missingName, name);
-            lowest = Math.min(lowest, distance);
-            results.get(distance).push(name);
-        }
-        // Experimenting a bit, it seems an edit distance of 3 is roughly the
-        // right metric for relevant "similar" results without showing obviously wrong suggestions
-        return results
-            .get(lowest)
-            .concat(results.get(lowest + 1), results.get(lowest + 2));
+        return getSimilarValues(this._declarations.keys(), missingName);
     }
     /**
      * Get the help message to be displayed to the user if `--help` is passed.
      */
     getHelp(i18n) {
-        return (0, help_1.getOptionsHelp)(this, i18n);
+        return getOptionsHelp(this, i18n);
     }
 }
-exports.Options = Options;
 /**
  * Binds an option to an accessor. Does not register the option.
  *
  * Note: This is a standard ES decorator. It will not work with pre-TS 5.0 experimental decorators enabled.
  */
-function Option(name) {
+export function Option(name) {
     return (_, _context) => {
         return {
             get() {
@@ -276,31 +280,3 @@ function Option(name) {
         };
     };
 }
-// Based on https://en.wikipedia.org/wiki/Levenshtein_distance#Iterative_with_two_matrix_rows
-// Slightly modified for improved match results for options
-function editDistance(s, t) {
-    if (s.length < t.length)
-        return editDistance(t, s);
-    let v0 = Array.from({ length: t.length + 1 }, (_, i) => i);
-    let v1 = Array.from({ length: t.length + 1 }, () => 0);
-    for (let i = 0; i < s.length; i++) {
-        v1[0] = i + 1;
-        for (let j = 0; j < s.length; j++) {
-            const deletionCost = v0[j + 1] + 1;
-            const insertionCost = v1[j] + 1;
-            let substitutionCost;
-            if (s[i] === t[j]) {
-                substitutionCost = v0[j];
-            }
-            else if (s[i]?.toUpperCase() === t[j]?.toUpperCase()) {
-                substitutionCost = v0[j] + 1;
-            }
-            else {
-                substitutionCost = v0[j] + 3;
-            }
-            v1[j + 1] = Math.min(deletionCost, insertionCost, substitutionCost);
-        }
-        [v0, v1] = [v1, v0];
-    }
-    return v0[t.length];
-}

package/dist/lib/utils/options/readers/arguments.d.ts

@@ -1,5 +1,5 @@
-import type { OptionsReader, Options } from "..";
-import type { Logger } from "../../loggers";
+import type { OptionsReader, Options } from "../index.js";
+import type { Logger } from "../../loggers.js";
 /**
  * Obtains option values from command-line arguments
  */

package/dist/lib/utils/options/readers/arguments.js

@@ -1,21 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ArgumentsReader = void 0;
-const assert_1 = require("assert");
-const declaration_1 = require("../declaration");
+import { ok } from "assert";
+import { ParameterType } from "../declaration.js";
 const ARRAY_OPTION_TYPES = new Set([
-    declaration_1.ParameterType.Array,
-    declaration_1.ParameterType.PathArray,
-    declaration_1.ParameterType.ModuleArray,
-    declaration_1.ParameterType.GlobArray,
+    ParameterType.Array,
+    ParameterType.PathArray,
+    ParameterType.ModuleArray,
+    ParameterType.GlobArray,
 ]);
 /**
  * Obtains option values from command-line arguments
  */
-class ArgumentsReader {
+export class ArgumentsReader {
+    name = "arguments";
+    order;
+    supportsPackages = false;
+    args;
     constructor(priority, args = process.argv.slice(2)) {
-        this.name = "arguments";
-        this.supportsPackages = false;
         this.order = priority;
         this.args = args;
     }
@@ -29,7 +28,7 @@ class ArgumentsReader {
                 options.setValue(name, value);
             }
             catch (err) {
-                (0, assert_1.ok)(err instanceof Error);
+                ok(err instanceof Error);
                 logger.error(err.message);
             }
         };
@@ -46,8 +45,8 @@ class ArgumentsReader {
                 if (seen.has(decl.name) && ARRAY_OPTION_TYPES.has(decl.type)) {
                     trySet(decl.name, options.getValue(decl.name).concat(this.args[index]));
                 }
-                else if (decl.type === declaration_1.ParameterType.Boolean ||
-                    decl.type === declaration_1.ParameterType.Flags) {
+                else if (decl.type === ParameterType.Boolean ||
+                    decl.type === ParameterType.Flags) {
                     const value = String(this.args[index]).toLowerCase();
                     if (value === "true" || value === "false") {
                         trySet(decl.name, value === "true");
@@ -72,7 +71,7 @@ class ArgumentsReader {
             if (name.includes(".")) {
                 const actualName = name.split(".")[0].replace(/^--?/, "");
                 const decl = options.getDeclaration(actualName);
-                if (decl && decl.type === declaration_1.ParameterType.Flags) {
+                if (decl && decl.type === ParameterType.Flags) {
                     const flagName = name.split(".", 2)[1];
                     const value = String(this.args[index]).toLowerCase();
                     if (value === "true" || value === "false") {
@@ -92,4 +91,3 @@ class ArgumentsReader {
         }
     }
 }
-exports.ArgumentsReader = ArgumentsReader;

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

@@ -1,4 +1,4 @@
-export { ArgumentsReader } from "./arguments";
-export { PackageJsonReader } from "./package-json";
-export { TSConfigReader } from "./tsconfig";
-export { TypeDocReader } from "./typedoc";
+export { ArgumentsReader } from "./arguments.js";
+export { PackageJsonReader } from "./package-json.js";
+export { TSConfigReader } from "./tsconfig.js";
+export { TypeDocReader } from "./typedoc.js";

package/dist/lib/utils/options/readers/index.js

@@ -1,11 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeDocReader = exports.TSConfigReader = exports.PackageJsonReader = exports.ArgumentsReader = void 0;
-var arguments_1 = require("./arguments");
-Object.defineProperty(exports, "ArgumentsReader", { enumerable: true, get: function () { return arguments_1.ArgumentsReader; } });
-var package_json_1 = require("./package-json");
-Object.defineProperty(exports, "PackageJsonReader", { enumerable: true, get: function () { return package_json_1.PackageJsonReader; } });
-var tsconfig_1 = require("./tsconfig");
-Object.defineProperty(exports, "TSConfigReader", { enumerable: true, get: function () { return tsconfig_1.TSConfigReader; } });
-var typedoc_1 = require("./typedoc");
-Object.defineProperty(exports, "TypeDocReader", { enumerable: true, get: function () { return typedoc_1.TypeDocReader; } });
+export { ArgumentsReader } from "./arguments.js";
+export { PackageJsonReader } from "./package-json.js";
+export { TSConfigReader } from "./tsconfig.js";
+export { TypeDocReader } from "./typedoc.js";

package/dist/lib/utils/options/readers/package-json.d.ts

@@ -1,6 +1,6 @@
-import type { OptionsReader } from "..";
-import type { Logger } from "../../loggers";
-import type { Options } from "../options";
+import type { OptionsReader } from "../index.js";
+import type { Logger } from "../../loggers.js";
+import type { Options } from "../options.js";
 export declare class PackageJsonReader implements OptionsReader {
     order: number;
     supportsPackages: boolean;

package/dist/lib/utils/options/readers/package-json.js

@@ -1,26 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PackageJsonReader = void 0;
-const assert_1 = require("assert");
-const paths_1 = require("../../paths");
-const fs_1 = require("../../fs");
-const path_1 = require("path");
-class PackageJsonReader {
-    constructor() {
-        // Should run after the TypeDoc config reader but before the TS config
-        // reader, so that it can still specify a path to a `tsconfig.json` file.
-        this.order = 150;
-        this.supportsPackages = true;
-        this.name = "package-json";
-    }
+import { ok } from "assert";
+import { nicePath } from "../../paths.js";
+import { discoverPackageJson } from "../../fs.js";
+import { dirname } from "path";
+export class PackageJsonReader {
+    // Should run after the TypeDoc config reader but before the TS config
+    // reader, so that it can still specify a path to a `tsconfig.json` file.
+    order = 150;
+    supportsPackages = true;
+    name = "package-json";
     read(container, logger, cwd) {
-        const result = (0, fs_1.discoverPackageJson)(cwd);
+        const result = discoverPackageJson(cwd);
         if (!result) {
             return;
         }
         const { file, content } = result;
         if ("typedoc" in content) {
-            logger.warn(logger.i18n.typedoc_key_in_0_ignored((0, paths_1.nicePath)(file)));
+            logger.warn(logger.i18n.typedoc_key_in_0_ignored(nicePath(file)));
         }
         const optsKey = "typedocOptions";
         if (!(optsKey in content)) {
@@ -28,18 +23,17 @@ class PackageJsonReader {
         }
         const opts = content[optsKey];
         if (opts === null || typeof opts !== "object") {
-            logger.error(logger.i18n.typedoc_options_must_be_object_in_0((0, paths_1.nicePath)(file)));
+            logger.error(logger.i18n.typedoc_options_must_be_object_in_0(nicePath(file)));
             return;
         }
         for (const [opt, val] of Object.entries(opts)) {
             try {
-                container.setValue(opt, val, (0, path_1.dirname)(file));
+                container.setValue(opt, val, dirname(file));
             }
             catch (err) {
-                (0, assert_1.ok)(err instanceof Error);
+                ok(err instanceof Error);
                 logger.error(err.message);
             }
         }
     }
 }
-exports.PackageJsonReader = PackageJsonReader;

package/dist/lib/utils/options/readers/tsconfig.d.ts

@@ -1,5 +1,5 @@
-import type { Options, OptionsReader } from "../options";
-import type { Logger } from "../../loggers";
+import type { Options, OptionsReader } from "../options.js";
+import type { Logger } from "../../loggers.js";
 export declare class TSConfigReader implements OptionsReader {
     /**
      * Note: Runs after the {@link TypeDocReader}.

package/dist/lib/utils/options/readers/tsconfig.js

@@ -1,69 +1,61 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TSConfigReader = void 0;
-const path_1 = require("path");
-const typescript_1 = __importDefault(require("typescript"));
-const fs_1 = require("../../fs");
-const assert_1 = require("assert");
-const validation_1 = require("../../validation");
-const paths_1 = require("../../paths");
-const module_1 = require("module");
-const tsdoc_defaults_1 = require("../tsdoc-defaults");
-const array_1 = require("../../array");
-const tsconfig_1 = require("../../tsconfig");
+import { resolve, join, dirname } from "path";
+import ts from "typescript";
+import { isFile } from "../../fs.js";
+import { ok } from "assert";
+import { additionalProperties, isTagString, optional, validate, } from "../../validation.js";
+import { nicePath, normalizePath } from "../../paths.js";
+import { createRequire } from "module";
+import { tsdocBlockTags, tsdocInlineTags, tsdocModifierTags, } from "../tsdoc-defaults.js";
+import { unique } from "../../array.js";
+import { findTsConfigFile, getTypeDocOptionsFromTsConfig, readTsConfig, } from "../../tsconfig.js";
 function isSupportForTags(obj) {
-    return ((0, validation_1.validate)({}, obj) &&
+    return (validate({}, obj) &&
         Object.entries(obj).every(([key, val]) => {
             return (/^@[a-zA-Z][a-zA-Z0-9]*$/.test(key) && typeof val === "boolean");
         }));
 }
 const tsDocSchema = {
-    $schema: (0, validation_1.optional)(String),
-    extends: (0, validation_1.optional)([Array, String]),
-    noStandardTags: (0, validation_1.optional)(Boolean),
-    tagDefinitions: (0, validation_1.optional)([
+    $schema: optional(String),
+    extends: optional([Array, String]),
+    noStandardTags: optional(Boolean),
+    tagDefinitions: optional([
         Array,
         {
-            tagName: validation_1.isTagString,
+            tagName: isTagString,
             syntaxKind: ["inline", "block", "modifier"],
-            allowMultiple: (0, validation_1.optional)(Boolean),
-            [validation_1.additionalProperties]: false,
+            allowMultiple: optional(Boolean),
+            [additionalProperties]: false,
         },
     ]),
-    supportForTags: (0, validation_1.optional)(isSupportForTags),
+    supportForTags: optional(isSupportForTags),
     // The official parser has code to support for these two, but
     // the schema doesn't allow them... just silently ignore them for now.
-    supportedHtmlElements: (0, validation_1.optional)({}),
-    reportUnsupportedHtmlElements: (0, validation_1.optional)(Boolean),
-    [validation_1.additionalProperties]: false,
+    supportedHtmlElements: optional({}),
+    reportUnsupportedHtmlElements: optional(Boolean),
+    [additionalProperties]: false,
 };
-class TSConfigReader {
-    constructor() {
-        /**
-         * Note: Runs after the {@link TypeDocReader}.
-         */
-        this.order = 200;
-        this.name = "tsconfig-json";
-        this.supportsPackages = true;
-        this.seenTsdocPaths = new Set();
-    }
+export class TSConfigReader {
+    /**
+     * Note: Runs after the {@link TypeDocReader}.
+     */
+    order = 200;
+    name = "tsconfig-json";
+    supportsPackages = true;
+    seenTsdocPaths = new Set();
     read(container, logger, cwd) {
         const file = container.getValue("tsconfig") || cwd;
-        let fileToRead = (0, tsconfig_1.findTsConfigFile)(file);
+        let fileToRead = findTsConfigFile(file);
         if (!fileToRead) {
             // If the user didn't give us this option, we shouldn't complain about not being able to find it.
             if (container.isSet("tsconfig")) {
-                logger.error(logger.i18n.tsconfig_file_0_does_not_exist((0, paths_1.nicePath)(file)));
+                logger.error(logger.i18n.tsconfig_file_0_does_not_exist(nicePath(file)));
             }
             return;
         }
-        fileToRead = (0, paths_1.normalizePath)((0, path_1.resolve)(fileToRead));
-        logger.verbose(`Reading tsconfig at ${(0, paths_1.nicePath)(fileToRead)}`);
-        this.addTagsFromTsdocJson(container, logger, (0, path_1.resolve)(fileToRead));
-        const parsed = (0, tsconfig_1.readTsConfig)(fileToRead, logger);
+        fileToRead = normalizePath(resolve(fileToRead));
+        logger.verbose(`Reading tsconfig at ${nicePath(fileToRead)}`);
+        this.addTagsFromTsdocJson(container, logger, resolve(fileToRead));
+        const parsed = readTsConfig(fileToRead, logger);
         if (!parsed) {
             return;
         }
@@ -71,7 +63,7 @@ class TSConfigReader {
         if (parsed.errors.length) {
             return;
         }
-        const typedocOptions = (0, tsconfig_1.getTypeDocOptionsFromTsConfig)(fileToRead);
+        const typedocOptions = getTypeDocOptionsFromTsConfig(fileToRead);
         if (typedocOptions.options) {
             logger.error(logger.i18n.tsconfig_file_specifies_options_file());
             delete typedocOptions.options;
@@ -84,18 +76,18 @@ class TSConfigReader {
         for (const [key, val] of Object.entries(typedocOptions || {})) {
             try {
                 // We catch the error, so can ignore the strict type checks
-                container.setValue(key, val, (0, path_1.join)(fileToRead, ".."));
+                container.setValue(key, val, join(fileToRead, ".."));
             }
             catch (error) {
-                (0, assert_1.ok)(error instanceof Error);
+                ok(error instanceof Error);
                 logger.error(error.message);
             }
         }
     }
     addTagsFromTsdocJson(container, logger, tsconfig) {
         this.seenTsdocPaths.clear();
-        const tsdoc = (0, path_1.join)((0, path_1.dirname)(tsconfig), "tsdoc.json");
-        if (!(0, fs_1.isFile)(tsdoc)) {
+        const tsdoc = join(dirname(tsconfig), "tsdoc.json");
+        if (!isFile(tsdoc)) {
             return;
         }
         const overwritten = ["blockTags", "inlineTags", "modifierTags"].filter((opt) => container.isSet(opt));
@@ -114,9 +106,9 @@ class TSConfigReader {
         const inlineTags = [];
         const modifierTags = [];
         if (!config.noStandardTags) {
-            blockTags.push(...tsdoc_defaults_1.tsdocBlockTags);
-            inlineTags.push(...tsdoc_defaults_1.tsdocInlineTags);
-            modifierTags.push(...tsdoc_defaults_1.tsdocModifierTags);
+            blockTags.push(...tsdocBlockTags);
+            inlineTags.push(...tsdocInlineTags);
+            modifierTags.push(...tsdocModifierTags);
         }
         for (const { tagName, syntaxKind } of config.tagDefinitions?.filter(supported) || []) {
             const arr = {
@@ -126,35 +118,35 @@ class TSConfigReader {
             }[syntaxKind];
             arr.push(tagName);
         }
-        container.setValue("blockTags", (0, array_1.unique)(blockTags));
-        container.setValue("inlineTags", (0, array_1.unique)(inlineTags));
-        container.setValue("modifierTags", (0, array_1.unique)(modifierTags));
+        container.setValue("blockTags", unique(blockTags));
+        container.setValue("inlineTags", unique(inlineTags));
+        container.setValue("modifierTags", unique(modifierTags));
     }
     readTsDoc(logger, path) {
         if (this.seenTsdocPaths.has(path)) {
-            logger.error(logger.i18n.circular_reference_extends_0((0, paths_1.nicePath)(path)));
+            logger.error(logger.i18n.circular_reference_extends_0(nicePath(path)));
             return;
         }
         this.seenTsdocPaths.add(path);
-        const { config, error } = typescript_1.default.readConfigFile((0, paths_1.normalizePath)(path), typescript_1.default.sys.readFile);
+        const { config, error } = ts.readConfigFile(normalizePath(path), ts.sys.readFile);
         if (error) {
-            logger.error(logger.i18n.failed_read_tsdoc_json_0((0, paths_1.nicePath)(path)));
+            logger.error(logger.i18n.failed_read_tsdoc_json_0(nicePath(path)));
             return;
         }
-        if (!(0, validation_1.validate)(tsDocSchema, config)) {
-            logger.error(logger.i18n.invalid_tsdoc_json_0((0, paths_1.nicePath)(path)));
+        if (!validate(tsDocSchema, config)) {
+            logger.error(logger.i18n.invalid_tsdoc_json_0(nicePath(path)));
             return;
         }
         const workingConfig = {};
         if (config.extends) {
-            const resolver = (0, module_1.createRequire)(path);
+            const resolver = createRequire(path);
             for (const extendedPath of config.extends) {
                 let resolvedPath;
                 try {
                     resolvedPath = resolver.resolve(extendedPath);
                 }
                 catch {
-                    logger.error(logger.i18n.failed_resolve_0_to_file_in_1(extendedPath, (0, paths_1.nicePath)(path)));
+                    logger.error(logger.i18n.failed_resolve_0_to_file_in_1(extendedPath, nicePath(path)));
                     return;
                 }
                 const parentConfig = this.readTsDoc(logger, resolvedPath);
@@ -167,7 +159,6 @@ class TSConfigReader {
         return workingConfig;
     }
 }
-exports.TSConfigReader = TSConfigReader;
 function mergeConfigs(from, into) {
     if (from.supportForTags) {
         into.supportForTags ||= {};

package/dist/lib/utils/options/readers/typedoc.d.ts

@@ -1,6 +1,6 @@
-import type { OptionsReader } from "..";
-import type { Logger } from "../../loggers";
-import type { Options } from "../options";
+import type { OptionsReader } from "../options.js";
+import type { Logger } from "../../loggers.js";
+import type { Options } from "../options.js";
 /**
  * Obtains option values from typedoc.json
  *