rspress-plugin-api-extractor 0.1.2 → 0.2.1

package/category-resolver.js

@@ -0,0 +1,50 @@
+//#region src/category-resolver.ts
+/**
+* Resolver for category and source configurations with proper precedence handling.
+* Encapsulates the logic for merging category configs and resolving source configs.
+*/
+var CategoryResolver = class {
+	/**
+	* Deep merge two category config objects
+	* Later config overrides earlier config
+	*/
+	mergeTwoCategories(base, override) {
+		const result = { ...base };
+		for (const [key, config] of Object.entries(override)) if (result[key]) result[key] = {
+			...result[key],
+			...config,
+			itemKinds: config.itemKinds ?? result[key].itemKinds,
+			overviewHeaders: config.overviewHeaders ?? result[key].overviewHeaders
+		};
+		else result[key] = config;
+		return result;
+	}
+	/**
+	* Merge category configs with proper precedence
+	* Later configs override earlier ones
+	*/
+	mergeCategories(...configs) {
+		let result = {};
+		for (const config of configs) if (config) result = this.mergeTwoCategories(result, config);
+		return result;
+	}
+	/**
+	* Resolve final category config for a specific API/version.
+	* Precedence: built-in defaults, then plugin defaults, then package categories, then version categories.
+	*/
+	resolveCategoryConfig(pluginDefaults, packageCategories, versionCategories) {
+		return this.mergeCategories(pluginDefaults, packageCategories, versionCategories);
+	}
+	/**
+	* Resolve final source config for a specific API/version.
+	* Precedence: package source, then version source, then loader source (highest).
+	* Loader source is passed in as versionSource since it's already been extracted.
+	*/
+	resolveSourceConfig(packageSource, versionSource) {
+		if (versionSource) return versionSource;
+		if (packageSource) return packageSource;
+	}
+};
+
+//#endregion
+export { CategoryResolver };

package/code-post-processor.js

@@ -0,0 +1,38 @@
+import { isTwoslashDirective } from "./twoslash-patterns.js";
+
+//#region src/code-post-processor.ts
+/**
+* Add logical blank lines between code sections for visual clarity.
+*
+* Runs after Prettier formatting to insert breathing room between
+* imports, comments, and return statements without affecting the
+* structural formatting Prettier already applied.
+*/
+function addLogicalBlankLines(code) {
+	const lines = code.split("\n");
+	const result = [];
+	let inMultiLineImport = false;
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		const trimmed = line.trim();
+		const wasInMultiLineImport = inMultiLineImport;
+		if (!inMultiLineImport && trimmed.startsWith("import ") && !trimmed.endsWith(";")) inMultiLineImport = true;
+		else if (inMultiLineImport && trimmed.endsWith(";")) inMultiLineImport = false;
+		const isCurrentImport = trimmed.startsWith("import ") || wasInMultiLineImport;
+		if (result.length > 0 && !isCurrentImport) {
+			const prevTrimmed = result[result.length - 1].trim();
+			if (prevTrimmed !== "") {
+				const isDirective = isTwoslashDirective(trimmed);
+				const prevIsImportEnd = prevTrimmed.startsWith("import ") && prevTrimmed.endsWith(";") || /}\s*from\s+/.test(prevTrimmed) && prevTrimmed.endsWith(";");
+				if (prevIsImportEnd && trimmed !== "" && !isDirective) result.push("");
+				if (trimmed.startsWith("//") && !isDirective && !prevTrimmed.startsWith("//") && !prevIsImportEnd) result.push("");
+				if (/^return[\s;(]/.test(trimmed) && !prevTrimmed.startsWith("//")) result.push("");
+			}
+		}
+		result.push(line);
+	}
+	return result.join("\n");
+}
+
+//#endregion
+export { addLogicalBlankLines };

package/config-helpers.js

