typedoc 0.27.9 → 0.28.0-beta.1

package/dist/lib/utils/entry-point.js

@@ -2,9 +2,9 @@ import { join, relative, resolve } from "path";
 import ts from "typescript";
 import * as FS from "fs";
 import { expandPackages } from "./package-manifest.js";
-import { createMinimatch, matchesAny, nicePath, normalizePath, } from "./paths.js";
-import { deriveRootDir, discoverPackageJson, getCommonDirectory, glob, inferPackageEntryPointPaths, isDir, } from "./fs.js";
-import { assertNever } from "./general.js";
+import { deriveRootDir, getCommonDirectory, MinimatchSet, nicePath, normalizePath } from "./paths.js";
+import { discoverPackageJson, glob, inferPackageEntryPointPaths, isDir } from "./fs.js";
+import { assertNever, i18n } from "#utils";
 /**
  * Defines how entry points are interpreted.
  * @enum
@@ -33,7 +33,7 @@ export const EntryPointStrategy = {
 export function inferEntryPoints(logger, options) {
     const packageJson = discoverPackageJson(options.packageDir ?? process.cwd());
     if (!packageJson) {
-        logger.warn(logger.i18n.no_entry_points_provided());
+        logger.warn(i18n.no_entry_points_provided());
         return [];
     }
     const pathEntries = inferPackageEntryPointPaths(packageJson.file);
@@ -63,18 +63,18 @@ export function inferEntryPoints(logger, options) {
             });
         }
         else if (/\.[cm]?js$/.test(path)) {
-            logger.warn(logger.i18n.failed_to_resolve_0_to_ts_path(nicePath(path)));
+            logger.warn(i18n.failed_to_resolve_0_to_ts_path(nicePath(path)));
         }
     }
     if (entryPoints.length === 0) {
-        logger.warn(logger.i18n.no_entry_points_provided());
+        logger.warn(i18n.no_entry_points_provided());
         return [];
     }
     return entryPoints;
 }
 export function getEntryPoints(logger, options) {
     if (!options.isSet("entryPoints")) {
-        logger.warn(logger.i18n.no_entry_points_provided());
+        logger.warn(i18n.no_entry_points_provided());
         return [];
     }
     const entryPoints = options.getValue("entryPoints");
@@ -101,7 +101,7 @@ export function getEntryPoints(logger, options) {
             assertNever(strategy);
     }
     if (result.length === 0) {
-        logger.error(logger.i18n.unable_to_find_any_entry_points());
+        logger.error(i18n.unable_to_find_any_entry_points());
         return;
     }
     return result;
@@ -122,7 +122,7 @@ export function getDocumentEntryPoints(logger, options) {
     // that have at some point or another been used for markdown: https://superuser.com/a/285878
     const supportedFileRegex = /\.(md|markdown)$/;
     const expanded = expandInputFiles(logger, docPaths, options, supportedFileRegex);
-    const baseDir = options.getValue("basePath") || deriveRootDir(expanded);
+    const baseDir = options.getValue("basePath") || getCommonDirectory(expanded);
     return expanded.map((path) => {
         return {
             displayName: relative(baseDir, path).replace(/\.[^.]+$/, ""),
@@ -143,22 +143,22 @@ export function getWatchEntryPoints(logger, options, program) {
             result = getExpandedEntryPointsForPaths(logger, expandGlobs(entryPoints, exclude, logger), options, [program]);
             break;
         case EntryPointStrategy.Packages:
-            logger.error(logger.i18n.watch_does_not_support_packages_mode());
+            logger.error(i18n.watch_does_not_support_packages_mode());
             break;
         case EntryPointStrategy.Merge:
-            logger.error(logger.i18n.watch_does_not_support_merge_mode());
+            logger.error(i18n.watch_does_not_support_merge_mode());
             break;
         default:
             assertNever(strategy);
     }
     if (result && result.length === 0) {
-        logger.error(logger.i18n.unable_to_find_any_entry_points());
+        logger.error(i18n.unable_to_find_any_entry_points());
         return;
     }
     return result;
 }
 export function getPackageDirectories(logger, options, packageGlobPaths) {
-    const exclude = createMinimatch(options.getValue("exclude"));
+    const exclude = new MinimatchSet(options.getValue("exclude"));
     const rootDir = deriveRootDir(packageGlobPaths);
     // packages arguments are workspace tree roots, or glob patterns
     // This expands them to leave only leaf packages
@@ -172,7 +172,7 @@ function getModuleName(fileName, baseDir) {
  * This is in contrast with the package-oriented `getEntryPointsForPackages`
  */
 function getEntryPointsForPaths(logger, inputFiles, options, programs = getEntryPrograms(inputFiles, logger, options)) {
-    const baseDir = options.getValue("basePath") || deriveRootDir(inputFiles);
+    const baseDir = options.getValue("basePath") || getCommonDirectory(inputFiles);
     const entryPoints = [];
     let expandSuggestion = true;
     entryLoop: for (const fileOrDir of inputFiles.map(normalizePath)) {
@@ -193,10 +193,10 @@ function getEntryPointsForPaths(logger, inputFiles, options, programs = getEntry
                 }
             }
         }
