@dialexjs/cli 0.7.2 → 0.9.1

package/dist/{project-Dz0FbydQ.mjs → project-B27699T2.mjs}

@@ -10,60 +10,66 @@ import { createHash } from "node:crypto";
 import { DEFAULT_CONFIG } from "dialexjs";
 import { loadConfigSync } from "unconfig";
 import chokidar from "chokidar";
-//#region src/utils/dictionary-edit.ts
-const TODO_PREFIX = "[TODO] ";
-const IDENTIFIER$1 = /^[A-Za-z_$][\w$]*$/;
-function unwrap(node) {
+//#region src/utils/ast.ts
+/** Strips `as`, `satisfies` and parentheses around an expression. */
+function unwrapNode(node) {
 	while (node && (node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression" || node.type === "ParenthesizedExpression")) node = node.expression;
 	return node;
 }
-const isObject = (node) => node?.type === "ObjectExpression";
-function keyName(prop) {
+const isObjectNode = (node) => node?.type === "ObjectExpression";
+/** The static name of a property key, or `undefined` when it is computed. */
+function propertyKeyName(prop) {
 	const key = prop?.key;
 	if (!key || prop.computed) return void 0;
 	if (key.type === "Identifier") return key.name;
 	if (key.type === "StringLiteral" || key.type === "Literal" && typeof key.value === "string") return key.value;
 	if (key.type === "NumericLiteral") return String(key.value);
 }
-const isPropLike = (p) => p?.type === "ObjectProperty" || p?.type === "Property" || p?.type === "ObjectMethod";
-function findProp(obj, key) {
-	return obj.properties.find((p) => isPropLike(p) && keyName(p) === key);
+const isPropLike$1 = (p) => p?.type === "ObjectProperty" || p?.type === "Property" || p?.type === "ObjectMethod";
+/** The first property of `obj` with the static name `key`. */
+function findProperty(obj, key) {
+	return obj.properties.find((p) => isPropLike$1(p) && propertyKeyName(p) === key);
 }
+//#endregion
+//#region src/utils/dictionary-edit.ts
+const TODO_PREFIX = "[TODO] ";
+const IDENTIFIER$1 = /^[A-Za-z_$][\w$]*$/;
+const isPropLike = (p) => p?.type === "ObjectProperty" || p?.type === "Property" || p?.type === "ObjectMethod";
 function stringValue(node) {
-	node = unwrap(node);
+	node = unwrapNode(node);
 	if (node?.type === "StringLiteral") return node.value;
 	if (node?.type === "Literal" && typeof node.value === "string") return node.value;
 	if (node?.type === "TemplateLiteral" && node.expressions.length === 0) return node.quasis[0]?.value?.cooked ?? void 0;
 }
 function leafKind(node) {
-	node = unwrap(node);
+	node = unwrapNode(node);
 	if (stringValue(node) !== void 0) return "string";
 	if (node?.type === "ArrowFunctionExpression" || node?.type === "FunctionExpression" || node?.type === "ObjectMethod") return "function";
 	return "other";
 }
 function dictionaryProp(obj) {
-	const value = unwrap(findProp(obj, "dictionary")?.value);
-	return isObject(value) ? value : void 0;
+	const value = unwrapNode(findProperty(obj, "dictionary")?.value);
+	return isObjectNode(value) ? value : void 0;
 }
 function locateName(declaration) {
-	const decl = unwrap(declaration);
+	const decl = unwrapNode(declaration);
 	if (decl?.type === "CallExpression") {
-		const first = unwrap(decl.arguments[0]);
-		if (isObject(first)) return stringValue(findProp(first, "name")?.value);
+		const first = unwrapNode(decl.arguments[0]);
+		if (isObjectNode(first)) return stringValue(findProperty(first, "name")?.value);
 		return stringValue(first);
 	}
-	if (isObject(decl)) return stringValue(findProp(decl, "name")?.value);
+	if (isObjectNode(decl)) return stringValue(findProperty(decl, "name")?.value);
 }
 function locateLocalesObject(declaration) {
-	const decl = unwrap(declaration);
+	const decl = unwrapNode(declaration);
 	if (decl?.type === "CallExpression") {
-		const first = unwrap(decl.arguments[0]);
-		const second = unwrap(decl.arguments[1]);
-		if (isObject(second)) return second;
-		if (isObject(first)) return dictionaryProp(first);
+		const first = unwrapNode(decl.arguments[0]);
+		const second = unwrapNode(decl.arguments[1]);
+		if (isObjectNode(second)) return second;
+		if (isObjectNode(first)) return dictionaryProp(first);
 		return;
 	}
-	if (isObject(decl)) return dictionaryProp(decl);
+	if (isObjectNode(decl)) return dictionaryProp(decl);
 }
 /** Quotes a property key only when it is not a valid identifier. */
 function keyCode(key) {
@@ -82,15 +88,15 @@ function makeStringNode(value) {
 */
 function isStaticallyComplete(localesObj) {
 	const walk = (obj) => obj.properties.every((prop) => {
-		if (!isPropLike(prop) || keyName(prop) === void 0) return false;
+		if (!isPropLike(prop) || propertyKeyName(prop) === void 0) return false;
 		if (prop.type === "ObjectMethod") return true;
-		const value = unwrap(prop.value);
-		return isObject(value) ? walk(value) : true;
+		const value = unwrapNode(prop.value);
+		return isObjectNode(value) ? walk(value) : true;
 	});
 	return localesObj.properties.every((prop) => {
-		if (!isPropLike(prop) || keyName(prop) === void 0 || prop.type === "ObjectMethod") return false;
-		const value = unwrap(prop.value);
-		return isObject(value) && walk(value);
+		if (!isPropLike(prop) || propertyKeyName(prop) === void 0 || prop.type === "ObjectMethod") return false;
+		const value = unwrapNode(prop.value);
+		return isObjectNode(value) && walk(value);
 	});
 }
 /**
@@ -129,11 +135,11 @@ async function saveDictionaryFile(df) {
 	}
 }
 function listLocales(df) {
-	return df.localesObj.properties.filter(isPropLike).map(keyName).filter((k) => k !== void 0);
+	return df.localesObj.properties.filter(isPropLike).map(propertyKeyName).filter((k) => k !== void 0);
 }
 function localeObject(df, locale) {
-	const value = unwrap(findProp(df.localesObj, locale)?.value);
-	return isObject(value) ? value : void 0;
+	const value = unwrapNode(findProperty(df.localesObj, locale)?.value);
+	return isObjectNode(value) ? value : void 0;
 }
 /** Lists every leaf (string, function, or other value) of a locale, in source order. */
 function listLeaves(df, locale) {
@@ -143,11 +149,11 @@ function listLeaves(df, locale) {
 	const walk = (obj, prefix) => {
 		for (const prop of obj.properties) {
 			if (!isPropLike(prop)) continue;
-			const name = keyName(prop);
+			const name = propertyKeyName(prop);
 			if (name === void 0) continue;
 			const path = [...prefix, name];
-			const value = prop.type === "ObjectMethod" ? prop : unwrap(prop.value);
-			if (isObject(value)) walk(value, path);
+			const value = prop.type === "ObjectMethod" ? prop : unwrapNode(prop.value);
+			if (isObjectNode(value)) walk(value, path);
 			else {
 				const kind = leafKind(value);
 				leaves.push({
@@ -164,11 +170,11 @@ function listLeaves(df, locale) {
 function getProp(df, locale, path) {
 	let obj = localeObject(df, locale);
 	for (let i = 0; obj && i < path.length; i++) {
-		const prop = findProp(obj, path[i]);
+		const prop = findProperty(obj, path[i]);
 		if (!prop) return void 0;
 		if (i === path.length - 1) return prop;
-		const next = unwrap(prop.value);
-		obj = isObject(next) ? next : void 0;
+		const next = unwrapNode(prop.value);
+		obj = isObjectNode(next) ? next : void 0;
 	}
 }
 function hasPath(df, locale, path) {
@@ -191,13 +197,13 @@ function ensureLocale(df, locale) {
 function ensureParent(df, locale, path) {
 	let obj = ensureLocale(df, locale);
 	for (const segment of path.slice(0, -1)) {
-		let prop = findProp(obj, segment);
+		let prop = findProperty(obj, segment);
 		if (!prop) {
 			prop = makeProp(segment, "{}");
 			obj.properties.push(prop);
 		}
-		const next = unwrap(prop.value);
-		if (!isObject(next)) return void 0;
+		const next = unwrapNode(prop.value);
+		if (!isObjectNode(next)) return void 0;
 		obj = next;
 	}
 	return obj;
@@ -210,7 +216,7 @@ function setString(df, locale, path, value) {
 	const parent = ensureParent(df, locale, path);
 	if (!parent) return "skipped";
 	const last = path[path.length - 1];
-	const existing = findProp(parent, last);
+	const existing = findProperty(parent, last);
 	if (existing) {
 		if (existing.type === "ObjectMethod" || leafKind(existing.value) !== "string") return "skipped";
 		existing.value = makeStringNode(value);
@@ -259,7 +265,7 @@ const toRange = (loc) => loc ? {
 * it is a good place to attach a diagnostic or jump to.
 */
 function locationOf(df, locale, path = []) {
-	const prop = path.length === 0 ? findProp(df.localesObj, locale) : getProp(df, locale, path);
+	const prop = path.length === 0 ? findProperty(df.localesObj, locale) : getProp(df, locale, path);
 	return toRange((prop?.key ?? prop)?.loc);
 }
 /** The source text of the dictionary object itself (the object whose keys are locales). */
@@ -518,6 +524,10 @@ function lockFor(root, sourceLocale) {
 }
 //#endregion
 //#region src/analysis.ts
+function lintLevel(setting) {
+	const level = Array.isArray(setting) ? setting[0] : setting;
+	return level === "off" || level === "warn" || level === "error" ? level : void 0;
+}
 function createAnalysisCache() {
 	return {
 		dictionaries: /* @__PURE__ */ new Map(),
@@ -534,12 +544,115 @@ const DEFAULT_SOURCE_GLOB = "**/*.{ts,tsx,js,jsx,mjs,cjs,vue,svelte,astro,mdx}";
 const DICTIONARY_CALL = /\b(?:getDictionary|useDictionary|DialexDictionary)\(\s*(["'`])([^"'`$\n]+)\1/dg;
 /** `t("dictionary.path.to.key")` */
 const T_CALL = /(?<![\w$.])t\(\s*(["'`])([\w-]+(?:\.[\w-]+)+)\1/dg;
-/** Finds `getDictionary("x")`-style and `t("x.y.z")` references in source text. */
-function scanReferences(text) {
+/**
+* Offsets of `//`, `/* *\/` and `<!-- -->` comments. Quoted strings are skipped so `"http://x"`
+* is not a comment; `'` and `"` end at a newline, template literals do not.
+*/
+function commentRanges(text) {
+	const ranges = [];
+	const length = text.length;
+	let i = 0;
+	while (i < length) {
+		const c = text[i];
+		if (c === "\"" || c === "'" || c === "`") {
+			i++;
+			while (i < length && text[i] !== c && (c === "`" || text[i] !== "\n")) {
+				if (text[i] === "\\") i++;
+				i++;
+			}
+			i++;
+			continue;
+		}
+		let close;
+		if (c === "/" && text[i + 1] === "/") close = "\n";
+		else if (c === "/" && text[i + 1] === "*") close = "*/";
+		else if (c === "<" && text.startsWith("<!--", i)) close = "-->";
+		if (close === void 0) {
+			i++;
+			continue;
+		}
+		const found = text.indexOf(close, i + 2);
+		const end = found === -1 ? length : close === "\n" ? found : found + close.length;
+		ranges.push([i, end]);
+		i = end;
+	}
+	return ranges;
+}
+const IGNORE_DIRECTIVE = /dialex-ignore(-next-line)?(?![\w-])/;
+/** `dictionaries: { name: ..., "other-name": ..., shorthand }`, up to the first key. */
+const DICTIONARIES_OBJECT = /\bdictionaries\s*:\s*\{/g;
+const OBJECT_KEY = /\s*(?:([A-Za-z_$][\w$-]*)|(["'])([^"'\n]+)\2)\s*(?=[:,}])/y;
+/** Replaces comments with spaces of the same length, keeping offsets and line breaks. */
+function maskComments(text, comments) {
+	if (comments.length === 0) return text;
+	let out = "";
+	let at = 0;
+	for (const [from, to] of comments) {
+		out += text.slice(at, from) + text.slice(from, to).replace(/[^\n]/g, " ");
+		at = to;
+	}
+	return out + text.slice(at);
+}
+/** Names that an object literal `dictionaries: { ... }` registers inline. */
+function inlineDictionaryNames(masked) {
+	const names = /* @__PURE__ */ new Set();
+	for (const match of masked.matchAll(DICTIONARIES_OBJECT)) {
+		let i = match.index + match[0].length;
+		let depth = 1;
+		let expectKey = true;
+		while (i < masked.length && depth > 0) {
+			if (expectKey && depth === 1) {
+				OBJECT_KEY.lastIndex = i;
+				const key = OBJECT_KEY.exec(masked);
+				if (key) {
+					names.add(key[1] ?? key[3]);
+					i = OBJECT_KEY.lastIndex;
+				}
+				expectKey = false;
+				continue;
+			}
+			const c = masked[i];
+			if (c === "\"" || c === "'" || c === "`") {
+				i++;
+				while (i < masked.length && masked[i] !== c && (c === "`" || masked[i] !== "\n")) {
+					if (masked[i] === "\\") i++;
+					i++;
+				}
+			} else if (c === "{" || c === "[" || c === "(") depth++;
+			else if (c === "}" || c === "]" || c === ")") depth--;
+			else if (c === "," && depth === 1) expectKey = true;
+			i++;
+		}
+	}
+	return [...names];
+}
+/** Lines that a `dialex-ignore` / `dialex-ignore-next-line` comment excludes from checking. */
+function ignoredLines(text, comments) {
+	const lines = /* @__PURE__ */ new Set();
+	if (!text.includes("dialex-ignore")) return lines;
+	const starts = lineStarts(text);
+	for (const [from, to] of comments) {
+		const directive = IGNORE_DIRECTIVE.exec(text.slice(from, to));
+		if (!directive) continue;
+		const first = positionAt(starts, from).line;
+		const last = positionAt(starts, Math.max(from, to - 1)).line;
+		if (directive[1]) lines.add(last + 1);
+		else for (let line = first; line <= last; line++) lines.add(line);
+	}
+	return lines;
+}
+/** References and inline dictionary names found in one source file. */
+function scanText(text) {
+	const comments = commentRanges(text);
+	const ignored = ignoredLines(text, comments);
+	const starts = ignored.size > 0 ? lineStarts(text) : [];
+	const inComment = (offset) => comments.some(([from, to]) => offset >= from && offset < to);
 	const references = [];
 	const collect = (pattern, kind) => {
 		for (const match of text.matchAll(pattern)) {
 			const [start, end] = match.indices[2];
+			if (comments.length > 0 && inComment(start)) continue;
+			if (ignored.size > 0 && ignored.has(positionAt(starts, start).line)) continue;
 			references.push({
 				kind,
 				value: match[2],
@@ -550,7 +663,18 @@ function scanReferences(text) {
 	};
 	collect(DICTIONARY_CALL, "dictionary");
 	collect(T_CALL, "path");
-	return references.sort((a, b) => a.start - b.start);
+	references.sort((a, b) => a.start - b.start);
+	return {
+		references,
+		inline: text.includes("dictionaries") ? inlineDictionaryNames(maskComments(text, comments)) : []
+	};
+}
+/**
+* Finds `getDictionary("x")`-style and `t("x.y.z")` references in source text. References inside
+* comments, and on lines a `dialex-ignore` comment covers, are skipped.
+*/
+function scanReferences(text) {
+	return scanText(text).references;
 }
 function lineStarts(text) {
 	const starts = [0];
@@ -640,29 +764,37 @@ async function fromRuntime(file) {
 		};
 	}
 }
-async function loadDictionaryData(file, runtime) {
-	let astError;
+function fromParsed(parsed) {
 	try {
-		const df = await loadDictionaryFile(file);
+		const df = parsed();
 		if (df?.complete && df.name) return {
 			ok: true,
 			data: fromSyntaxTree(df)
 		};
 	} catch (error) {
-		astError = error;
+		return {
+			ok: false,
+			level: "error",
+			code: "invalid-dictionary",
+			message: `Failed to parse dictionary: ${error.message}`
+		};
 	}
+}
+const UNANALYZABLE = {
+	ok: false,
+	level: "info",
+	code: "unanalyzable",
+	message: "This dictionary uses spreads, computed keys, imported values, or a computed name, so it cannot be analyzed statically."
+};
+/** Reads a dictionary from its syntax tree. Never runs project code. */
+function loadDictionaryDataStatic(file) {
+	return fromParsed(() => parseDictionaryText(file, fs.readFileSync(file, "utf-8"))) ?? UNANALYZABLE;
+}
+async function loadDictionaryData(file, runtime) {
+	const parsed = fromParsed(() => parseDictionaryText(file, fs.readFileSync(file, "utf-8")));
+	if (parsed?.ok) return parsed;
 	if (runtime) return fromRuntime(file);
-	return astError ? {
-		ok: false,
-		level: "error",
-		code: "invalid-dictionary",
-		message: `Failed to parse dictionary: ${astError.message}`
-	} : {
-		ok: false,
-		level: "info",
-		code: "unanalyzable",
-		message: "This dictionary uses spreads, computed keys, imported values, or a computed name, so it cannot be analyzed statically."
-	};
+	return parsed ?? UNANALYZABLE;
 }
 function stampOf(file) {
 	try {
@@ -683,21 +815,39 @@ async function cachedDictionary(file, runtime, cache) {
 	});
 	return loaded;
 }
+function cachedDictionaryStatic(file, cache) {
+	const stamp = cache ? stampOf(file) : void 0;
+	const hit = stamp ? cache.dictionaries.get(file) : void 0;
+	if (hit && hit.stamp === stamp) return hit.loaded;
+	const loaded = loadDictionaryDataStatic(file);
+	if (cache && stamp) cache.dictionaries.set(file, {
+		stamp,
+		loaded
+	});
+	return loaded;
+}
 function scanSource(text) {
 	const starts = lineStarts(text);
 	const rangeOf = (start, end) => ({
 		start: positionAt(starts, start),
 		end: positionAt(starts, end)
 	});
+	const { references, inline } = scanText(text);
 	return {
 		tokens: [...new Set(text.match(/[\w$-]+/g) ?? [])],
-		refs: scanReferences(text).map((ref) => ({
+		refs: references.map((ref) => ({
 			ref,
 			range: rangeOf(ref.start, ref.end)
-		}))
+		})),
+		inline
 	};
 }
-async function analyzeProject(options) {
+/**
+* The analysis itself, written once. It yields a `LoadRequest` for every dictionary so that a
+* synchronous driver (`analyzeProjectSync`) and an asynchronous one (`analyzeProject`, which may
+* import dictionaries at runtime) can share it.
+*/
+function* analysisSteps(options) {
 	const { root, config } = options;
 	const include = config.include || "**/*.content.ts";
 	const configuredLocales = config.locales || [];
@@ -718,7 +868,12 @@ async function analyzeProject(options) {
 	const dictionaries = [];
 	const lock = options.lock === false ? void 0 : readLock(root);
 	for (const file of files) {
-		const loaded = await cachedDictionary(file, options.runtime === true, cache);
+		const loaded = yield {
+			file,
+			runtime: options.runtime === true,
+			cache,
+			text: options.contents?.get(file)
+		};
 		if (!loaded.ok) {
 			for (const message of loaded.message.split("\n")) issues.push({
 				file,
@@ -831,8 +986,10 @@ async function analyzeProject(options) {
 		ignore: extraIgnore,
 		gitignoreFilter: gitignore
 	}).filter((f) => !dictionaryFiles.has(f));
+	const inline = /* @__PURE__ */ new Set();
 	if (sourceFiles.length > 0) {
 		const tokens = /* @__PURE__ */ new Set();
+		const scans = [];
 		for (const file of sourceFiles) {
 			const stamp = cache ? stampOf(file) : void 0;
 			let scan = stamp ? cache.sources.get(file) : void 0;
@@ -850,32 +1007,37 @@ async function analyzeProject(options) {
 				if (cache && stamp) cache.sources.set(file, scan);
 			}
 			for (const token of scan.scan.tokens) tokens.add(token);
-			for (const { ref, range } of scan.scan.refs) {
-				if (ref.kind === "dictionary") {
-					if (!known.has(ref.value)) issues.push({
-						file,
-						level: "error",
-						code: "unknown-dictionary",
-						message: `Unknown dictionary "${ref.value}"`,
-						range,
-						dictionary: ref.value
-					});
-					continue;
-				}
-				const [name, ...rest] = ref.value.split(".");
-				const dictionary = known.get(name);
-				if (!dictionary) continue;
-				const keyPath = rest.join(".");
-				if (!dictionary.paths.some((p) => p === keyPath || p.startsWith(`${keyPath}.`))) issues.push({
+			scans.push({
+				file,
+				scan: scan.scan
+			});
+		}
+		for (const { scan } of scans) for (const name of scan.inline) inline.add(name);
+		for (const { file, scan } of scans) for (const { ref, range } of scan.refs) {
+			if (ref.kind === "dictionary") {
+				if (!known.has(ref.value) && !inline.has(ref.value)) issues.push({
 					file,
 					level: "error",
-					code: "unknown-path",
-					message: `Unknown translation path "${ref.value}"`,
+					code: "unknown-dictionary",
+					message: `Unknown dictionary "${ref.value}"`,
 					range,
-					dictionary: name,
-					path: rest
+					dictionary: ref.value
 				});
+				continue;
 			}
+			const [name, ...rest] = ref.value.split(".");
+			const dictionary = known.get(name);
+			if (!dictionary) continue;
+			const keyPath = rest.join(".");
+			if (!dictionary.paths.some((p) => p === keyPath || p.startsWith(`${keyPath}.`))) issues.push({
+				file,
+				level: "error",
+				code: "unknown-path",
+				message: `Unknown translation path "${ref.value}"`,
+				range,
+				dictionary: name,
+				path: rest
+			});
 		}
 		if (options.unused !== false) for (const dictionary of dictionaries) {
 			if (!tokens.has(dictionary.name)) {
@@ -909,13 +1071,47 @@ async function analyzeProject(options) {
 		const live = /* @__PURE__ */ new Set([...files, ...sourceFiles]);
 		for (const map of [cache.dictionaries, cache.sources]) for (const key of map.keys()) if (key.startsWith(root) && !live.has(key)) map.delete(key);
 	}
+	const rules = config.lint?.rules;
+	if (rules && Object.keys(rules).length > 0) for (let i = issues.length - 1; i >= 0; i--) {
+		const level = lintLevel(rules[issues[i].code]);
+		if (!level) continue;
+		if (level === "off") issues.splice(i, 1);
+		else issues[i].level = level === "error" ? "error" : "warning";
+	}
 	return {
 		issues,
 		dictionaries,
 		files,
-		sourceFilesScanned: sourceFiles.length
+		sourceFilesScanned: sourceFiles.length,
+		inlineDictionaries: [...inline]
 	};
 }
+/** Analyzes a project. With `runtime: true`, dictionaries the syntax tree cannot describe are imported. */
+async function analyzeProject(options) {
+	const steps = analysisSteps(options);
+	let step = steps.next();
+	while (!step.done) {
+		const { file, runtime, cache, text } = step.value;
+		step = steps.next(text === void 0 ? await cachedDictionary(file, runtime, cache) : fromParsed(() => parseDictionaryText(file, text)) ?? UNANALYZABLE);
+	}
+	return step.value;
+}
+/**
+* `analyzeProject` for callers that cannot await, such as lint rules. Reads dictionaries from the
+* syntax tree only: `runtime` is ignored, so project code is never executed.
+*/
+function analyzeProjectSync(options) {
+	const steps = analysisSteps({
+		...options,
+		runtime: false
+	});
+	let step = steps.next();
+	while (!step.done) {
+		const { file, cache, text } = step.value;
+		step = steps.next(text === void 0 ? cachedDictionaryStatic(file, cache) : fromParsed(() => parseDictionaryText(file, text)) ?? UNANALYZABLE);
+	}
+	return step.value;
+}
 /** Project root-relative path with forward slashes, for display. */
 function relativeFile(root, file) {
 	return path.relative(root, file);
@@ -930,44 +1126,48 @@ const logger = {
 	log: (msg) => console.log(msg)
 };
 //#endregion
+//#region src/utils/load-config.ts
+/**
+* Runs the first config file that exists (`dialex.config.*`, then `i18n.config.*`, or
+* `configFile`) with `unconfig` and returns what it exports. **This executes project code.**
+* Returns `undefined` when the project has no config file; throws what the file throws.
+*/
+function loadConfigObject(root, configFile) {
+	const sources = [];
+	if (configFile) sources.push({ files: configFile });
+	for (const name of ["dialex.config", "i18n.config"]) sources.push({
+		files: name,
+		extensions: [
+			"ts",
+			"mts",
+			"cts",
+			"js",
+			"mjs",
+			"cjs",
+			"json",
+			""
+		]
+	});
+	const result = loadConfigSync({
+		sources,
+		merge: false,
+		defaults: {},
+		cwd: root
+	});
+	const file = result?.sources?.[0];
+	if (!file) return void 0;
+	return {
+		config: result.config && typeof result.config === "object" ? result.config : {},
+		file
+	};
+}
+//#endregion
 //#region src/utils/scanner.ts
 function resolveDialexConfig(root, inlineConfig = {}) {
 	let loadedConfig = {};
 	try {
-		const sources = [];
-		if (inlineConfig.configFile) sources.push({ files: inlineConfig.configFile });
-		sources.push({
-			files: "dialex.config",
-			extensions: [
-				"ts",
-				"mts",
-				"cts",
-				"js",
-				"mjs",
-				"cjs",
-				"json",
-				""
-			]
-		}, {
-			files: "i18n.config",
-			extensions: [
-				"ts",
-				"mts",
-				"cts",
-				"js",
-				"mjs",
-				"cjs",
-				"json",
-				""
-			]
-		});
-		const result = loadConfigSync({
-			sources,
-			merge: false,
-			defaults: {},
-			cwd: root
-		});
-		if (result && result.config) loadedConfig = result.config;
+		const loaded = loadConfigObject(root, inlineConfig.configFile);
+		if (loaded) loadedConfig = loaded.config;
 	} catch {}
 	return {
 		...DEFAULT_CONFIG,
@@ -990,7 +1190,15 @@ const REGISTRY_ADAPTERS = [
 	"vue",
 	"web",
 	"h3",
-	"angular"
+	"angular",
+	"svelte",
+	"solid",
+	"preact",
+	"qwik",
+	"lit",
+	"hapi",
+	"adonis",
+	"trpc"
 ];
 /** Dependencies that tell which `dialexjs/*` entry points a project can import. */
 const ADAPTER_DEPENDENCIES = {
@@ -1011,6 +1219,17 @@ const ADAPTER_DEPENDENCIES = {
 	h3: ["h3"],
 	nitropack: ["h3"],
 	"@angular/core": ["angular"],
+	svelte: ["svelte"],
+	"solid-js": ["solid"],
+	preact: ["preact"],
+	"@builder.io/qwik": ["qwik"],
+	lit: ["lit"],
+	"@hapi/hapi": ["hapi"],
+	"@adonisjs/core": ["adonis"],
+	"@adonisjs/http-server": ["adonis"],
+	"@trpc/server": ["trpc"],
+	"react-native": ["react"],
+	expo: ["react"],
 	"react-router": ["web"],
 	"react-router-dom": ["web"],
 	"@remix-run/react": ["web"],
@@ -1041,9 +1260,9 @@ function detectAdapters(root) {
 * The `dialex-env.d.ts` a project should have: its path and contents, or `undefined` when there
 * are no dictionary files. Nothing is written.
 */
-function renderDts(root, files, locales, messageArguments = {}) {
+function renderDts(root, files, locales, messageArguments = {}, directory) {
 	if (files.length === 0) return void 0;
-	const dtsDir = fs.existsSync(path.join(root, "src")) ? path.join(root, "src") : root;
+	const dtsDir = directory ?? (fs.existsSync(path.join(root, "src")) ? path.join(root, "src") : root);
 	const imports = [];
 	const records = [];
 	files.forEach((file, index) => {
@@ -1226,9 +1445,9 @@ function splitLocales(df) {
 	const bound = topLevelNames(df);
 	const slices = [];
 	for (const prop of df.localesObj.properties) {
-		const locale = keyName(prop);
-		const value = unwrap(prop.value);
-		if (locale === void 0 || !isObject(value)) return {
+		const locale = propertyKeyName(prop);
+		const value = unwrapNode(prop.value);
+		if (locale === void 0 || !isObjectNode(value)) return {
 			ok: false,
 			reason: "a locale is not an object literal"
 		};
@@ -1253,8 +1472,10 @@ function splitLocales(df) {
 }
 //#endregion
 //#region src/utils/static-config.ts
+/** The names a config file can have, without extension, in order of preference. */
 const CONFIG_NAMES = ["dialex.config", "i18n.config"];
-const EXTENSIONS = [
+/** The extensions tried for each name, in order. */
+const CONFIG_EXTENSIONS = [
 	"ts",
 	"mts",
 	"cts",
@@ -1263,6 +1484,22 @@ const EXTENSIONS = [
 	"cjs",
 	"json"
 ];
+/** The keys of the config that tooling reads. */
+const CONFIG_KEYS = [
+	"defaultLocale",
+	"locales",
+	"include",
+	"exclude",
+	"output",
+	"fallbacks",
+	"prefixDefault",
+	"lazy",
+	"lint"
+];
+/** The paths `readStaticConfig` and `resolveConfig` try, in order, for a project root. */
+function configCandidates(root, configFile) {
+	return configFile ? [path.resolve(root, configFile)] : CONFIG_NAMES.flatMap((name) => CONFIG_EXTENSIONS.map((ext) => path.join(root, `${name}.${ext}`)));
+}
 const DEFAULT_STATIC_CONFIG = {
 	defaultLocale: "en",
 	locales: [],
@@ -1270,11 +1507,12 @@ const DEFAULT_STATIC_CONFIG = {
 	exclude: [],
 	fallbacks: {},
 	prefixDefault: true,
-	lazy: false
+	lazy: false,
+	lint: { rules: {} }
 };
 const NOT_LITERAL = Symbol("not literal");
 function literal(node) {
-	node = unwrap(node);
+	node = unwrapNode(node);
 	switch (node?.type) {
 		case "StringLiteral":
 		case "NumericLiteral":
@@ -1288,7 +1526,7 @@ function literal(node) {
 		case "ObjectExpression": {
 			const result = {};
 			for (const prop of node.properties) {
-				const key = keyName(prop);
+				const key = propertyKeyName(prop);
 				const value = key === void 0 ? NOT_LITERAL : literal(prop.value);
 				if (value === NOT_LITERAL) return NOT_LITERAL;
 				result[key] = value;
@@ -1300,12 +1538,36 @@ function literal(node) {
 }
 /** The object literal passed to `defineConfig({...})`, or exported directly. */
 function findConfigObject(declaration) {
-	const node = unwrap(declaration);
+	const node = unwrapNode(declaration);
 	if (node?.type === "CallExpression") return findConfigObject(node.arguments[0]);
-	return isObject(node) ? node : void 0;
+	return isObjectNode(node) ? node : void 0;
 }
 const isStringArray = (value) => Array.isArray(value) && value.every((v) => typeof v === "string");
-function apply(object, config, notes) {
+const LINT_LEVELS = [
+	"off",
+	"warn",
+	"error"
+];
+/** `lint: { rules: { code: "warn" | ["warn", {...}] } }`, or `undefined` when it is not that shape. */
+function lintRules(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+	const rules = value.rules;
+	if (rules === void 0) return {};
+	if (typeof rules !== "object" || rules === null || Array.isArray(rules)) return void 0;
+	const result = {};
+	for (const [code, setting] of Object.entries(rules)) {
+		const [level, options] = Array.isArray(setting) ? setting : [setting];
+		if (typeof level !== "string" || !LINT_LEVELS.includes(level)) return void 0;
+		if (options !== void 0 && (typeof options !== "object" || options === null)) return void 0;
+		result[code] = setting;
+	}
+	return result;
+}
+/**
+* Applies the values of a config object (read from a syntax tree or from a loaded module) over
+* `config`, with the same checks and notes either way.
+*/
+function applyConfigValues(object, config, notes) {
 	const accept = (key, valid, expected) => {
 		if (!(key in object)) return;
 		const value = object[key];
@@ -1316,25 +1578,33 @@ function apply(object, config, notes) {
 	accept("locales", isStringArray, "an array of string literals");
 	accept("include", (v) => typeof v === "string" || isStringArray(v), "a string or array of strings");
 	accept("exclude", isStringArray, "an array of string literals");
+	accept("output", (v) => typeof v === "string" && v !== "", "a string literal");
 	accept("fallbacks", (v) => typeof v === "object" && v !== null && Object.values(v).every((list) => isStringArray(list)), "an object of string arrays");
 	accept("prefixDefault", (v) => typeof v === "boolean", "true or false");
 	accept("lazy", (v) => typeof v === "boolean" || v === "locale", "true, false or \"locale\"");
+	if ("lint" in object) {
+		const rules = lintRules(object.lint);
+		if (rules) config.lint = { rules };
+		else notes.push("\"lint\" could not be read statically (expected { rules: { code: \"off\" | \"warn\" | \"error\" | [level, options] } }).");
+	}
 }
 /** Reads a config file's source text. Exposed for tests and for unsaved buffers. */
 function parseStaticConfig(text, file = "dialex.config.ts") {
 	const notes = [];
 	const config = { ...DEFAULT_STATIC_CONFIG };
+	let opaque = false;
 	if (file.endsWith(".json")) {
 		try {
 			const data = JSON.parse(text);
-			if (data && typeof data === "object") apply(data, config, notes);
+			if (data && typeof data === "object") applyConfigValues(data, config, notes);
 		} catch (error) {
 			notes.push(`Could not parse ${path.basename(file)}: ${error.message}`);
 		}
 		return {
 			config,
 			file,
-			notes
+			notes,
+			opaque
 		};
 	}
 	try {
@@ -1343,22 +1613,15 @@ function parseStaticConfig(text, file = "dialex.config.ts") {
 		if (!object) notes.push(`${path.basename(file)} does not export a config object literal.`);
 		else {
 			const values = {};
-			for (const key of [
-				"defaultLocale",
-				"locales",
-				"include",
-				"exclude",
-				"fallbacks",
-				"prefixDefault",
-				"lazy"
-			]) {
-				const prop = findProp(object, key);
+			opaque = object.properties.some((p) => p.type === "SpreadElement" || p.type === "SpreadProperty" || p.computed === true);
+			for (const key of CONFIG_KEYS) {
+				const prop = findProperty(object, key);
 				if (!prop) continue;
 				const value = literal(prop.value);
 				if (value === NOT_LITERAL) notes.push(`"${key}" could not be read statically (not a literal).`);
 				else values[key] = value;
 			}
-			apply(values, config, notes);
+			applyConfigValues(values, config, notes);
 		}
 	} catch (error) {
 		notes.push(`Could not parse ${path.basename(file)}: ${error.message}`);
@@ -1366,16 +1629,17 @@ function parseStaticConfig(text, file = "dialex.config.ts") {
 	return {
 		config,
 		file,
-		notes
+		notes,
+		opaque
 	};
 }
 /** Reads `dialex.config.*` (or `i18n.config.*`) from `root`, or from `configFile` if given. */
 function readStaticConfig(root, configFile) {
-	const candidates = configFile ? [path.resolve(root, configFile)] : CONFIG_NAMES.flatMap((name) => EXTENSIONS.map((ext) => path.join(root, `${name}.${ext}`)));
-	for (const file of candidates) if (fs.existsSync(file)) return parseStaticConfig(fs.readFileSync(file, "utf-8"), file);
+	for (const file of configCandidates(root, configFile)) if (fs.existsSync(file)) return parseStaticConfig(fs.readFileSync(file, "utf-8"), file);
 	return {
 		config: { ...DEFAULT_STATIC_CONFIG },
-		notes: []
+		notes: [],
+		opaque: false
 	};
 }
 //#endregion
@@ -1408,7 +1672,15 @@ function configFile(from) {
 	if (fs.existsSync(from) && fs.statSync(from).isFile()) return from;
 	for (const candidate of [`${from}.json`, path.join(from, "tsconfig.json")]) if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) return candidate;
 }
-/** `moduleResolution` and `include` of a tsconfig, following relative `extends`. */
+/** A package in `extends` (`@adonisjs/tsconfig/tsconfig.app.json`), looked up from `dir` upwards. */
+function packageConfig(from, specifier) {
+	for (let dir = from;; dir = path.dirname(dir)) {
+		const found = configFile(path.join(dir, "node_modules", specifier));
+		if (found) return found;
+		if (path.dirname(dir) === dir) return void 0;
+	}
+}
+/** `moduleResolution` and `include` of a tsconfig, following `extends` (relative or a package). */
 function read(file, depth = 0) {
 	const result = { references: [] };
 	let json;
@@ -1418,8 +1690,12 @@ function read(file, depth = 0) {
 		return result;
 	}
 	const dir = path.dirname(file);
-	const parent = typeof json.extends === "string" && json.extends.startsWith(".") && depth < 5 ? configFile(path.resolve(dir, json.extends)) : void 0;
-	if (parent) Object.assign(result, read(parent, depth + 1));
+	const parents = Array.isArray(json.extends) ? json.extends : [json.extends];
+	for (const extendsFrom of parents) {
+		if (typeof extendsFrom !== "string" || depth >= 5) continue;
+		const parent = extendsFrom.startsWith(".") ? configFile(path.resolve(dir, extendsFrom)) : packageConfig(dir, extendsFrom);
+		if (parent) Object.assign(result, read(parent, depth + 1));
+	}
 	const options = json.compilerOptions ?? {};
 	const module = typeof options.module === "string" ? options.module.toLowerCase() : void 0;
 	const resolution = typeof options.moduleResolution === "string" ? options.moduleResolution.toLowerCase() : module === "node16" || module === "nodenext" ? module : void 0;
@@ -1462,7 +1738,8 @@ function renderGenerated(root, options = {}) {
 	const config = options.static ? staticRead.config : resolveDialexConfig(root, inlineConfig);
 	const found = scanFiles(root, config.include || DEFAULT_CONFIG.include, { exclude: config.exclude }).sort();
 	const srcDir = fs.existsSync(path.join(root, "src")) ? path.join(root, "src") : root;
-	const outputPath = options.output ? path.resolve(root, options.output) : path.join(srcDir, "dialex.generated.ts");
+	const outputOption = options.output ?? config.output;
+	const outputPath = outputOption ? path.resolve(root, outputOption) : path.join(srcDir, "dialex.generated.ts");
 	const outputDir = path.dirname(outputPath);
 	const files = found.filter((file) => file !== outputPath && !file.endsWith(".d.ts") && path.basename(file) !== "dialex.generated.ts");
 	const parsed = files.map((file) => parseDictionaryText(file, fs.readFileSync(file, "utf-8")));
@@ -1552,12 +1829,12 @@ export const dialex = { dictionaries, config };
 export default dictionaries;
 `;
 	}
-	const dts = renderDts(root, files, locales, messageArguments(parsed, clientConfig.defaultLocale));
+	const dts = renderDts(root, files, locales, messageArguments(parsed, clientConfig.defaultLocale), outputOption ? outputDir : void 0);
 	return {
 		files,
 		outputPath,
 		content,
-		dtsPath: dts?.path ?? path.join(srcDir, "dialex-env.d.ts"),
+		dtsPath: dts?.path ?? path.join(outputOption ? outputDir : srcDir, "dialex-env.d.ts"),
 		dtsContent: dts?.content,
 		configFile: staticRead.file,
 		extraFiles,
@@ -1729,6 +2006,6 @@ async function loadStaticProject(root, configFile) {
 /** `home` + `["nav", "about"]` -> `home.nav.about` */
 const toKey = (dictionary, keyPath) => [dictionary, ...keyPath].join(".");
 //#endregion
-export { scanFiles as A, locationOf as B, lockPath as C, BUILTIN_IGNORE as D, writeLock as E, getString as F, renderDictionaryFile as H, hasPath as I, listLeaves as L, copyLeaf as M, dictionaryLocation as N, SOURCE_BUILTIN_IGNORE as O, getLeafSource as P, listLocales as R, lockFor as S, record as T, saveDictionaryFile as U, parseDictionaryText as V, setString as W, relativeFile as _, renderGenerated as a, hashSource as b, DEFAULT_STATIC_CONFIG as c, resolveDialexConfig as d, logger as f, createAnalysisCache as g, clearGitignore as h, generateDictionaries as i, TODO_PREFIX as j, createGitignoreFilter as k, parseStaticConfig as l, analyzeProject as m, loadStaticProject as n, runGenerate as o, DEFAULT_SOURCE_GLOB as p, toKey as r, startGenerateWatcher as s, loadProject as t, readStaticConfig as u, scanReferences as v, readLock as w, isStale as x, LOCK_FILE as y, loadDictionaryFile as z };
+export { SOURCE_BUILTIN_IGNORE as A, listLocales as B, isStale as C, record as D, readLock as E, dictionaryLocation as F, saveDictionaryFile as G, locationOf as H, getLeafSource as I, setString as K, getString as L, scanFiles as M, TODO_PREFIX as N, writeLock as O, copyLeaf as P, hasPath as R, hashSource as S, lockPath as T, parseDictionaryText as U, loadDictionaryFile as V, renderDictionaryFile as W, createAnalysisCache as _, renderGenerated as a, scanText as b, DEFAULT_STATIC_CONFIG as c, resolveDialexConfig as d, logger as f, clearGitignore as g, analyzeProjectSync as h, generateDictionaries as i, createGitignoreFilter as j, BUILTIN_IGNORE as k, parseStaticConfig as l, analyzeProject as m, loadStaticProject as n, runGenerate as o, DEFAULT_SOURCE_GLOB as p, toKey as r, startGenerateWatcher as s, loadProject as t, readStaticConfig as u, relativeFile as v, lockFor as w, LOCK_FILE as x, scanReferences as y, listLeaves as z };
 
-//# sourceMappingURL=project-Dz0FbydQ.mjs.map
+//# sourceMappingURL=project-B27699T2.mjs.map