rspress-plugin-api-extractor 0.13.3 → 0.15.0

package/twoslash-cache.js

@@ -1,174 +0,0 @@
-import { createHash } from "node:crypto";
-import { gunzipSync, gzipSync } from "node:zlib";
-
-//#region src/twoslash-cache.ts
-/**
-* Persisted Twoslash result cache.
-*
-* Type-checking code blocks is by far the dominant cost of the render phase —
-* measured at ~97% of it, concentrated in the minority of blocks that carry an
-* `@example` (see `render-phase-instrumentation.md`). `@shikijs/twoslash`
-* exposes a first-class `typesCache` seam for exactly this, so the work here is
-* a keying scheme and a store rather than a new interception point.
-*
-* ## Soundness
-*
-* A Twoslash result depends on the code, the compiler options, the declarations
-* it is checked against, and the compiler doing the checking. The keys cover
-* all four: the per-entry key carries the code, its language and the compiler
-* options; {@link twoslashEnvHash} carries the declarations and the TypeScript
-* version.
-*
-* The TypeScript version is load-bearing and easy to overlook — `lib.d.ts`
-* ships with the compiler and inference changes between releases, so an upgrade
-* against unchanged declarations yields different hovers. Omitting it would let
-* a warm cache serve results from the previous compiler and stay wrong until
-* the API's own declarations happened to change.
-*
-* NOT covered, and covered instead by {@link TWOSLASH_CACHE_FORMAT}: the
-* `@shikijs/twoslash` / `twoslash` renderer version, which determines the shape
-* of the stored `nodes`. Bump the format constant when upgrading those, since
-* nothing derives it automatically.
-*
-* ## Invalidation granularity
-*
-* The consequence of that soundness is coarse invalidation: any VFS change
-* discards the whole generation, because a declaration change anywhere can
-* legitimately change any block's inferred types. So this cache makes repeat
-* builds over an UNCHANGED API nearly free — CI re-runs, prose-only edits,
-* theme and config changes, rebuilding a site without touching the library —
-* and does nothing for the build right after an API item changes.
-*
-* Sharpening that would need per-scope type environments, so one package's
-* change stops invalidating every other package's blocks. That is fix (b) in
-* `render-phase-instrumentation.md`, tracked as a correctness fix; it would
-* make this cache substantially more effective on a multi-API site as a side
-* effect.
-*
-* ## Synchronous by necessity
-*
-* `TwoslashTypesCache.read`/`write` are synchronous — they are called from
-* inside Shiki's `preprocess` hook. Persistence is therefore load-once at
-* startup and save-once at the end, against an in-memory map; there is no
-* per-entry I/O. See `TwoslashCacheService`.
-*/
-/**
-* Bumped when the stored shape changes, so an older blob is treated as absent
-* rather than deserialized into the wrong shape.
-*
-* Also the manual lever for renderer changes: bump this when upgrading
-* `@shikijs/twoslash` or `twoslash`, whose versions determine the shape of the
-* stored `nodes` and are not derived into any key.
-*/
-const TWOSLASH_CACHE_FORMAT = 1;
-function sha256(input) {
-	return createHash("sha256").update(input).digest("hex");
-}
-/**
-* Fingerprint the type environment a generation is checked against.
-*
-* Covers the declarations (`vfs`) and the compiler that interprets them
-* (`toolchain`). The VFS is hashed over sorted `path\0content` pairs so the
-* digest is stable against map iteration order.
-*
-* `toolchain` must carry the TypeScript version. The declarations alone do not
-* determine the answer: `lib.d.ts` ships with the compiler and inference
-* behaviour changes between releases, so upgrading TypeScript against unchanged
-* declarations produces different hovers. Without the version in the key the
-* warm cache would serve results computed by the previous compiler, and stay
-* wrong until the API's own declarations happened to change.
-*
-* Compiler OPTIONS are deliberately not folded in here — they belong on the
-* per-entry key, so one generation can hold results from the several
-* configurations a multi-API site may declare.
-*/
-function twoslashEnvHash(vfs, toolchain) {
-	const hash = createHash("sha256");
-	hash.update(`format:${1}\0toolchain:${toolchain}\0`);
-	for (const key of [...vfs.keys()].sort()) hash.update(`${key}\0${vfs.get(key) ?? ""}\0`);
-	return hash.digest("hex");
-}
-/** JSON with object keys sorted, so equivalent options hash identically. */
-function stableStringify(value) {
-	if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
-	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
-	return `{${Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`).join(",")}}`;
-}
-/**
-* Per-entry key: the code, its language, and the compiler configuration it is
-* checked under.
-*
-* The configuration matters because two APIs on one site may be documented
-* under different `tsconfig`s — the same source checked under different options
-* can produce different types, so it must not share a cache entry.
-*/
-function twoslashEntryKey(code, lang, compilerOptions) {
-	return sha256(`${lang ?? "ts"}\0${stableStringify(compilerOptions ?? {})}\0${code}`);
-}
-/**
-* The cache key a whole generation is stored under. One blob per environment,
-* so a changed environment reads as a miss rather than serving stale results.
-*/
-function twoslashBlobKey(envHash) {
-	return `twoslash/v${1}/${envHash}`;
-}
-/**
-* Build a synchronous Twoslash cache over an in-memory map, optionally seeded
-* with entries loaded from a previous build.
-*/
-function makeTwoslashCache(initial) {
-	const map = new Map(initial);
-	let hits = 0;
-	let misses = 0;
-	let dirty = false;
-	return {
-		read: (code, lang, options) => {
-			const found = map.get(twoslashEntryKey(code, lang, options?.compilerOptions));
-			if (found === void 0) {
-				misses += 1;
-				return null;
-			}
-			hits += 1;
-			return found;
-		},
-		write: (code, data, lang, options) => {
-			const value = {
-				nodes: data.nodes,
-				code: data.code,
-				...data.meta?.extension != null ? { meta: { extension: data.meta.extension } } : {}
-			};
-			map.set(twoslashEntryKey(code, lang, options?.compilerOptions), value);
-			dirty = true;
-		},
-		stats: () => ({
-			hits,
-			misses,
-			entries: map.size,
-			dirty
-		}),
-		entries: () => map
-	};
-}
-/** Serialize a generation for storage. Gzipped JSON — hover text compresses well. */
-function encodeTwoslashCache(entries) {
-	return gzipSync(Buffer.from(JSON.stringify(Object.fromEntries(entries)), "utf-8"));
-}
-/**
-* Deserialize a stored generation.
-*
-* Returns an empty map for anything unreadable — a truncated blob, a format
-* change, a corrupted file. A cache that cannot be read is a cache miss, never
-* a build failure.
-*/
-function decodeTwoslashCache(blob) {
-	try {
-		const parsed = JSON.parse(gunzipSync(blob).toString("utf-8"));
-		if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return /* @__PURE__ */ new Map();
-		return new Map(Object.entries(parsed));
-	} catch {
-		return /* @__PURE__ */ new Map();
-	}
-}
-
-//#endregion
-export { decodeTwoslashCache, encodeTwoslashCache, makeTwoslashCache, twoslashBlobKey, twoslashEntryKey, twoslashEnvHash };

package/twoslash-patterns.js

@@ -1,87 +0,0 @@
-//#region src/twoslash-patterns.ts
-/**
-* Twoslash directive detection patterns.
-*
-* These regexes mirror the upstream Twoslash source at:
-* https://github.com/twoslashes/twoslash/blob/main/packages/twoslash/src/regexp.ts
-*
-* All patterns allow an optional space after `//` (e.g., both `// @noErrors`
-* and `//@noErrors` are valid Twoslash syntax).
-*/
-/**
-* Config directives: boolean flags and key-value pairs.
-*
-* Upstream: `reConfigBoolean` + `reConfigValue` + `reFilenamesMakers`
-*
-* @example
-* ```
-* // @noErrors
-* //@strict
-* // @errors: 2304
-* // @target: ES2020
-* // @filename: example.ts
-* ```
-*/
-const RE_CONFIG = /^\/\/\s?@\w+/;
-/**
-* Annotation markers: query, completion, and highlight markers.
-*
-* Upstream: `reAnnonateMarkers` — `/^\s*\/\/\s*\^(\?|\||\^+)( .*)?$/gm`
-*
-* These are positioned under code lines with `^` characters for alignment.
-* After `line.trim()`, leading whitespace is removed but internal spaces
-* between `//` and `^` are preserved.
-*
-* @example
-* ```
-* // ^? — query (show type info)
-* //    ^? — query with alignment spaces
-* // ^| — completion (show autocomplete)
-* // ^^^ — highlight range
-* // ^^^^ description text
-* ```
-*/
-const RE_ANNOTATION = /^\/\/\s*\^[?|^]/;
-/**
-* Cut directives: control which code is visible in output.
-*
-* Upstream: `reCutBefore`, `reCutAfter`, `reCutStart`, `reCutEnd`
-*
-* @example
-* ```
-* // ---cut---
-* //---cut-before---
-* // ---cut-after---
-* // ---cut-start---
-* // ---cut-end---
-* ```
-*/
-const RE_CUT = /^\/\/\s?---cut/;
-/**
-* Test whether a trimmed line is any Twoslash directive.
-*
-* Covers all directive types: config flags, config values, filename markers,
-* annotation markers (query/completion/highlight), and cut directives.
-*
-* @param trimmedLine - The line with leading/trailing whitespace removed
-* @returns true if the line is a Twoslash directive
-*/
-function isTwoslashDirective(trimmedLine) {
-	return RE_CONFIG.test(trimmedLine) || RE_ANNOTATION.test(trimmedLine) || RE_CUT.test(trimmedLine);
-}
-/**
-* Classify a cut directive line.
-*
-* @param trimmedLine - The line with leading/trailing whitespace removed
-* @returns The cut type, or null if not a cut directive
-*/
-function classifyCutDirective(trimmedLine) {
-	if (/^\/\/\s?---cut(-before)?---$/.test(trimmedLine)) return "cut-before";
-	if (/^\/\/\s?---cut-after---$/.test(trimmedLine)) return "cut-after";
-	if (/^\/\/\s?---cut-start---$/.test(trimmedLine)) return "cut-start";
-	if (/^\/\/\s?---cut-end---$/.test(trimmedLine)) return "cut-end";
-	return null;
-}
-
-//#endregion
-export { classifyCutDirective, isTwoslashDirective };