@@ -0,0 +1,106 @@
+import { normalizeBaseRoute, unscopedName } from "./path-derivation.js";
+import fs from "node:fs";
+import path from "node:path";
+
+//#region src/config-helpers.ts
+const PREFIX = "[rspress-plugin-api-extractor]";
+function discoverModel(dir, packageName) {
+	const apiJsonFiles = fs.readdirSync(dir).filter((f) => f.endsWith(".api.json"));
+	if (apiJsonFiles.length === 1) return path.join(dir, apiJsonFiles[0]);
+	if (apiJsonFiles.length === 0) throw new Error(`${PREFIX} api.fromDir: no *.api.json model found in ${dir}. Pass an explicit \`model\` to override.`);
+	const unscoped = unscopedName(packageName);
+	const preferred = apiJsonFiles.find((f) => f === `${unscoped}.api.json`);
+	if (preferred) return path.join(dir, preferred);
+	throw new Error(`${PREFIX} api.fromDir: multiple *.api.json files in ${dir} (${apiJsonFiles.join(", ")}) and none match "${unscoped}.api.json". Pass an explicit \`model\`.`);
+}
+function discoverDir(dir) {
+	let stat;
+	try {
+		stat = fs.statSync(dir);
+	} catch {
+		throw new Error(`${PREFIX} api.fromDir: directory not found: ${dir}`);
+	}
+	if (!stat.isDirectory()) throw new Error(`${PREFIX} api.fromDir: not a directory: ${dir}`);
+	let pkg;
+	try {
+		pkg = JSON.parse(fs.readFileSync(path.join(dir, "package.json"), "utf8"));
+	} catch {
+		throw new Error(`${PREFIX} api.fromDir: missing or unreadable package.json in ${dir}`);
+	}
+	if (!pkg.name) throw new Error(`${PREFIX} api.fromDir: package.json in ${dir} has no "name" field`);
+	return {
+		dir,
+		dirname: path.basename(dir),
+		packageName: pkg.name,
+		version: pkg.version ?? "",
+		modelPath: discoverModel(dir, pkg.name)
+	};
+}
+function resolveBaseRoute(baseRoute, info) {
+	return normalizeBaseRoute((typeof baseRoute === "function" ? baseRoute(info) : baseRoute).replace(/\{dirname\}/g, info.dirname).replace(/\{packageName\}/g, info.packageName));
+}
+/**
+* Build a `MultiApiConfig` by discovering fields from a single package folder
+* produced by `@savvy-web/rslib-builder`'s `localPaths` option. Exposed as
+* `ApiExtractorPlugin.api.fromDir`; the returned config can be passed to the
+* single-API `api:` option or used as an element of the multi-API `apis:` array.
+*
+* `baseRoute` is intentionally left unset unless overridden, so the plugin
+* applies its own context-aware default (`/api` under `api:`,
+* `/{packageName}/api` under `apis:`). See {@link BaseRoute}.
+*/
+function fromDir(dir, overrides = {}) {
+	const { baseRoute, cwd, ...rest } = overrides;
+	const info = discoverDir(path.resolve(cwd ?? process.cwd(), dir));
+	const discovered = {
+		packageName: info.packageName,
+		name: info.packageName,
+		model: info.modelPath,
+		packageJson: path.join(info.dir, "package.json")
+	};
+	if (baseRoute !== void 0) discovered.baseRoute = resolveBaseRoute(baseRoute, info);
+	const tsconfigPath = path.join(info.dir, "tsconfig.json");
+	if (fs.existsSync(tsconfigPath)) discovered.tsconfig = tsconfigPath;
+	return {
+		...discovered,
+		...rest
+	};
+}
+function isModelFolder(dir) {
+	if (!fs.existsSync(path.join(dir, "package.json"))) return false;
+	try {
+		return fs.readdirSync(dir).some((f) => f.endsWith(".api.json"));
+	} catch {
+		return false;
+	}
+}
+/**
+* Strictly scan a parent directory of package folders and build one
+* `MultiApiConfig` per subfolder. Exposed as `ApiExtractorPlugin.apis.fromDir`;
+* the returned array is intended for the multi-API `apis:` option. Every
+* non-dotfile subdirectory MUST be a valid model folder. `options` (minus
+* `cwd`) is applied as shared defaults to each `api.fromDir` call.
+*/
+function fromParentDir(parentDir, options = {}) {
+	const { cwd, ...rest } = options;
+	const absParent = path.resolve(cwd ?? process.cwd(), parentDir);
+	let stat;
+	try {
+		stat = fs.statSync(absParent);
+	} catch {
+		throw new Error(`${PREFIX} apis.fromDir: directory not found: ${absParent}`);
+	}
+	if (!stat.isDirectory()) throw new Error(`${PREFIX} apis.fromDir: not a directory: ${absParent}`);
+	const subdirs = fs.readdirSync(absParent, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name).sort();
+	const configs = [];
+	for (const name of subdirs) {
+		const subdir = path.join(absParent, name);
+		if (!isModelFolder(subdir)) throw new Error(`${PREFIX} apis.fromDir: "${name}" in ${absParent} is not a valid model folder (needs package.json and a *.api.json). Use api.fromDir for selective inclusion.`);
+		configs.push(fromDir(subdir, rest));
+	}
+	if (configs.length === 0) throw new Error(`${PREFIX} apis.fromDir: no model folders found in ${absParent}. Have the package models been built?`);
+	return configs;
+}
+
+//#endregion
+export { fromDir, fromParentDir };

