@depup/typedoc 0.28.17-depup.0

package/dist/lib/serialization/schema.d.ts

@@ -0,0 +1,283 @@
+/**
+ * Contains interfaces which describe the JSON output. Each interface is related to a specific type of serializer.
+ *
+ * ## Plugins
+ * Plugins which modify the serialization process can use declaration merging
+ * to add custom properties to the exported interfaces.
+ * For example, if your custom serializer adds a property to all {@link Reflection} objects:
+ * ```ts
+ * declare module 'typedoc/dist/lib/serialization/schema' {
+ *     export interface AbstractReflection {
+ *         myCustomProp: boolean
+ *     }
+ * }
+ * ```
+ *
+ * If a plugin defines a new Model type, {@link ModelToObject} will not pick up the serializer type and
+ * the resulting type will not be included in the return type of {@link Serializer.toObject}.
+ * To fix this, use declaration merging to augment the {@link Serializer} class.
+ * ```ts
+ * declare module 'typedoc/dist/lib/serialization/serializer' {
+ *     export interface Serializer {
+ *         toObject(value: CustomModel, obj?: Partial<CustomModel>): CustomOutput
+ *     }
+ * }
+ * ```
+ *
+ * For documentation on the JSON output properties, view the corresponding model.
+ * @summary Contains interfaces which describe the JSON output.
+ * @module
+ */
+import type * as M from "#models";
+import type { IfInternal, NormalizedPath, TagString } from "#utils";
+export declare const SCHEMA_VERSION = "2.0";
+/**
+ * Describes the mapping from Model types to the corresponding JSON output type.
+ */
+export type ModelToObject<T> = [T] extends [Array<infer U>] ? ModelToObject<U>[] : [
+    M.SomeType
+] extends [T] ? SomeType : _ModelToObject<T>;
+type _ModelToObject<T> = T extends Primitive ? T : Required<T> extends Required<M.ReflectionGroup> ? ReflectionGroup : Required<T> extends Required<M.ReflectionCategory> ? ReflectionCategory : T extends M.ReflectionVariant[keyof M.ReflectionVariant] ? ReflectionVariantMap[T["variant"]] : T extends M.SomeType ? TypeKindMap[T["type"]] : T extends M.Type ? SomeType : T extends M.Comment ? Comment : T extends M.CommentTag ? CommentTag : T extends M.CommentDisplayPart ? CommentDisplayPart : T extends M.SourceReference ? SourceReference : T extends M.FileRegistry ? FileRegistry : T extends M.ReflectionSymbolId ? ReflectionSymbolId : never;
+type Primitive = string | number | undefined | null | boolean;
+type ToSerialized<T> = T extends Primitive ? T : T extends bigint ? {
+    value: string;
+    negative: boolean;
+} : ModelToObject<T>;
+/**
+ * Helper to describe a set of serialized properties. Primitive types are returned
+ * directly, while other models are first passed through ModelToObject.
+ * This helper removes the readonly modifier from properties since the result of serialization
+ * is a plain object that consumers may modify as they choose, TypeDoc doesn't care.
+ */
+type S<T, K extends keyof T> = {
+    -readonly [K2 in K]: ToSerialized<T[K2]>;
+};
+export type ReflectionId = M.ReflectionId;
+export type FileId = M.FileId;
+export interface ReflectionSymbolId {
+    packageName: string;
+    packagePath: NormalizedPath;
+    qualifiedName: string;
+}
+export interface ReflectionGroup extends S<M.ReflectionGroup, "title" | "description" | "categories"> {
+    children?: M.ReflectionGroup["children"][number]["id"][];
+}
+export interface ReflectionCategory extends S<M.ReflectionCategory, "title" | "description"> {
+    children?: M.ReflectionCategory["children"][number]["id"][];
+}
+/** @category Reflections */
+export interface ReflectionVariantMap {
+    declaration: DeclarationReflection;
+    param: ParameterReflection;
+    project: ProjectReflection;
+    reference: ReferenceReflection;
+    signature: SignatureReflection;
+    typeParam: TypeParameterReflection;
+    document: DocumentReflection;
+}
+/** @category Reflections */
+export type SomeReflection = ReflectionVariantMap[keyof ReflectionVariantMap];
+/** @category Reflections */
+export interface DocumentReflection extends Omit<Reflection, "variant">, S<M.DocumentReflection, "variant" | "content" | "relevanceBoost" | "children"> {
+    frontmatter: Record<string, unknown>;
+}
+/** @category Reflections */
+export interface ReferenceReflection extends Omit<DeclarationReflection, "variant">, S<M.ReferenceReflection, "variant"> {
+    /**
+     * -1 if the reference refers to a symbol that does not exist in the documentation.
+     * Otherwise, the reflection ID.
+     */
+    target: ReflectionId;
+}
+/** @category Reflections */
+export interface SignatureReflection extends Omit<Reflection, "variant">, S<M.SignatureReflection, "variant" | "sources" | "parameters" | "typeParameters" | "type" | "overwrites" | "inheritedFrom" | "implementationOf"> {
+}
+/** @category Reflections */
+export interface ParameterReflection extends Omit<Reflection, "variant">, S<M.ParameterReflection, "variant" | "type" | "defaultValue"> {
+    variant: "param";
+}
+/** @category Reflections */
+export interface DeclarationReflection extends Omit<ContainerReflection, "variant">, S<M.DeclarationReflection, "variant" | "packageVersion" | "sources" | "relevanceBoost" | "type" | "signatures" | "indexSignatures" | "defaultValue" | "overwrites" | "inheritedFrom" | "implementationOf" | "extendedTypes" | "extendedBy" | "implementedTypes" | "implementedBy" | "getSignature" | "setSignature" | "typeParameters" | "readme"> {
+}
+/** @category Reflections */
+export interface TypeParameterReflection extends Omit<Reflection, "variant">, S<M.TypeParameterReflection, "variant" | "type" | "default" | "varianceModifier"> {
+}
+/** @category Reflections */
+export interface ProjectReflection extends Omit<ContainerReflection, "variant">, S<M.ProjectReflection, "variant" | "packageName" | "packageVersion" | "readme"> {
+    /**
+     * Used to determine if TypeDoc supports deserializing the specified json
+     * See {@link SCHEMA_VERSION} for the current version.
+     */
+    schemaVersion: string;
+    symbolIdMap: Record<ReflectionId, ReflectionSymbolId> | IfInternal<undefined, never>;
+    files: FileRegistry;
+}
+/** @category Reflections */
+export interface ContainerReflection extends Reflection, S<M.ContainerReflection, "children" | "documents" | "groups" | "categories"> {
+    childrenIncludingDocuments?: ReflectionId[];
+}
+/** @category Reflections */
+export interface Reflection extends S<M.Reflection, "id" | "variant" | "name" | "kind" | "comment"> {
+    flags: ReflectionFlags;
+}
+/** @category Types */
+export type SomeType = TypeKindMap[keyof TypeKindMap];
+/** @category Types */
+export type TypeKindMap = {
+    array: ArrayType;
+    conditional: ConditionalType;
+    indexedAccess: IndexedAccessType;
+    inferred: InferredType;
+    intersection: IntersectionType;
+    intrinsic: IntrinsicType;
+    literal: LiteralType;
+    mapped: MappedType;
+    optional: OptionalType;
+    predicate: PredicateType;
+    query: QueryType;
+    reference: ReferenceType;
+    reflection: ReflectionType;
+    rest: RestType;
+    templateLiteral: TemplateLiteralType;
+    tuple: TupleType;
+    namedTupleMember: NamedTupleMemberType;
+    typeOperator: TypeOperatorType;
+    union: UnionType;
+    unknown: UnknownType;
+};
+/** @category Types */
+export interface ArrayType extends Type, S<M.ArrayType, "type" | "elementType"> {
+}
+/** @category Types */
+export interface ConditionalType extends Type, S<M.ConditionalType, "type" | "checkType" | "extendsType" | "trueType" | "falseType"> {
+}
+/** @category Types */
+export interface IndexedAccessType extends Type, S<M.IndexedAccessType, "type" | "indexType" | "objectType"> {
+}
+/** @category Types */
+export interface InferredType extends Type, S<M.InferredType, "type" | "name" | "constraint"> {
+}
+/** @category Types */
+export interface IntersectionType extends Type, S<M.IntersectionType, "type" | "types"> {
+}
+/** @category Types */
+export interface IntrinsicType extends Type, S<M.IntrinsicType, "type" | "name"> {
+}
+/** @category Types */
+export interface OptionalType extends Type, S<M.OptionalType, "type" | "elementType"> {
+}
+/** @category Types */
+export interface PredicateType extends Type, S<M.PredicateType, "type" | "name" | "asserts" | "targetType"> {
+}
+/** @category Types */
+export interface QueryType extends Type, S<M.QueryType, "type" | "queryType"> {
+}
+/** @category Types */
+export interface ReferenceType extends Type, S<M.ReferenceType, "type" | "name" | "typeArguments" | "package" | "externalUrl"> {
+    target: ReflectionId | ReflectionSymbolId;
+    qualifiedName?: string;
+    refersToTypeParameter?: boolean;
+    preferValues?: boolean;
+    highlightedProperties?: Record<string, CommentDisplayPart[]>;
+}
+/** @category Types */
+export interface ReflectionType extends Type, S<M.ReflectionType, "type" | "declaration"> {
+}
+/** @category Types */
+export interface RestType extends Type, S<M.RestType, "type" | "elementType"> {
+}
+/** @category Types */
+export interface LiteralType extends Type, S<M.LiteralType, "type" | "value"> {
+}
+/** @category Types */
+export interface TupleType extends Type, S<M.TupleType, "type"> {
+    elements?: ModelToObject<M.TupleType["elements"]>;
+}
+/** @category Types */
+export interface NamedTupleMemberType extends Type, S<M.NamedTupleMember, "type" | "name" | "isOptional" | "element"> {
+}
+/** @category Types */
+export interface TemplateLiteralType extends Type, S<M.TemplateLiteralType, "type" | "head"> {
+    tail: [SomeType, string][];
+}
+/** @category Types */
+export interface MappedType extends Type, S<M.MappedType, "type" | "parameter" | "parameterType" | "templateType" | "readonlyModifier" | "optionalModifier" | "nameType"> {
+}
+/** @category Types */
+export interface TypeOperatorType extends Type, S<M.TypeOperatorType, "type" | "operator" | "target"> {
+}
+/** @category Types */
+export interface UnionType extends Type, S<M.UnionType, "type" | "types" | "elementSummaries"> {
+}
+/** @category Types */
+export interface UnknownType extends Type, S<M.UnknownType, "type" | "name"> {
+}
+/** @category Types */
+export interface Type {
+}
+type BoolKeys<T> = {
+    [K in keyof T]-?: T[K] extends boolean ? K : never;
+}[keyof T];
+export interface ReflectionFlags extends Partial<S<M.ReflectionFlags, BoolKeys<M.ReflectionFlags>>> {
+}
+/** @category Comments */
+export interface Comment extends Partial<S<M.Comment, "blockTags" | "label">> {
+    summary: CommentDisplayPart[];
+    modifierTags?: TagString[];
+}
+/** @category Comments */
+export interface CommentTag extends S<M.CommentTag, "tag" | "name" | "typeAnnotation"> {
+    content: CommentDisplayPart[];
+}
+/**
+ * @see {@link M.CommentDisplayPart}
+ * @category Comments
+ */
+export type CommentDisplayPart = {
+    kind: "text";
+    text: string;
+} | {
+    kind: "code";
+    text: string;
+} | InlineTagDisplayPart | RelativeLinkDisplayPart;
+/**
+ * If `target` is a number, it is a reflection ID. If a string, it is a URL.
+ * `target` will only be set for `@link`, `@linkcode`, and `@linkplain` tags.
+ * @category Comments
+ */
+export interface InlineTagDisplayPart {
+    kind: "inline-tag";
+    tag: TagString;
+    text: string;
+    target?: string | ReflectionId | ReflectionSymbolId;
+    tsLinkText?: string;
+}
+/**
+ * This is used for relative links within comments/documents.
+ * It is used to mark pieces of text which need to be replaced
+ * to make links work properly.
+ */
+export interface RelativeLinkDisplayPart {
+    kind: "relative-link";
+    /**
+     * The original relative text from the parsed comment.
+     */
+    text: string;
+    /**
+     * File ID, if present
+     */
+    target?: FileId;
+    /**
+     * Anchor within the target file, if present
+     */
+    targetAnchor?: string;
+}
+export interface SourceReference extends S<M.SourceReference, "fileName" | "line" | "character" | "url"> {
+}
+export interface FileRegistry {
+    /** Relative path according to the serialization root */
+    entries: Record<FileId, NormalizedPath>;
+    /** File ID to reflection ID */
+    reflections: Record<FileId, ReflectionId>;
+}
+export {};