package/type-reference-extractor.js

@@ -1,199 +0,0 @@
-import { ApiItemKind } from "@microsoft/api-extractor-model";
-
-//#region src/type-reference-extractor.ts
-/**
-* Extracts type references from API Extractor models to generate import statements.
-*
-* This class analyzes API items and their excerpt tokens to identify external type
-* references that need to be imported in the generated TypeScript declaration files.
-*
-* **How it works:**
-* 1. Walks through all API items (classes, interfaces, functions, etc.)
-* 2. Extracts type references from excerpt tokens
-* 3. Filters out built-in types and internal references
-* 4. Groups external references by package
-* 5. Generates `import type` statements
-*
-* **Reference Types:**
-* - **Built-in:** TypeScript types like `Promise`, `Record`, `NonNullable` (skipped)
-* - **Internal:** References to types in the same package (skipped)
-* - **External:** References to types from npm packages (imported)
-*
-* **Canonical Reference Format:**
-* API Extractor uses canonical references like:
-* - `"zod!ZodType:interface"` → External reference to `zod` package
-* - `"mypackage!MyType:type"` → Internal reference (same package)
-* - `"!Promise:interface"` → Built-in TypeScript type
-* - `"!\"node:buffer\".__global.Buffer:interface"` → Node.js built-in (treated as built-in)
-*
-* @example
-* ```ts
-* const extractor = new TypeReferenceExtractor(apiPackage, "my-package");
-* const imports = extractor.extractImports();
-*
-* for (const stmt of imports) {
-*   console.log(`import type { ${[...stmt.symbols].join(", ")} } from "${stmt.packageName}";`);
-* }
-* // Output:
-* // import type { ZodType } from "zod";
-* // import type { Effect } from "@effect/schema";
-* ```
-*/
-var TypeReferenceExtractor = class {
-	apiPackage;
-	currentPackageName;
-	/**
-	* All type references found in the API package
-	*/
-	references = /* @__PURE__ */ new Map();
-	constructor(apiPackage, currentPackageName) {
-		this.apiPackage = apiPackage;
-		this.currentPackageName = currentPackageName;
-	}
-	/**
-	* Extract all type references from the API package and generate import statements.
-	* Returns an array of import statements grouped by package.
-	*/
-	extractImports() {
-		this.walkApiPackage();
-		return this.generateImportStatements();
-	}
-	/**
-	* Extract type references for a specific entry point only.
-	* This enables per-entry-point import optimization for multi-entry packages.
-	*
-	* @param entryPoint - The specific entry point to extract imports for
-	* @returns Import statements containing only types used in this entry point
-	*/
-	extractImportsForEntryPoint(entryPoint) {
-		this.references.clear();
-		for (const member of entryPoint.members) this.walkApiItem(member);
-		return this.generateImportStatements();
-	}
-	/**
-	* Extract type references for a single API item.
-	* This enables generating imports for individual signatures.
-	*
-	* @param apiItem - The specific API item to extract imports for
-	* @returns Import statements containing only types used in this item
-	*/
-	extractImportsForApiItem(apiItem) {
-		this.references.clear();
-		this.walkApiItem(apiItem);
-		return this.generateImportStatements();
-	}
-	/**
-	* Generate import statements from collected references.
-	* Used by both extractImports() and extractImportsForEntryPoint().
-	*/
-	generateImportStatements() {
-		const packageMap = /* @__PURE__ */ new Map();
-		for (const ref of this.references.values()) {
-			if (ref.isBuiltIn || ref.isInternal) continue;
-			if (!packageMap.has(ref.packageName)) packageMap.set(ref.packageName, /* @__PURE__ */ new Set());
-			packageMap.get(ref.packageName)?.add(ref.symbolName);
-		}
-		const imports = [];
-		for (const [packageName, symbols] of packageMap.entries()) imports.push({
-			packageName,
-			symbols,
-			typeOnly: true
-		});
-		imports.sort((a, b) => a.packageName.localeCompare(b.packageName));
-		return imports;
-	}
-	/**
-	* Generate import statement strings from ImportStatement objects.
-	* Returns an array of formatted import statements.
-	*/
-	static formatImports(imports) {
-		const statements = [];
-		for (const stmt of imports) {
-			const sortedSymbols = Array.from(stmt.symbols).sort();
-			const statement = `${stmt.typeOnly ? "import type" : "import"} { ${sortedSymbols.join(", ")} } from "${stmt.packageName}";`;
-			statements.push(statement);
-		}
-		return statements;
-	}
-	/**
-	* Walk through the entire API package and extract all type references
-	*/
-	walkApiPackage() {
-		for (const entryPoint of this.apiPackage.entryPoints) for (const member of entryPoint.members) this.walkApiItem(member);
-	}
-	/**
-	* Recursively walk through an API item and its children to extract type references
-	*/
-	walkApiItem(apiItem) {
-		this.extractFromExcerpt(apiItem);
-		if ("members" in apiItem) {
-			const members = apiItem.members;
-			if (Array.isArray(members)) for (const member of members) this.walkApiItem(member);
-		}
-	}
-	/**
-	* Extract type references from an API item using its excerpt
-	*/
-	extractFromExcerpt(apiItem) {
-		const excerpt = this.getExcerpt(apiItem);
-		if (!excerpt) return;
-		this.extractFromExcerptTokens(excerpt);
-	}
-	/**
-	* Get the appropriate excerpt from an API item based on its kind
-	*/
-	getExcerpt(apiItem) {
-		const item = apiItem;
-		if (item.excerpt) return item.excerpt;
-		if (apiItem.kind === ApiItemKind.TypeAlias && item.typeExcerpt) return item.typeExcerpt;
-		if ((apiItem.kind === ApiItemKind.Property || apiItem.kind === ApiItemKind.PropertySignature) && item.propertyTypeExcerpt) return item.propertyTypeExcerpt;
-		if (item.returnTypeExcerpt) return item.returnTypeExcerpt;
-		return null;
-	}
-	/**
-	* Extract type references from excerpt tokens
-	*/
-	extractFromExcerptTokens(excerpt) {
-		if (!excerpt.spannedTokens || excerpt.spannedTokens.length === 0) return;
-		for (const token of excerpt.spannedTokens) {
-			if (token.kind !== "Reference") continue;
-			const canonicalRef = token.canonicalReference?.toString();
-			if (!canonicalRef || typeof canonicalRef !== "string") continue;
-			const ref = this.parseCanonicalReference(canonicalRef, token.text);
-			if (ref) this.references.set(ref.canonicalReference, ref);
-		}
-	}
-	/**
-	* Parse a canonical reference string to extract type reference information.
-	*
-	* Canonical reference format: "packageName!symbolName:kind"
-	* Examples:
-	* - "zod!ZodType:interface" → External reference
-	* - "mypackage!MyType:type" → Internal reference
-	* - "!Promise:interface" → Built-in type
-	* - "!\"node:buffer\".__global.Buffer:interface" → Node.js built-in
-	*/
-	parseCanonicalReference(canonicalRef, symbolText) {
-		const exclamationIndex = canonicalRef.indexOf("!");
-		if (exclamationIndex === -1) return null;
-		const packagePart = canonicalRef.substring(0, exclamationIndex);
-		const rest = canonicalRef.substring(exclamationIndex + 1);
-		const colonIndex = rest.indexOf(":");
-		const symbolFromCanonical = colonIndex !== -1 ? rest.substring(0, colonIndex) : rest;
-		const isBuiltIn = packagePart === "" || packagePart.startsWith("\"");
-		const isInternal = packagePart === this.currentPackageName;
-		let symbolName;
-		if (symbolText.includes(".")) symbolName = symbolText.split(".")[0].trim();
-		else symbolName = symbolFromCanonical.trim();
-		return {
-			symbolName,
-			packageName: packagePart,
-			canonicalReference: canonicalRef,
-			isBuiltIn,
-			isInternal
-		};
-	}
-};
-
-//#endregion
-export { TypeReferenceExtractor };