package/config-utils.js

@@ -0,0 +1,258 @@
+import { Effect } from "effect";
+import { SemVer } from "semver-effect";
+
+//#region src/config-utils.ts
+/**
+* Type guard to check if version value is a full VersionConfig
+*/
+function isVersionConfig(value) {
+	return typeof value === "object" && value !== null && !(value instanceof URL) && !Buffer.isBuffer(value) && "model" in value;
+}
+/**
+* Type guard to check if loader result includes source config
+*/
+function isLoadedModel(result) {
+	return typeof result === "object" && result !== null && "model" in result;
+}
+/**
+* Normalize llmsPlugin config to always be an LlmsPlugin object
+*/
+function normalizeLlmsPluginConfig(config) {
+	if (config === false) return { enabled: false };
+	if (config === true || config === void 0) return { enabled: true };
+	return {
+		enabled: true,
+		...config
+	};
+}
+/**
+* Merge LLM plugin configurations with precedence: version, then API, then global.
+* Returns merged config with sensible defaults.
+*/
+function mergeLlmsPluginConfig(globalConfig, apiConfig, versionConfig) {
+	const merged = {
+		...normalizeLlmsPluginConfig(globalConfig),
+		...apiConfig,
+		...versionConfig
+	};
+	if (merged.enabled) return {
+		enabled: true,
+		scopes: merged.scopes ?? true,
+		apiTxt: merged.apiTxt ?? true,
+		showCopyButton: merged.showCopyButton ?? true,
+		showViewOptions: merged.showViewOptions ?? true,
+		copyButtonText: merged.copyButtonText ?? "Copy Markdown",
+		viewOptions: merged.viewOptions ?? [
+			"markdownLink",
+			"chatgpt",
+			"claude"
+		]
+	};
+	return { enabled: false };
+}
+/**
+* Common type utility packages to automatically load from devDependencies.
+* These packages provide type transformations and utilities commonly used in TypeScript projects.
+*/
+const TYPE_UTILITY_PACKAGES = ["type-fest", "ts-extras"];
+/**
+* Extract peerDependencies from PackageJson and convert to ExternalPackageSpec array.
+* This allows automatic loading of peer dependency types for documentation examples.
+*
+* @param packageJson - The parsed package.json object
+* @returns Array of external package specs from peerDependencies, or empty array if none
+*
+* @example
+* ```ts
+* const pkg = { name: "my-lib", peerDependencies: { "zod": "^3.22.4" } };
+* const external = extractPeerDependencies(pkg);
+* // Returns: [{ name: "zod", version: "^3.22.4" }]
+* ```
+*/
+function extractPeerDependencies(packageJson) {
+	if (!packageJson?.peerDependencies) return [];
+	return Object.entries(packageJson.peerDependencies).map(([name, version]) => ({
+		name,
+		version
+	}));
+}
+/**
+* Extract type utility packages (type-fest, ts-extras) from devDependencies.
+* These packages are commonly used for type transformations and should be available in documentation examples.
+*
+* @param packageJson - The parsed package.json object
+* @returns Array of external package specs for type utilities found in devDependencies
+*
+* @example
+* ```ts
+* const pkg = { devDependencies: { "type-fest": "^4.0.0", "ts-extras": "^0.12.0" } };
+* const external = extractTypeUtilities(pkg);
+* // Returns: [{ name: "type-fest", version: "^4.0.0" }, { name: "ts-extras", version: "^0.12.0" }]
+* ```
+*/
+function extractTypeUtilities(packageJson) {
+	if (!packageJson?.devDependencies) return [];
+	const utilities = [];
+	for (const utilityName of TYPE_UTILITY_PACKAGES) {
+		const version = packageJson.devDependencies[utilityName];
+		if (version) utilities.push({
+			name: utilityName,
+			version
+		});
+	}
+	return utilities;
+}
+/**
+* Extract all automatically-detected external packages from package.json.
+* Controlled by AutoDetectDependencies to determine which dependency types to include.
+*
+* @param packageJson - The parsed package.json object
+* @param options - Options controlling which dependency types to include
+* @returns Array of all external package specs to load for documentation
+*
+* @example
+* ```ts
+* const pkg = {
+*   dependencies: { "effect": "^3.0.0" },
+*   peerDependencies: { "zod": "^3.22.4" },
+*   devDependencies: { "type-fest": "^4.0.0" }
+* };
+*
+* // Default: only peerDependencies + type utilities
+* extractAutoDetectedPackages(pkg);
+* // Returns: [{ name: "zod", version: "^3.22.4" }, { name: "type-fest", version: "^4.0.0" }]
+*
+* // Include all dependency types
+* extractAutoDetectedPackages(pkg, { dependencies: true, peerDependencies: true, autoDependencies: true });
+* // Returns: [{ name: "effect", ... }, { name: "zod", ... }, { name: "type-fest", ... }]
+* ```
+*/
+function extractAutoDetectedPackages(packageJson, options = {}) {
+	const { dependencies = false, devDependencies = false, peerDependencies = true, autoDependencies = true } = options;
+	const packages = [];
+	if (dependencies && packageJson?.dependencies) packages.push(...Object.entries(packageJson.dependencies).map(([name, version]) => ({
+		name,
+		version
+	})));
+	if (devDependencies && packageJson?.devDependencies) packages.push(...Object.entries(packageJson.devDependencies).filter(([name]) => !autoDependencies || !TYPE_UTILITY_PACKAGES.includes(name)).map(([name, version]) => ({
+		name,
+		version
+	})));
+	if (peerDependencies) packages.push(...extractPeerDependencies(packageJson));
+	if (autoDependencies) packages.push(...extractTypeUtilities(packageJson));
+	return resolvePackageVersionConflicts(packages);
+}
+/**
+* Deduplicate external packages by name, resolving to the highest version when conflicts exist.
+* Uses semver-effect to pick the highest version from duplicates.
+*
+* @param packages - Array of external package specs (may contain duplicates)
+* @returns Deduplicated array with highest versions
+*
+* @example
+* ```ts
+* const packages = [
+*   { name: "zod", version: "^3.22.4" },
+*   { name: "zod", version: "^3.23.0" },
+*   { name: "effect", version: "^3.0.0" }
+* ];
+* const resolved = resolvePackageVersionConflicts(packages);
+* // Returns: [{ name: "zod", version: "^3.23.0" }, { name: "effect", version: "^3.0.0" }]
+* ```
+*/
+function resolvePackageVersionConflicts(packages) {
+	const packageMap = /* @__PURE__ */ new Map();
+	for (const pkg of packages) {
+		const versions = packageMap.get(pkg.name) || [];
+		versions.push(pkg.version);
+		packageMap.set(pkg.name, versions);
+	}
+	const resolved = [];
+	for (const [name, versions] of packageMap) {
+		if (versions.length === 1) {
+			resolved.push({
+				name,
+				version: versions[0]
+			});
+			continue;
+		}
+		const highestVersion = findHighestVersion(versions);
+		resolved.push({
+			name,
+			version: highestVersion
+		});
+	}
+	return resolved;
+}
+/**
+* Strip range prefixes from a version string to get a clean semver.
+*/
+function stripRangePrefix(version) {
+	return version.replace(/^[~^>=<]+\s*/, "");
+}
+/**
+* Find the highest version from a list of version specifiers using semver-effect.
+* Handles version ranges and exact versions.
+*
+* @param versions - Array of version strings (can be ranges or exact versions)
+* @returns The highest version specifier
+*
+* @example
+* ```ts
+* findHighestVersion(["^3.22.4", "^3.23.0", "3.22.5"])
+* // Returns: "^3.23.0"
+* ```
+*/
+function findHighestVersion(versions) {
+	const parsedVersions = [];
+	for (const version of versions) {
+		const cleaned = stripRangePrefix(version);
+		const result = Effect.runSyncExit(SemVer.parse(cleaned));
+		if (result._tag === "Success") parsedVersions.push({
+			original: version,
+			version: result.value
+		});
+	}
+	if (parsedVersions.length === 0) return versions[versions.length - 1];
+	parsedVersions.sort((a, b) => {
+		if (SemVer.gt(a.version, b.version)) return -1;
+		if (SemVer.lt(a.version, b.version)) return 1;
+		return 0;
+	});
+	return parsedVersions[0].original;
+}
+/**
+* Validate that manually specified externalPackages don't conflict with peerDependencies.
+* Throws an error if a package appears in both with different versions.
+*
+* @param externalPackages - Manually specified external packages
+* @param packageJson - The parsed package.json object
+* @throws Error if versions conflict
+*
+* @example
+* ```ts
+* const external = [{ name: "zod", version: "3.22.4" }];
+* const pkg = { peerDependencies: { "zod": "^3.22.4" } };
+* validateExternalPackages(external, pkg);
+* // Throws if versions conflict
+* ```
+*/
+function validateExternalPackages(externalPackages, packageJson) {
+	if (!externalPackages || !packageJson?.peerDependencies) return;
+	const conflicts = [];
+	for (const pkg of externalPackages) {
+		const peerVersion = packageJson.peerDependencies[pkg.name];
+		if (peerVersion && peerVersion !== pkg.version) conflicts.push({
+			name: pkg.name,
+			external: pkg.version,
+			peer: peerVersion
+		});
+	}
+	if (conflicts.length > 0) {
+		const details = conflicts.map((c) => `  - ${c.name}: externalPackages="${c.external}" vs peerDependencies="${c.peer}"`).join("\n");
+		throw new Error(`Version conflict detected between externalPackages and peerDependencies:\n${details}\n\nRemove conflicting entries from externalPackages to use peerDependencies versions automatically.`);
+	}
+}
+
+//#endregion
+export { extractAutoDetectedPackages, isLoadedModel, isVersionConfig, mergeLlmsPluginConfig, validateExternalPackages };

