typedoc 0.28.2 → 0.28.3

package/dist/lib/cli.js

@@ -20,7 +20,7 @@ async function main() {
             new td.TypeDocReader(),
             new td.PackageJsonReader(),
             new td.TSConfigReader(),
-            new td.ArgumentsReader(300),
+            new td.ArgumentsReader(300).ignoreErrors(),
         ]);
         const exitCode = await run(app);
         if (exitCode !== ExitCodes.Watching) {

package/dist/lib/converter/context.js

@@ -145,7 +145,7 @@ export class Context {
             reflection.escapedName = symbol?.escapedName ? String(symbol.escapedName) : undefined;
             this.addChild(reflection);
         }
-        if (symbol && this.converter.isExternal(symbol)) {
+        if (symbol && this.converter.isExternal(symbol, this.checker)) {
             reflection.setFlag(ReflectionFlag.External);
         }
         if (exportSymbol) {
@@ -188,7 +188,7 @@ export class Context {
         }
     }
     shouldIgnore(symbol) {
-        return this.converter.shouldIgnore(symbol);
+        return this.converter.shouldIgnore(symbol, this.checker);
     }
     /**
      * Register a newly generated reflection. All created reflections should be

package/dist/lib/converter/converter.d.ts

@@ -226,10 +226,10 @@ export declare class Converter extends AbstractComponent<Application, ConverterE
      * information at this point since comment discovery hasn't happened.
      * @internal
      */
-    shouldIgnore(symbol: ts.Symbol): boolean;
+    shouldIgnore(symbol: ts.Symbol, checker: ts.TypeChecker): boolean;
     private isExcluded;
     /** @internal */
-    isExternal(symbol: ts.Symbol): boolean;
+    isExternal(symbol: ts.Symbol, checker: ts.TypeChecker): boolean;
     processDocumentTags(reflection: Reflection, parent: ContainerReflection): void;
     private addDocument;
     private _buildCommentParserConfig;

package/dist/lib/converter/converter.js

@@ -59,6 +59,7 @@ import { SourcePlugin } from "./plugins/SourcePlugin.js";
 import { TypePlugin } from "./plugins/TypePlugin.js";
 import { IncludePlugin } from "./plugins/IncludePlugin.js";
 import { MergeModuleWithPlugin } from "./plugins/MergeModuleWithPlugin.js";
+import { resolveAliasedSymbol } from "./utils/symbols.js";
 /**
  * Compiles source files using TypeScript and converts compiler symbols to reflections.
  *
@@ -310,7 +311,12 @@ let Converter = (() => {
             this.compile(entryPoints, context);
             this.resolve(context);
             this.trigger(Converter.EVENT_END, context);
-            this._config = undefined;
+            // Delete caches of options so that test usage which changes options
+            // doesn't have confusing behavior where tests run in isolation work
+            // but break when run as a batch.
+            delete this._config;
+            delete this.excludeCache;
+            delete this.externalPatternCache;
             return project;
         }
         /** @internal */
@@ -487,11 +493,12 @@ let Converter = (() => {
          * information at this point since comment discovery hasn't happened.
          * @internal
          */
-        shouldIgnore(symbol) {
+        shouldIgnore(symbol, checker) {
+            symbol = resolveAliasedSymbol(symbol, checker);
             if (this.isExcluded(symbol)) {
                 return true;
             }
-            return this.excludeExternals && this.isExternal(symbol);
+            return this.excludeExternals && this.isExternal(symbol, checker);
         }
         isExcluded(symbol) {
             this.excludeCache ??= new MinimatchSet(this.application.options.getValue("exclude"));
@@ -499,10 +506,10 @@ let Converter = (() => {
             return (symbol.getDeclarations() ?? []).some((node) => cache.matchesAny(node.getSourceFile().fileName));
         }
         /** @internal */
-        isExternal(symbol) {
+        isExternal(symbol, checker) {
             this.externalPatternCache ??= new MinimatchSet(this.externalPattern);
             const cache = this.externalPatternCache;
-            const declarations = symbol.getDeclarations();
+            const declarations = resolveAliasedSymbol(symbol, checker).getDeclarations();
             // `undefined` has no declarations, if someone does `export default undefined`
             // the symbol ends up as having no declarations (the export symbol does, but
             // not the source symbol)

package/dist/lib/converter/plugins/IncludePlugin.js

@@ -246,3 +246,5 @@ regionTagREsByExt["php"] = regionTagREsByExt["cs"];
 regionTagREsByExt["ps1"] = regionTagREsByExt["cs"];
 regionTagREsByExt["py"] = regionTagREsByExt["cs"];
 regionTagREsByExt["js"] = regionTagREsByExt["ts"];
+regionTagREsByExt["mts"] = regionTagREsByExt["ts"];
+regionTagREsByExt["cts"] = regionTagREsByExt["ts"];

package/dist/lib/converter/symbols.js

@@ -8,6 +8,7 @@ import { convertTypeParameters, createConstructSignatureWithType, createSignatur
 import { convertJsDocAlias, convertJsDocCallback } from "./jsdoc.js";
 import { getHeritageTypes } from "./utils/nodes.js";
 import { removeUndefined } from "./utils/reflections.js";
+import { resolveAliasedSymbol } from "./utils/symbols.js";
 const symbolConverters = {
     [ts.SymbolFlags.RegularEnum]: convertEnum,
     [ts.SymbolFlags.ConstEnum]: convertEnum,
@@ -61,7 +62,7 @@ for (const key of Object.keys(symbolConverters)) {
 }
 assert(conversionOrder.reduce((a, b) => a | b, 0) === allConverterFlags, "conversionOrder contains a symbol flag that converters do not.");
 function _convertSymbolNow(context, symbol, exportSymbol) {
-    if (context.shouldIgnore(symbol)) {
+    if (context.shouldIgnore(resolveAliasedSymbol(symbol, context.checker))) {
         return;
     }
     // This check can catch symbols which ought to be documented as references

package/dist/lib/converter/types.js

@@ -795,5 +795,11 @@ function convertTypeInlined(context, type) {
         const elementType = convertType(context, context.checker.getTypeArguments(type)[0]);
         return new ArrayType(elementType);
     }
+    if (isTypeReference(type) && context.checker.isTupleType(type)) {
+        const tupleNode = context.checker.typeToTypeNode(type.target, void 0, ts.NodeBuilderFlags.IgnoreErrors);
+        if (ts.isTupleTypeNode(tupleNode)) {
+            return tupleConverter.convertType(context, type, tupleNode);
+        }
+    }
     return typeLiteralConverter.convertType(context, type);
 }

package/dist/lib/internationalization/locales/en.cjs

@@ -118,7 +118,6 @@ module.exports = {
     failed_to_resolve_0_to_ts_path: `Failed to resolve entry point path {0} from package.json to a TypeScript source file`,
     use_expand_or_glob_for_files_in_dir: `If you wanted to include files inside this directory, set --entryPointStrategy to expand or specify a glob`,
     glob_0_did_not_match_any_files: `The glob {0} did not match any files`,
-    glob_should_use_posix_slash: `Try replacing Windows path separators (\\) with posix path separators (/)`,
     entry_point_0_did_not_match_any_files_after_exclude: `The glob {0} did not match any files after applying exclude patterns`,
     entry_point_0_did_not_exist: `Provided entry point {0} does not exist`,
     entry_point_0_did_not_match_any_packages: `The entry point glob {0} did not match any directories containing package.json`,
@@ -129,6 +128,7 @@ module.exports = {
     // options
     circular_reference_extends_0: `Circular reference encountered for "extends" field of {0}`,
     failed_resolve_0_to_file_in_1: `Failed to resolve {0} to a file in {1}`,
+    glob_0_should_use_posix_slash: `The glob "{0}" escapes a non-special character. Glob inputs to TypeDoc may not use Windows path separators (\\), try replacing with posix path separators (/)`,
     option_0_can_only_be_specified_by_config_file: `The '{0}' option can only be specified via a config file`,
     option_0_expected_a_value_but_none_provided: `--{0} expected a value, but none was given as an argument`,
     unknown_option_0_may_have_meant_1: `Unknown option: {0}, you may have meant:\n\t{1}`,

package/dist/lib/internationalization/locales/en.d.cts

@@ -109,7 +109,6 @@ declare const _default: {
     readonly failed_to_resolve_0_to_ts_path: "Failed to resolve entry point path {0} from package.json to a TypeScript source file";
     readonly use_expand_or_glob_for_files_in_dir: "If you wanted to include files inside this directory, set --entryPointStrategy to expand or specify a glob";
     readonly glob_0_did_not_match_any_files: "The glob {0} did not match any files";
-    readonly glob_should_use_posix_slash: "Try replacing Windows path separators (\\) with posix path separators (/)";
     readonly entry_point_0_did_not_match_any_files_after_exclude: "The glob {0} did not match any files after applying exclude patterns";
     readonly entry_point_0_did_not_exist: "Provided entry point {0} does not exist";
     readonly entry_point_0_did_not_match_any_packages: "The entry point glob {0} did not match any directories containing package.json";
@@ -118,6 +117,7 @@ declare const _default: {
     readonly saved_relative_path_0_resolved_from_1_is_not_a_file: "Serialized project referenced {0}, which does not exist relative to {1}";
     readonly circular_reference_extends_0: "Circular reference encountered for \"extends\" field of {0}";
     readonly failed_resolve_0_to_file_in_1: "Failed to resolve {0} to a file in {1}";
+    readonly glob_0_should_use_posix_slash: "The glob \"{0}\" escapes a non-special character. Glob inputs to TypeDoc may not use Windows path separators (\\), try replacing with posix path separators (/)";
     readonly option_0_can_only_be_specified_by_config_file: "The '{0}' option can only be specified via a config file";
     readonly option_0_expected_a_value_but_none_provided: "--{0} expected a value, but none was given as an argument";
     readonly unknown_option_0_may_have_meant_1: "Unknown option: {0}, you may have meant:\n\t{1}";

package/dist/lib/internationalization/locales/ja.cjs

@@ -89,7 +89,6 @@ module.exports = localeUtils.buildIncompleteTranslation({
     entry_point_0_not_in_program: "エントリ ポイント {0} は、tsconfig の 'files' または 'include' オプションによって参照されていません。",
     use_expand_or_glob_for_files_in_dir: "このディレクトリ内のファイルを含める場合は、--entryPointStrategyを設定して展開するか、globを指定します。",
     glob_0_did_not_match_any_files: "グロブ {0} はどのファイルにも一致しませんでした",
-    // glob_should_use_posix_slash
     entry_point_0_did_not_match_any_files_after_exclude: "除外パターンを適用した後、グロブ {0} はどのファイルにも一致しませんでした",
     entry_point_0_did_not_exist: "指定されたエントリ ポイント {0} は存在しません",
     entry_point_0_did_not_match_any_packages: "エントリ ポイント glob {0} は、package.json を含むディレクトリと一致しませんでした。",

package/dist/lib/internationalization/locales/zh.cjs

@@ -120,7 +120,6 @@ module.exports = localeUtils.buildIncompleteTranslation({
     failed_to_resolve_0_to_ts_path: "无法将 package.json 中的入口点 {0} 解析至 TypeScript 源文件",
     use_expand_or_glob_for_files_in_dir: "如果要包含此目录中的文件，请设置 --entryPointStrategy 以展开或指定 glob",
     glob_0_did_not_match_any_files: "glob {0} 与任何文件均不匹配",
-    glob_should_use_posix_slash: `请将 Windows 路径分隔符（\\）替换为 POSIX 路径分隔符（/）`,
     entry_point_0_did_not_match_any_files_after_exclude: "应用排除模式后，glob {0} 没有匹配任何文件",
     entry_point_0_did_not_exist: "提供的入口点 {0} 不存在",
     entry_point_0_did_not_match_any_packages: "入口点 glob {0} 与任何包含 package.json 的目录不匹配",

package/dist/lib/internationalization/locales/zh.d.cts

@@ -109,7 +109,6 @@ declare const _default: {
     failed_to_resolve_0_to_ts_path: "无法将 package.json 中的入口点 {0} 解析至 TypeScript 源文件";
     use_expand_or_glob_for_files_in_dir: string;
     glob_0_did_not_match_any_files: "glob {0} 与任何文件均不匹配";
-    glob_should_use_posix_slash: string;
     entry_point_0_did_not_match_any_files_after_exclude: "应用排除模式后，glob {0} 没有匹配任何文件";
     entry_point_0_did_not_exist: "提供的入口点 {0} 不存在";
     entry_point_0_did_not_match_any_packages: "入口点 glob {0} 与任何包含 package.json 的目录不匹配";

package/dist/lib/models/types.js

@@ -1,7 +1,41 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
 import { ReflectionSymbolId } from "./ReflectionSymbolId.js";
 import { ReflectionKind } from "./kind.js";
 import { Comment } from "./Comment.js";
-import { i18n, joinArray } from "#utils";
+import { i18n, joinArray, NonEnumerable } from "#utils";
 /**
  * Base class of all type definitions.
  * @category Types
@@ -658,227 +692,241 @@ export class QueryType extends Type {
  * ```
  * @category Types
  */
-export class ReferenceType extends Type {
-    type = "reference";
-    /**
-     * The name of the referenced type.
-     *
-     * If the symbol cannot be found because it's not part of the documentation this
-     * can be used to represent the type.
-     */
-    name;
-    /**
-     * The type arguments of this reference.
-     */
-    typeArguments;
-    /**
-     * The resolved reflection.
-     */
-    get reflection() {
-        if (typeof this._target === "number") {
-            return this._project?.getReflectionById(this._target);
-        }
-        const resolvePotential = this._project?.getReflectionsFromSymbolId(this._target);
-        if (!resolvePotential?.length) {
-            return;
-        }
-        const kind = this.preferValues
-            ? ReflectionKind.ValueReferenceTarget
-            : ReflectionKind.TypeReferenceTarget;
-        const resolved = resolvePotential.find((refl) => refl.kindOf(kind)) ||
-            resolvePotential.find((refl) => refl.kindOf(~kind));
-        // Do not mark the type as resolved at this point so that if it
-        // points to a member which is removed (e.g. by typedoc-plugin-zod)
-        // and then replaced it still ends up pointing at the right reflection.
-        // We will lock type reference resolution when serializing to JSON.
-        // this._target = resolved.id;
-        return resolved;
-    }
-    /**
-     * Sometimes a few properties are more important than the rest
-     * of the properties within a type. This occurs most often with
-     * object parameters, where users want to specify `@param foo.bar`
-     * to highlight something about the `bar` property.
-     *
-     * Does NOT support nested properties.
-     */
-    highlightedProperties;
-    /**
-     * If not resolved, the symbol id of the reflection, otherwise undefined.
-     */
-    get symbolId() {
-        if (!this.reflection && typeof this._target === "object") {
-            return this._target;
-        }
-    }
-    /**
-     * Checks if this type is a reference type because it uses a name, but is intentionally not pointing
-     * to a reflection. This happens for type parameters and when representing a mapped type.
-     */
-    isIntentionallyBroken() {
-        if (typeof this._target === "object" &&
-            this._project?.symbolIdHasBeenRemoved(this._target)) {
-            return true;
+let ReferenceType = (() => {
+    let _classSuper = Type;
+    let __project_decorators;
+    let __project_initializers = [];
+    let __project_extraInitializers = [];
+    return class ReferenceType extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __project_decorators = [NonEnumerable];
+            __esDecorate(null, null, __project_decorators, { kind: "field", name: "_project", static: false, private: false, access: { has: obj => "_project" in obj, get: obj => obj._project, set: (obj, value) => { obj._project = value; } }, metadata: _metadata }, __project_initializers, __project_extraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
-        return this._target === -1 || this.refersToTypeParameter;
-    }
-    /**
-     * Convert this reference type to a declaration reference used for resolution of external types.
-     */
-    toDeclarationReference() {
-        return {
-            resolutionStart: "global",
-            moduleSource: this.package,
-            symbolReference: {
-                path: this.qualifiedName
-                    .split(".")
-                    .map((p) => ({ path: p, navigation: "." })),
-            },
-        };
-    }
-    /**
-     * The fully qualified name of the referenced type, relative to the file it is defined in.
-     * This will usually be the same as `name`, unless namespaces are used.
-     */
-    qualifiedName;
-    /**
-     * The package that this type is referencing.
-     */
-    package;
-    /**
-     * If this reference type refers to a reflection defined by a project not being rendered,
-     * points to the url that this type should be linked to.
-     */
-    externalUrl;
-    /**
-     * If set, no warnings about something not being exported should be created
-     * since this may be referring to a type created with `infer X` which will not
-     * be registered on the project.
-     */
-    refersToTypeParameter = false;
-    /**
-     * If set, will prefer reflections with {@link ReflectionKind | ReflectionKinds} which represent
-     * values rather than those which represent types.
-     */
-    preferValues = false;
-    _target;
-    _project;
-    constructor(name, target, project, qualifiedName) {
-        super();
-        this.name = name;
-        if (typeof target === "number") {
-            this._target = target;
+        type = "reference";
+        /**
+         * The name of the referenced type.
+         *
+         * If the symbol cannot be found because it's not part of the documentation this
+         * can be used to represent the type.
+         */
+        name;
+        /**
+         * The type arguments of this reference.
+         */
+        typeArguments;
+        /**
+         * The resolved reflection.
+         */
+        get reflection() {
+            if (typeof this._target === "number") {
+                return this._project?.getReflectionById(this._target);
+            }
+            const resolvePotential = this._project?.getReflectionsFromSymbolId(this._target);
+            if (!resolvePotential?.length) {
+                return;
+            }
+            const kind = this.preferValues
+                ? ReflectionKind.ValueReferenceTarget
+                : ReflectionKind.TypeReferenceTarget;
+            const resolved = resolvePotential.find((refl) => refl.kindOf(kind)) ||
+                resolvePotential.find((refl) => refl.kindOf(~kind));
+            // Do not mark the type as resolved at this point so that if it
+            // points to a member which is removed (e.g. by typedoc-plugin-zod)
+            // and then replaced it still ends up pointing at the right reflection.
+            // We will lock type reference resolution when serializing to JSON.
+            // this._target = resolved.id;
+            return resolved;
         }
-        else {
-            this._target = "variant" in target ? target.id : target;
+        /**
+         * Sometimes a few properties are more important than the rest
+         * of the properties within a type. This occurs most often with
+         * object parameters, where users want to specify `@param foo.bar`
+         * to highlight something about the `bar` property.
+         *
+         * Does NOT support nested properties.
+         */
+        highlightedProperties;
+        /**
+         * If not resolved, the symbol id of the reflection, otherwise undefined.
+         */
+        get symbolId() {
+            if (!this.reflection && typeof this._target === "object") {
+                return this._target;
+            }
         }
-        this._project = project;
-        this.qualifiedName = qualifiedName;
-    }
-    static createUnresolvedReference(name, target, project, qualifiedName) {
-        return new ReferenceType(name, target, project, qualifiedName);
-    }
-    static createResolvedReference(name, target, project) {
-        return new ReferenceType(name, target, project, name);
-    }
-    /**
-     * This is used for type parameters, which don't actually point to something,
-     * and also for temporary references which will be cleaned up with real references
-     * later during conversion.
-     * @internal
-     */
-    static createBrokenReference(name, project) {
-        return new ReferenceType(name, -1, project, name);
-    }
-    getTypeString() {
-        const name = this.reflection ? this.reflection.name : this.name;
-        let typeArgs = "";
-        if (this.typeArguments && this.typeArguments.length > 0) {
-            typeArgs += "<";
-            typeArgs += this.typeArguments
-                .map((arg) => arg.stringify(TypeContext.referenceTypeArgument))
-                .join(", ");
-            typeArgs += ">";
+        /**
+         * Checks if this type is a reference type because it uses a name, but is intentionally not pointing
+         * to a reflection. This happens for type parameters and when representing a mapped type.
+         */
+        isIntentionallyBroken() {
+            if (typeof this._target === "object" &&
+                this._project?.symbolIdHasBeenRemoved(this._target)) {
+                return true;
+            }
+            return this._target === -1 || this.refersToTypeParameter;
         }
-        return name + typeArgs;
-    }
-    needsParenthesis() {
-        return false;
-    }
-    toObject(serializer) {
-        let target;
-        if (typeof this._target === "number") {
-            target = this._target;
+        /**
+         * Convert this reference type to a declaration reference used for resolution of external types.
+         */
+        toDeclarationReference() {
+            return {
+                resolutionStart: "global",
+                moduleSource: this.package,
+                symbolReference: {
+                    path: this.qualifiedName
+                        .split(".")
+                        .map((p) => ({ path: p, navigation: "." })),
+                },
+            };
         }
-        else if (this._project?.symbolIdHasBeenRemoved(this._target)) {
-            target = -1;
+        /**
+         * The fully qualified name of the referenced type, relative to the file it is defined in.
+         * This will usually be the same as `name`, unless namespaces are used.
+         */
+        qualifiedName;
+        /**
+         * The package that this type is referencing.
+         */
+        package;
+        /**
+         * If this reference type refers to a reflection defined by a project not being rendered,
+         * points to the url that this type should be linked to.
+         */
+        externalUrl;
+        /**
+         * If set, no warnings about something not being exported should be created
+         * since this may be referring to a type created with `infer X` which will not
+         * be registered on the project.
+         */
+        refersToTypeParameter = false;
+        /**
+         * If set, will prefer reflections with {@link ReflectionKind | ReflectionKinds} which represent
+         * values rather than those which represent types.
+         */
+        preferValues = false;
+        _target;
+        _project = __runInitializers(this, __project_initializers, void 0);
+        constructor(name, target, project, qualifiedName) {
+            super();
+            __runInitializers(this, __project_extraInitializers);
+            this.name = name;
+            if (typeof target === "number") {
+                this._target = target;
+            }
+            else {
+                this._target = "variant" in target ? target.id : target;
+            }
+            this._project = project;
+            this.qualifiedName = qualifiedName;
         }
-        else if (this.reflection) {
-            target = this.reflection.id;
+        static createUnresolvedReference(name, target, project, qualifiedName) {
+            return new ReferenceType(name, target, project, qualifiedName);
         }
-        else {
-            target = this._target.toObject();
+        static createResolvedReference(name, target, project) {
+            return new ReferenceType(name, target, project, name);
         }
-        const result = {
-            type: this.type,
-            target,
-            typeArguments: serializer.toObjectsOptional(this.typeArguments),
-            name: this.name,
-            package: this.package,
-            externalUrl: this.externalUrl,
-        };
-        if (this.name !== this.qualifiedName) {
-            result.qualifiedName = this.qualifiedName;
+        /**
+         * This is used for type parameters, which don't actually point to something,
+         * and also for temporary references which will be cleaned up with real references
+         * later during conversion.
+         * @internal
+         */
+        static createBrokenReference(name, project) {
+            return new ReferenceType(name, -1, project, name);
         }
-        if (this.refersToTypeParameter) {
-            result.refersToTypeParameter = true;
+        getTypeString() {
+            const name = this.reflection ? this.reflection.name : this.name;
+            let typeArgs = "";
+            if (this.typeArguments && this.typeArguments.length > 0) {
+                typeArgs += "<";
+                typeArgs += this.typeArguments
+                    .map((arg) => arg.stringify(TypeContext.referenceTypeArgument))
+                    .join(", ");
+                typeArgs += ">";
+            }
+            return name + typeArgs;
         }
-        if (typeof target !== "number" && this.preferValues) {
-            result.preferValues = true;
+        needsParenthesis() {
+            return false;
         }
-        if (this.highlightedProperties) {
-            result.highlightedProperties = Object.fromEntries(Array.from(this.highlightedProperties.entries(), ([key, parts]) => {
-                return [
-                    key,
-                    Comment.serializeDisplayParts(parts),
-                ];
-            }));
+        toObject(serializer) {
+            let target;
+            if (typeof this._target === "number") {
+                target = this._target;
+            }
+            else if (this._project?.symbolIdHasBeenRemoved(this._target)) {
+                target = -1;
+            }
+            else if (this.reflection) {
+                target = this.reflection.id;
+            }
+            else {
+                target = this._target.toObject();
+            }
+            const result = {
+                type: this.type,
+                target,
+                typeArguments: serializer.toObjectsOptional(this.typeArguments),
+                name: this.name,
+                package: this.package,
+                externalUrl: this.externalUrl,
+            };
+            if (this.name !== this.qualifiedName) {
+                result.qualifiedName = this.qualifiedName;
+            }
+            if (this.refersToTypeParameter) {
+                result.refersToTypeParameter = true;
+            }
+            if (typeof target !== "number" && this.preferValues) {
+                result.preferValues = true;
+            }
+            if (this.highlightedProperties) {
+                result.highlightedProperties = Object.fromEntries(Array.from(this.highlightedProperties.entries(), ([key, parts]) => {
+                    return [
+                        key,
+                        Comment.serializeDisplayParts(parts),
+                    ];
+                }));
+            }
+            return result;
         }
-        return result;
-    }
-    fromObject(de, obj) {
-        this.typeArguments = de.reviveMany(obj.typeArguments, (t) => de.constructType(t));
-        if (typeof obj.target === "number" && obj.target !== -1) {
-            de.defer((project) => {
-                const target = project.getReflectionById(de.oldIdToNewId[obj.target] ?? -1);
-                if (target) {
-                    this._project = project;
-                    this._target = target.id;
-                }
-                else {
-                    de.logger.warn(i18n.serialized_project_referenced_0_not_part_of_project(JSON.stringify(obj.target)));
+        fromObject(de, obj) {
+            this.typeArguments = de.reviveMany(obj.typeArguments, (t) => de.constructType(t));
+            if (typeof obj.target === "number" && obj.target !== -1) {
+                de.defer((project) => {
+                    const target = project.getReflectionById(de.oldIdToNewId[obj.target] ?? -1);
+                    if (target) {
+                        this._project = project;
+                        this._target = target.id;
+                    }
+                    else {
+                        de.logger.warn(i18n.serialized_project_referenced_0_not_part_of_project(JSON.stringify(obj.target)));
+                    }
+                });
+            }
+            else if (obj.target === -1) {
+                this._target = -1;
+            }
+            else {
+                this._project = de.project;
+                this._target = new ReflectionSymbolId(obj.target);
+            }
+            this.qualifiedName = obj.qualifiedName ?? obj.name;
+            this.package = obj.package;
+            this.refersToTypeParameter = !!obj.refersToTypeParameter;
+            this.preferValues = !!obj.preferValues;
+            if (obj.highlightedProperties) {
+                this.highlightedProperties = new Map();
+                for (const [key, parts] of Object.entries(obj.highlightedProperties)) {
+                    this.highlightedProperties.set(key, Comment.deserializeDisplayParts(de, parts));
                 }
-            });
-        }
-        else if (obj.target === -1) {
-            this._target = -1;
-        }
-        else {
-            this._project = de.project;
-            this._target = new ReflectionSymbolId(obj.target);
-        }
-        this.qualifiedName = obj.qualifiedName ?? obj.name;
-        this.package = obj.package;
-        this.refersToTypeParameter = !!obj.refersToTypeParameter;
-        this.preferValues = !!obj.preferValues;
-        if (obj.highlightedProperties) {
-            this.highlightedProperties = new Map();
-            for (const [key, parts] of Object.entries(obj.highlightedProperties)) {
-                this.highlightedProperties.set(key, Comment.deserializeDisplayParts(de, parts));
             }
         }
-    }
-}
+    };
+})();
+export { ReferenceType };
 /**
  * Represents a type which has it's own reflection like literal types.
  * This type will likely go away at some point and be replaced by a dedicated

package/dist/lib/output/themes/MarkedPlugin.js

@@ -204,6 +204,11 @@ let MarkedPlugin = (() => {
                                                     .reflection_0_links_to_1_with_text_2_but_resolved_to_3(page.model.getFriendlyFullName(), part.target.getFriendlyFullName(), part.text, target.getFriendlyFullName()));
                                             }
                                         }
+                                        // If the url goes to this page, render as `#`
+                                        // to go to the top of the page.
+                                        if (url == "") {
+                                            url = "#";
+                                        }
                                     }
                                     if (useHtml) {
                                         const text = part.tag === "@linkcode" ? `<code>${part.text}</code>` : part.text;

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

@@ -231,9 +231,6 @@ function expandGlobs(globs, exclude, logger) {
             // #2918 - do not pass entry through nicePath here in case it contains
             // windows path separators which should cause additional warnings.
             logger.warn(i18n.glob_0_did_not_match_any_files(entry));
-            if (entry.includes("\\") && !entry.includes("/")) {
-                logger.info(i18n.glob_should_use_posix_slash());
-            }
         }
         else if (filtered.length === 0) {
             logger.warn(i18n.entry_point_0_did_not_match_any_files_after_exclude(entry));

package/dist/lib/utils/highlighter.js

@@ -1,7 +1,8 @@
 import * as shiki from "@gerrit0/mini-shiki";
 import { JSX, unique } from "#utils";
 import assert from "assert";
-const aliases = new Map();
+const tsAliases = [["mts", "typescript"], ["cts", "typescript"]];
+const aliases = new Map(tsAliases);
 for (const lang of shiki.bundledLanguagesInfo) {
     for (const alias of lang.aliases || []) {
         aliases.set(alias, lang.id);
@@ -131,7 +132,7 @@ export function getSupportedThemes() {
     return supportedThemes;
 }
 export function isLoadedLanguage(lang) {
-    return (plaintextLanguages.includes(lang) || ignoredLanguages?.includes(lang) || highlighter?.supports(lang) || false);
+    return (isSupportedLanguage(lang) || highlighter?.supports(lang) || false);
 }
 export function highlight(code, lang) {
     assert(highlighter, "Tried to highlight with an uninitialized highlighter");

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

@@ -199,7 +199,17 @@ const converters = {
         return resolved;
     },
     [ParameterType.GlobArray](value, option, configPath) {
-        const toGlobString = (v) => createGlobString(configPath, String(v));
+        const toGlobString = (v) => {
+            const s = String(v);
+            // If the string tries to escape a character which isn't a special
+            // glob character, the user probably provided a Windows style path
+            // by accident due to shell completion, tell them to either remove
+            // the useless escape or switch to Unix path separators.
+            if (/\\[^?*()[\]\\{}]/.test(s)) {
+                throw new Error(i18n.glob_0_should_use_posix_slash(s));
+            }
+            return createGlobString(configPath, s);
+        };
         const globs = Array.isArray(value) ? value.map(toGlobString) : [toGlobString(value)];
         option.validate?.(globs);
         return globs;

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

@@ -8,6 +8,8 @@ export declare class ArgumentsReader implements OptionsReader {
     readonly order: number;
     readonly supportsPackages = false;
     private args;
+    private skipErrorReporting;
     constructor(priority: number, args?: string[]);
+    ignoreErrors(): this;
     read(container: Options, logger: Logger): void;
 }

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

@@ -15,10 +15,15 @@ export class ArgumentsReader {
     order;
     supportsPackages = false;
     args;
+    skipErrorReporting = false;
     constructor(priority, args = process.argv.slice(2)) {
         this.order = priority;
         this.args = args;
     }
+    ignoreErrors() {
+        this.skipErrorReporting = true;
+        return this;
+    }
     read(container, logger) {
         // Make container's type more lax, we do the appropriate checks manually.
         const options = container;
@@ -30,7 +35,9 @@ export class ArgumentsReader {
             }
             catch (err) {
                 ok(err instanceof Error);
-                logger.error(err.message);
+                if (!this.skipErrorReporting) {
+                    logger.error(err.message);
+                }
             }
         };
         while (index < this.args.length) {
@@ -40,7 +47,9 @@ export class ArgumentsReader {
                 : options.getDeclaration("entryPoints");
             if (decl) {
                 if (decl.configFileOnly) {
-                    logger.error(i18n.option_0_can_only_be_specified_by_config_file(decl.name));
+                    if (!this.skipErrorReporting) {
+                        logger.error(i18n.option_0_can_only_be_specified_by_config_file(decl.name));
+                    }
                     continue;
                 }
                 if (seen.has(decl.name) && ARRAY_OPTION_TYPES.has(decl.type)) {
@@ -61,7 +70,9 @@ export class ArgumentsReader {
                 else {
                     if (index === this.args.length) {
                         // Only boolean values have optional values.
-                        logger.warn(i18n.option_0_expected_a_value_but_none_provided(decl.name));
+                        if (!this.skipErrorReporting) {
+                            logger.warn(i18n.option_0_expected_a_value_but_none_provided(decl.name));
+                        }
                     }
                     trySet(decl.name, this.args[index]);
                 }
@@ -87,7 +98,9 @@ export class ArgumentsReader {
                     continue;
                 }
             }
-            logger.error(i18n.unknown_option_0_may_have_meant_1(name, options.getSimilarOptions(name).join("\n\t")));
+            if (!this.skipErrorReporting) {
+                logger.error(i18n.unknown_option_0_may_have_meant_1(name, options.getSimilarOptions(name).join("\n\t")));
+            }
             index++;
         }
     }

package/dist/lib/utils-common/array.d.ts

@@ -2,6 +2,7 @@ export declare const emptyArray: readonly [];
 /**
  * Inserts an item into an array sorted by priority. If two items have the same priority,
  * the item will be inserted later will be placed later in the array.
+ * Higher priority is placed earlier in the array.
  * @param arr modified by inserting item.
  * @param item
  */

package/dist/lib/utils-common/array.js

@@ -2,6 +2,7 @@ export const emptyArray = [];
 /**
  * Inserts an item into an array sorted by priority. If two items have the same priority,
  * the item will be inserted later will be placed later in the array.
+ * Higher priority is placed earlier in the array.
  * @param arr modified by inserting item.
  * @param item
  */

package/dist/lib/utils-common/events.d.ts

@@ -11,6 +11,7 @@ export declare class EventDispatcher<T extends Record<keyof T, unknown[]>> {
      * @param event the event to listen to.
      * @param listener function to be called when an this event is emitted.
      * @param priority optional priority to insert this hook with.
+     *  Higher priority is placed earlier in the listener array.
      */
     on<K extends keyof T>(event: K, listener: (this: undefined, ...args: T[K]) => void, priority?: number): void;
     /**

package/dist/lib/utils-common/events.js

@@ -14,6 +14,7 @@ export class EventDispatcher {
      * @param event the event to listen to.
      * @param listener function to be called when an this event is emitted.
      * @param priority optional priority to insert this hook with.
+     *  Higher priority is placed earlier in the listener array.
      */
     on(event, listener, priority = 0) {
         const list = (this._listeners.get(event) || []).slice();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typedoc",
   "description": "Create api documentation for TypeScript projects.",
-  "version": "0.28.2",
+  "version": "0.28.3",
   "homepage": "https://typedoc.org",
   "type": "module",
   "exports": {