package/dist/lib/serialization/schema.js

@@ -0,0 +1,32 @@
+/**
+ * Contains interfaces which describe the JSON output. Each interface is related to a specific type of serializer.
+ *
+ * ## Plugins
+ * Plugins which modify the serialization process can use declaration merging
+ * to add custom properties to the exported interfaces.
+ * For example, if your custom serializer adds a property to all {@link Reflection} objects:
+ * ```ts
+ * declare module 'typedoc/dist/lib/serialization/schema' {
+ *     export interface AbstractReflection {
+ *         myCustomProp: boolean
+ *     }
+ * }
+ * ```
+ *
+ * If a plugin defines a new Model type, {@link ModelToObject} will not pick up the serializer type and
+ * the resulting type will not be included in the return type of {@link Serializer.toObject}.
+ * To fix this, use declaration merging to augment the {@link Serializer} class.
+ * ```ts
+ * declare module 'typedoc/dist/lib/serialization/serializer' {
+ *     export interface Serializer {
+ *         toObject(value: CustomModel, obj?: Partial<CustomModel>): CustomOutput
+ *     }
+ * }
+ * ```
+ *
+ * For documentation on the JSON output properties, view the corresponding model.
+ * @summary Contains interfaces which describe the JSON output.
+ * @module
+ */
+// Keep this in sync with JSON_SCHEMA_VERSION in ProjectReflection.ts
+export const SCHEMA_VERSION = "2.0";