package/typescript-config.js

@@ -1,170 +0,0 @@
-import { TsConfigParseError, parseTsConfig } from "./tsconfig-parser.js";
-
-//#region src/typescript-config.ts
-/**
-* Default TypeScript compiler options for Twoslash and type resolution.
-*
-* These defaults are optimized for documentation:
-* - Modern ES targets (ESNext)
-* - Bundler module resolution for broad compatibility
-* - Lenient settings (non-strict) since docs often show simplified examples
-* - Skip lib checks for faster processing
-*
-* @remarks
-* Numeric values correspond to TypeScript enums:
-* - target: 99 = ESNext
-* - module: 99 = ESNext
-* - moduleResolution: 100 = Bundler
-*/
-const DEFAULT_COMPILER_OPTIONS = {
-	target: 99,
-	module: 99,
-	moduleResolution: 100,
-	lib: ["ESNext", "DOM"],
-	strict: false,
-	skipLibCheck: true,
-	esModuleInterop: true,
-	allowSyntheticDefaultImports: true
-};
-/**
-* Merge two TypeResolutionCompilerOptions objects.
-* Properties from `override` take precedence over `base`.
-*
-* @param base - Base compiler options
-* @param override - Options to merge on top (takes precedence)
-* @returns Merged options
-*
-* @example
-* ```ts
-* const base = { target: 99, lib: ["ESNext"] };
-* const override = { lib: ["ESNext", "DOM"], strict: true };
-* const merged = mergeCompilerOptions(base, override);
-* // Result: { target: 99, lib: ["ESNext", "DOM"], strict: true }
-* ```
-*/
-function mergeCompilerOptions(base, override) {
-	if (!override) return { ...base };
-	const merged = { ...base };
-	if (override.target !== void 0) merged.target = override.target;
-	if (override.module !== void 0) merged.module = override.module;
-	if (override.moduleResolution !== void 0) merged.moduleResolution = override.moduleResolution;
-	if (override.lib !== void 0) merged.lib = override.lib;
-	if (override.strict !== void 0) merged.strict = override.strict;
-	if (override.skipLibCheck !== void 0) merged.skipLibCheck = override.skipLibCheck;
-	if (override.esModuleInterop !== void 0) merged.esModuleInterop = override.esModuleInterop;
-	if (override.allowSyntheticDefaultImports !== void 0) merged.allowSyntheticDefaultImports = override.allowSyntheticDefaultImports;
-	if (override.jsx !== void 0) merged.jsx = override.jsx;
-	if (override.types !== void 0) merged.types = override.types;
-	return merged;
-}
-/**
-* Resolve a single TypeScriptConfig to compiler options (async version).
-* Handles both path-based and function-based tsconfig.
-*
-* Follows the priority cascade:
-* 1. Load tsconfig (from path or function)
-* 2. Merge compilerOptions on top
-*
-* @param config - TypeScript config with optional tsconfig path/function and/or compilerOptions
-* @param projectRoot - Project root for resolving relative tsconfig paths
-* @returns Promise resolving to compiler options (not merged with defaults)
-*
-* @example
-* ```ts
-* // Path-based tsconfig
-* await resolveTypeScriptConfigSingleAsync({ tsconfig: "tsconfig.json" }, "/project");
-*
-* // Function-based tsconfig
-* await resolveTypeScriptConfigSingleAsync({
-*   tsconfig: async () => ({ target: 99, lib: ["ESNext"] })
-* }, "/project");
-*
-* // Both (compilerOptions override tsconfig)
-* await resolveTypeScriptConfigSingleAsync({
-*   tsconfig: async () => ({ target: 99 }),
-*   compilerOptions: { strict: false }
-* }, "/project");
-* ```
-*/
-async function resolveTypeScriptConfigSingleAsync(config, projectRoot) {
-	if (!config) return {};
-	let options = {};
-	if (config.tsconfig) {
-		if (typeof config.tsconfig === "function") options = await config.tsconfig();
-		else {
-			const tsconfigPath = String(config.tsconfig);
-			try {
-				options = parseTsConfig(tsconfigPath, projectRoot);
-			} catch (error) {
-				if (error instanceof TsConfigParseError) throw error;
-				throw new TsConfigParseError(tsconfigPath, error instanceof Error ? error.message : String(error), error);
-			}
-		}
-	}
-	if (config.compilerOptions) options = mergeCompilerOptions(options, config.compilerOptions);
-	return options;
-}
-/**
-* Resolve TypeScript compiler options from a cascade of configurations (async).
-*
-* Resolution order (later levels override earlier):
-* 1. DEFAULT_COMPILER_OPTIONS (sensible defaults)
-* 2. Global plugin config
-* 3. API-level config
-* 4. Version-level config
-* 5. Per-package override (for external packages)
-*
-* At each level, if a TypeScriptConfig has both `tsconfig` and `compilerOptions`,
-* the tsconfig is loaded first, then compilerOptions are merged on top.
-*
-* @param projectRoot - Project root directory for resolving relative paths
-* @param global - Global plugin TypeScript configuration
-* @param api - API-level TypeScript configuration
-* @param version - Version-level TypeScript configuration
-* @param packageOverride - Per-package TypeScript configuration override
-* @returns Promise resolving to fully resolved compiler options
-*
-* @example
-* ```ts
-* // Simple global config
-* const options = await resolveTypeScriptConfig("/project", {
-*   tsconfig: "tsconfig.json"
-* });
-*
-* // With async tsconfig loader
-* const options = await resolveTypeScriptConfig("/project", {
-*   tsconfig: async () => ({ target: 99, lib: ["ESNext"] })
-* });
-*
-* // With API override
-* const options = await resolveTypeScriptConfig(
-*   "/project",
-*   { tsconfig: "tsconfig.json" },
-*   { compilerOptions: { strict: false } }
-* );
-*
-* // Full cascade
-* const options = await resolveTypeScriptConfig(
-*   "/project",
-*   { tsconfig: "tsconfig.json" },           // global
-*   { compilerOptions: { strict: false } },  // API
-*   { compilerOptions: { target: 9 } },      // version
-*   { compilerOptions: { module: 1 } }       // package override
-* );
-* ```
-*/
-async function resolveTypeScriptConfig(projectRoot, global, api, version, packageOverride) {
-	let options = { ...DEFAULT_COMPILER_OPTIONS };
-	const globalOptions = await resolveTypeScriptConfigSingleAsync(global, projectRoot);
-	options = mergeCompilerOptions(options, globalOptions);
-	const apiOptions = await resolveTypeScriptConfigSingleAsync(api, projectRoot);
-	options = mergeCompilerOptions(options, apiOptions);
-	const versionOptions = await resolveTypeScriptConfigSingleAsync(version, projectRoot);
-	options = mergeCompilerOptions(options, versionOptions);
-	const packageOptions = await resolveTypeScriptConfigSingleAsync(packageOverride, projectRoot);
-	options = mergeCompilerOptions(options, packageOptions);
-	return options;
-}
-
-//#endregion
-export { DEFAULT_COMPILER_OPTIONS, mergeCompilerOptions, resolveTypeScriptConfig, resolveTypeScriptConfigSingleAsync };