@staticbolt/core 1.0.0-beta.3 → 1.0.0-beta.31

package/lib/{dependency-tracker-BuZfopIj.mjs → utilities-jK4uUZBV.mjs}

@@ -1,32 +1,101 @@
-import { i as CUSTOM_ATTRIBUTES, t as Log } from "./logger-BuxMGhij.mjs";
+import { _ as replaceExtension, c as isAbsolute, d as join, f as normalize, n as CUSTOM_ATTRIBUTES, o as dirname, r as Log, s as extname } from "./common-D1QTZ8ra.mjs";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { ResolverFactory } from "oxc-resolver";
+import chalk from "chalk";
+import json5 from "json5";
+import { readFile } from "node:fs/promises";
+import _generator from "@babel/generator";
 import { NodeType } from "@staticbolt/node-html-parser";
-import c from "chalk";
 import { Node as Node$1 } from "postcss";
-import _generator from "@babel/generator";
-import _traverse from "@babel/traverse";
 import boxen from "boxen";
 import { common, createEmphasize } from "emphasize";
-import { readFileSync } from "node:fs";
-import { readFile } from "node:fs/promises";
 import { createHash } from "node:crypto";
 
-//#region src/types/metadata.ts
-const METADATA_TYPES = Object.freeze({
-	Script: "Script",
-	HTML: "Html",
-	Markdown: "Markdown",
-	CSS: "Style",
-	SVG: "Svg",
-	Package: "Package",
-	TextAsset: "TextAsset",
-	BinaryAsset: "BinaryAsset",
-	WebAppManifest: "WebAppManifest"
-});
+//#region src/helpers/dependency-tracker.ts
+/**
+* Tracks bidirectional dependencies between importers and their sources.\
+* Handles reconciliation when dependencies change, so stale entries are automatically removed when an importer stops referencing
+* a source.
+*/
+var DependencyTracker = class {
+	/** Source → Set of importers that depend on it */
+	#sourcesToImporters = /* @__PURE__ */ new Map();
+	/** Importer → Set of sources it depends on */
+	#importerToSources = /* @__PURE__ */ new Map();
+	/** Updates the full set of sources for a given importer, reconciling any stale entries from previous calls. */
+	update(importer, sources) {
+		const nextSources = new Set(sources);
+		const previousSources = this.#importerToSources.get(importer) ?? /* @__PURE__ */ new Set();
+		for (const source of previousSources) if (!nextSources.has(source)) this.#sourcesToImporters.get(source)?.delete(importer);
+		for (const source of nextSources) {
+			if (!this.#sourcesToImporters.has(source)) this.#sourcesToImporters.set(source, /* @__PURE__ */ new Set());
+			this.#sourcesToImporters.get(source).add(importer);
+		}
+		this.#importerToSources.set(importer, nextSources);
+	}
+	/** Deletes all dependency data for a given id, whether it's acting as an importer, a source, or both (e.g. on file unlink). */
+	delete(id) {
+		this.#sourcesToImporters.delete(id);
+		const sources = this.#importerToSources.get(id);
+		if (sources) {
+			for (const source of sources) this.#sourcesToImporters.get(source)?.delete(id);
+			this.#importerToSources.delete(id);
+		}
+	}
+	/** Returns all importers that depend on a given source, or an empty set. */
+	getImporters(source) {
+		return this.#sourcesToImporters.get(source) ?? /* @__PURE__ */ new Set();
+	}
+	/** Returns all sources that a given importer depends on, or an empty set. */
+	getSources(importer) {
+		return this.#importerToSources.get(importer) ?? /* @__PURE__ */ new Set();
+	}
+};
+
+//#endregion
+//#region src/utilities/html-links.ts
+/**
+* Checks if the link is an HTML link (not a file link)
+*
+* @param source - The link
+* @returns
+*/
+function isHtmlLink(source) {
+	return /^(?:#|https?|mailto:|tel:|url\(|ftp:|data:|javascript:)/i.test(source);
+}
+function isValidRelativePath(source) {
+	if (!source) return false;
+	if (isAbsolute(source)) return false;
+	return !isHtmlLink(source);
+}
+function splitHtmlLink(url) {
+	const qIndex = url.indexOf("?");
+	const hIndex = url.indexOf("#");
+	let delimIndex = -1;
+	if (qIndex !== -1 && hIndex !== -1) delimIndex = Math.min(qIndex, hIndex);
+	else if (qIndex !== -1) delimIndex = qIndex;
+	else if (hIndex !== -1) delimIndex = hIndex;
+	if (delimIndex !== -1) {
+		const pathEnd = url[delimIndex - 1] === "/" ? delimIndex - 1 : delimIndex;
+		return [url.slice(0, pathEnd), url.slice(pathEnd)];
+	}
+	if (url.endsWith("/")) {
+		if (url === "/" || url === "./") return [url, ""];
+		return [url.slice(0, -1), "/"];
+	}
+	return [url, ""];
+}
 
 //#endregion
 //#region src/helpers/is-script-type.ts
-const allowedTypes = new Set([
+/**
+* The `type` that marks a script as TypeScript for the editor: Prettier formats it as such, the editor's own script support
+* leaves it alone, and the build drops it from the output.
+*/
+const TYPESCRIPT_TYPE = "application/x-typescript";
+const allowedTypes = /* @__PURE__ */ new Set([
 	"module",
+	TYPESCRIPT_TYPE,
 	"text/javascript",
 	"application/javascript",
 	"text/ecmascript",
@@ -37,6 +106,350 @@ function isScriptType(type) {
 	return !type || allowedTypes.has(type.toLowerCase());
 }
 
+//#endregion
+//#region src/helpers/lsp-checks.ts
+/** The placeholder syntaxes a plugin or a runtime may fill in: `{{ }}`, `[[ ]]`, `${ }`, `<% %>`, `{% %}` and `%name%`. */
+const PLACEHOLDER = /\{\{[\s\S]*?\}\}|\[\[[\s\S]*?\]\]|\$\{[\s\S]*?\}|<%[\s\S]*?%>|\{%[\s\S]*?%\}|%[\w.-]+%/;
+/** Whether an attribute value is only known later: it holds a placeholder something else fills in. */
+function isDynamic(value) {
+	return PLACEHOLDER.test(value);
+}
+/**
+* Reports an attribute whose value is a path to a file that is not there. A URL, an absolute link or a value with a placeholder
+* is left alone.
+*/
+function checkFileExists(attribute, document, report) {
+	if (!attribute.value) return;
+	if (isDynamic(attribute.value)) return;
+	if (!isValidRelativePath(attribute.value)) return;
+	if (document.resolve(attribute.value)?.exists) return;
+	report.error(attribute, `"${attribute.value}" does not exist`);
+}
+/** Reports an attribute whose value is not the JSON of an object. A value with a placeholder is left alone. */
+function checkJsonObject(attribute, report) {
+	if (!attribute.value) return;
+	if (isDynamic(attribute.value)) return;
+	if (isJsonObject(attribute.value)) return;
+	report.error(attribute, `"${attribute.name}" must be a JSON object`);
+}
+/** Whether a string is the JSON of an object. */
+function isJsonObject(text) {
+	try {
+		const parsed = JSON.parse(text);
+		return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed);
+	} catch {
+		return false;
+	}
+}
+/** Whether a script element holds JavaScript, going by its `type`: the build leaves any other kind of script alone. */
+function isJavaScript(script) {
+	return isScriptType(script.attribute("type")?.value ?? null);
+}
+/** Whether a `<script>` is marked as TypeScript for the editor, which also keeps the editor's own script support out. */
+function isTypeScriptScript(script) {
+	return script.attribute("type")?.value?.toLowerCase() === TYPESCRIPT_TYPE;
+}
+/** Whether an element has nothing but whitespace between its tags. */
+function isEmptyElement(element, document) {
+	if (!element.contentRange) return true;
+	return document.textOf(element.contentRange).trim() === "";
+}
+
+//#endregion
+//#region src/utilities/value-or-error.ts
+function errorsWrapper(function_) {
+	return (...arguments_) => {
+		try {
+			const promiseOrValue = function_(...arguments_);
+			if (isPromise(promiseOrValue)) return new Promise((resolve) => {
+				promiseOrValue.then((value) => {
+					resolve([value, null]);
+				}).catch((error) => {
+					resolve(handleError(error, function_.name));
+				});
+			});
+			return [promiseOrValue, null];
+		} catch (error) {
+			return handleError(error, function_.name);
+		}
+	};
+}
+function isPromise(value) {
+	return value && typeof value === "object" && "then" in value && typeof value.then === "function" && "catch" in value && typeof value.catch === "function";
+}
+function handleError(error, functionName = "") {
+	if (!error) return [null, /* @__PURE__ */ new Error(`[${functionName}] Unexpected error`)];
+	if (typeof error === "string") return [null, new Error(error)];
+	if (error instanceof Error) return [null, error];
+	if (typeof error === "object" && "message" in error && typeof error.message === "string") return [null, new Error(error.message)];
+	return [null, /* @__PURE__ */ new Error(`[${functionName}] Unexpected error`)];
+}
+const valueOrError = errorsWrapper;
+
+//#endregion
+//#region src/utilities/read-file.ts
+async function safeReadFile(path, options) {
+	try {
+		return [await readFile(path, options), null];
+	} catch (error) {
+		return handleError(error, "readFile");
+	}
+}
+function safeReadFileSync(path, options) {
+	try {
+		return [readFileSync(path, options), null];
+	} catch (error) {
+		return handleError(error, "readFileSync");
+	}
+}
+
+//#endregion
+//#region src/utilities/read-json-file.ts
+/** Read a file and parse it as JSON safely. */
+function readJsonFile(path, code) {
+	if (!code) {
+		const [fileString, readError] = safeReadFileSync(path, "utf8");
+		if (readError) return [null, readError];
+		code = fileString;
+	}
+	const [parsed, parseError] = valueOrError(json5.parse)(code);
+	if (parseError !== null) return [null, parseError];
+	return [parsed, null];
+}
+
+//#endregion
+//#region src/resolver/get-aliases.ts
+/** Gets path aliases from `tsconfig.json` */
+function getPathAliases(root) {
+	const [tsconfig, tsconfigParseError] = readTsconfig(root);
+	if (tsconfigParseError !== null) return [null, tsconfigParseError];
+	const paths = tsconfig.paths ?? {};
+	const alias = {};
+	for (const key in paths) {
+		const aliasName = key.replace(/\*$/, "");
+		alias[aliasName] = paths[key][0].replace(/\*$/, "");
+	}
+	return [alias, null];
+}
+function readTsconfig(root) {
+	const tsconfigPath = join(root, "tsconfig.json");
+	const [tsconfig, tsconfigParseError] = readJsonFile(tsconfigPath);
+	if (tsconfigParseError !== null) return [null, tsconfigParseError];
+	if (!tsconfig.compilerOptions) return [null, /* @__PURE__ */ new Error("[readTsconfig] No compilerOptions found in tsconfig.json")];
+	return [tsconfig.compilerOptions, null];
+}
+
+//#endregion
+//#region src/resolver/resolver.ts
+const nodeModulesResolver = new ResolverFactory({
+	conditionNames: [
+		"browser",
+		"import",
+		"default"
+	],
+	extensions: [
+		".js",
+		".json",
+		".node",
+		".css"
+	],
+	symlinks: false
+});
+var Resolver = class Resolver {
+	root;
+	isProduction;
+	aliases = {};
+	notFound = /* @__PURE__ */ new Set();
+	files = /* @__PURE__ */ new Set();
+	directories = /* @__PURE__ */ new Set();
+	misses = /* @__PURE__ */ new Set();
+	/** Whether a source that resolves to a missing file is logged, once. The result says so either way. */
+	shouldWarnOnMissing;
+	static JS_EXTENSIONS = /* @__PURE__ */ new Set([
+		".js",
+		".mjs",
+		".cjs",
+		".jsx",
+		".ts",
+		".mts",
+		".cts",
+		".tsx"
+	]);
+	static HTML_EXTENSIONS = /* @__PURE__ */ new Set([".html", ".md"]);
+	constructor(root, isProduction = false, configAliases = {}, shouldWarnOnMissing = true) {
+		this.root = root;
+		this.isProduction = isProduction;
+		this.shouldWarnOnMissing = shouldWarnOnMissing;
+		const [aliases] = getPathAliases(root);
+		this.aliases = {
+			...aliases,
+			...configAliases
+		};
+	}
+	resolve(sourceOrLink, filePath) {
+		if (!isValidRelativePath(sourceOrLink)) return;
+		const absFilePath = isAbsolute(filePath) ? filePath : join(this.root, filePath);
+		const [source, suffix] = splitHtmlLink(sourceOrLink);
+		if (isAbsolute(source)) return;
+		const isDirectory = suffix === "/";
+		const absSource = join(dirname(absFilePath), source);
+		const foundFile = this.findFile(absSource, isDirectory);
+		if (foundFile) return {
+			path: foundFile,
+			exists: true,
+			suffix
+		};
+		const sourceForAlias = suffix === "/" ? source + "/" : source;
+		const resolvedPathAlias = Resolver.resolvePathAlias(sourceForAlias, this.aliases);
+		if (resolvedPathAlias) {
+			const absSource = join(this.root, resolvedPathAlias);
+			const foundFile = this.findFile(absSource, isDirectory);
+			const isFileAlias = Object.hasOwn(this.aliases, sourceForAlias) && !sourceForAlias.endsWith("/");
+			if (!foundFile) this.#warnMissing(absSource.replace(/\/$/, ""), `[resolver] Source "${sourceOrLink}" found in "${filePath}" was resolved to "${resolvedPathAlias}", but the file is missing.`);
+			return {
+				path: foundFile ?? absSource,
+				exists: !!foundFile,
+				suffix,
+				isFileAlias,
+				isDirAlias: !isFileAlias
+			};
+		}
+		if (!source.startsWith(".")) {
+			const resolverResult = nodeModulesResolver.sync(this.root, source);
+			if (resolverResult.path) return {
+				path: resolverResult.path,
+				suffix,
+				exists: true,
+				isPackage: true
+			};
+		}
+		if (source.startsWith("./") || source.startsWith("../")) {
+			this.#warnMissing(absSource, `[resolver] Source "${sourceOrLink}" found in "${filePath}" points to a non-existent file.`);
+			return {
+				path: absSource,
+				suffix,
+				exists: false
+			};
+		}
+	}
+	/** Logs a missing file the first time it is resolved to, when the resolver is set to. */
+	#warnMissing(absSource, message) {
+		if (!this.shouldWarnOnMissing) return;
+		if (this.notFound.has(absSource)) return;
+		this.notFound.add(absSource);
+		Log.warn(message);
+	}
+	resolveAlias(source) {
+		return Resolver.resolvePathAlias(source, this.aliases);
+	}
+	normalize(filePath) {
+		return normalize(filePath);
+	}
+	static isFile(filePath) {
+		try {
+			return statSync(filePath).isFile();
+		} catch (error) {
+			const code = error.code;
+			if (code === "ENOENT" || code === "ENOTDIR") return false;
+			throw error;
+		}
+	}
+	/** Aliased path to path */
+	static resolvePathAlias(filePath, aliases) {
+		for (const [key, value] of Object.entries(aliases)) {
+			if (key.endsWith("/")) {
+				if (!filePath.startsWith(key)) continue;
+				return filePath.replace(key, () => value);
+			}
+			if (filePath === key) return value;
+		}
+	}
+	/** Path to aliased path */
+	static resolveAliasPath(filePath, aliases) {
+		let shortest;
+		for (const [key, value] of Object.entries(aliases)) {
+			if (key.endsWith("/")) {
+				if (!filePath.startsWith(value)) continue;
+				const aliased = filePath.replace(value, () => key);
+				if (!shortest || aliased.length < shortest.length) shortest = aliased;
+				continue;
+			}
+			if (filePath === value && (!shortest || key.length < shortest.length)) shortest = key;
+		}
+		return shortest ?? filePath;
+	}
+	/** Path to aliased path */
+	aliasPath(filePath) {
+		return Resolver.resolveAliasPath(filePath, this.aliases);
+	}
+	findFile(filePath, shouldCheckDirectory = false) {
+		const missKey = (shouldCheckDirectory ? "d:" : "f:") + filePath;
+		if (this.isProduction && this.misses.has(missKey)) return;
+		const found = this.#findFileUncached(filePath, shouldCheckDirectory);
+		if (found === void 0 && this.isProduction) this.misses.add(missKey);
+		return found;
+	}
+	#findFileUncached(filePath, shouldCheckDirectory) {
+		if (this.files.has(filePath)) return filePath;
+		if (Resolver.isFile(filePath)) {
+			this.files.add(filePath);
+			return filePath;
+		}
+		const extension = extname(filePath);
+		if (!extension) {
+			for (const candidateExtension of [...Resolver.JS_EXTENSIONS, ...Resolver.HTML_EXTENSIONS]) {
+				const candidate = replaceExtension(filePath, candidateExtension);
+				if (this.files.has(candidate)) return candidate;
+				if (Resolver.isFile(candidate)) {
+					this.files.add(candidate);
+					return candidate;
+				}
+			}
+			const withIndex = join(filePath, "index");
+			for (const candidateExtension of Resolver.HTML_EXTENSIONS) {
+				const candidate = replaceExtension(withIndex, candidateExtension);
+				if (this.files.has(candidate)) return candidate;
+				if (Resolver.isFile(candidate)) {
+					this.files.add(candidate);
+					return candidate;
+				}
+			}
+			if (shouldCheckDirectory) {
+				if (this.directories.has(filePath)) return filePath;
+				if (existsSync(filePath)) {
+					this.directories.add(filePath);
+					return filePath;
+				}
+			}
+			return;
+		}
+		if (Resolver.JS_EXTENSIONS.has(extension)) {
+			for (const jsExtension of Resolver.JS_EXTENSIONS) {
+				const candidate = replaceExtension(filePath, jsExtension);
+				if (Resolver.isFile(candidate)) {
+					this.files.add(candidate);
+					return candidate;
+				}
+			}
+			return;
+		}
+	}
+};
+
+//#endregion
+//#region src/types/metadata.ts
+const METADATA_TYPES = Object.freeze({
+	Script: "Script",
+	HTML: "Html",
+	Markdown: "Markdown",
+	CSS: "Style",
+	SVG: "Svg",
+	Package: "Package",
+	TextAsset: "TextAsset",
+	BinaryAsset: "BinaryAsset",
+	WebAppManifest: "WebAppManifest"
+});
+
 //#endregion
 //#region src/utilities/metadata-utilities.ts
 function isScriptMetadata(metadata) {
@@ -84,7 +497,8 @@ function filterScriptMetadata(metadata) {
 		for (const scriptTag of scriptTags) {
 			const scriptId = scriptTag.getAttribute(CUSTOM_ATTRIBUTES.MetadataID);
 			if (!scriptId) continue;
-			if (!isScriptType(scriptTag.getAttribute("type"))) continue;
+			const scriptType = scriptTag.getAttribute("type");
+			if (!isScriptType(scriptType)) continue;
 			const scriptMetadata = metadata.scriptsMetadataList.get(scriptId);
 			if (!scriptMetadata) continue;
 			result.push({
@@ -125,11 +539,6 @@ function filterStyleMetadata(metadata) {
 	return result;
 }
 
-//#endregion
-//#region src/helpers/babel-fixed-imports.ts
-const generator = typeof _generator === "function" ? _generator : _generator.default;
-const traverse = typeof _traverse === "function" ? _traverse : _traverse.default;
-
 //#endregion
 //#region src/utilities/highlight-code.ts
 /** - Highlight code string for terminal */
@@ -156,7 +565,7 @@ function highlightCode(code, { lang = "ts", maxCodeLength = 170, maxLineLength =
 		withNewLines += currentLine + "\n";
 	}
 	let highlighted = createEmphasize(common).highlight(lang, withNewLines.trim()).value;
-	if (isTruncated) highlighted += "\n" + c.inverse(" ... ");
+	if (isTruncated) highlighted += "\n" + chalk.inverse(" ... ");
 	if (!boxed) return highlighted;
 	return boxen(highlighted, {
 		padding: .5,
@@ -168,6 +577,7 @@ function highlightCode(code, { lang = "ts", maxCodeLength = 170, maxLineLength =
 
 //#endregion
 //#region src/utilities/print-formatted-error.ts
+const generator = typeof _generator === "function" ? _generator : _generator.default;
 var PrintFormattedError = class PrintFormattedError {
 	options = {};
 	constructor(options = {}) {
@@ -191,9 +601,9 @@ var PrintFormattedError = class PrintFormattedError {
 			Object.assign(options, item);
 		}
 		let message = "";
-		if (options.filePath) message += c.italic(options.filePath) + "\n";
+		if (options.filePath) message += chalk.italic(options.filePath) + "\n";
 		const functionName = options.function?.name ?? options.functionName;
-		if (functionName) message += c.dim(`[${functionName}] `);
+		if (functionName) message += chalk.dim(`[${functionName}] `);
 		message += messagesArray.join(" ");
 		const codeFromNode = options.node && nodeToString(options.node);
 		const code = options.code ?? codeFromNode?.code;
@@ -233,54 +643,6 @@ function nodeToString(node) {
 	};
 }
 
-//#endregion
-//#region src/utilities/value-or-error.ts
-function errorsWrapper(function_) {
-	return (...arguments_) => {
-		try {
-			const promiseOrValue = function_(...arguments_);
-			if (isPromise(promiseOrValue)) return new Promise((resolve) => {
-				promiseOrValue.then((value) => {
-					resolve([value, null]);
-				}).catch((error) => {
-					resolve(handleError(error, function_.name));
-				});
-			});
-			return [promiseOrValue, null];
-		} catch (error) {
-			return handleError(error, function_.name);
-		}
-	};
-}
-function isPromise(value) {
-	return value && typeof value === "object" && "then" in value && typeof value.then === "function" && "catch" in value && typeof value.catch === "function";
-}
-function handleError(error, functionName = "") {
-	if (!error) return [null, /* @__PURE__ */ new Error(`[${functionName}] Unexpected error`)];
-	if (typeof error === "string") return [null, new Error(error)];
-	if (error instanceof Error) return [null, error];
-	if (typeof error === "object" && "message" in error && typeof error.message === "string") return [null, new Error(error.message)];
-	return [null, /* @__PURE__ */ new Error(`[${functionName}] Unexpected error`)];
-}
-const valueOrError = errorsWrapper;
-
-//#endregion
-//#region src/utilities/read-file.ts
-async function safeReadFile(path, options) {
-	try {
-		return [await readFile(path, options), null];
-	} catch (error) {
-		return handleError(error, "readFile");
-	}
-}
-function safeReadFileSync(path, options) {
-	try {
-		return [readFileSync(path, options), null];
-	} catch (error) {
-		return handleError(error, "readFileSync");
-	}
-}
-
 //#endregion
 //#region src/utilities/utilities.ts
 /** `process.stdout.write` */
@@ -289,10 +651,9 @@ function print(...input) {
 }
 /** - Clear the line in the terminal */
 function clearLn() {
-	if ("clearLine" in process.stdout && typeof process.stdout.clearLine === "function") {
-		process.stdout.clearLine(0);
-		process.stdout.cursorTo(0);
-	}
+	if (!("clearLine" in process.stdout && typeof process.stdout.clearLine === "function")) return;
+	process.stdout.clearLine(0);
+	process.stdout.cursorTo(0);
 }
 /** Used to assign a computed value to a variable */
 function assign(function_) {
@@ -405,7 +766,7 @@ function hashContent(content) {
 }
 const matchHtmlRegExp = /["'&<>]/;
 function escapeHtml(input) {
-	const string = "" + input;
+	const string = input;
 	const match = matchHtmlRegExp.exec(string);
 	if (!match) return string;
 	let escape;
@@ -439,47 +800,5 @@ function escapeHtml(input) {
 }
 
 //#endregion
-//#region src/helpers/dependency-tracker.ts
-/**
-* Tracks bidirectional dependencies between importers and their sources.\
-* Handles reconciliation when dependencies change, so stale entries are automatically removed when an importer stops referencing
-* a source.
-*/
-var DependencyTracker = class {
-	/** Source → Set of importers that depend on it */
-	#sourcesToImporters = /* @__PURE__ */ new Map();
-	/** Importer → Set of sources it depends on */
-	#importerToSources = /* @__PURE__ */ new Map();
-	/** Updates the full set of sources for a given importer, reconciling any stale entries from previous calls. */
-	update(importer, sources) {
-		const nextSources = new Set(sources);
-		const previousSources = this.#importerToSources.get(importer) ?? /* @__PURE__ */ new Set();
-		for (const source of previousSources) if (!nextSources.has(source)) this.#sourcesToImporters.get(source)?.delete(importer);
-		for (const source of nextSources) {
-			if (!this.#sourcesToImporters.has(source)) this.#sourcesToImporters.set(source, /* @__PURE__ */ new Set());
-			this.#sourcesToImporters.get(source).add(importer);
-		}
-		this.#importerToSources.set(importer, nextSources);
-	}
-	/** Deletes all dependency data for a given id, whether it's acting as an importer, a source, or both (e.g. on file unlink). */
-	delete(id) {
-		this.#sourcesToImporters.delete(id);
-		const sources = this.#importerToSources.get(id);
-		if (sources) {
-			for (const source of sources) this.#sourcesToImporters.get(source)?.delete(id);
-			this.#importerToSources.delete(id);
-		}
-	}
-	/** Returns all importers that depend on a given source, or an empty set. */
-	getImporters(source) {
-		return this.#sourcesToImporters.get(source) ?? /* @__PURE__ */ new Set();
-	}
-	/** Returns all sources that a given importer depends on, or an empty set. */
-	getSources(importer) {
-		return this.#importerToSources.get(importer) ?? /* @__PURE__ */ new Set();
-	}
-};
-
-//#endregion
-export { isHtmlMetadata as A, PrintFormattedError as C, filterScriptMetadata as D, traverse as E, isSvgMetadata as F, isTextAssetMetadata as I, isWebManifestMetadata as L, isPackageMetadata as M, isScriptMetadata as N, filterStyleMetadata as O, isStyleMetadata as P, isScriptType as R, valueOrError as S, generator as T, kebabToCamelCase as _, capitalize as a, safeReadFile as b, cloneObject as c, getLineColumn as d, hashContent as f, isURL as g, isObject as h, camelCaseToKebabCase as i, isMarkdownMetadata as j, isBinaryAssetMetadata as k, downloadContent as l, isDefined as m, assign as n, clamp as o, humanReadableBytes as p, bytesToKB as r, clearLn as s, DependencyTracker as t, escapeHtml as u, mergeMaps as v, printFmtError as w, safeReadFileSync as x, print as y, METADATA_TYPES as z };
-//# sourceMappingURL=dependency-tracker-BuZfopIj.mjs.map
+export { isTextAssetMetadata as A, checkJsonObject as B, isBinaryAssetMetadata as C, isScriptMetadata as D, isPackageMetadata as E, safeReadFile as F, isTypeScriptScript as G, isEmptyElement as H, safeReadFileSync as I, isHtmlLink as J, TYPESCRIPT_TYPE as K, handleError as L, METADATA_TYPES as M, Resolver as N, isStyleMetadata as O, readJsonFile as P, valueOrError as R, filterStyleMetadata as S, isMarkdownMetadata as T, isJavaScript as U, isDynamic as V, isJsonObject as W, splitHtmlLink as X, isValidRelativePath as Y, DependencyTracker as Z, mergeMaps as _, clamp as a, printFmtError as b, downloadContent as c, hashContent as d, humanReadableBytes as f, kebabToCamelCase as g, isURL as h, capitalize as i, isWebManifestMetadata as j, isSvgMetadata as k, escapeHtml as l, isObject as m, bytesToKB as n, clearLn as o, isDefined as p, isScriptType as q, camelCaseToKebabCase as r, cloneObject as s, assign as t, getLineColumn as u, print as v, isHtmlMetadata as w, filterScriptMetadata as x, PrintFormattedError as y, checkFileExists as z };
+//# sourceMappingURL=utilities-jK4uUZBV.mjs.map