package/dist/lib/serialization/serializer.d.ts

@@ -0,0 +1,52 @@
+import type { ProjectReflection } from "#models";
+import { SerializeEvent } from "./events.js";
+import type { ModelToObject } from "./schema.js";
+import type { SerializerComponent } from "./components.js";
+import { EventDispatcher, type NormalizedPath } from "#utils";
+export interface SerializerEvents {
+    begin: [SerializeEvent];
+    end: [SerializeEvent];
+}
+/**
+ * Serializes TypeDoc's models to JSON
+ *
+ * @group None
+ * @summary Serializes TypeDoc's models to JSON
+ */
+export declare class Serializer extends EventDispatcher<SerializerEvents> {
+    /**
+     * Triggered when the {@link Serializer} begins transforming a project.
+     * @event
+     */
+    static readonly EVENT_BEGIN = "begin";
+    /**
+     * Triggered when the {@link Serializer} has finished transforming a project.
+     * @event
+     */
+    static readonly EVENT_END = "end";
+    private serializers;
+    /**
+     * Only set when serializing.
+     */
+    projectRoot: NormalizedPath;
+    /**
+     * Only set when serializing
+     */
+    project: ProjectReflection;
+    addSerializer<T extends object>(serializer: SerializerComponent<T>): void;
+    removeSerializer(serializer: SerializerComponent<any>): void;
+    toObject<T extends {
+        toObject(serializer: Serializer): ModelToObject<T>;
+    }>(value: T): ModelToObject<T>;
+    toObject<T extends {
+        toObject(serializer: Serializer): ModelToObject<T>;
+    }>(value: T | undefined): ModelToObject<T> | undefined;
+    toObjectsOptional<T extends {
+        toObject(serializer: Serializer): ModelToObject<T>;
+    }>(value: T[] | undefined): ModelToObject<T>[] | undefined;
+    /**
+     * Same as toObject but emits {@link Serializer.EVENT_BEGIN} and {@link Serializer.EVENT_END} events.
+     * @param value
+     */
+    projectToObject(value: ProjectReflection, projectRoot: NormalizedPath): ModelToObject<ProjectReflection>;
+}

