@rafters/veneer 0.0.0-stage → 0.0.1

package/dist/lint-BabXVYQJ.mjs

@@ -0,0 +1,1024 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+import { readFile, readdir, stat } from "node:fs/promises";
+import { existsSync, realpathSync } from "node:fs";
+import { format } from "node:util";
+import { AstroCheck } from "@astrojs/language-server";
+//#region src/config.ts
+const CONFIG_FILE = ".rafters/config.rafters.json";
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function fieldError(field, problem, ...value) {
+	const error = {
+		code: "config-field",
+		message: `${field}: ${problem}`,
+		field
+	};
+	if (value.length > 0) error.value = value[0];
+	return error;
+}
+function errnoOf(error) {
+	return error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : void 0;
+}
+function messageOf(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+async function readConfigObject(root) {
+	const unreadable = (problem) => ({ error: {
+		code: "config-unreadable",
+		message: `${CONFIG_FILE}: ${problem}`
+	} });
+	let bytes;
+	try {
+		bytes = await readFile(path.join(root, CONFIG_FILE));
+	} catch (error) {
+		const errno = errnoOf(error);
+		if (errno === "ENOENT" || errno === "ENOTDIR") return { error: {
+			code: "config-missing",
+			message: `${CONFIG_FILE} not found`
+		} };
+		return unreadable(messageOf(error));
+	}
+	try {
+		const parsed = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+		return isObject(parsed) ? { config: parsed } : unreadable("the text is not a JSON object");
+	} catch (error) {
+		return unreadable(messageOf(error));
+	}
+}
+function entryPath(entry) {
+	if (typeof entry === "string") return entry;
+	if (!isObject(entry) || typeof entry.path !== "string") return void 0;
+	return !("root" in entry) || entry.root === true ? entry.path : void 0;
+}
+async function checkEntryPath(root, entry) {
+	if (entry === "") return "the path is empty";
+	if (path.isAbsolute(entry)) return "the path is absolute";
+	const fromRoot = path.relative(root, path.resolve(root, entry));
+	if (fromRoot === ".." || fromRoot.startsWith(`..${path.sep}`) || path.isAbsolute(fromRoot)) return "the path is outside the project root";
+	try {
+		return (await stat(path.resolve(root, entry))).isDirectory() || "the path is not a folder";
+	} catch (error) {
+		const errno = errnoOf(error);
+		if (errno === "ENOENT" || errno === "ENOTDIR") return false;
+		throw error;
+	}
+}
+async function readConfig(root) {
+	const read = await readConfigObject(root);
+	if ("error" in read) return {
+		ok: false,
+		errors: [read.error]
+	};
+	const { config } = read;
+	const errors = [];
+	const componentFolders = [];
+	const notices = [];
+	const { componentsPath, intent, veneer } = config;
+	if (componentsPath === void 0) errors.push(fieldError("componentsPath", "the field is missing"));
+	else if (typeof componentsPath !== "string" && !(Array.isArray(componentsPath) && componentsPath.length > 0)) errors.push(fieldError("componentsPath", "expected a string or a non-empty list", componentsPath));
+	else {
+		const entries = Array.isArray(componentsPath) ? componentsPath : [componentsPath];
+		for (const [index, entry] of entries.entries()) {
+			const field = Array.isArray(componentsPath) ? `componentsPath[${index}]` : "componentsPath";
+			const written = entryPath(entry);
+			if (written === void 0) {
+				errors.push(fieldError(field, "expected a string or { path, root: true }", entry));
+				continue;
+			}
+			const checked = await checkEntryPath(root, written);
+			if (typeof checked === "string") errors.push(fieldError(field, checked, entry));
+			else if (checked) componentFolders.push(written);
+			else notices.push({
+				code: "components-folder-missing",
+				message: `${written} named by componentsPath does not exist`
+			});
+		}
+	}
+	if (intent !== void 0 && typeof intent !== "string") errors.push(fieldError("intent", "expected a string", intent));
+	if (veneer !== void 0 && !isObject(veneer)) errors.push(fieldError("veneer", "expected an object", veneer));
+	else if (veneer?.mdxPath !== void 0 && typeof veneer.mdxPath !== "string") errors.push(fieldError("veneer.mdxPath", "expected a string", veneer.mdxPath));
+	if (errors.length > 0) return {
+		ok: false,
+		errors
+	};
+	return {
+		ok: true,
+		intent: typeof intent === "string" ? intent : null,
+		componentFolders,
+		notices
+	};
+}
+//#endregion
+//#region src/read.ts
+const NO_ASTRO_LINE = "seems to be an Astro project, but we couldn't find Astro or Astro is not installed";
+const NO_INTEGRATION_LINE = "Couldn't find package @astrojs/";
+const SEVERITIES = {
+	1: "error",
+	2: "warning",
+	3: "info",
+	4: "hint"
+};
+const require$1 = createRequire(import.meta.url);
+const typescriptPath = require$1.resolve("typescript");
+const ts = require$1(typescriptPath);
+var ProjectError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "ProjectError";
+		this.code = code;
+	}
+};
+let aProjectIsOpen = false;
+let serverIsPrepared = false;
+let constructedContext;
+let unsavedChanges = 0;
+const capturePlugin = {
+	name: "veneer-capture-context",
+	capabilities: {},
+	create(context) {
+		constructedContext ??= context;
+		return {};
+	}
+};
+function prepareLanguageServer() {
+	if (serverIsPrepared) return;
+	serverIsPrepared = true;
+	const serverRequire = createRequire(require$1.resolve("@astrojs/language-server/package.json"));
+	const { setIsTrusted } = serverRequire("./dist/importPackage.js");
+	setIsTrusted(false);
+	const kit = serverRequire("@volar/kit/lib/createChecker.js");
+	const original = kit.createTypeScriptChecker;
+	kit.createTypeScriptChecker = (languages, services, ...rest) => original(languages, [...services, capturePlugin], ...rest);
+}
+function constructAstroCheck(root) {
+	const consoleError = console.error;
+	console.error = (...args) => {
+		if (!format(...args).endsWith(NO_ASTRO_LINE)) consoleError(...args);
+	};
+	try {
+		return new AstroCheck(root, typescriptPath, void 0);
+	} finally {
+		console.error = consoleError;
+	}
+}
+function holdingOnly(file) {
+	return (directory) => {
+		const prefix = directory.endsWith("/") ? directory : `${directory}/`;
+		if (!file.startsWith(prefix)) return {
+			files: [],
+			directories: []
+		};
+		const [next = "", ...below] = file.slice(prefix.length).split("/");
+		return below.length === 0 ? {
+			files: [next],
+			directories: []
+		} : {
+			files: [],
+			directories: [next]
+		};
+	};
+}
+function overlaySys(unsaved) {
+	const { sys } = ts;
+	const { readFile, getModifiedTime, fileExists, readDirectory } = sys;
+	sys.readFile = (file, encoding) => unsaved.get(file)?.text ?? readFile.call(sys, file, encoding);
+	sys.getModifiedTime = (file) => unsaved.get(file)?.modified ?? getModifiedTime?.call(sys, file);
+	sys.fileExists = (file) => unsaved.has(file) || fileExists.call(sys, file);
+	sys.readDirectory = (directory, extensions, excludes, includes, depth) => {
+		const found = readDirectory.call(sys, directory, extensions, excludes, includes, depth);
+		const taken = [...unsaved.keys()].filter((file) => !found.includes(file) && ts.matchFiles(directory, extensions, excludes, includes, sys.useCaseSensitiveFileNames, sys.getCurrentDirectory(), depth, holdingOnly(file), (name) => name).length > 0);
+		return [...found, ...taken];
+	};
+	return () => {
+		sys.readFile = readFile;
+		sys.getModifiedTime = getModifiedTime;
+		sys.fileExists = fileExists;
+		sys.readDirectory = readDirectory;
+	};
+}
+function programOf(context) {
+	const program = context?.inject("typescript/languageService")?.getProgram();
+	if (!program) throw new Error("the language service holds no program");
+	return program;
+}
+function toDiagnostic(file, diagnostic) {
+	const { range, severity, source, code, message } = diagnostic;
+	return {
+		file,
+		line: range.start.line + 1,
+		column: range.start.character + 1,
+		endLine: range.end.line + 1,
+		endColumn: range.end.character + 1,
+		severity: SEVERITIES[severity ?? 1],
+		code: `${source ?? ""}(${code ?? ""})`,
+		message
+	};
+}
+function isProjectRelative(file) {
+	return !path.isAbsolute(file) && !file.includes("\\") && file === path.posix.normalize(file) && !file.startsWith("../");
+}
+function badPath(file) {
+	return new ProjectError("bad-path", `${file} is not a project-relative path with / separators`);
+}
+function unsavedEntry(text) {
+	unsavedChanges += 1;
+	return {
+		text,
+		modified: new Date(-unsavedChanges)
+	};
+}
+async function openProject(projectRoot, options = {}) {
+	if (aProjectIsOpen) throw new ProjectError("already-open", "a veneer project is already open in this process");
+	const root = path.resolve(projectRoot);
+	if (!existsSync(path.join(root, "tsconfig.json"))) throw new ProjectError("tsconfig-missing", `tsconfig.json not found at ${root}`);
+	const unsaved = /* @__PURE__ */ new Map();
+	for (const [file, text] of Object.entries(options.unsaved ?? {})) {
+		if (!isProjectRelative(file)) throw badPath(file);
+		unsaved.set(path.join(root, file), unsavedEntry(text));
+	}
+	aProjectIsOpen = true;
+	const consoleInfo = console.info;
+	console.info = (...args) => {
+		if (!format(...args).startsWith(NO_INTEGRATION_LINE)) consoleInfo(...args);
+	};
+	const restoreSys = overlaySys(unsaved);
+	try {
+		prepareLanguageServer();
+		constructedContext = void 0;
+		const astroCheck = constructAstroCheck(root);
+		let context = constructedContext;
+		constructedContext = void 0;
+		const fileNames = astroCheck.linter.getRootFileNames().slice(0, 1);
+		await astroCheck.lint({ fileNames });
+		let program = programOf(context);
+		let closed = false;
+		const rootFile = (file) => {
+			if (closed) throw new ProjectError("closed", "the veneer project is closed");
+			if (!isProjectRelative(file)) throw badPath(file);
+			const absolute = path.join(root, file);
+			if (!astroCheck.linter.getRootFileNames().includes(absolute)) throw new ProjectError("not-root-file", `${file} is not a root file of the program`);
+			return absolute;
+		};
+		return {
+			ts,
+			checker: astroCheck.linter,
+			root,
+			program() {
+				if (closed) throw new ProjectError("closed", "the veneer project is closed");
+				return program;
+			},
+			async diagnostics(file) {
+				const absolute = rootFile(file);
+				const { fileResult } = await astroCheck.lint({ fileNames: [absolute] });
+				program = programOf(context);
+				return fileResult.flatMap(({ errors }) => errors.map((d) => toDiagnostic(file, d)));
+			},
+			setUnsaved(file, text) {
+				const absolute = rootFile(file);
+				unsaved.set(absolute, unsavedEntry(text));
+				astroCheck.linter.fileUpdated(absolute);
+			},
+			clearUnsaved(file) {
+				const absolute = rootFile(file);
+				unsaved.delete(absolute);
+				astroCheck.linter.fileUpdated(absolute);
+			},
+			close() {
+				if (closed) throw new ProjectError("closed", "the veneer project is closed");
+				closed = true;
+				unsaved.clear();
+				restoreSys();
+				context = void 0;
+				aProjectIsOpen = false;
+			}
+		};
+	} catch (error) {
+		restoreSys();
+		aProjectIsOpen = false;
+		throw error;
+	} finally {
+		console.info = consoleInfo;
+	}
+}
+//#endregion
+//#region src/resolve.ts
+const require = createRequire(import.meta.url);
+const { URI } = createRequire(require.resolve("@astrojs/language-server/package.json"))("vscode-uri");
+function compareCodePoints(a, b) {
+	const left = [...a];
+	const right = [...b];
+	for (let i = 0; i < Math.min(left.length, right.length); i += 1) {
+		const difference = (left[i]?.codePointAt(0) ?? 0) - (right[i]?.codePointAt(0) ?? 0);
+		if (difference !== 0) return difference;
+	}
+	return left.length - right.length;
+}
+const posix = (file) => file.split(path.sep).join("/");
+const relativeFile = (root, file) => posix(path.relative(root, file));
+const inNodeModules = (declaration) => declaration.getSourceFile().fileName.includes("/node_modules/");
+async function walkFolder(folder, into) {
+	const entries = await readdir(folder, { withFileTypes: true });
+	for (const entry of entries) {
+		const entryPath = path.join(folder, entry.name);
+		let isFolder = entry.isDirectory();
+		let isFile = entry.isFile();
+		if (entry.isSymbolicLink()) {
+			isFile = (await stat(entryPath).catch(() => void 0))?.isFile() ?? false;
+			isFolder = false;
+		}
+		if (isFolder) {
+			if (entry.name !== "node_modules" && !entry.name.startsWith(".")) await walkFolder(entryPath, into);
+		} else if (isFile && (entry.name.endsWith(".tsx") || entry.name.endsWith(".astro"))) into.add(posix(entryPath));
+	}
+}
+function scriptOf(reader, file) {
+	return reader.project.checker.language.scripts.get(URI.file(file));
+}
+function sourceOffset(reader, file, offset) {
+	const { language } = reader.project.checker;
+	const script = scriptOf(reader, file);
+	const tsx = script?.generated?.embeddedCodes.get("tsx");
+	if (!script || !tsx) return void 0;
+	for (const [source] of language.maps.get(tsx, script).toSourceLocation(offset)) return source;
+}
+function generatedOffset(reader, file, offset) {
+	const { language } = reader.project.checker;
+	const script = scriptOf(reader, file);
+	const tsx = script?.generated?.embeddedCodes.get("tsx");
+	if (!script || !tsx) return void 0;
+	for (const [generated] of language.maps.get(tsx, script).toGeneratedLocation(offset)) return generated;
+}
+function positionOf(reader, sourceFile, offset) {
+	const file = sourceFile.fileName;
+	let position;
+	if (file.endsWith(".astro")) {
+		const source = sourceOffset(reader, file, offset);
+		const snapshot = scriptOf(reader, file)?.snapshot;
+		if (source === void 0 || !snapshot) return void 0;
+		const text = snapshot.getText(0, snapshot.getLength());
+		position = reader.ts.createSourceMapSource(file, text).getLineAndCharacterOfPosition(source);
+	} else position = sourceFile.getLineAndCharacterOfPosition(offset);
+	return {
+		line: position.line + 1,
+		column: position.character + 1
+	};
+}
+function collectBindingDefaults(ts, pattern, into) {
+	for (const element of pattern.elements) {
+		if (element.dotDotDotToken || !element.initializer) continue;
+		const key = element.propertyName ?? element.name;
+		if (ts.isIdentifier(key) || ts.isStringLiteral(key)) into.set(key.text, element.initializer.getText());
+	}
+}
+function renderFunction({ ts, tc }, start) {
+	const seen = /* @__PURE__ */ new Set();
+	let node = start;
+	while (node && !seen.has(node)) {
+		seen.add(node);
+		if (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isArrowFunction(node)) return node;
+		if (ts.isVariableDeclaration(node)) node = node.initializer;
+		else if (ts.isParenthesizedExpression(node) || ts.isAsExpression(node)) node = node.expression;
+		else if (ts.isCallExpression(node)) node = node.arguments[0];
+		else if (ts.isIdentifier(node)) {
+			const declaration = tc.getSymbolAtLocation(node)?.valueDeclaration;
+			node = declaration && (ts.isVariableDeclaration(declaration) || ts.isFunctionDeclaration(declaration)) ? declaration : void 0;
+		} else return void 0;
+	}
+}
+function tsxDefaults(reader, declaration) {
+	const { ts, tc } = reader;
+	const defaults = /* @__PURE__ */ new Map();
+	const render = renderFunction(reader, declaration);
+	const parameter = render?.parameters[0];
+	if (!parameter) return defaults;
+	if (ts.isObjectBindingPattern(parameter.name)) {
+		collectBindingDefaults(ts, parameter.name, defaults);
+		return defaults;
+	}
+	const { body } = render;
+	const parameterSymbol = tc.getSymbolAtLocation(parameter.name);
+	if (!body || !parameterSymbol) return defaults;
+	const visit = (node) => {
+		if (ts.isFunctionLike(node)) return;
+		if (ts.isVariableDeclaration(node) && ts.isObjectBindingPattern(node.name) && node.initializer && ts.isIdentifier(node.initializer) && tc.getSymbolAtLocation(node.initializer) === parameterSymbol) collectBindingDefaults(ts, node.name, defaults);
+		ts.forEachChild(node, visit);
+	};
+	ts.forEachChild(body, visit);
+	return defaults;
+}
+function withoutAssertions(ts, node) {
+	let current = node;
+	while (ts.isAsExpression(current) || ts.isSatisfiesExpression(current) || ts.isTypeAssertionExpression(current) || ts.isNonNullExpression(current) || ts.isParenthesizedExpression(current)) current = current.expression;
+	return current;
+}
+function astroDefaults(ts, sourceFile) {
+	const defaults = /* @__PURE__ */ new Map();
+	const visit = (node) => {
+		if (ts.isVariableDeclaration(node) && ts.isObjectBindingPattern(node.name) && node.initializer && withoutAssertions(ts, node.initializer).getText() === "Astro.props") collectBindingDefaults(ts, node.name, defaults);
+		ts.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return defaults;
+}
+function literalValuesOfTypes({ ts }, types) {
+	const values = /* @__PURE__ */ new Map();
+	for (const type of types) for (const member of type.isUnion() ? type.types : [type]) {
+		if (member.flags & (ts.TypeFlags.Undefined | ts.TypeFlags.Null | ts.TypeFlags.Never)) continue;
+		if (!member.isStringLiteral() && !member.isNumberLiteral()) return void 0;
+		values.set(valueKey(member.value), member.value);
+	}
+	return values.size >= 2 ? [...values.values()] : void 0;
+}
+const valueKey = (value) => `${typeof value}:${value}`;
+var WalkFailed = class extends Error {};
+function resolvedDeclaration({ ts, tc }, name) {
+	const symbol = tc.getSymbolAtLocation(name);
+	return (symbol && symbol.flags & ts.SymbolFlags.Alias ? tc.getAliasedSymbol(symbol) : symbol)?.declarations?.[0];
+}
+function initializerOf(reader, name) {
+	const { ts } = reader;
+	const declaration = resolvedDeclaration(reader, name);
+	if (!declaration || !ts.isVariableDeclaration(declaration) || !declaration.initializer) throw new WalkFailed();
+	return withoutAssertions(ts, declaration.initializer);
+}
+function literalValue(ts, node) {
+	if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) return node.text;
+	if (ts.isNumericLiteral(node)) return Number(node.text);
+	if (ts.isPrefixUnaryExpression(node) && node.operator === ts.SyntaxKind.MinusToken && ts.isNumericLiteral(node.operand)) return -Number(node.operand.text);
+	return node.kind === ts.SyntaxKind.NullKeyword ? null : void 0;
+}
+function walkArrayElements(reader, array, walking) {
+	const { ts } = reader;
+	if (!ts.isArrayLiteralExpression(array) || walking.has(array)) throw new WalkFailed();
+	walking.add(array);
+	const values = array.elements.flatMap((element) => {
+		if (ts.isSpreadElement(element)) return walkArrayElements(reader, initializerOf(reader, element.expression), walking);
+		const value = literalValue(ts, element);
+		if (value === void 0 || value === null) throw new WalkFailed();
+		return [value];
+	});
+	walking.delete(array);
+	return values;
+}
+function walkDeclaredType(reader, name, walking) {
+	const { ts, tc } = reader;
+	const declaration = resolvedDeclaration(reader, name);
+	if (declaration && ts.isTypeAliasDeclaration(declaration)) {
+		if (walking.has(declaration)) throw new WalkFailed();
+		walking.add(declaration);
+		const values = walkTypeNode(reader, declaration.type, walking);
+		walking.delete(declaration);
+		return values;
+	}
+	if (declaration && ts.isEnumDeclaration(declaration)) return declaration.members.map((member) => {
+		const value = tc.getConstantValue(member);
+		if (value === void 0) throw new WalkFailed();
+		return value;
+	});
+	throw new WalkFailed();
+}
+function walkPropertyAnnotation(reader, object, key, walking) {
+	const { ts, tc } = reader;
+	const annotated = tc.getPropertyOfType(tc.getTypeFromTypeNode(object), key)?.declarations?.find((declaration) => (ts.isPropertySignature(declaration) || ts.isPropertyDeclaration(declaration)) && declaration.type !== void 0);
+	if (!annotated?.type || walking.has(annotated)) throw new WalkFailed();
+	walking.add(annotated);
+	const values = walkTypeNode(reader, annotated.type, walking);
+	walking.delete(annotated);
+	return values;
+}
+function walkTypeNode(reader, node, walking) {
+	const { ts } = reader;
+	if (ts.isParenthesizedTypeNode(node)) return walkTypeNode(reader, node.type, walking);
+	if (ts.isUnionTypeNode(node)) return node.types.flatMap((member) => walkTypeNode(reader, member, walking));
+	if (node.kind === ts.SyntaxKind.UndefinedKeyword || node.kind === ts.SyntaxKind.NullKeyword || node.kind === ts.SyntaxKind.NeverKeyword) return [];
+	if (ts.isLiteralTypeNode(node)) {
+		const value = literalValue(ts, node.literal);
+		if (value === void 0) throw new WalkFailed();
+		return value === null ? [] : [value];
+	}
+	if (ts.isTypeReferenceNode(node)) return walkDeclaredType(reader, node.typeName, walking);
+	if (ts.isImportTypeNode(node)) {
+		if (!node.qualifier || node.isTypeOf) throw new WalkFailed();
+		return walkDeclaredType(reader, node.qualifier, walking);
+	}
+	if (ts.isTypeOperatorNode(node) && node.operator === ts.SyntaxKind.KeyOfKeyword && ts.isTypeQueryNode(node.type)) {
+		const object = initializerOf(reader, node.type.exprName);
+		if (!ts.isObjectLiteralExpression(object)) throw new WalkFailed();
+		return object.properties.map((property) => {
+			const key = property.name;
+			if (key && (ts.isIdentifier(key) || ts.isStringLiteral(key))) return key.text;
+			if (key && ts.isNumericLiteral(key)) return Number(key.text);
+			throw new WalkFailed();
+		});
+	}
+	if (ts.isIndexedAccessTypeNode(node)) {
+		const object = ts.isParenthesizedTypeNode(node.objectType) ? node.objectType.type : node.objectType;
+		if (ts.isTypeQueryNode(object) && node.indexType.kind === ts.SyntaxKind.NumberKeyword) return walkArrayElements(reader, initializerOf(reader, object.exprName), walking);
+		if (ts.isLiteralTypeNode(node.indexType) && ts.isStringLiteral(node.indexType.literal)) return walkPropertyAnnotation(reader, object, node.indexType.literal.text, walking);
+	}
+	throw new WalkFailed();
+}
+function inCodePointOrder(values) {
+	return [...values].sort((a, b) => compareCodePoints(String(a), String(b)) || Number(typeof a === "number") - Number(typeof b === "number"));
+}
+function orderedValues(reader, values, declarations) {
+	const { ts } = reader;
+	const annotations = declarations.flatMap((declaration) => (ts.isPropertySignature(declaration) || ts.isPropertyDeclaration(declaration)) && declaration.type ? [declaration.type] : []);
+	if (annotations.length === 0) return inCodePointOrder(values);
+	const walked = /* @__PURE__ */ new Map();
+	try {
+		for (const annotation of annotations) for (const value of walkTypeNode(reader, annotation, /* @__PURE__ */ new Set())) if (!walked.has(valueKey(value))) walked.set(valueKey(value), value);
+	} catch (error) {
+		if (error instanceof WalkFailed) return inCodePointOrder(values);
+		throw error;
+	}
+	return walked.size === values.length && values.every((value) => walked.has(valueKey(value))) ? [...walked.values()] : inCodePointOrder(values);
+}
+function annotationText({ ts }, declaration) {
+	if (ts.isMethodSignature(declaration)) {
+		if (!declaration.type) return void 0;
+		return declaration.getSourceFile().text.slice(declaration.parameters.pos - 1, declaration.type.end);
+	}
+	if (!("type" in declaration)) return void 0;
+	const annotation = declaration.type;
+	return annotation && ts.isTypeNode(annotation) ? annotation.getText() : void 0;
+}
+function printedType({ ts, tc }, types) {
+	const flags = ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope;
+	const print = (type) => tc.typeToString(type, void 0, flags);
+	const printed = new Set(types.map(print));
+	if (printed.size === 1) return [...printed].join("");
+	const parts = [...new Set(types.map((type) => print(tc.getNonNullableType(type))))].map((text) => text.includes("=>") ? `(${text})` : text);
+	if (types.some((type) => (type.isUnion() ? type.types : [type]).some((part) => part.flags & ts.TypeFlags.Undefined))) parts.push("undefined");
+	return parts.join(" | ");
+}
+function propType(reader, declarations, types) {
+	const annotations = declarations.map((declaration) => annotationText(reader, declaration));
+	if (annotations.some((annotation) => annotation === void 0)) return [printedType(reader, types)];
+	const entries = annotations.map((annotation) => (annotation ?? "").replace(/\s+/g, " ").trim().replace(/^\| /, ""));
+	return [...new Set(entries)].filter((entry) => entry !== "never");
+}
+function declarationInBases(tc, type, name, seen = /* @__PURE__ */ new Set()) {
+	if (seen.has(type)) return void 0;
+	seen.add(type);
+	if (type.isUnionOrIntersection()) {
+		for (const part of type.types) {
+			const found = declarationInBases(tc, part, name, seen);
+			if (found) return found;
+		}
+		return;
+	}
+	const own = tc.getPropertyOfType(type, name)?.declarations?.find((declaration) => !inNodeModules(declaration));
+	if (own) return own;
+	if (!type.isClassOrInterface()) return void 0;
+	for (const base of tc.getBaseTypes(type)) {
+		const found = declarationInBases(tc, base, name, seen);
+		if (found) return found;
+	}
+}
+function packageOf(file) {
+	const segments = file.slice(file.lastIndexOf("/node_modules/") + 14).split("/");
+	return (segments[0] ?? "").startsWith("@") ? segments.slice(0, 2).join("/") : segments[0] ?? "";
+}
+function enclosingTypeName({ ts }, declaration) {
+	let node = declaration.parent;
+	while (node) {
+		if (ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node)) return node.name.text;
+		node = node.parent;
+	}
+	return "(anonymous)";
+}
+function readOwnProp(reader, name, symbols, recorded, optional, fallback) {
+	const { ts, tc, project } = reader;
+	const listed = symbols.flatMap((symbol) => symbol.declarations ?? []);
+	const declarations = [.../* @__PURE__ */ new Set([...listed.filter((declaration) => !inNodeModules(declaration)), recorded])].sort((a, b) => compareCodePoints(a.getSourceFile().fileName, b.getSourceFile().fileName) || a.pos - b.pos);
+	const types = symbols.map((symbol) => tc.getTypeOfSymbol(symbol));
+	const nameNode = ts.getNameOfDeclaration(recorded) ?? recorded;
+	const sourceFile = recorded.getSourceFile();
+	const file = relativeFile(project.root, sourceFile.fileName);
+	const position = positionOf(reader, sourceFile, nameNode.getStart());
+	if (!position) throw new Error(`no source position for prop ${name} in ${file}`);
+	const prop = {
+		name,
+		type: propType(reader, declarations, types),
+		optional,
+		file,
+		line: position.line,
+		column: position.column
+	};
+	if (fallback !== void 0) prop.default = fallback;
+	const values = literalValuesOfTypes(reader, types);
+	if (values) prop.values = orderedValues(reader, values, declarations);
+	const documented = symbols.find((symbol) => symbol.declarations?.includes(recorded)) ?? tc.getSymbolAtLocation(nameNode);
+	const doc = documented ? ts.displayPartsToString(documented.getDocumentationComment(tc)) : "";
+	if (doc !== "") prop.doc = doc;
+	return prop;
+}
+function readProps(reader, parameterType, sourceFile, defaults) {
+	const { ts, tc } = reader;
+	const branches = parameterType.isUnion() ? parameterType.types : [parameterType];
+	const grouped = /* @__PURE__ */ new Map();
+	for (const branch of branches) for (const symbol of tc.getPropertiesOfType(branch)) grouped.set(symbol.name, [...grouped.get(symbol.name) ?? [], symbol]);
+	const props = [];
+	const inherited = /* @__PURE__ */ new Map();
+	const inheritedDefaults = [];
+	const anyNames = [];
+	for (const [name, symbols] of grouped) {
+		const listed = symbols.flatMap((symbol) => symbol.declarations ?? []);
+		const recorded = listed.find((declaration) => declaration.getSourceFile() === sourceFile) ?? listed.find((declaration) => !inNodeModules(declaration)) ?? declarationInBases(tc, parameterType, name) ?? listed[0];
+		const fallback = defaults.get(name);
+		if (recorded && !inNodeModules(recorded)) {
+			const optional = symbols.length < branches.length || symbols.some((symbol) => (symbol.flags & ts.SymbolFlags.Optional) !== 0);
+			props.push(readOwnProp(reader, name, symbols, recorded, optional, fallback));
+			if (symbols.some((symbol) => tc.getTypeOfSymbol(symbol).flags & ts.TypeFlags.Any)) anyNames.push(name);
+			continue;
+		}
+		const pkg = recorded ? packageOf(recorded.getSourceFile().fileName) : "(synthetic)";
+		const type = recorded ? enclosingTypeName(reader, recorded) : "(synthetic)";
+		const key = `${pkg}\0${type}`;
+		const group = inherited.get(key) ?? {
+			package: pkg,
+			type,
+			count: 0
+		};
+		group.count += 1;
+		inherited.set(key, group);
+		if (fallback !== void 0) inheritedDefaults.push([name, fallback]);
+	}
+	return {
+		props: props.sort((a, b) => compareCodePoints(a.file, b.file) || a.line - b.line || a.column - b.column),
+		inherited: [...inherited.values()].sort((a, b) => compareCodePoints(a.package, b.package) || compareCodePoints(a.type, b.type)),
+		inheritedDefaults: Object.fromEntries(inheritedDefaults.sort(([a], [b]) => compareCodePoints(a, b))),
+		anyNames
+	};
+}
+function propsOfSignature(reader, signature, sourceFile, defaults) {
+	const parameter = signature.parameters[0];
+	return parameter ? readProps(reader, reader.tc.getTypeOfSymbol(parameter), sourceFile, defaults) : {
+		props: [],
+		inherited: [],
+		inheritedDefaults: {},
+		anyNames: []
+	};
+}
+function ownPropNames(reader, component, sourceFile) {
+	const signature = reader.tc.getTypeOfSymbol(component).getCallSignatures()[0];
+	if (!signature) return [];
+	return propsOfSignature(reader, signature, sourceFile, /* @__PURE__ */ new Map()).props.map(({ name }) => name);
+}
+function intelligenceBlock(reader, sourceFile) {
+	const { ts } = reader;
+	const blocks = [];
+	const visit = (node) => {
+		blocks.push(...node.jsDoc ?? []);
+		ts.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return blocks.flatMap((block) => {
+		const start = block.getStart();
+		const at = sourceFile.fileName.endsWith(".astro") ? sourceOffset(reader, sourceFile.fileName, start) : start;
+		return at === void 0 ? [] : [{
+			block,
+			at
+		}];
+	}).sort((a, b) => a.at - b.at)[0]?.block;
+}
+function intelligence(reader, sourceFile) {
+	const { ts } = reader;
+	const block = intelligenceBlock(reader, sourceFile);
+	if (!block) return { tags: [] };
+	const tags = (block.tags ?? []).map((tag) => ({
+		name: tag.tagName.text,
+		text: ts.getTextOfJSDocComment(tag.comment) ?? ""
+	}));
+	const description = ts.getTextOfJSDocComment(block.comment);
+	return description ? {
+		description,
+		tags
+	} : { tags };
+}
+async function parseErrorReason(reader, sourceFile) {
+	const { ts, project } = reader;
+	const file = sourceFile.fileName;
+	if (!file.endsWith(".astro")) return void 0;
+	const root = scriptOf(reader, file)?.generated?.root;
+	const compiler = root && "compilerDiagnostics" in root ? root.compilerDiagnostics : void 0;
+	if (!(Array.isArray(compiler) && compiler.some((diagnostic) => diagnostic.severity === 1))) return void 0;
+	const syntactic = new Set(project.program().getSyntacticDiagnostics(sourceFile).map((diagnostic) => ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n")));
+	return (await project.checker.check(file)).filter(({ severity, source, message }) => (severity === void 0 || severity === 1) && (source === "astro" || source === "ts" && typeof message === "string" && syntactic.has(message))).sort((a, b) => a.range.start.line - b.range.start.line || a.range.start.character - b.range.start.character).map(({ message }) => message).join("; ");
+}
+async function componentsOfFile(reader, file) {
+	const { ts, tc, project } = reader;
+	const sourceFile = project.program().getSourceFile(file);
+	const moduleSymbol = sourceFile && tc.getSymbolAtLocation(sourceFile);
+	if (!sourceFile || !moduleSymbol) return [];
+	const exportNames = /* @__PURE__ */ new Map();
+	for (const exported of tc.getExportsOfModule(moduleSymbol)) {
+		const symbol = exported.flags & ts.SymbolFlags.Alias ? tc.getAliasedSymbol(exported) : exported;
+		if (symbol.flags & ts.SymbolFlags.Value) exportNames.set(symbol, [...exportNames.get(symbol) ?? [], exported.name]);
+	}
+	const isAstro = file.endsWith(".astro");
+	const relative = relativeFile(project.root, file);
+	const { description, tags } = intelligence(reader, sourceFile);
+	const parseReason = await parseErrorReason(reader, sourceFile);
+	const components = [];
+	for (const [symbol, names] of exportNames) {
+		const name = names.filter((n) => /^[A-Z]/.test(n)).sort(compareCodePoints)[0];
+		const signature = tc.getTypeOfSymbol(symbol).getCallSignatures()[0];
+		if (name === void 0 || !signature) continue;
+		let defaults = /* @__PURE__ */ new Map();
+		if (!isAstro) defaults = tsxDefaults(reader, symbol.valueDeclaration);
+		else if (names.includes("default")) defaults = astroDefaults(ts, sourceFile);
+		const read = propsOfSignature(reader, signature, sourceFile, defaults);
+		const component = {
+			name,
+			file: relative,
+			resolved: true,
+			tags,
+			props: read.props,
+			inherited: read.inherited,
+			inheritedDefaults: read.inheritedDefaults
+		};
+		if (description !== void 0) component.description = description;
+		if (parseReason !== void 0) {
+			component.resolved = false;
+			component.reason = parseReason;
+		} else if (read.anyNames.length > 0) {
+			component.resolved = false;
+			component.reason = `props typed any: ${read.anyNames.join(", ")}`;
+		}
+		components.push(component);
+	}
+	return components;
+}
+async function resolveComponents(project, componentFolders) {
+	const reader = {
+		project,
+		ts: project.ts,
+		tc: project.program().getTypeChecker()
+	};
+	const files = /* @__PURE__ */ new Set();
+	for (const folder of componentFolders) await walkFolder(path.resolve(project.root, folder), files);
+	const rootFiles = new Set(project.checker.getRootFileNames().map(posix));
+	const components = [];
+	const notices = [];
+	for (const file of files) if (rootFiles.has(file)) components.push(...await componentsOfFile(reader, file));
+	else notices.push({
+		code: "outside-program",
+		message: `${relativeFile(project.root, file)} is under componentsPath but not in the tsconfig's files`
+	});
+	components.sort((a, b) => compareCodePoints(a.file, b.file) || compareCodePoints(a.name, b.name));
+	return {
+		components,
+		notices
+	};
+}
+//#endregion
+//#region src/lint.ts
+const CLASS_ATTRIBUTES = /* @__PURE__ */ new Set([
+	"class",
+	"className",
+	"class:list"
+]);
+const MAX_RESOLVE_STEPS = 8;
+const realPath = (file) => existsSync(file) ? realpathSync(file) : file;
+function offsetAt(text, line, column) {
+	const breaks = /\r\n|\r|\n/g;
+	let start = 0;
+	for (let at = 1; at < line && breaks.exec(text); at += 1) start = breaks.lastIndex;
+	return start + column - 1;
+}
+function programOffset(reader, sourceFile, diagnostic) {
+	const file = sourceFile.fileName;
+	if (!file.endsWith(".astro")) return offsetAt(sourceFile.text, diagnostic.line, diagnostic.column);
+	const snapshot = scriptOf(reader, file)?.snapshot;
+	if (!snapshot) return void 0;
+	return generatedOffset(reader, file, offsetAt(snapshot.getText(0, snapshot.getLength()), diagnostic.line, diagnostic.column));
+}
+function innermostNode(ts, sourceFile, offset) {
+	let node = sourceFile;
+	for (;;) {
+		let inner;
+		ts.forEachChild(node, (child) => {
+			if (child.getStart(sourceFile) <= offset && offset < child.end) inner = child;
+		});
+		if (!inner) return node;
+		node = inner;
+	}
+}
+function elementUsing(ts, node) {
+	if (ts.isSourceFile(node)) return void 0;
+	const { parent } = node;
+	if (ts.isJsxAttribute(parent) && parent.name === node) return parent.parent.parent;
+	const tag = ts.isPropertyAccessExpression(parent) && parent.name === node ? parent : node;
+	const element = tag.parent;
+	return ts.isJsxOpeningLikeElement(element) && element.tagName === tag ? element : void 0;
+}
+function resolveTag({ ts, tc }, { tagName }) {
+	let symbol = tc.getSymbolAtLocation(ts.isPropertyAccessExpression(tagName) ? tagName.name : tagName);
+	for (let step = 0; symbol && step < MAX_RESOLVE_STEPS; step += 1) {
+		const declaration = symbol.valueDeclaration;
+		if (symbol.flags & ts.SymbolFlags.Alias) symbol = tc.getAliasedSymbol(symbol);
+		else if (declaration && ts.isVariableDeclaration(declaration) && declaration.initializer && ts.isIdentifier(declaration.initializer)) symbol = tc.getSymbolAtLocation(declaration.initializer);
+		else return symbol;
+	}
+}
+function deprecatedText({ ts, tc }, element, name) {
+	const parameter = tc.getResolvedSignature(element)?.parameters[0];
+	const tag = (parameter && tc.getTypeOfSymbol(parameter).getProperty(name))?.getJsDocTags(tc).find((found) => found.name === "deprecated");
+	return tag ? ts.displayPartsToString(tag.text) || void 0 : void 0;
+}
+function utilityOf(className) {
+	let depth = 0;
+	let start = 0;
+	for (let at = 0; at < className.length; at += 1) {
+		const character = className[at];
+		if (character === "[" || character === "(") depth += 1;
+		else if (character === "]" || character === ")") depth -= 1;
+		else if (character === ":" && depth === 0) start = at + 1;
+	}
+	return className.slice(start);
+}
+function classLiterals(ts, node) {
+	if (ts.isStringLiteralLike(node)) return [node];
+	if (ts.isJsxExpression(node) || ts.isParenthesizedExpression(node)) return node.expression ? classLiterals(ts, node.expression) : [];
+	if (ts.isArrayLiteralExpression(node)) return node.elements.flatMap((element) => classLiterals(ts, element));
+	if (ts.isObjectLiteralExpression(node)) return node.properties.flatMap((property) => ts.isPropertyAssignment(property) && ts.isStringLiteral(property.name) ? [property.name] : []);
+	return [];
+}
+function bracketsInLiteral(reader, file, sourceFile, literal) {
+	return [...literal.getText(sourceFile).slice(1, -1).matchAll(/\S+/g)].flatMap((match) => {
+		const [className] = match;
+		if (!utilityOf(className).includes("[")) return [];
+		const position = positionOf(reader, sourceFile, literal.getStart(sourceFile) + 1 + match.index);
+		if (!position) return [];
+		return [{
+			file,
+			line: position.line,
+			column: position.column,
+			endLine: position.line,
+			endColumn: position.column + className.length,
+			severity: "error",
+			code: "rafters(arbitrary-value)",
+			message: `${className} is an arbitrary value`
+		}];
+	});
+}
+function bracketValues(reader, file, sourceFile) {
+	const { ts } = reader;
+	const found = [];
+	const visit = (node) => {
+		if (ts.isJsxAttribute(node) && node.initializer) {
+			const { name } = node;
+			const attribute = ts.isJsxNamespacedName(name) ? `${name.namespace.text}:${name.name.text}` : name.text;
+			if (CLASS_ATTRIBUTES.has(attribute)) for (const literal of classLiterals(ts, node.initializer)) found.push(...bracketsInLiteral(reader, file, sourceFile, literal));
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return found;
+}
+const FILL_WORD = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
+const FILL_ALPHA = /^(100|[1-9]?[0-9])$/;
+const AUTHORED_FILL = "a fill the designer authors, fill=\"bg-fill-<name>\"";
+const isFillStop = (stop) => {
+	const [word = "", alpha, ...rest] = stop.split("/");
+	return FILL_WORD.test(word) && (alpha === void 0 || FILL_ALPHA.test(alpha)) && rest.length === 0;
+};
+function retiredFillForm(value) {
+	if (value.startsWith("bg-fill-")) return void 0;
+	if (FILL_WORD.test(value) && !value.includes("-to-")) return "bare";
+	return value.split("-to-").length <= 2 && value.split("-to-").every(isFillStop) ? "composed" : void 0;
+}
+async function loadSurfaces(root) {
+	try {
+		const { surfaceWords } = await import("./tokens-CYaadJgI.mjs");
+		return { words: surfaceWords(root) };
+	} catch (error) {
+		return { failure: error instanceof Error ? error.message : String(error) };
+	}
+}
+function fillLiteral(ts, node) {
+	const { initializer } = node;
+	if (!initializer) return void 0;
+	if (ts.isStringLiteral(initializer)) return initializer;
+	const inner = ts.isJsxExpression(initializer) ? initializer.expression : void 0;
+	return inner && ts.isStringLiteralLike(inner) ? inner : void 0;
+}
+function fillAttributes({ ts }, sourceFile) {
+	const found = [];
+	const visit = (node) => {
+		if (ts.isJsxAttribute(node) && ts.isIdentifier(node.name) && node.name.text === "fill") found.push(node);
+		ts.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return found;
+}
+async function lint(project, options) {
+	const files = options.files ?? project.checker.getRootFileNames().filter((file) => file.endsWith(".tsx") || file.endsWith(".astro")).map((file) => relativeFile(project.root, file));
+	const perFile = [];
+	for (const file of files) perFile.push([file, await project.diagnostics(file)]);
+	const program = project.program();
+	const reader = {
+		project,
+		ts: project.ts,
+		tc: program.getTypeChecker()
+	};
+	const { ts } = reader;
+	const folders = options.componentFolders.map((folder) => realPath(path.resolve(project.root, folder)) + path.sep);
+	const isUnderFolder = (file) => {
+		const real = realPath(file);
+		return folders.some((folder) => real.startsWith(folder));
+	};
+	const propsHelp = /* @__PURE__ */ new Map();
+	const reportedUse = (sourceFile, diagnostic) => {
+		const offset = programOffset(reader, sourceFile, diagnostic);
+		if (offset === void 0) return void 0;
+		const node = innermostNode(ts, sourceFile, offset);
+		const element = elementUsing(ts, node);
+		const component = element && resolveTag(reader, element);
+		const declaration = component?.valueDeclaration ?? component?.declarations?.[0];
+		if (!element || !component || !declaration) return void 0;
+		const declaredIn = declaration.getSourceFile();
+		if (!isUnderFolder(declaredIn.fileName)) return void 0;
+		let help;
+		if (diagnostic.code === "ts(6385)") help = deprecatedText(reader, element, node.getText(sourceFile));
+		else {
+			help = propsHelp.get(component);
+			if (help === void 0) {
+				help = ownPropNames(reader, component, declaredIn).join(", ");
+				propsHelp.set(component, help);
+			}
+		}
+		return help ? {
+			...diagnostic,
+			help
+		} : diagnostic;
+	};
+	let surfaces;
+	const replacement = async (value, form) => {
+		if (form === "composed") return AUTHORED_FILL;
+		surfaces ??= loadSurfaces(project.root);
+		const loaded = await surfaces;
+		if ("failure" in loaded) return `the project's tokens could not be loaded, so no replacement is named: ${loaded.failure}`;
+		return loaded.words.has(value) ? `surface="${value}"` : AUTHORED_FILL;
+	};
+	const retiredFills = async (file, sourceFile) => {
+		const flagged = [];
+		for (const attribute of fillAttributes(reader, sourceFile)) {
+			const literal = fillLiteral(ts, attribute);
+			const form = literal && retiredFillForm(literal.text);
+			if (!literal || !form) continue;
+			const component = resolveTag(reader, attribute.parent.parent);
+			const declaration = component?.valueDeclaration ?? component?.declarations?.[0];
+			if (!declaration || !isUnderFolder(declaration.getSourceFile().fileName)) continue;
+			const start = positionOf(reader, sourceFile, attribute.getStart(sourceFile));
+			const end = positionOf(reader, sourceFile, attribute.end);
+			if (!start || !end) continue;
+			flagged.push({
+				file,
+				line: start.line,
+				column: start.column,
+				endLine: end.line,
+				endColumn: end.column,
+				severity: "error",
+				code: "rafters(retired-fill)",
+				message: `fill="${literal.text}" is a retired fill value`,
+				help: await replacement(literal.text, form)
+			});
+		}
+		return flagged;
+	};
+	const found = [];
+	for (const [file, diagnostics] of perFile) {
+		const absolute = path.join(project.root, file);
+		const sourceFile = program.getSourceFile(absolute);
+		if (!sourceFile) continue;
+		for (const diagnostic of diagnostics) {
+			const reported = reportedUse(sourceFile, diagnostic);
+			if (reported) found.push(reported);
+		}
+		if (!isUnderFolder(absolute)) {
+			found.push(...bracketValues(reader, file, sourceFile));
+			found.push(...await retiredFills(file, sourceFile));
+		}
+	}
+	return found.sort((a, b) => compareCodePoints(a.file, b.file) || a.line - b.line || a.column - b.column);
+}
+function firstLine(message) {
+	return (typeof message === "string" ? message : message.value).split(/\r\n|\r|\n/, 1)[0] ?? "";
+}
+function report(diagnostics) {
+	const lines = diagnostics.flatMap(({ file, line, column, severity, code, message, help }) => {
+		const entry = `${file}:${line}:${column} ${severity} ${code} ${firstLine(message)}`;
+		return help === void 0 ? [entry] : [entry, `  help: ${help}`];
+	});
+	const count = diagnostics.length;
+	lines.push(count === 1 ? "1 problem" : `${count} problems`);
+	return lines.map((line) => `${line}\n`).join("");
+}
+//#endregion
+export { ProjectError as a, resolveComponents as i, report as n, openProject as o, compareCodePoints as r, readConfig as s, lint as t };