nitro-nightly 3.0.1-20260125-215009-8882bc9e → 3.0.1-20260127-164246-ef01b092

package/dist/_libs/tsconfck.mjs

@@ -1,11 +1,8 @@
 import fs, { promises } from "node:fs";
 import path from "node:path";
 import { createRequire } from "module";
-
-//#region node_modules/.pnpm/tsconfck@3.1.6_typescript@5.9.3/node_modules/tsconfck/src/util.js
 const POSIX_SEP_RE = new RegExp("\\" + path.posix.sep, "g");
 const NATIVE_SEP_RE = new RegExp("\\" + path.sep, "g");
-/** @type {Map<string,RegExp>}*/
 const PATTERN_REGEX_CACHE = /* @__PURE__ */ new Map();
 const GLOB_ALL_PATTERN = `**/*`;
 const TS_EXTENSIONS = [
@@ -23,90 +20,36 @@ const TSJS_EXTENSIONS = TS_EXTENSIONS.concat([
 const TS_EXTENSIONS_RE_GROUP = `\\.(?:${TS_EXTENSIONS.map((ext) => ext.substring(1)).join("|")})`;
 const TSJS_EXTENSIONS_RE_GROUP = `\\.(?:${TSJS_EXTENSIONS.map((ext) => ext.substring(1)).join("|")})`;
 const IS_POSIX = path.posix.sep === path.sep;
-/**
-* @template T
-* @returns {{resolve:(result:T)=>void, reject:(error:any)=>void, promise: Promise<T>}}
-*/
 function makePromise() {
-	let resolve$1, reject;
+	let resolve, reject;
 	return {
 		promise: new Promise((res, rej) => {
-			resolve$1 = res;
+			resolve = res;
 			reject = rej;
 		}),
-		resolve: resolve$1,
+		resolve,
 		reject
 	};
 }
-/**
-* @param {string} filename
-* @param {import('./cache.js').TSConfckCache} [cache]
-* @returns {Promise<string|void>}
-*/
 async function resolveTSConfigJson(filename, cache) {
 	if (path.extname(filename) !== ".json") return;
 	const tsconfig = path.resolve(filename);
 	if (cache && (cache.hasParseResult(tsconfig) || cache.hasParseResult(filename))) return tsconfig;
-	return promises.stat(tsconfig).then((stat$1) => {
-		if (stat$1.isFile() || stat$1.isFIFO()) return tsconfig;
+	return promises.stat(tsconfig).then((stat) => {
+		if (stat.isFile() || stat.isFIFO()) return tsconfig;
 		else throw new Error(`${filename} exists but is not a regular file.`);
 	});
 }
-/**
-*
-* @param {string} dir an absolute directory path
-* @returns {boolean}  if dir path includes a node_modules segment
-*/
 const isInNodeModules = IS_POSIX ? (dir) => dir.includes("/node_modules/") : (dir) => dir.match(/[/\\]node_modules[/\\]/);
-/**
-* convert posix separator to native separator
-*
-* eg.
-* windows: C:/foo/bar -> c:\foo\bar
-* linux: /foo/bar -> /foo/bar
-*
-* @param {string} filename with posix separators
-* @returns {string} filename with native separators
-*/
 const posix2native = IS_POSIX ? (filename) => filename : (filename) => filename.replace(POSIX_SEP_RE, path.sep);
-/**
-* convert native separator to posix separator
-*
-* eg.
-* windows: C:\foo\bar -> c:/foo/bar
-* linux: /foo/bar -> /foo/bar
-*
-* @param {string} filename - filename with native separators
-* @returns {string} filename with posix separators
-*/
 const native2posix = IS_POSIX ? (filename) => filename : (filename) => filename.replace(NATIVE_SEP_RE, path.posix.sep);
-/**
-* converts params to native separator, resolves path and converts native back to posix
-*
-* needed on windows to handle posix paths in tsconfig
-*
-* @param dir {string|null} directory to resolve from
-* @param filename {string} filename or pattern to resolve
-* @returns string
-*/
 const resolve2posix = IS_POSIX ? (dir, filename) => dir ? path.resolve(dir, filename) : path.resolve(filename) : (dir, filename) => native2posix(dir ? path.resolve(posix2native(dir), posix2native(filename)) : path.resolve(posix2native(filename)));
-/**
-*
-* @param {import('./public.d.ts').TSConfckParseResult} result
-* @param {import('./public.d.ts').TSConfckParseOptions} [options]
-* @returns {string[]}
-*/
 function resolveReferencedTSConfigFiles(result, options) {
 	const dir = path.dirname(result.tsconfigFile);
 	return result.tsconfig.references.map((ref) => {
 		return resolve2posix(dir, ref.path.endsWith(".json") ? ref.path : path.join(ref.path, options?.configName ?? "tsconfig.json"));
 	});
 }
-/**
-* @param {string} filename
-* @param {import('./public.d.ts').TSConfckParseResult} result
-* @returns {import('./public.d.ts').TSConfckParseResult}
-*/
 function resolveSolutionTSConfig(filename, result) {
 	const extensions = result.tsconfig.compilerOptions?.allowJs ? TSJS_EXTENSIONS : TS_EXTENSIONS;
 	if (result.referenced && extensions.some((ext) => filename.endsWith(ext)) && !isIncluded(filename, result)) {
@@ -115,12 +58,6 @@ function resolveSolutionTSConfig(filename, result) {
 	}
 	return result;
 }
-/**
-*
-* @param {string} filename
-* @param {import('./public.d.ts').TSConfckParseResult} result
-* @returns {boolean}
-*/
 function isIncluded(filename, result) {
 	const dir = native2posix(path.dirname(result.tsconfigFile));
 	const files = (result.tsconfig.files || []).map((file) => resolve2posix(dir, file));
@@ -130,15 +67,6 @@ function isIncluded(filename, result) {
 	if (isGlobMatch(absoluteFilename, dir, result.tsconfig.include || (result.tsconfig.files ? [] : [GLOB_ALL_PATTERN]), allowJs)) return !isGlobMatch(absoluteFilename, dir, result.tsconfig.exclude || [], allowJs);
 	return false;
 }
-/**
-* test filenames agains glob patterns in tsconfig
-*
-* @param filename {string} posix style abolute path to filename to test
-* @param dir {string} posix style absolute path to directory of tsconfig containing patterns
-* @param patterns {string[]} glob patterns to match against
-* @param allowJs {boolean} allowJs setting in tsconfig to include js extensions in checks
-* @returns {boolean} true when at least one pattern matches filename
-*/
 function isGlobMatch(filename, dir, patterns, allowJs) {
 	const extensions = allowJs ? TSJS_EXTENSIONS : TS_EXTENSIONS;
 	return patterns.some((pattern) => {
@@ -188,11 +116,6 @@ function isGlobMatch(filename, dir, patterns, allowJs) {
 		return regex.test(filename);
 	});
 }
-/**
-* @param {string} resolvedPattern
-* @param {boolean} allowJs
-* @returns {RegExp}
-*/
 function pattern2regex(resolvedPattern, allowJs) {
 	let regexStr = "^";
 	for (let i = 0; i < resolvedPattern.length; i++) {
@@ -217,45 +140,25 @@ function pattern2regex(resolvedPattern, allowJs) {
 	regexStr += "$";
 	return new RegExp(regexStr);
 }
-/**
-* replace tokens like ${configDir}
-* @param {import('./public.d.ts').TSConfckParseResult} result
-*/
 function replaceTokens(result) {
 	if (result.tsconfig) result.tsconfig = JSON.parse(JSON.stringify(result.tsconfig).replaceAll(/"\${configDir}/g, `"${native2posix(path.dirname(result.tsconfigFile))}`));
 }
-
-//#endregion
-//#region node_modules/.pnpm/tsconfck@3.1.6_typescript@5.9.3/node_modules/tsconfck/src/find.js
-/**
-* find the closest tsconfig.json file
-*
-* @param {string} filename - path to file to find tsconfig for (absolute or relative to cwd)
-* @param {import('./public.d.ts').TSConfckFindOptions} [options] - options
-* @returns {Promise<string|null>} absolute path to closest tsconfig.json or null if not found
-*/
 async function find(filename, options) {
 	let dir = path.dirname(path.resolve(filename));
 	if (options?.ignoreNodeModules && isInNodeModules(dir)) return null;
 	const cache = options?.cache;
 	const configName = options?.configName ?? "tsconfig.json";
 	if (cache?.hasConfigPath(dir, configName)) return cache.getConfigPath(dir, configName);
-	const { promise, resolve: resolve$1, reject } = makePromise();
+	const { promise, resolve, reject } = makePromise();
 	if (options?.root && !path.isAbsolute(options.root)) options.root = path.resolve(options.root);
 	findUp(dir, {
 		promise,
-		resolve: resolve$1,
+		resolve,
 		reject
 	}, options);
 	return promise;
 }
-/**
-*
-* @param {string} dir
-* @param {{promise:Promise<string|null>,resolve:(result:string|null)=>void,reject:(err:any)=>void}} madePromise
-* @param {import('./public.d.ts').TSConfckFindOptions} [options] - options
-*/
-function findUp(dir, { resolve: resolve$1, reject, promise }, options) {
+function findUp(dir, { resolve, reject, promise }, options) {
 	const { cache, root, configName } = options ?? {};
 	if (cache) if (cache.hasConfigPath(dir, configName)) {
 		let cached;
@@ -265,58 +168,30 @@ function findUp(dir, { resolve: resolve$1, reject, promise }, options) {
 			reject(e);
 			return;
 		}
-		if (cached?.then) cached.then(resolve$1).catch(reject);
-		else resolve$1(cached);
+		if (cached?.then) cached.then(resolve).catch(reject);
+		else resolve(cached);
 	} else cache.setConfigPath(dir, promise, configName);
 	const tsconfig = path.join(dir, options?.configName ?? "tsconfig.json");
 	fs.stat(tsconfig, (err, stats) => {
-		if (stats && (stats.isFile() || stats.isFIFO())) resolve$1(tsconfig);
+		if (stats && (stats.isFile() || stats.isFIFO())) resolve(tsconfig);
 		else if (err?.code !== "ENOENT") reject(err);
 		else {
 			let parent;
-			if (root === dir || (parent = path.dirname(dir)) === dir) resolve$1(null);
+			if (root === dir || (parent = path.dirname(dir)) === dir) resolve(null);
 			else findUp(parent, {
 				promise,
-				resolve: resolve$1,
+				resolve,
 				reject
 			}, options);
 		}
 	});
 }
-
-//#endregion
-//#region node_modules/.pnpm/tsconfck@3.1.6_typescript@5.9.3/node_modules/tsconfck/src/find-all.js
-/**
-* @typedef WalkState
-* @interface
-* @property {string[]} files - files
-* @property {number} calls - number of ongoing calls
-* @property {(dir: string)=>boolean} skip - function to skip dirs
-* @property {boolean} err - error flag
-* @property {string[]} configNames - config file names
-*/
-const sep$1 = path.sep;
-
-//#endregion
-//#region node_modules/.pnpm/tsconfck@3.1.6_typescript@5.9.3/node_modules/tsconfck/src/to-json.js
-/**
-* convert content of tsconfig.json to regular json
-*
-* @param {string} tsconfigJson - content of tsconfig.json
-* @returns {string} content as regular json, comments and dangling commas have been replaced with whitespace
-*/
+path.sep;
 function toJson(tsconfigJson) {
 	const stripped = stripDanglingComma(stripJsonComments(stripBom(tsconfigJson)));
 	if (stripped.trim() === "") return "{}";
 	else return stripped;
 }
-/**
-* replace dangling commas from pseudo-json string with single space
-* implementation heavily inspired by strip-json-comments
-*
-* @param {string} pseudoJson
-* @returns {string}
-*/
 function stripDanglingComma(pseudoJson) {
 	let insideString = false;
 	let offset = 0;
@@ -345,12 +220,6 @@ function stripDanglingComma(pseudoJson) {
 	}
 	return result + pseudoJson.substring(offset);
 }
-/**
-*
-* @param {string} jsonString
-* @param {number} quotePosition
-* @returns {boolean}
-*/
 function isEscaped(jsonString, quotePosition) {
 	let index = quotePosition - 1;
 	let backslashCount = 0;
@@ -360,24 +229,13 @@ function isEscaped(jsonString, quotePosition) {
 	}
 	return Boolean(backslashCount % 2);
 }
-/**
-*
-* @param {string} string
-* @param {number?} start
-* @param {number?} end
-*/
 function strip(string, start, end) {
 	return string.slice(start, end).replace(/\S/g, " ");
 }
 const singleComment = Symbol("singleComment");
 const multiComment = Symbol("multiComment");
-/**
-* @param {string} jsonString
-* @returns {string}
-*/
 function stripJsonComments(jsonString) {
 	let isInsideString = false;
-	/** @type {false | symbol} */
 	let isInsideComment = false;
 	let offset = 0;
 	let result = "";
@@ -416,39 +274,23 @@ function stripJsonComments(jsonString) {
 	}
 	return result + (isInsideComment ? strip(jsonString.slice(offset)) : jsonString.slice(offset));
 }
-/**
-* @param {string} string
-* @returns {string}
-*/
 function stripBom(string) {
 	if (string.charCodeAt(0) === 65279) return string.slice(1);
 	return string;
 }
-
-//#endregion
-//#region node_modules/.pnpm/tsconfck@3.1.6_typescript@5.9.3/node_modules/tsconfck/src/parse.js
 const not_found_result = {
 	tsconfigFile: null,
 	tsconfig: {}
 };
-/**
-* parse the closest tsconfig.json file
-*
-* @param {string} filename - path to a tsconfig .json or a source file or directory (absolute or relative to cwd)
-* @param {import('./public.d.ts').TSConfckParseOptions} [options] - options
-* @returns {Promise<import('./public.d.ts').TSConfckParseResult>}
-* @throws {TSConfckParseError}
-*/
 async function parse(filename, options) {
-	/** @type {import('./cache.js').TSConfckCache} */
 	const cache = options?.cache;
 	if (cache?.hasParseResult(filename)) return getParsedDeep(filename, cache, options);
-	const { resolve: resolve$1, reject, promise } = makePromise();
+	const { resolve, reject, promise } = makePromise();
 	cache?.setParseResult(filename, promise, true);
 	try {
 		let tsconfigFile = await resolveTSConfigJson(filename, cache) || await find(filename, options);
 		if (!tsconfigFile) {
-			resolve$1(not_found_result);
+			resolve(not_found_result);
 			return promise;
 		}
 		let result;
@@ -458,19 +300,12 @@ async function parse(filename, options) {
 			await Promise.all([parseExtends(result, cache), parseReferences(result, options)]);
 		}
 		replaceTokens(result);
-		resolve$1(resolveSolutionTSConfig(filename, result));
+		resolve(resolveSolutionTSConfig(filename, result));
 	} catch (e) {
 		reject(e);
 	}
 	return promise;
 }
-/**
-* ensure extends and references are parsed
-*
-* @param {string} filename - cached file
-* @param {import('./cache.js').TSConfckCache} cache - cache
-* @param {import('./public.d.ts').TSConfckParseOptions} options - options
-*/
 async function getParsedDeep(filename, cache, options) {
 	const result = await cache.getParseResult(filename);
 	if (result.tsconfig.extends && !result.extended || result.tsconfig.references && !result.referenced) {
@@ -480,13 +315,6 @@ async function getParsedDeep(filename, cache, options) {
 	}
 	return result;
 }
-/**
-*
-* @param {string} tsconfigFile - path to tsconfig file
-* @param {import('./cache.js').TSConfckCache} [cache] - cache
-* @param {boolean} [skipCache] - skip cache
-* @returns {Promise<import('./public.d.ts').TSConfckParseResult>}
-*/
 async function parseFile(tsconfigFile, cache, skipCache) {
 	if (!skipCache && cache?.hasParseResult(tsconfigFile) && !cache.getParseResult(tsconfigFile)._isRootFile_) return cache.getParseResult(tsconfigFile);
 	const promise = promises.readFile(tsconfigFile, "utf-8").then(toJson).then((json) => {
@@ -502,23 +330,11 @@ async function parseFile(tsconfigFile, cache, skipCache) {
 	if (!skipCache && (!cache?.hasParseResult(tsconfigFile) || !cache.getParseResult(tsconfigFile)._isRootFile_)) cache?.setParseResult(tsconfigFile, promise);
 	return promise;
 }
-/**
-* normalize to match the output of ts.parseJsonConfigFileContent
-*
-* @param {any} tsconfig - typescript tsconfig output
-* @param {string} dir - directory
-*/
 function normalizeTSConfig(tsconfig, dir) {
 	const baseUrl = tsconfig.compilerOptions?.baseUrl;
 	if (baseUrl && !baseUrl.startsWith("${") && !path.isAbsolute(baseUrl)) tsconfig.compilerOptions.baseUrl = resolve2posix(dir, baseUrl);
 	return tsconfig;
 }
-/**
-*
-* @param {import('./public.d.ts').TSConfckParseResult} result
-* @param {import('./public.d.ts').TSConfckParseOptions} [options]
-* @returns {Promise<void>}
-*/
 async function parseReferences(result, options) {
 	if (!result.tsconfig.references) return;
 	const referencedFiles = resolveReferencedTSConfigFiles(result, options);
@@ -530,20 +346,13 @@ async function parseReferences(result, options) {
 	});
 	result.referenced = referenced;
 }
-/**
-* @param {import('./public.d.ts').TSConfckParseResult} result
-* @param {import('./cache.js').TSConfckCache}[cache]
-* @returns {Promise<void>}
-*/
 async function parseExtends(result, cache) {
 	if (!result.tsconfig.extends) return;
-	/** @type {import('./public.d.ts').TSConfckParseResult[]} */
 	const extended = [{
 		tsconfigFile: result.tsconfigFile,
 		tsconfig: JSON.parse(JSON.stringify(result.tsconfig))
 	}];
 	let pos = 0;
-	/** @type {string[]} */
 	const extendsPath = [];
 	let currentBranchDepth = 0;
 	while (pos < extended.length) {
@@ -551,7 +360,6 @@ async function parseExtends(result, cache) {
 		extendsPath.push(extending.tsconfigFile);
 		if (extending.tsconfig.extends) {
 			currentBranchDepth += 1;
-			/** @type {string[]} */
 			let resolvedExtends;
 			if (!Array.isArray(extending.tsconfig.extends)) resolvedExtends = [resolveExtends(extending.tsconfig.extends, extending.tsconfigFile)];
 			else resolvedExtends = extending.tsconfig.extends.reverse().map((ex) => resolveExtends(ex, extending.tsconfigFile));
@@ -567,12 +375,6 @@ async function parseExtends(result, cache) {
 	result.extended = extended;
 	for (const ext of result.extended.slice(1)) extendTSConfig(result, ext);
 }
-/**
-*
-* @param {string} extended
-* @param {string} from
-* @returns {string}
-*/
 function resolveExtends(extended, from) {
 	if ([".", ".."].includes(extended)) extended = extended + "/tsconfig.json";
 	const req = createRequire(from);
@@ -599,17 +401,11 @@ const EXTENDABLE_KEYS = [
 	"typeAcquisition",
 	"buildOptions"
 ];
-/**
-*
-* @param {import('./public.d.ts').TSConfckParseResult} extending
-* @param {import('./public.d.ts').TSConfckParseResult} extended
-* @returns void
-*/
 function extendTSConfig(extending, extended) {
 	const extendingConfig = extending.tsconfig;
 	const extendedConfig = extended.tsconfig;
 	const relativePath = native2posix(path.relative(path.dirname(extending.tsconfigFile), path.dirname(extended.tsconfigFile)));
-	for (const key of Object.keys(extendedConfig).filter((key$1) => EXTENDABLE_KEYS.includes(key$1))) if (key === "compilerOptions") {
+	for (const key of Object.keys(extendedConfig).filter((key) => EXTENDABLE_KEYS.includes(key))) if (key === "compilerOptions") {
 		if (!extendingConfig.compilerOptions) extendingConfig.compilerOptions = {};
 		for (const option of Object.keys(extendedConfig.compilerOptions)) {
 			if (Object.prototype.hasOwnProperty.call(extendingConfig.compilerOptions, option)) continue;
@@ -634,52 +430,19 @@ const REBASE_KEYS = [
 	"excludeDirectories",
 	"excludeFiles"
 ];
-/** @typedef {string | string[]} PathValue */
-/**
-*
-* @param {string} key
-* @param {PathValue} value
-* @param {string} prependPath
-* @returns {PathValue}
-*/
 function rebaseRelative(key, value, prependPath) {
 	if (!REBASE_KEYS.includes(key)) return value;
 	if (Array.isArray(value)) return value.map((x) => rebasePath(x, prependPath));
 	else return rebasePath(value, prependPath);
 }
-/**
-*
-* @param {string} value
-* @param {string} prependPath
-* @returns {string}
-*/
 function rebasePath(value, prependPath) {
 	if (path.isAbsolute(value) || value.startsWith("${configDir}")) return value;
 	else return path.posix.normalize(path.posix.join(prependPath, value));
 }
 var TSConfckParseError = class TSConfckParseError extends Error {
-	/**
-	* error code
-	* @type {string}
-	*/
 	code;
-	/**
-	* error cause
-	* @type { Error | undefined}
-	*/
 	cause;
-	/**
-	* absolute path of tsconfig file where the error happened
-	* @type {string}
-	*/
 	tsconfigFile;
-	/**
-	*
-	* @param {string} message - error message
-	* @param {string} code - error code
-	* @param {string} tsconfigFile - path to tsconfig file
-	* @param {Error?} cause - cause of this error
-	*/
 	constructor(message, code, tsconfigFile, cause) {
 		super(message);
 		Object.setPrototypeOf(this, TSConfckParseError.prototype);
@@ -689,11 +452,6 @@ var TSConfckParseError = class TSConfckParseError extends Error {
 		this.tsconfigFile = tsconfigFile;
 	}
 };
-/**
-*
-* @param {any} tsconfig
-* @param {string} tsconfigFile
-*/
 function applyDefaults(tsconfig, tsconfigFile) {
 	if (isJSConfig(tsconfigFile)) tsconfig.compilerOptions = {
 		...DEFAULT_JSCONFIG_COMPILER_OPTIONS,
@@ -707,81 +465,31 @@ const DEFAULT_JSCONFIG_COMPILER_OPTIONS = {
 	skipLibCheck: true,
 	noEmit: true
 };
-/**
-* @param {string} configFileName
-*/
 function isJSConfig(configFileName) {
 	return path.basename(configFileName) === "jsconfig.json";
 }
-
-//#endregion
-//#region node_modules/.pnpm/tsconfck@3.1.6_typescript@5.9.3/node_modules/tsconfck/src/parse-native.js
-/** @typedef TSDiagnosticError {
-code: number;
-category: number;
-messageText: string;
-start?: number;
-} TSDiagnosticError */
-
-//#endregion
-//#region node_modules/.pnpm/tsconfck@3.1.6_typescript@5.9.3/node_modules/tsconfck/src/cache.js
-/** @template T */
 var TSConfckCache = class {
-	/**
-	* clear cache, use this if you have a long running process and tsconfig files have been added,changed or deleted
-	*/
 	clear() {
 		this.#configPaths.clear();
 		this.#parsed.clear();
 	}
-	/**
-	* has cached closest config for files in dir
-	* @param {string} dir
-	* @param {string} [configName=tsconfig.json]
-	* @returns {boolean}
-	*/
 	hasConfigPath(dir, configName = "tsconfig.json") {
 		return this.#configPaths.has(`${dir}/${configName}`);
 	}
-	/**
-	* get cached closest tsconfig for files in dir
-	* @param {string} dir
-	* @param {string} [configName=tsconfig.json]
-	* @returns {Promise<string|null>|string|null}
-	* @throws {unknown} if cached value is an error
-	*/
 	getConfigPath(dir, configName = "tsconfig.json") {
 		const key = `${dir}/${configName}`;
 		const value = this.#configPaths.get(key);
 		if (value == null || value.length || value.then) return value;
 		else throw value;
 	}
-	/**
-	* has parsed tsconfig for file
-	* @param {string} file
-	* @returns {boolean}
-	*/
 	hasParseResult(file) {
 		return this.#parsed.has(file);
 	}
-	/**
-	* get parsed tsconfig for file
-	* @param {string} file
-	* @returns {Promise<T>|T}
-	* @throws {unknown} if cached value is an error
-	*/
 	getParseResult(file) {
 		const value = this.#parsed.get(file);
 		if (value.then || value.tsconfig) return value;
 		else throw value;
 	}
-	/**
-	* @internal
-	* @private
-	* @param file
-	* @param {boolean} isRootFile a flag to check if current file which involking the parse() api, used to distinguish the normal cache which only parsed by parseFile()
-	* @param {Promise<T>} result
-	*/
 	setParseResult(file, result, isRootFile = false) {
 		Object.defineProperty(result, "_isRootFile_", {
 			value: isRootFile,
@@ -796,37 +504,16 @@ var TSConfckCache = class {
 			if (this.#parsed.get(file) === result) this.#parsed.set(file, e);
 		});
 	}
-	/**
-	* @internal
-	* @private
-	* @param {string} dir
-	* @param {Promise<string|null>} configPath
-	* @param {string} [configName=tsconfig.json]
-	*/
 	setConfigPath(dir, configPath, configName = "tsconfig.json") {
 		const key = `${dir}/${configName}`;
 		this.#configPaths.set(key, configPath);
-		configPath.then((path$1) => {
-			if (this.#configPaths.get(key) === configPath) this.#configPaths.set(key, path$1);
+		configPath.then((path) => {
+			if (this.#configPaths.get(key) === configPath) this.#configPaths.set(key, path);
 		}).catch((e) => {
 			if (this.#configPaths.get(key) === configPath) this.#configPaths.set(key, e);
 		});
 	}
-	/**
-	* map directories to their closest tsconfig.json
-	* @internal
-	* @private
-	* @type{Map<string,(Promise<string|null>|string|null)>}
-	*/
 	#configPaths = /* @__PURE__ */ new Map();
-	/**
-	* map files to their parsed tsconfig result
-	* @internal
-	* @private
-	* @type {Map<string,(Promise<T>|T)> }
-	*/
 	#parsed = /* @__PURE__ */ new Map();
 };
-
-//#endregion
-export { parse as n, TSConfckCache as t };
+export { parse as n, TSConfckCache as t };

package/dist/_libs/ultrahtml.mjs

@@ -1,5 +1,4 @@
-//#region node_modules/.pnpm/ultrahtml@1.6.0/node_modules/ultrahtml/dist/index.js
-var S = Symbol("Fragment"), D = new Set([
+var D = new Set([
 	"area",
 	"base",
 	"br",
@@ -119,20 +118,8 @@ var T = class {
 			await Promise.all(n);
 		}
 	}
-}, O = class {
-	constructor(t) {
-		this.callback = t;
-	}
-	visit(t, i, r) {
-		if (this.callback(t, i, r), Array.isArray(t.children)) for (let n = 0; n < t.children.length; n++) {
-			let a = t.children[n];
-			this.visit(a, t, n);
-		}
-	}
-}, p = Symbol("HTMLString"), M = Symbol("AttrString"), f = Symbol("RenderFn");
+};
 function z(e, t) {
 	return new T(t).visit(e);
 }
-
-//#endregion
-export { z as n, P as t };
+export { z as n, P as t };