package/dist/lib/serialization/serializer.js

@@ -0,0 +1,65 @@
+import { SerializeEvent } from "./events.js";
+import { EventDispatcher, insertPrioritySorted, removeIfPresent } from "#utils";
+/**
+ * Serializes TypeDoc's models to JSON
+ *
+ * @group None
+ * @summary Serializes TypeDoc's models to JSON
+ */
+export class Serializer extends EventDispatcher {
+    /**
+     * Triggered when the {@link Serializer} begins transforming a project.
+     * @event
+     */
+    static EVENT_BEGIN = "begin";
+    /**
+     * Triggered when the {@link Serializer} has finished transforming a project.
+     * @event
+     */
+    static EVENT_END = "end";
+    serializers = [];
+    /**
+     * Only set when serializing.
+     */
+    projectRoot;
+    /**
+     * Only set when serializing
+     */
+    project;
+    addSerializer(serializer) {
+        insertPrioritySorted(this.serializers, serializer);
+    }
+    removeSerializer(serializer) {
+        removeIfPresent(this.serializers, serializer);
+    }
+    toObject(value) {
+        if (value === undefined) {
+            return undefined;
+        }
+        return this.serializers
+            .filter((s) => s.supports(value))
+            .reduce((val, s) => s.toObject(value, val, this), value.toObject(this));
+    }
+    toObjectsOptional(value) {
+        if (!value || value.length === 0) {
+            return undefined;
+        }
+        return value.map((val) => this.toObject(val));
+    }
+    /**
+     * Same as toObject but emits {@link Serializer.EVENT_BEGIN} and {@link Serializer.EVENT_END} events.
+     * @param value
+     */
+    projectToObject(value, projectRoot) {
+        this.projectRoot = projectRoot;
+        this.project = value;
+        const eventBegin = new SerializeEvent(value);
+        this.trigger(Serializer.EVENT_BEGIN, eventBegin);
+        const project = this.toObject(value);
+        const eventEnd = new SerializeEvent(value, project);
+        this.trigger(Serializer.EVENT_END, eventEnd);
+        this.project = undefined;
+        this.projectRoot = undefined;
+        return project;
+    }
+}

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