package/content-hash.js

@@ -0,0 +1,79 @@
+import { createHash } from "node:crypto";
+
+//#region src/content-hash.ts
+/**
+* Normalizes content string for consistent hashing.
+*
+* Applies the following transformations:
+* - Converts all line endings to Unix-style (`\n`)
+* - Trims leading and trailing whitespace
+* - Collapses multiple consecutive blank lines to a single blank line
+*
+* @param content - The content string to normalize
+* @returns Normalized content string
+*
+* @example
+* ```typescript
+* const normalized = normalizeContent("line1\r\n\r\n\r\nline2  ");
+* // Returns: "line1\n\nline2"
+* ```
+*/
+function normalizeContent(content) {
+	return content.replaceAll("\r\n", "\n").replaceAll("\r", "\n").trim().replaceAll(/\n{3,}/g, "\n\n");
+}
+/**
+* Generates a SHA-256 hash of normalized markdown content.
+*
+* The content is normalized before hashing to ensure consistent results
+* regardless of line ending differences or trailing whitespace.
+*
+* @param content - The markdown content to hash (excluding frontmatter)
+* @returns Hexadecimal SHA-256 hash string
+*
+* @example
+* ```typescript
+* const hash = hashContent("# My Title\n\nContent here");
+* ```
+*/
+function hashContent(content) {
+	const normalized = normalizeContent(content);
+	return createHash("sha256").update(normalized).digest("hex");
+}
+/**
+* Generates a SHA-256 hash of frontmatter fields.
+*
+* Excludes timestamp-related fields (`publishedTime`, `modifiedTime`, `head`,
+* `article:published_time`, `article:modified_time`) to prevent circular
+* dependencies in change detection.
+*
+* @param frontmatter - The frontmatter object to hash
+* @returns Hexadecimal SHA-256 hash string
+*
+* @remarks
+* Keys are sorted alphabetically before hashing to ensure consistent
+* results regardless of object key order.
+*
+* @example
+* ```typescript
+* const hash = hashFrontmatter({
+*   title: "My Page",
+*   description: "Page description"
+* });
+* ```
+*/
+function hashFrontmatter(frontmatter) {
+	const filtered = {};
+	for (const [key, value] of Object.entries(frontmatter)) {
+		if (key === "publishedTime" || key === "modifiedTime" || key === "head" || key === "article:published_time" || key === "article:modified_time") continue;
+		filtered[key] = value;
+	}
+	const sorted = Object.keys(filtered).sort().reduce((acc, key) => {
+		acc[key] = filtered[key];
+		return acc;
+	}, {});
+	const json = JSON.stringify(sorted);
+	return createHash("sha256").update(json).digest("hex");
+}
+
+//#endregion
+export { hashContent, hashFrontmatter };