-        logger.warn(logger.i18n.entry_point_0_not_in_program(nicePath(fileOrDir)));
+        logger.warn(i18n.entry_point_0_not_in_program(nicePath(fileOrDir)));
         if (expandSuggestion && isDir(fileOrDir)) {
             expandSuggestion = false;
-            logger.info(logger.i18n.use_expand_or_glob_for_files_in_dir());
+            logger.info(i18n.use_expand_or_glob_for_files_in_dir());
         }
     }
     return entryPoints;
@@ -208,20 +208,23 @@ export function getExpandedEntryPointsForPaths(logger, inputFiles, options, prog
         : /\.([cm]ts|tsx?)$/;
     return getEntryPointsForPaths(logger, expandInputFiles(logger, inputFiles, options, supportedFileRegex), options, programs);
 }
-function expandGlobs(inputFiles, exclude, logger) {
-    const excludePatterns = createMinimatch(exclude);
-    const base = deriveRootDir(inputFiles);
-    const result = inputFiles.flatMap((entry) => {
+function expandGlobs(globs, exclude, logger) {
+    const excludePatterns = new MinimatchSet(exclude);
+    const base = deriveRootDir(globs);
+    const result = globs.flatMap((entry) => {
         const result = glob(entry, base, {
             includeDirectories: true,
             followSymlinks: true,
         });
-        const filtered = result.filter((file) => file === entry || !matchesAny(excludePatterns, file));
+        const filtered = result.filter((file) => file === entry || !excludePatterns.matchesAny(file));
         if (result.length === 0) {
-            logger.warn(logger.i18n.glob_0_did_not_match_any_files(nicePath(entry)));
+            logger.warn(i18n.glob_0_did_not_match_any_files(nicePath(entry)));
+            if (entry.includes("\\") && !entry.includes("/")) {
+                logger.info(i18n.glob_should_use_posix_slash());
+            }
         }
         else if (filtered.length === 0) {
-            logger.warn(logger.i18n.entry_point_0_did_not_match_any_files_after_exclude(nicePath(entry)));
+            logger.warn(i18n.entry_point_0_did_not_match_any_files_after_exclude(nicePath(entry)));
         }
         else if (filtered.length !== 1) {
             logger.verbose(`Expanded ${nicePath(entry)} to:\n\t${filtered
@@ -275,7 +278,7 @@ function getEntryPrograms(inputFiles, logger, options) {
  */
 function expandInputFiles(logger, entryPoints, options, supportedFile) {
     const files = [];
-    const exclude = createMinimatch(options.getValue("exclude"));
+    const exclude = new MinimatchSet(options.getValue("exclude"));
     function add(file, entryPoint) {
         let stats;
         try {
@@ -295,7 +298,7 @@ function expandInputFiles(logger, entryPoints, options, supportedFile) {
             });
         }
         else if (supportedFile.test(file)) {
-            if (!entryPoint && matchesAny(exclude, file)) {
+            if (!entryPoint && exclude.matchesAny(file)) {
                 return;
             }
             files.push(normalizePath(file));
@@ -304,7 +307,7 @@ function expandInputFiles(logger, entryPoints, options, supportedFile) {
     entryPoints.forEach((file) => {
         const resolved = resolve(file);
         if (!FS.existsSync(resolved)) {
-            logger.warn(logger.i18n.entry_point_0_did_not_exist(file));
+            logger.warn(i18n.entry_point_0_did_not_exist(file));
             return;
         }
         add(resolved, true);

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

@@ -1,10 +1,6 @@
+import { type GlobString, type NormalizedPath } from "#utils";
 export declare function isFile(file: string): boolean;
 export declare function isDir(path: string): boolean;
-export declare function deriveRootDir(globPaths: string[]): string;
-/**
- * Get the longest directory path common to all files.
- */
-export declare function getCommonDirectory(files: readonly string[]): string;
 /**
  * Load the given file and return its contents.
  *
@@ -43,20 +39,16 @@ export interface DiscoverFilesController {
     /** Defaults to false */
     followSymlinks?: boolean;
 }
-export declare function discoverFiles(rootDir: string, controller: DiscoverFilesController): string[];
+export declare function discoverFiles(rootDir: NormalizedPath, controller: DiscoverFilesController): NormalizedPath[];
 /**
  * Simpler version of `glob.sync` that only covers our use cases, always ignoring node_modules.
  */
-export declare function glob(pattern: string, root: string, options?: {
+export declare function glob(pattern: GlobString, root: NormalizedPath, options?: {
     includeDirectories?: boolean;
     followSymlinks?: boolean;
-}): string[];
+}): NormalizedPath[];
 export declare function hasTsExtension(path: string): boolean;
 export declare function hasDeclarationFileExtension(path: string): boolean;
-export declare function discoverInParentDir<T extends {}>(name: string, dir: string, read: (content: string) => T | undefined): {
-    file: string;
-    content: T;
-} | undefined;
 export declare function discoverInParentDirExactMatch<T extends {}>(name: string, dir: string, read: (content: string) => T | undefined, usedFile?: (path: string) => void): {
     file: string;
     content: T;
@@ -69,5 +61,5 @@ export declare function discoverPackageJson(dir: string, usedFile?: (path: strin
         name: string;
     };
 } | undefined;
-export declare function findPackageForPath(sourcePath: string): string | undefined;
+export declare function findPackageForPath(sourcePath: string): readonly [packageName: string, packageDir: string] | undefined;
 export declare function inferPackageEntryPointPaths(packagePath: string): [importPath: string, resolvedPath: string][];

package/dist/lib/utils/fs.js

@@ -2,10 +2,8 @@ import * as fs from "fs";
 import { promises as fsp } from "fs";
 import { Minimatch } from "minimatch";
 import { dirname, join, relative, resolve } from "path";
-import { optional, validate } from "./validation.js";
-import { createMinimatch, normalizePath } from "./paths.js";
-import { filterMap } from "./array.js";
-import { escapeRegExp } from "./general.js";
+import { escapeRegExp, Validation } from "#utils";
+import { normalizePath } from "./paths.js";
 import { ok } from "assert";
 export function isFile(file) {
     try {
@@ -23,39 +21,6 @@ export function isDir(path) {
         return false;
     }
 }
-export function deriveRootDir(globPaths) {
-    const normalized = globPaths.map(normalizePath);
-    const globs = createMinimatch(normalized);
-    const rootPaths = globs.flatMap((glob, i) => filterMap(glob.set, (set) => {
-        const stop = set.findIndex((part) => typeof part !== "string");
-        if (stop === -1) {
-            return normalized[i];
-        }
-        else {
-            const kept = set.slice(0, stop).join("/");
-            return normalized[i].substring(0, normalized[i].indexOf(kept) + kept.length);
-        }
-    }));
-    return getCommonDirectory(rootPaths);
-}
-/**
- * Get the longest directory path common to all files.
- */
-export function getCommonDirectory(files) {
-    if (!files.length) {
-        return "";
-    }
-    const roots = files.map((f) => f.split(/\\|\//));
-    if (roots.length === 1) {
-        return roots[0].slice(0, -1).join("/");
-    }
-    let i = 0;
-    while (i < roots[0].length &&
-        new Set(roots.map((part) => part[i])).size === 1) {
-        i++;
-    }
-    return roots[0].slice(0, i).join("/");
-}
 /**
  * Load the given file and return its contents.
  *
@@ -171,8 +136,7 @@ export function discoverFiles(rootDir, controller) {
         const childPath = [...dir, path].join("/");
         let realpath;
         try {
-            realpath =
-                realpathCache.get(childPath) ?? fs.realpathSync(childPath);
+            realpath = realpathCache.get(childPath) ?? fs.realpathSync(childPath);
             realpathCache.set(childPath, realpath);
         }
         catch {
@@ -229,7 +193,7 @@ export function discoverFiles(rootDir, controller) {
  * Simpler version of `glob.sync` that only covers our use cases, always ignoring node_modules.
  */
 export function glob(pattern, root, options = {}) {
-    const mini = new Minimatch(normalizePath(pattern));
+    const mini = new Minimatch(pattern);
     const shouldIncludeNodeModules = pattern.includes("node_modules");
     const controller = {
         matches(path) {
@@ -257,27 +221,6 @@ export function hasTsExtension(path) {
 export function hasDeclarationFileExtension(path) {
     return /\.d\.[cm]?ts$/.test(path);
 }
-export function discoverInParentDir(name, dir, read) {
-    if (!isDir(dir))
-        return;
-    const reachedTopDirectory = (dirName) => dirName === resolve(join(dirName, ".."));
-    while (!reachedTopDirectory(dir)) {
-        for (const file of fs.readdirSync(dir)) {
-            if (file.toLowerCase() !== name.toLowerCase())
-                continue;
-            try {
-                const content = read(readFile(join(dir, file)));
-                if (content != null) {
-                    return { file: join(dir, file), content };
-                }
-            }
-            catch {
-                // Ignore, file didn't pass validation
-            }
-        }
-        dir = resolve(join(dir, ".."));
-    }
-}
 export function discoverInParentDirExactMatch(name, dir, read, usedFile) {
     if (!isDir(dir))
         return;
@@ -299,12 +242,12 @@ export function discoverInParentDirExactMatch(name, dir, read, usedFile) {
 export function discoverPackageJson(dir, usedFile) {
     return discoverInParentDirExactMatch("package.json", dir, (content) => {
         const pkg = JSON.parse(content);
-        if (validate({ name: String, version: optional(String) }, pkg)) {
+        if (Validation.validate({ name: String, version: Validation.optional(String) }, pkg)) {
             return pkg;
         }
     }, usedFile);
 }
-// dir -> package name according to package.json in this or some parent dir
+// dir -> package info
 const packageCache = new Map();
 export function findPackageForPath(sourcePath) {
     // Attempt to decide package name from path if it contains "node_modules"
@@ -316,7 +259,8 @@ export function findPackageForPath(sourcePath) {
         if (sourcePath[startIndex] === "@") {
             stopIndex = sourcePath.indexOf("/", stopIndex + 1);
         }
-        return sourcePath.substring(startIndex, stopIndex);
+        const packageName = sourcePath.substring(startIndex, stopIndex);
+        return [packageName, sourcePath.substring(0, stopIndex)];
     }
     const dir = dirname(sourcePath);
     const cache = packageCache.get(dir);
@@ -325,12 +269,12 @@ export function findPackageForPath(sourcePath) {
     }
     const packageJson = discoverPackageJson(dir);
     if (packageJson) {
-        packageCache.set(dir, packageJson.content.name);
-        return packageJson.content.name;
+        packageCache.set(dir, [packageJson.content.name, dirname(packageJson.file)]);
+        return [packageJson.content.name, dirname(packageJson.file)];
     }
 }
 export function inferPackageEntryPointPaths(packagePath) {
-    const packageDir = dirname(packagePath);
+    const packageDir = normalizePath(dirname(packagePath));
     const packageJson = JSON.parse(readFile(packagePath));
     const exports = packageJson.exports;
     if (typeof exports === "string") {

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

@@ -1,50 +1,4 @@
-/**
- * This type provides a flag that can be used to turn off more lax overloads intended for
- * plugin use only to catch type errors in the TypeDoc codebase. The prepublishOnly npm
- * script will be used to switch this flag to false when publishing, then immediately back
- * to true after a successful publish.
- */
-type InternalOnly = false;
-/**
- * Helper type to convert `T` to `F` if compiling TypeDoc with stricter types.
- *
- * Can be used in overloads to map a parameter type to `never`. For example, the
- * following function will work with any string argument, but to improve the type safety
- * of internal code, we only ever want to pass 'a' or 'b' to it. Plugins on the other
- * hand need to be able to pass any string to it. Overloads similar to this are used
- * in the {@link Options} class.
- *
- * This is also used to prevent TypeDoc code from using deprecated methods which will
- * be removed in a future release.
- *
- * ```ts
- * function over(flag: 'a' | 'b'): string
- * // deprecated
- * function over(flag: IfInternal<never, string>): string
- * function over(flag: string): string { return flag }
- * ```
- */
-export type IfInternal<T, F> = InternalOnly extends true ? T : F;
-/**
- * Helper type to convert `T` to `never` if compiling TypeDoc with stricter types.
- *
- * See {@link IfInternal} for the rationale.
- */
-export type NeverIfInternal<T> = IfInternal<never, T>;
-/**
- * Resolves a string type into a union of characters, `"ab"` turns into `"a" | "b"`.
- */
-export type Chars<T extends string> = T extends `${infer C}${infer R}` ? C | Chars<R> : never;
-/**
- * Utility to help type checking ensure that there is no uncovered case.
- */
-export declare function assertNever(x: never): never;
-export declare function escapeRegExp(s: string): string;
-export declare function editDistance(s: string, t: string): number;
-export declare function dedent(text: string): string;
-export declare function getSimilarValues(values: Iterable<string>, compareTo: string): string[];
-export declare function NonEnumerable(_cls: unknown, context: ClassFieldDecoratorContext): void;
 export declare const TYPEDOC_ROOT: string;
 export declare function hasBeenLoadedMultipleTimes(): boolean;
 export declare function getLoadedPaths(): string[];
-export {};
+export declare function isDebugging(): boolean;

package/dist/lib/utils/general.js

@@ -1,79 +1,6 @@
 import { dirname } from "path";
-import * as Util from "util";
 import url from "url";
-import { DefaultMap } from "./map.js";
-/**
- * Utility to help type checking ensure that there is no uncovered case.
- */
-export function assertNever(x) {
-    throw new Error(`Expected handling to cover all possible cases, but it didn't cover: ${Util.inspect(x)}`);
-}
-// From MDN
-export function escapeRegExp(s) {
-    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); // $& means the whole matched string
-}
-// Based on https://en.wikipedia.org/wiki/Levenshtein_distance#Iterative_with_two_matrix_rows
-// Slightly modified for improved match results for options
-export 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];
-}
-export function dedent(text) {
-    const lines = text.split(/\r?\n/);
-    while (lines.length && lines[0].search(/\S/) === -1) {
-        lines.shift();
-    }
-    while (lines.length && lines[lines.length - 1].search(/\S/) === -1) {
-        lines.pop();
-    }
-    const minIndent = lines.reduce((indent, line) => line.length ? Math.min(indent, line.search(/\S/)) : indent, Infinity);
-    return lines.map((line) => line.substring(minIndent)).join("\n");
-}
-export function getSimilarValues(values, compareTo) {
-    const results = new DefaultMap(() => []);
-    let lowest = Infinity;
-    for (const name of values) {
-        const distance = editDistance(compareTo, 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));
-}
-export function NonEnumerable(_cls, context) {
-    context.addInitializer(function () {
-        Object.defineProperty(this, context.name, {
-            enumerable: false,
-            configurable: true,
-            writable: true,
-        });
-    });
-}
+import { url as debuggerUrl } from "inspector";
 // transform /abs/path/to/typedoc/dist/lib/utils/general -> /abs/path/to/typedoc
 export const TYPEDOC_ROOT = dirname(dirname(dirname(dirname(url.fileURLToPath(import.meta.url)))));
 /**
@@ -93,3 +20,6 @@ export function hasBeenLoadedMultipleTimes() {
 export function getLoadedPaths() {
     return g[pathSymbol] || [];
 }
+export function isDebugging() {
+    return !!debuggerUrl();
+}

package/dist/lib/utils/highlighter.js

@@ -1,6 +1,5 @@
 import * as shiki from "@gerrit0/mini-shiki";
-import * as JSX from "./jsx.js";
-import { unique } from "./array.js";
+import { JSX, unique } from "#utils";
 import assert from "assert";
 const aliases = new Map();
 for (const lang of shiki.bundledLanguagesInfo) {

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

@@ -1,4 +1,3 @@
-export declare function escapeHtml(html: string): string;
 /**
  * Replaces non-[URL code points](https://url.spec.whatwg.org/#url-code-points)
  * with an underscore. Also disallows some additional special characters which either

package/dist/lib/utils/html.js

@@ -1,4 +1,4 @@
-import { assertNever } from "./general.js";
+import { assertNever } from "#utils";
 import { htmlEntities } from "./html-entities.js";
 const htmlEntitiesTrie = {};
 for (const [name, data] of Object.entries(htmlEntities)) {
@@ -9,16 +9,6 @@ for (const [name, data] of Object.entries(htmlEntities)) {
     }
     current.data = data;
 }
-const htmlEscapes = {
-    "&": "&",
-    "<": "&lt;",
-    ">": "&gt;",
-    '"': "&quot;",
-    "'": "&#39;",
-};
-export function escapeHtml(html) {
-    return html.replace(/[&<>'"]/g, (c) => htmlEscapes[c]);
-}
 /**
  * Replaces non-[URL code points](https://url.spec.whatwg.org/#url-code-points)
  * with an underscore. Also disallows some additional special characters which either
@@ -27,6 +17,8 @@ export function escapeHtml(html) {
  * Ref: #2714
  */
 export function createNormalizedUrl(url) {
+    // We are intentionally operating on code points here.
+    // eslint-disable-next-line @typescript-eslint/no-misused-spread
     const codePoints = [...url].map((c) => c.codePointAt(0));
     for (let i = 0; i < codePoints.length; ++i) {
         if (isalnum(codePoints[i]))
@@ -591,8 +583,7 @@ export class HtmlAttributeParser {
         // If the number is a noncharacter, then this is a noncharacter-character-reference parse error.
         // ... and do nothing, so don't bother checking.
         // Handle replacements
-        this.characterReferenceCode =
-            characterReferenceCodePointReplacements.get(this.characterReferenceCode) ?? this.characterReferenceCode;
+        this.characterReferenceCode = characterReferenceCodePointReplacements.get(this.characterReferenceCode) ?? this.characterReferenceCode;
         this.temporaryBuffer = [this.characterReferenceCode];
         this.flushTemporaryBuffer();
     }

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

@@ -1,23 +1,15 @@
-export { filterMap, insertPrioritySorted, partition, removeIf, removeIfPresent, unique, } from "./array.js";
 export { AbstractComponent } from "./component.js";
-export * from "./enum.js";
-export { EventDispatcher } from "./events.js";
-export { isFile, copy, copySync, getCommonDirectory, readFile, writeFile, writeFileSync, discoverInParentDir, discoverPackageJson, } from "./fs.js";
-export { normalizePath } from "./paths.js";
-export type { IfInternal, NeverIfInternal, Chars } from "./general.js";
-export { assertNever, TYPEDOC_ROOT } from "./general.js";
-export { ConsoleLogger, Logger, LogLevel } from "./loggers.js";
-export { DefaultMap } from "./map.js";
-export { ArgumentsReader, Option, CommentStyle, Options, PackageJsonReader, ParameterHint, ParameterType, TSConfigReader, TypeDocReader, OptionDefaults, } from "./options/index.js";
-export type { ArrayDeclarationOption, BooleanDeclarationOption, DeclarationOption, DeclarationOptionBase, DeclarationOptionToOptionType, KeyToDeclaration, MapDeclarationOption, MixedDeclarationOption, NumberDeclarationOption, FlagsDeclarationOption, ObjectDeclarationOption, OptionsReader, StringDeclarationOption, TypeDocOptionMap, TypeDocOptions, ValidationOptions, TypeDocOptionValues, ParameterTypeToOptionTypeMap, ManuallyValidatedOption, JsDocCompatibility, OutputSpecification, } from "./options/index.js";
+export * from "./fs.js";
+export { getLoadedPaths, hasBeenLoadedMultipleTimes, TYPEDOC_ROOT } from "./general.js";
+export { FancyConsoleLogger } from "./loggers.js";
+export { ArgumentsReader, CommentStyle, Option, OptionDefaults, Options, PackageJsonReader, ParameterHint, ParameterType, TSConfigReader, TypeDocReader, } from "./options/index.js";
+export type { ArrayDeclarationOption, BooleanDeclarationOption, DeclarationOption, DeclarationOptionBase, DeclarationOptionToOptionType, FlagsDeclarationOption, JsDocCompatibility, KeyToDeclaration, ManuallyValidatedOption, MapDeclarationOption, MixedDeclarationOption, NumberDeclarationOption, ObjectDeclarationOption, OptionsReader, OutputSpecification, ParameterTypeToOptionTypeMap, StringDeclarationOption, TypeDocOptionMap, TypeDocOptions, TypeDocOptionValues, ValidationOptions, } from "./options/index.js";
+export * from "./paths.js";
 export { loadPlugins } from "./plugins.js";
 export { getSortFunction } from "./sort.js";
 export type { SortStrategy } from "./sort.js";
-export { EventHooks } from "./hooks.js";
 export * from "./entry-point.js";
-import * as JSX from "./jsx.js";
-export { JSX };
-export { Fragment, Raw, renderElement } from "./jsx.js";
-export * as Validation from "./validation.js";
+export * from "./html.js";
+export * from "./tsconfig.js";
 export * from "./tsutils.js";
-export { MinimalSourceFile } from "./minimalSourceFile.js";
+export * from "./ValidatingFileRegistry.js";

package/dist/lib/utils/index.js

@@ -1,20 +1,13 @@
-export { filterMap, insertPrioritySorted, partition, removeIf, removeIfPresent, unique, } from "./array.js";
 export { AbstractComponent } from "./component.js";
-export * from "./enum.js";
-export { EventDispatcher } from "./events.js";
-export { isFile, copy, copySync, getCommonDirectory, readFile, writeFile, writeFileSync, discoverInParentDir, discoverPackageJson, } from "./fs.js";
-export { normalizePath } from "./paths.js";
-export { assertNever, TYPEDOC_ROOT } from "./general.js";
-export { ConsoleLogger, Logger, LogLevel } from "./loggers.js";
-export { DefaultMap } from "./map.js";
-export { ArgumentsReader, Option, CommentStyle, Options, PackageJsonReader, ParameterHint, ParameterType, TSConfigReader, TypeDocReader, OptionDefaults, } from "./options/index.js";
+export * from "./fs.js";
+export { getLoadedPaths, hasBeenLoadedMultipleTimes, TYPEDOC_ROOT } from "./general.js";
+export { FancyConsoleLogger } from "./loggers.js";
+export { ArgumentsReader, CommentStyle, Option, OptionDefaults, Options, PackageJsonReader, ParameterHint, ParameterType, TSConfigReader, TypeDocReader, } from "./options/index.js";
+export * from "./paths.js";
 export { loadPlugins } from "./plugins.js";
 export { getSortFunction } from "./sort.js";
-export { EventHooks } from "./hooks.js";
 export * from "./entry-point.js";
-import * as JSX from "./jsx.js";
-export { JSX };
-export { Fragment, Raw, renderElement } from "./jsx.js";
-export * as Validation from "./validation.js";
+export * from "./html.js";
+export * from "./tsconfig.js";
 export * from "./tsutils.js";
-export { MinimalSourceFile } from "./minimalSourceFile.js";
+export * from "./ValidatingFileRegistry.js";