@@ -0,0 +1,12 @@
+import { type FileId, FileRegistry } from "../models/FileRegistry.js";
+import type { Deserializer, JSONOutput } from "#serialization";
+import { type NormalizedPath } from "#utils";
+export declare class ValidatingFileRegistry extends FileRegistry {
+    basePath: NormalizedPath;
+    constructor(basePath?: NormalizedPath);
+    register(sourcePath: NormalizedPath, relativePath: NormalizedPath): {
+        target: FileId;
+        anchor: string | undefined;
+    } | undefined;
+    fromObject(de: Deserializer, obj: JSONOutput.FileRegistry): void;
+}

package/dist/lib/utils/ValidatingFileRegistry.js

@@ -0,0 +1,52 @@
+import { FileRegistry } from "../models/FileRegistry.js";
+import { i18n, NormalizedPathUtils } from "#utils";
+import { existsSync } from "fs";
+export class ValidatingFileRegistry extends FileRegistry {
+    basePath;
+    constructor(basePath = "") {
+        super();
+        this.basePath = basePath;
+    }
+    register(sourcePath, relativePath) {
+        let absolute = NormalizedPathUtils.resolve(NormalizedPathUtils.dirname(sourcePath), relativePath);
+        let absoluteWithoutAnchor = absolute.replace(/#.*/, "");
+        // Note: We allow paths to directories to be registered here, but the AssetsPlugin will not
+        // copy them to the output path. This is so that we can link to directories and associate them
+        // with reflections in packages mode.
+        if (!existsSync(absoluteWithoutAnchor)) {
+            // If the relative path didn't exist normally, also check the path relative to the assetBasePath option
+            if (this.basePath != "") {
+                absolute = NormalizedPathUtils.resolve(this.basePath, relativePath);
+                absoluteWithoutAnchor = absolute.replace(/#.*/, "");
+                if (!existsSync(absoluteWithoutAnchor)) {
+                    return;
+                }
+            }
+            else {
+                return;
+            }
+        }
+        return this.registerAbsolute(absolute);
+    }
+    fromObject(de, obj) {
+        for (const [key, val] of Object.entries(obj.entries)) {
+            const absolute = NormalizedPathUtils.resolve(de.projectRoot, val);
+            if (!existsSync(absolute)) {
+                de.logger.warn(i18n.saved_relative_path_0_resolved_from_1_does_not_exist(val, de.projectRoot));
+                continue;
+            }
+            de.oldFileIdToNewFileId[+key] = this.registerAbsolute(absolute).target;
+        }
+        de.defer((project) => {
+            for (const [media, reflId] of Object.entries(obj.reflections)) {
+                const refl = project.getReflectionById(de.oldIdToNewId[reflId]);
+                if (refl) {
+                    this.mediaToReflection.set(de.oldFileIdToNewFileId[+media], refl.id);
+                }
+                else {
+                    de.logger.warn(i18n.serialized_project_referenced_0_not_part_of_project(reflId.toString()));
+                }
+            }
+        });
+    }
+}

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

@@ -0,0 +1,38 @@
+import type { Application } from "../application.js";
+import { EventDispatcher } from "#utils";
+/**
+ * Exposes a reference to the root Application component.
+ */
+export interface ComponentHost {
+    readonly application: Application;
+}
+export interface Component<E extends Record<keyof E, unknown[]> = {}> extends AbstractComponent<ComponentHost, E> {
+}
+/**
+ * Component base class.  Has an owner (unless it's the application root component),
+ * can dispatch events to its children, and has access to the root Application component.
+ *
+ * @template O type of component's owner.
+ */
+export declare abstract class AbstractComponent<O extends ComponentHost, E extends Record<keyof E, unknown[]>> extends EventDispatcher<E> implements ComponentHost {
+    /**
+     * The owner of this component instance.
+     */
+    private _componentOwner;
+    /**
+     * The name of this component as set by the `@Component` decorator.
+     */
+    componentName: string;
+    /**
+     * Create new Component instance.
+     */
+    constructor(owner: O);
+    /**
+     * Return the application / root component instance.
+     */
+    get application(): Application;
+    /**
+     * Return the owner of this component.
+     */
+    get owner(): O;
+}

package/dist/lib/utils/component.js

@@ -0,0 +1,41 @@
+import { EventDispatcher } from "#utils";
+/**
+ * Component base class.  Has an owner (unless it's the application root component),
+ * can dispatch events to its children, and has access to the root Application component.
+ *
+ * @template O type of component's owner.
+ */
+export class AbstractComponent extends EventDispatcher {
+    /**
+     * The owner of this component instance.
+     */
+    _componentOwner;
+    /**
+     * The name of this component as set by the `@Component` decorator.
+     */
+    componentName;
+    /**
+     * Create new Component instance.
+     */
+    constructor(owner) {
+        super();
+        this._componentOwner = owner;
+    }
+    /**
+     * Return the application / root component instance.
+     */
+    get application() {
+        if (this._componentOwner === null) {
+            return this;
+        }
+        return this._componentOwner.application;
+    }
+    /**
+     * Return the owner of this component.
+     */
+    get owner() {
+        return this._componentOwner === null
+            ? this
+            : this._componentOwner;
+    }
+}

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

@@ -0,0 +1,7 @@
+/**
+ * Compresses a JSON-serializable object into a Base64-encoded deflate string.
+ *
+ * @param data - The JSON-serializable object to compress.
+ * @returns A promise that resolves to a Base64-encoded string of the deflate-compressed data.
+ */
+export declare function compressJson(data: any): Promise<string>;

package/dist/lib/utils/compress.js

@@ -0,0 +1,13 @@
+import { deflate } from "zlib";
+import { promisify } from "util";
+const deflateP = promisify(deflate);
+/**
+ * Compresses a JSON-serializable object into a Base64-encoded deflate string.
+ *
+ * @param data - The JSON-serializable object to compress.
+ * @returns A promise that resolves to a Base64-encoded string of the deflate-compressed data.
+ */
+export async function compressJson(data) {
+    const gz = await deflateP(Buffer.from(JSON.stringify(data)));
+    return gz.toString("base64");
+}

package/dist/lib/utils/declaration-maps.d.ts

@@ -0,0 +1,3 @@
+import type ts from "typescript";
+export declare function resolveDeclarationMaps(file: string): string;
+export declare function addInferredDeclarationMapPaths(opts: ts.CompilerOptions, files: readonly string[]): void;

package/dist/lib/utils/declaration-maps.js

@@ -0,0 +1,51 @@
+import { existsSync } from "fs";
+import { readFile } from "./fs.js";
+import { Validation } from "#utils";
+import { join, relative, resolve } from "path";
+import { getCommonDirectory, normalizePath } from "./paths.js";
+const declarationMapCache = new Map();
+export function resolveDeclarationMaps(file) {
+    if (!/\.d\.[cm]?ts$/.test(file))
+        return file;
+    if (declarationMapCache.has(file))
+        return declarationMapCache.get(file);
+    const mapFile = file + ".map";
+    if (!existsSync(mapFile))
+        return file;
+    let sourceMap;
+    try {
+        sourceMap = JSON.parse(readFile(mapFile));
+    }
+    catch {
+        return file;
+    }
+    if (Validation.validate({
+        file: String,
+        sourceRoot: Validation.optional(String),
+        sources: [Array, String],
+    }, sourceMap)) {
+        // There's a pretty large assumption in here that we only have
+        // 1 source file per js file. This is a pretty standard typescript approach,
+        // but people might do interesting things with transpilation that could break this.
+        let source = sourceMap.sources[0];
+        // If we have a sourceRoot, trim any leading slash from the source, and join them
+        // Similar to how it's done at https://github.com/mozilla/source-map/blob/58819f09018d56ef84dc41ba9c93f554e0645169/lib/util.js#L412
+        if (sourceMap.sourceRoot !== undefined) {
+            source = source.replace(/^\//, "");
+            source = join(sourceMap.sourceRoot, source);
+        }
+        const result = resolve(mapFile, "..", source);
+        declarationMapCache.set(file, result);
+        return result;
+    }
+    return file;
+}
+// See also: inferEntryPoints in entry-point.ts
+export function addInferredDeclarationMapPaths(opts, files) {
+    const rootDir = opts.rootDir || getCommonDirectory(files);
+    const declDir = opts.declarationDir || opts.outDir || rootDir;
+    for (const file of files) {
+        const mapFile = normalizePath(resolve(declDir, relative(rootDir, file)).replace(/\.([cm]?[tj]s)x?$/, ".d.$1"));
+        declarationMapCache.set(mapFile, file);
+    }
+}