package/errors.js

@@ -0,0 +1,29 @@
+import { Data } from "effect";
+
+//#region src/errors.ts
+const ConfigValidationErrorBase = Data.TaggedError("ConfigValidationError");
+var ConfigValidationError = class extends ConfigValidationErrorBase {
+	get message() {
+		return `Config validation failed for '${this.field}': ${this.reason}`;
+	}
+};
+const ApiModelLoadErrorBase = Data.TaggedError("ApiModelLoadError");
+const SnapshotDbErrorBase = Data.TaggedError("SnapshotDbError");
+var SnapshotDbError = class extends SnapshotDbErrorBase {
+	get message() {
+		return `Snapshot DB error during '${this.operation}' at '${this.dbPath}': ${this.reason}`;
+	}
+};
+const PathDerivationErrorBase = Data.TaggedError("PathDerivationError");
+const TypeRegistryErrorBase = Data.TaggedError("TypeRegistryError");
+var TypeRegistryError = class extends TypeRegistryErrorBase {
+	get message() {
+		return `Type registry error for '${this.packageName}@${this.version}': ${this.reason}`;
+	}
+};
+const PageGenerationErrorBase = Data.TaggedError("PageGenerationError");
+const TwoslashProcessingErrorBase = Data.TaggedError("TwoslashProcessingError");
+const PrettierFormatErrorBase = Data.TaggedError("PrettierFormatError");
+
+//#endregion
+export { ConfigValidationError, SnapshotDbError, TypeRegistryError };

package/formatter.js

@@ -0,0 +1,69 @@
+import { TypeSignatureFormatter } from "api-extractor-llms";
+
+//#region src/formatter.ts
+/**
+* Formats TypeScript type signatures for display in documentation.
+*
+* Transforms raw API Extractor excerpt text into clean, readable signatures.
+* The core {@link TypeSignatureFormatter.format | format} algorithm is
+* inherited from the `api-extractor-llms` `TypeSignatureFormatter`; this
+* subclass adds the positional constructor and the test-only
+* {@link TypeSignatureFormatter.addLinks | addLinks} cross-link injection.
+*
+* **Relationships:**
+* - Used by all page generators ({@link ClassPageGenerator}, etc.)
+* - Works with API Extractor's `Excerpt` model
+* - Can integrate with {@link MarkdownCrossLinker} for type linking
+*
+* @example
+* ```ts
+* const formatter = new TypeSignatureFormatter();
+*
+* // Format a simple signature
+* const signature = formatter.format(apiFunction.excerpt);
+* // "function myFunc(arg: string): Promise<void>"
+*
+* // With cross-linking
+* const linked = formatter.addLinks(signature, excerpt);
+* // "function myFunc(arg: string): Promise<[MyType](/api/types/mytype)>"
+* ```
+*/
+var TypeSignatureFormatter$1 = class extends TypeSignatureFormatter {
+	apiItemRoutes;
+	constructor(maxLineLength = 80, indent = "  ", apiItemRoutes) {
+		super({
+			maxLineLength,
+			indent
+		});
+		this.apiItemRoutes = apiItemRoutes;
+	}
+	/**
+	* Inject markdown cross-links into already-formatted signature text.
+	*
+	* A lower-level escape hatch kept for callers that want link injection at
+	* the formatter level; the build pipeline normally cross-links prose via
+	* MarkdownCrossLinker instead. The shared library's formatter has no
+	* equivalent, so this stays plugin-local. Covered by formatter.test.ts.
+	*/
+	addLinks(text, excerpt) {
+		if (!excerpt.spannedTokens || !this.apiItemRoutes) return text;
+		const typeReferences = /* @__PURE__ */ new Map();
+		for (const token of excerpt.spannedTokens) if (token.kind === "Reference" && token.canonicalReference) {
+			const canonicalRef = token.canonicalReference.toString();
+			const route = this.apiItemRoutes.get(canonicalRef);
+			if (route && token.text) typeReferences.set(token.text.trim(), route);
+		}
+		let result = text;
+		for (const [typeName, route] of typeReferences.entries()) {
+			const regex = new RegExp(`\\b${this.escapeRegExp(typeName)}\\b`, "g");
+			result = result.replace(regex, `[${typeName}](${route})`);
+		}
+		return result;
+	}
+	escapeRegExp(string) {
+		return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	}
+};
+
+//#endregion
+export { TypeSignatureFormatter$1 as TypeSignatureFormatter };