vue-i18n-lint 0.0.1

package/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ruben Gees
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,216 @@
+# vue-i18n-lint
+
+Fast and accurate linting for Vue i18n. Detects missing and unused translation keys across your locale files and source
+code.
+
+Intended for use in CI pipelines, pre-commit hooks, or as part of your development workflow to maintain translation
+integrity.
+
+## Quick start
+
+```sh
+npx vue-i18n-lint [command] [options] [path]
+```
+
+`path` defaults to the current working directory.
+
+<details>
+<summary>pnpm</summary>
+
+```sh
+pnpm dlx vue-i18n-lint [command] [options] [path]
+```
+
+</details>
+
+<details>
+<summary>yarn</summary>
+
+```sh
+yarn dlx vue-i18n-lint [command] [options] [path]
+```
+
+</details>
+
+<details>
+<summary>Bun</summary>
+
+```sh
+bunx vue-i18n-lint [command] [options] [path]
+```
+
+</details>
+
+## Installation
+
+The cli can also be installed and run locally in your project:
+
+```sh
+npm install -D vue-i18n-lint
+```
+
+<details>
+<summary>pnpm</summary>
+
+```sh
+pnpm add -D vue-i18n-lint
+```
+
+</details>
+
+<details>
+<summary>yarn</summary>
+
+```sh
+yarn add -D vue-i18n-lint
+```
+
+</details>
+
+<details>
+<summary>Bun</summary>
+
+```sh
+bun add -D vue-i18n-lint
+```
+
+</details>
+
+You can run it like this:
+
+```sh
+vue-i18n-lint [command] [options] [path]
+```
+
+### Subcommands
+
+| Command          | Description                                      |
+| ---------------- | ------------------------------------------------ |
+| `lint` (default) | Detect missing and unused translation keys       |
+| `remove-unused`  | Remove unused translation keys from locale files |
+| `init`           | Scaffold a configuration file                    |
+
+### Options
+
+| Option                    | Description                                                   | Default                            |
+| ------------------------- | ------------------------------------------------------------- | ---------------------------------- |
+| `--format`                | Output format: `text`, `json`, or `toon`                      | `text`                             |
+| `--locale-pattern`        | Glob pattern for i18n locale files                            | `**/locales/*.json`                |
+| `--src-pattern`           | Glob pattern for source files                                 | `**/*.{ts,cts,mts,js,cjs,mjs,vue}` |
+| `--ignore-patterns`       | Comma-separated glob patterns to ignore                       |                                    |
+| `--ignore-keys`           | Comma-separated keys to ignore in all checks                  |                                    |
+| `--ignore-missing-keys`   | Comma-separated keys to ignore only in the missing keys check |                                    |
+| `--ignore-unused-keys`    | Comma-separated keys to ignore only in the unused keys check  |                                    |
+| `--missing-keys-severity` | Severity for missing keys: `error`, `warning`, or `off`       | `error`                            |
+| `--unused-keys-severity`  | Severity for unused keys: `error`, `warning`, or `off`        | `warning`                          |
+
+### Example
+
+```sh
+npx vue-i18n-lint --locale-pattern "**/i18n/*.{json}" ./my-project
+```
+
+## Configuration file
+
+In addition to CLI options, vue-i18n-lint can be configured via a config file in your project root.
+[c12](https://github.com/unjs/c12) is used for config loading, so the following file names are supported:
+
+- `vue-i18n-lint.config.ts`
+- `vue-i18n-lint.config.js`
+- `vue-i18n-lint.config.json`
+- `vue-i18n-lint.config.yaml`
+
+```ts
+// vue-i18n-lint.config.ts
+import { defineConfig } from "vue-i18n-lint"
+
+export default defineConfig({
+  localePattern: "**/i18n/*.json",
+  srcPattern: "**/*.{ts,vue}",
+  ignorePatterns: ["**/fixtures/**"],
+  ignoreKeys: ["dynamic.key"],
+  checks: {
+    missingKeys: {
+      severity: "error",
+      ignore: ["only.missing"],
+    },
+    unusedKeys: {
+      severity: "warning",
+      ignore: ["only.unused"],
+    },
+  },
+})
+```
+
+Use the exported `defineConfig` helper for TypeScript autocompletion.
+
+Dynamic missing keys are reported with `<dynamic>` as a placeholder (e.g. `status.<dynamic>`).
+Use that string in `ignoreKeys` or `checks.missingKeys.ignore` to suppress them.
+
+### gitignore
+
+Files matched by any `.gitignore` in your project are automatically excluded when scanning locale and source files,
+in addition to any `ignorePatterns` you configure.
+
+## What it checks
+
+- **Missing keys**: Translation keys used in source code but not defined in any locale file
+- **Unused keys**: Translation keys defined in locale files but never referenced in source code
+
+## Dynamic keys
+
+Keys built from template literals or string concatenation with runtime variables are understood:
+
+```ts
+t(`status.${type}`) // matched against locale keys as "status.*"
+t("prefix." + key) // matched against locale keys as "prefix.*"
+```
+
+A dynamic key is not reported missing if at least one locale key matches its pattern. Locale keys
+that match a dynamic pattern are not reported as unused.
+
+If no locale key matches, the missing key is reported with `<dynamic>` as a placeholder,
+e.g. `status.<dynamic>`.
+
+Purely dynamic expressions with no static fragments (e.g. `t(variable)`) are ignored.
+
+Dynamic key support is best-effort. There are many more complex cases that can't be detected by vue-i18n-lint (yet).
+
+> [!TIP]
+> Ignoring dynamic keys is done using the `<dynamic>` placeholder, e.g. `ignoreKeys: ["status.<dynamic>"]`
+
+## Supported locale file formats
+
+- JSON, JSONC, JSON5
+- YAML
+- JS/TS modules (expecting a default export of an object)
+- `<i18n>` blocks in Vue SFCs
+
+## Severity levels
+
+Each check (`missingKeys`, `unusedKeys`) supports a `severity` setting:
+
+| Value       | Behavior                                                    |
+| ----------- | ----------------------------------------------------------- |
+| `"error"`   | Prints output and sets exit code to `1` if issues are found |
+| `"warning"` | Prints output but does not set exit code to `1`             |
+| `"off"`     | Does not print output and does not affect exit code         |
+
+## Removing unused keys
+
+The `remove-unused` subcommand removes unused translation keys directly from your locale files. Only the simple
+file types (JSON, JSONC, JSON5, YAML) are supported (JS/TS files and `<i18n>` blocks are ignored).
+
+```sh
+npx vue-i18n-lint remove-unused [options] [path]
+```
+
+Pass `--dry-run` to see how many keys would be removed without making changes:
+
+```sh
+npx vue-i18n-lint remove-unused --dry-run
+```
+
+## Requirements
+
+- Node.js >= 22

package/dist/cli.mjs

@@ -0,0 +1,963 @@
+#!/usr/bin/env node
+import { buildApplication, buildCommand, buildRouteMap, run, text_en } from "@stricli/core";
+import { existsSync, readFileSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { basename, extname, join, resolve } from "node:path";
+import { createDefu, defu } from "defu";
+import { loadConfig } from "c12";
+import { z } from "zod";
+import { styleText } from "node:util";
+import { codeFrameColumns } from "@babel/code-frame";
+import { encode } from "@toon-format/toon";
+import { table } from "table";
+import escape from "regexp.escape";
+import { globby } from "globby";
+import { parseJSON, parseJSON5, parseJSONC, parseYAML, stringifyJSON, stringifyJSON5, stringifyJSONC, stringifyYAML } from "confbox";
+import { createJiti } from "jiti";
+import { parse } from "@vue/compiler-sfc";
+import { Visitor, parseSync } from "oxc-parser";
+import { NodeTypes } from "@vue/compiler-core";
+//#region src/utils.ts
+const merge = createDefu((obj, key, value) => {
+	if (Array.isArray(value)) {
+		obj[key] = value;
+		return true;
+	}
+	return false;
+});
+function newPrefixSet(keys = []) {
+	const set = /* @__PURE__ */ new Set();
+	for (const key of keys) {
+		const parts = key.split(".");
+		for (let i = 1; i <= parts.length; i++) set.add(parts.slice(0, i).join("."));
+	}
+	return set;
+}
+function mapGetOrInsert(map, key, defaultValue) {
+	if (!map.has(key)) map.set(key, defaultValue);
+	return map.get(key);
+}
+function getOrInsertComputed(map, key, callback) {
+	if (!map.has(key)) map.set(key, callback(key));
+	return map.get(key);
+}
+function offsetToPosition(source, offset) {
+	const lines = source.slice(0, offset).split("\n");
+	return {
+		line: lines.length,
+		column: (lines[lines.length - 1]?.length ?? 0) + 1
+	};
+}
+function writeLine(writer, line = "") {
+	writer.write(`${line}\n`);
+}
+function formatFilePath(filePath, line, column) {
+	const base = `file://${resolve(filePath)}`;
+	if (line != null && column != null) return `${base}:${line}:${column}`;
+	if (line != null) return `${base}:${line}`;
+	return base;
+}
+function isPlainObject(value) {
+	return value != null && typeof value === "object" && !Array.isArray(value);
+}
+//#endregion
+//#region src/command/init.ts
+const configTemplate = `import { defineConfig } from "vue-i18n-lint"
+
+export default defineConfig({
+  localePattern: "**/locales/*.json",
+  srcPattern: "**/*.{ts,cts,mts,js,cjs,mjs,vue}",
+})
+`;
+const initCommand = buildCommand({
+	async func(_flags, path) {
+		const targetPath = path || ".";
+		const configPath = join(targetPath, "vue-i18n-lint.config.ts");
+		if (existsSync(configPath)) {
+			writeLine(this.process.stderr, `vue-i18n-lint.config.ts already exists in ${formatFilePath(targetPath)}.`);
+			this.process.exitCode = 1;
+			return;
+		}
+		await mkdir(targetPath, { recursive: true });
+		await writeFile(configPath, configTemplate, "utf-8");
+		writeLine(this.process.stdout, `Created vue-i18n-lint.config.ts in ${formatFilePath(targetPath)}.`);
+	},
+	parameters: { positional: {
+		kind: "tuple",
+		parameters: [{
+			brief: "Target path for the config file",
+			parse: String,
+			placeholder: "path",
+			optional: true
+		}]
+	} },
+	docs: { brief: "Create a default vue-i18n-lint configuration file" }
+});
+//#endregion
+//#region src/config/schema.ts
+const severityEnum = z.enum([
+	"error",
+	"warning",
+	"off"
+]);
+const formatEnum = z.enum([
+	"text",
+	"json",
+	"toon"
+]);
+const checkSchema = (defaultSeverity) => z.union([z.object({
+	severity: severityEnum.default(defaultSeverity),
+	ignore: z.array(z.string().nonempty()).default([])
+}), z.literal(false).transform(() => ({
+	severity: "off",
+	ignore: []
+}))]).default({
+	severity: defaultSeverity,
+	ignore: []
+});
+const configSchema = z.object({
+	path: z.string().nonempty(),
+	format: formatEnum.default("text"),
+	localePattern: z.string().nonempty().default("**/locales/*.json"),
+	srcPattern: z.string().nonempty().default("**/*.{ts,cts,mts,js,cjs,mjs,vue}"),
+	ignorePatterns: z.array(z.string().nonempty()).default([]),
+	ignoreKeys: z.array(z.string().nonempty()).default([]),
+	checks: z.object({
+		missingKeys: checkSchema("error"),
+		unusedKeys: checkSchema("warning")
+	}).default({
+		missingKeys: {
+			severity: "error",
+			ignore: []
+		},
+		unusedKeys: {
+			severity: "warning",
+			ignore: []
+		}
+	})
+});
+z.object({
+	path: z.string().optional(),
+	format: formatEnum.optional(),
+	localePattern: z.string().optional(),
+	srcPattern: z.string().optional(),
+	ignorePatterns: z.array(z.string()).optional(),
+	ignoreKeys: z.array(z.string()).optional(),
+	ignoreMissingKeys: z.array(z.string()).optional(),
+	ignoreUnusedKeys: z.array(z.string()).optional(),
+	missingKeysSeverity: severityEnum.optional(),
+	unusedKeysSeverity: severityEnum.optional()
+});
+//#endregion
+//#region src/config/load.ts
+async function loadVueI18nLintConfig(cliArgs) {
+	const path = cliArgs?.path || process.cwd();
+	const cliConfig = buildCliConfig(path, cliArgs);
+	const rawFileConfig = await loadFileConfig(path) ?? {};
+	const parsedFileConfig = configSchema.safeParse({
+		path,
+		...rawFileConfig
+	});
+	if (!parsedFileConfig.success) throw new Error(`Failed to load config:\n${z.prettifyError(parsedFileConfig.error)}`);
+	const mergedConfig = merge(cliConfig, parsedFileConfig.data);
+	const parsedMergedConfig = configSchema.safeParse(mergedConfig);
+	if (!parsedMergedConfig.success) throw new Error(`Failed to load config:\n${z.prettifyError(parsedMergedConfig.error)}`);
+	return parsedMergedConfig.data;
+}
+function buildCliConfig(path, cliArgs) {
+	return {
+		path,
+		format: cliArgs?.format,
+		localePattern: cliArgs?.localePattern,
+		srcPattern: cliArgs?.srcPattern,
+		ignorePatterns: cliArgs?.ignorePatterns,
+		ignoreKeys: cliArgs?.ignoreKeys,
+		checks: {
+			missingKeys: {
+				ignore: cliArgs?.ignoreMissingKeys,
+				severity: cliArgs?.missingKeysSeverity
+			},
+			unusedKeys: {
+				ignore: cliArgs?.ignoreUnusedKeys,
+				severity: cliArgs?.unusedKeysSeverity
+			}
+		}
+	};
+}
+async function loadFileConfig(path) {
+	try {
+		return (await loadConfig({
+			name: "vue-i18n-lint",
+			cwd: path
+		})).config;
+	} catch (e) {
+		throw new Error(`Failed to load config file`, { cause: e });
+	}
+}
+//#endregion
+//#region src/formatter.ts
+function formatSummaryPart(value, severity) {
+	return styleText(value === 0 ? "green" : severity === "warning" ? "yellow" : "red", String(value));
+}
+function outputTypeWarnings(process, warnings) {
+	writeLine(process.stdout, styleText("bold", `Warnings (${warnings.length}):\n`));
+	const grouped = Object.groupBy(warnings, (it) => it.file);
+	for (const [file, fileTypeWarnings] of Object.entries(grouped)) {
+		writeLine(process.stdout, formatFilePath(file));
+		for (const typeWarning of fileTypeWarnings ?? []) writeLine(process.stdout, `  • Unexpected type ${styleText("italic", typeWarning.type)} for key ${typeWarning.key}`);
+		writeLine(process.stdout);
+	}
+}
+function outputMissingKeys(process, keys) {
+	writeLine(process.stdout, styleText("bold", `Missing keys (${keys.length}):\n`));
+	for (const key of keys) outputMissingKey(process, key);
+}
+function outputMissingKey(process, key) {
+	for (const source of key.sources) {
+		writeLine(process.stdout, `  ${formatFilePath(source.file)}:${source.location.start.line}:${source.location.start.column}`);
+		const content = readSourceFile(source.file);
+		if (content != null) writeLine(process.stdout, codeFrameColumns(content, source.location, {
+			highlightCode: true,
+			linesAbove: 1,
+			linesBelow: 1,
+			message: `Missing in ${styleText("bold", key.locales.join(", "))}`
+		}));
+		writeLine(process.stdout);
+	}
+}
+function readSourceFile(file) {
+	try {
+		return readFileSync(file, { encoding: "utf-8" });
+	} catch {
+		return null;
+	}
+}
+function outputUnusedKeys(process, keys) {
+	writeLine(process.stdout, styleText("bold", `Unused keys (${keys.length}):\n`));
+	const rows = keys.toSorted((a, b) => b.files.length - a.files.length || a.key.localeCompare(b.key)).map((unusedKey) => [unusedKey.key, unusedKey.files.map((file) => file.locale).join(", ")]);
+	const config = { drawHorizontalLine(index, size) {
+		return index === 0 || index === 1 || index === size;
+	} };
+	writeLine(process.stdout, table([["Key", "Locales"], ...rows], config));
+}
+function outputJson(process, data) {
+	writeLine(process.stdout, JSON.stringify(data, null, 2));
+}
+function outputToon(process, data) {
+	writeLine(process.stdout, encode(data));
+}
+//#endregion
+//#region src/processor.ts
+function processFiles(localeFiles, sourceFiles, config) {
+	const result = { typeWarnings: calcTypeWarnings(localeFiles) };
+	if (config.checks.missingKeys.severity !== "off") {
+		const ignoreSet = /* @__PURE__ */ new Set([...config.ignoreKeys, ...config.checks.missingKeys.ignore ?? []]);
+		result.missing = calcMissingKeys(localeFiles, sourceFiles).filter((entry) => !ignoreSet.has(entry.key));
+	}
+	if (config.checks.unusedKeys.severity !== "off") {
+		const ignoreSet = /* @__PURE__ */ new Set([...config.ignoreKeys, ...config.checks.unusedKeys.ignore ?? []]);
+		result.unused = calcUnusedKeys(localeFiles, sourceFiles).filter((entry) => !ignoreSet.has(entry.key));
+	}
+	return result;
+}
+function calcTypeWarnings(localeFiles) {
+	return localeFiles.flatMap((localeFile) => localeFile.keys.filter((key) => key.type !== "string" && key.type !== "function").map((key) => ({
+		key: key.key,
+		locale: localeFile.locale,
+		file: localeFile.file,
+		type: key.type
+	})));
+}
+function calcMissingKeys(localeFiles, sourceFiles) {
+	const globalLocalePrefixes = new Map(localeFiles.map((it) => [it.locale, newPrefixSet(it.keys.map((k) => k.key))]));
+	const locales = /* @__PURE__ */ new Set([...globalLocalePrefixes.keys(), ...sourceFiles.flatMap((sf) => sf.localeFiles.map((lf) => lf.locale))]);
+	const missingKeys = /* @__PURE__ */ new Map();
+	const regexCache = /* @__PURE__ */ new Map();
+	for (const sourceFile of sourceFiles) {
+		const localLocalePrefixes = new Map(sourceFile.localeFiles.map((it) => [it.locale, newPrefixSet(it.keys.map((k) => k.key))]));
+		for (const { key, file, location } of sourceFile.keys) if (typeof key !== "string") {
+			const keyStr = dynamicKeyToString(key);
+			const regex = getOrInsertComputed(regexCache, keyStr, () => buildDynamicKeyRegex(key));
+			const missingLocales = Array.from(locales).filter((locale) => !setMatchesRegex(localLocalePrefixes.get(locale), regex) && !setMatchesRegex(globalLocalePrefixes.get(locale), regex));
+			if (missingLocales.length > 0) mapGetOrInsert(missingKeys, keyStr, {
+				key: keyStr,
+				locales: missingLocales,
+				sources: []
+			}).sources.push({
+				file,
+				location
+			});
+		} else {
+			const missingLocales = Array.from(locales).filter((locale) => !localLocalePrefixes.get(locale)?.has(key) && !globalLocalePrefixes.get(locale)?.has(key));
+			if (missingLocales.length > 0) mapGetOrInsert(missingKeys, key, {
+				key,
+				locales: missingLocales,
+				sources: []
+			}).sources.push({
+				file,
+				location
+			});
+		}
+	}
+	return Array.from(missingKeys.values());
+}
+function dynamicKeyToString(dynamicKey) {
+	return dynamicKey.map((part) => typeof part === "string" ? part : "<dynamic>").join("");
+}
+function buildDynamicKeyRegex(dynamicKey) {
+	return new RegExp("^" + dynamicKey.map((part) => typeof part === "string" ? escape(part) : ".*").join("") + "$");
+}
+function setMatchesRegex(set, regex) {
+	if (!set) return false;
+	return set.values().some((item) => regex.test(item));
+}
+function calcUnusedKeys(localeFiles, sourceFiles) {
+	const unusedKeys = /* @__PURE__ */ new Map();
+	const sourceKeys = /* @__PURE__ */ new Set();
+	const sourceDynamicKeys = /* @__PURE__ */ new Map();
+	for (const sourceFile of sourceFiles) {
+		const sourceFileKeys = /* @__PURE__ */ new Set();
+		const sourceFileDynamicKeys = /* @__PURE__ */ new Map();
+		for (const k of sourceFile.keys) if (typeof k.key === "string") sourceFileKeys.add(k.key);
+		else {
+			const keyStr = dynamicKeyToString(k.key);
+			if (!sourceFileDynamicKeys.has(keyStr)) sourceFileDynamicKeys.set(keyStr, buildDynamicKeyRegex(k.key));
+		}
+		const sourceDynamicRegex = combineRegexes(Array.from(sourceFileDynamicKeys.values()));
+		calcUnusedKeysInLocaleFiles(unusedKeys, sourceFile.localeFiles, sourceFileKeys, sourceDynamicRegex);
+		for (const key of sourceFileKeys) sourceKeys.add(key);
+		for (const [keyStr, regex] of sourceFileDynamicKeys) if (!sourceDynamicKeys.has(keyStr)) sourceDynamicKeys.set(keyStr, regex);
+	}
+	calcUnusedKeysInLocaleFiles(unusedKeys, localeFiles, sourceKeys, combineRegexes(Array.from(sourceDynamicKeys.values())));
+	return Array.from(unusedKeys.values());
+}
+function combineRegexes(regexes) {
+	if (regexes.length === 0) return null;
+	return new RegExp(regexes.map((r) => `(?:${r.source})`).join("|"));
+}
+function calcUnusedKeysInLocaleFiles(unusedKeys, localeFiles, sourceKeys, sourceDynamicRegex) {
+	for (const localeFile of localeFiles) for (const { key } of localeFile.keys) {
+		const parts = key.split(".");
+		if (!parts.some((_, i) => {
+			const joined = parts.slice(0, i + 1).join(".");
+			return sourceKeys.has(joined) || sourceDynamicRegex?.test(joined);
+		})) mapGetOrInsert(unusedKeys, key, {
+			key,
+			files: []
+		}).files.push({
+			locale: localeFile.locale,
+			file: localeFile.file,
+			scope: localeFile.scope
+		});
+	}
+}
+//#endregion
+//#region src/error.ts
+var ParseError = class extends Error {
+	file;
+	options;
+	constructor(message, file, options) {
+		super(message, { cause: options?.cause });
+		this.file = file;
+		this.options = options;
+		this.name = "ParseError";
+	}
+};
+function formatErrorMessage(e) {
+	if (!(e instanceof Error)) return String(e);
+	if (e instanceof ParseError) {
+		const location = formatFilePath(e.file, e.options?.line, e.options?.column);
+		const detail = e.cause != null ? `: ${formatErrorMessage(e.cause)}` : "";
+		return `${location}: ${e.message}${detail}`;
+	}
+	if (e.cause != null) return `${e.message}: ${formatErrorMessage(e.cause)}`;
+	else return e.message;
+}
+//#endregion
+//#region src/parser/localeParser.ts
+const jiti = createJiti(import.meta.url);
+const supportedJsExtensions = [
+	".js",
+	".mjs",
+	".cjs",
+	".ts",
+	".mts",
+	".cts"
+];
+const fileParsers = {
+	".json": parseJSON,
+	".jsonc": parseJSONC,
+	".json5": parseJSON5,
+	".yaml": parseYAML,
+	".yml": parseYAML
+};
+async function parseLocaleFile(filePath) {
+	if (supportedJsExtensions.includes(extname(filePath))) return await readLocaleScriptFile(filePath);
+	return parseLocale(await readFile(filePath, { encoding: "utf-8" }), filePath);
+}
+async function readLocaleScriptFile(filePath) {
+	let result;
+	try {
+		result = await jiti.import(resolve(filePath), { default: true });
+	} catch (e) {
+		throw new ParseError("Failed to import locale module", filePath, { cause: e });
+	}
+	if (!isPlainObject(result)) throw new ParseError("Locale module default export is not an object", filePath);
+	return result;
+}
+function parseLocale(content, file, options = {}) {
+	const ext = options.ext ?? extname(file);
+	const parse = fileParsers[ext];
+	if (!parse) throw new ParseError(`Unsupported locale type: ${ext}`, file);
+	let result;
+	try {
+		result = parse(content);
+	} catch (e) {
+		throw new ParseError("Failed to parse locale content", file, { cause: e });
+	}
+	if (!isPlainObject(result)) throw new ParseError("Locale content is not an object", file);
+	return result;
+}
+//#endregion
+//#region src/collector/localeExtractor.ts
+function extractLocaleKeys(data, prefix = "") {
+	return Object.entries(data).flatMap(([key, value]) => {
+		if (typeof value === "object") {
+			if (value === null) return {
+				key: `${prefix}${key}`,
+				type: "null"
+			};
+			return extractLocaleKeys(value, `${prefix}${key}.`);
+		}
+		return {
+			key: `${prefix}${key}`,
+			type: typeof value
+		};
+	});
+}
+//#endregion
+//#region src/collector/localeCollector.ts
+async function collectLocaleFile(filePath) {
+	const locale = basename(filePath, extname(filePath));
+	const data = await parseLocaleFile(filePath);
+	return {
+		locale,
+		file: filePath,
+		rawData: data,
+		keys: extractLocaleKeys(data),
+		scope: "global"
+	};
+}
+//#endregion
+//#region src/parser/scriptParser.ts
+function parseScript(file, content, options = {}) {
+	const source = options.wrapInParens ? `(${content})` : content;
+	const parseOptions = {};
+	const lang = asLang(options.lang);
+	if (lang) parseOptions.lang = lang;
+	const { program, errors } = parseSync(file, source, parseOptions);
+	if (errors.length > 0) {
+		const messages = errors.map((e) => `  • ${e.message}`).join("\n");
+		const rawOffset = errors[0].labels?.[0]?.start ?? 0;
+		const { line, column } = offsetToPosition(options.fileSource ?? content, rawOffset + (options.offset ?? 0));
+		throw new ParseError(`Failed to parse script:\n${messages}`, file, {
+			line,
+			column
+		});
+	}
+	return program;
+}
+function asLang(lang) {
+	if (lang === "js" || lang === "jsx" || lang === "ts" || lang === "tsx" || lang === "dts") return lang;
+}
+//#endregion
+//#region src/types.ts
+const DYNAMIC_PART = Symbol("dynamic");
+//#endregion
+//#region src/collector/translationFunctions.ts
+const TRANSLATION_FUNCTIONS = /* @__PURE__ */ new Set([
+	"t",
+	"te",
+	"tm",
+	"tc",
+	"$t",
+	"$te",
+	"$tm",
+	"$tc"
+]);
+const TRANSLATION_CALL_REGEX = /\$?t[emc]?\s*\(/;
+//#endregion
+//#region src/collector/jsCollector.ts
+function collectJsKeys(program, offset = 0) {
+	const result = [];
+	new Visitor({ CallExpression(node) {
+		if (!isTranslationFunction(node)) return;
+		const arg = node.arguments[0];
+		if (!arg) return;
+		const keys = extractKey(arg, offset);
+		result.push(...keys);
+	} }).visit(program);
+	return result;
+}
+function isTranslationFunction(node) {
+	if (node.callee.type === "Identifier") return TRANSLATION_FUNCTIONS.has(node.callee.name);
+	if (node.callee.type === "MemberExpression" && !node.callee.computed && node.callee.property.type === "Identifier") return TRANSLATION_FUNCTIONS.has(node.callee.property.name);
+	return false;
+}
+function extractKey(arg, offset) {
+	if (arg.type === "ConditionalExpression") return [...extractKey(arg.consequent, offset), ...extractKey(arg.alternate, offset)];
+	const normalizedParts = collect(arg).reduce((acc, curr) => {
+		const last = acc[acc.length - 1];
+		if (typeof last === "string" && typeof curr === "string") acc[acc.length - 1] = last + curr;
+		else if (last !== curr) acc.push(curr);
+		return acc;
+	}, []);
+	if (normalizedParts.length === 0) return [];
+	if (normalizedParts.every((p) => typeof p !== "string")) return [];
+	const start = offset + arg.start;
+	const end = offset + arg.end;
+	if (normalizedParts.length === 1 && typeof normalizedParts[0] === "string") {
+		const isQuoted = arg.type === "Literal" && typeof arg.value === "string" || arg.type === "TemplateLiteral";
+		return [{
+			key: normalizedParts[0],
+			start: isQuoted ? start + 1 : start,
+			end: isQuoted ? end - 1 : end
+		}];
+	}
+	return [{
+		key: normalizedParts,
+		start,
+		end
+	}];
+}
+function collect(arg) {
+	if (arg.type === "Literal" && (typeof arg.value === "string" || typeof arg.value === "number" || typeof arg.value === "boolean")) return [String(arg.value)];
+	if (arg.type === "TemplateLiteral") {
+		const parts = [];
+		for (let i = 0; i < arg.quasis.length; i++) {
+			const quasi = arg.quasis[i];
+			const expression = arg.expressions[i];
+			if (!quasi.tail && quasi.value.cooked) parts.push(quasi.value.cooked);
+			if (expression) parts.push(...collect(expression));
+			if (quasi.tail && quasi.value.cooked) parts.push(quasi.value.cooked);
+		}
+		return parts;
+	}
+	if (arg.type === "BinaryExpression" && arg.operator === "+") return [...collect(arg.left), ...collect(arg.right)];
+	return [DYNAMIC_PART];
+}
+//#endregion
+//#region src/collector/vueCollector.ts
+function collectVueKeys(file, templateAst, options) {
+	return templateAst.children.flatMap((c) => walkVueNode(file, c, options));
+}
+function walkVueNode(file, node, options) {
+	switch (node.type) {
+		case NodeTypes.ELEMENT: return [
+			...node.children.flatMap((c) => walkVueNode(file, c, options)),
+			...node.props.flatMap((c) => walkVueNode(file, c, options)),
+			...collectFromElementNode(node)
+		];
+		case NodeTypes.INTERPOLATION: return walkVueNode(file, node.content, options);
+		case NodeTypes.DIRECTIVE:
+			if (node.name === "t") return collectFromDirective(file, node, options);
+			return node.exp ? walkVueNode(file, node.exp, options) : [];
+		case NodeTypes.SIMPLE_EXPRESSION: return node.isStatic ? [] : collectFromExpression(file, node, options);
+		default: return [];
+	}
+}
+function collectFromElementNode(node) {
+	if (node.tag === "i18n-t") {
+		for (const prop of node.props) if (prop.type === NodeTypes.ATTRIBUTE && (prop.name === "keypath" || prop.name === "path") && prop.value?.content) return [{
+			key: prop.value.content,
+			start: prop.value.loc.start.offset + 1,
+			end: prop.value.loc.end.offset - 1
+		}];
+	}
+	return [];
+}
+function collectFromDirective(file, node, options) {
+	if (!node.exp || node.exp.type !== NodeTypes.SIMPLE_EXPRESSION) return [];
+	const content = node.exp.content.trim();
+	if (!content) return [];
+	const bodyPart = parseScript(file, content, {
+		wrapInParens: true,
+		offset: node.exp.loc.start.offset - 1,
+		fileSource: options?.fileSource
+	}).body[0];
+	if (!bodyPart || bodyPart.type !== "ExpressionStatement") return [];
+	return walkDirective(bodyPart.expression, node.exp.loc.start.offset - 1);
+}
+function walkDirective(expression, offset) {
+	if (expression.type === "ParenthesizedExpression") return walkDirective(expression.expression, offset);
+	if (expression.type === "Literal" && typeof expression.value === "string") return [{
+		key: expression.value,
+		start: expression.start + offset + 1,
+		end: expression.end + offset - 1
+	}];
+	if (expression.type === "ObjectExpression") {
+		for (const prop of expression.properties) if (prop.type === "Property" && prop.key.type === "Identifier" && prop.key.name === "path" && prop.value.type === "Literal" && typeof prop.value.value === "string") return [{
+			key: prop.value.value,
+			start: prop.value.start + offset + 1,
+			end: prop.value.end + offset - 1
+		}];
+	}
+	return [];
+}
+function collectFromExpression(file, node, options) {
+	const content = node.content;
+	if (!content.trim()) return [];
+	if (!TRANSLATION_CALL_REGEX.test(content)) return [];
+	return collectJsKeys(parseScript(file, content, {
+		wrapInParens: true,
+		offset: node.loc.start.offset - 1,
+		fileSource: options?.fileSource
+	}), node.loc.start.offset - 1);
+}
+//#endregion
+//#region src/collector/sourceCollector.ts
+async function collectSourceFile(file) {
+	const source = await readFile(file, { encoding: "utf-8" });
+	if (extname(file) === ".vue") return collectFromVue(source, file);
+	return {
+		keys: rawKeysToFileKeys(collectFromScript(source, file), file, source),
+		localeFiles: []
+	};
+}
+function collectFromScript(source, file) {
+	if (!TRANSLATION_CALL_REGEX.test(source)) return [];
+	return collectJsKeys(parseScript(file, source));
+}
+function collectFromVue(source, file) {
+	const { descriptor, errors } = parse(source, {
+		filename: basename(file),
+		templateParseOptions: { prefixIdentifiers: false }
+	});
+	if (errors.length > 0 && !descriptor.template && !descriptor.script && !descriptor.scriptSetup) throw new ParseError(`Failed to parse Vue file:\n${errors.map((e) => `  • ${e.message}`).join("\n")}`, file);
+	const rawKeys = [];
+	const templateAst = descriptor.template?.ast;
+	if (templateAst) rawKeys.push(...collectVueKeys(file, templateAst, { fileSource: source }));
+	for (const script of [descriptor.script, descriptor.scriptSetup]) {
+		if (!script) continue;
+		if (!TRANSLATION_CALL_REGEX.test(script.content)) continue;
+		const program = parseScript(file, script.content, {
+			lang: script.lang,
+			offset: script.loc.start.offset,
+			fileSource: source
+		});
+		rawKeys.push(...collectJsKeys(program, script.loc.start.offset));
+	}
+	return {
+		keys: rawKeysToFileKeys(rawKeys, file, source),
+		localeFiles: collectI18nBlocks(descriptor, file)
+	};
+}
+function collectI18nBlocks(descriptor, file) {
+	const localeFiles = [];
+	for (const block of descriptor.customBlocks) {
+		if (block.type !== "i18n") continue;
+		localeFiles.push(...parseI18nBlock(block, file));
+	}
+	return localeFiles;
+}
+function parseI18nBlock(block, file) {
+	const lang = typeof block.attrs["lang"] === "string" ? block.attrs["lang"] : "json";
+	const data = parseLocale(block.content, file, { ext: `.${lang}` });
+	return Object.entries(data).map(([locale, localeData]) => {
+		if (!isPlainObject(localeData)) return {
+			locale,
+			file,
+			keys: [],
+			rawData: {},
+			scope: "local"
+		};
+		return {
+			locale,
+			file,
+			scope: "local",
+			sourceFile: file,
+			rawData: localeData,
+			keys: extractLocaleKeys(localeData)
+		};
+	});
+}
+function rawKeysToFileKeys(rawKeys, file, source) {
+	return rawKeys.map((k) => ({
+		key: k.key,
+		file,
+		location: {
+			start: offsetToPosition(source, k.start),
+			end: offsetToPosition(source, k.end)
+		}
+	}));
+}
+//#endregion
+//#region src/command/shared.ts
+async function collectFiles(config, process) {
+	const globOptions = {
+		cwd: config.path,
+		ignore: config.ignorePatterns,
+		gitignore: true
+	};
+	const [rawLocalePaths, rawSrcPaths] = await Promise.all([globby(config.localePattern, globOptions), globby(config.srcPattern, globOptions)]);
+	const [localeFiles, sourceFiles] = await Promise.all([Promise.all(rawLocalePaths.map((p) => collectFile(resolve(config.path, p), collectLocaleFile, process))), Promise.all(rawSrcPaths.map((p) => collectFile(resolve(config.path, p), collectSourceFile, process)))]);
+	const validLocaleFiles = localeFiles.filter((f) => f != null);
+	const validSourceFiles = sourceFiles.filter((f) => f != null);
+	return {
+		localeFiles: validLocaleFiles,
+		sourceFiles: validSourceFiles,
+		parseErrors: localeFiles.length - validLocaleFiles.length + (sourceFiles.length - validSourceFiles.length)
+	};
+}
+async function collectFile(file, collect, process) {
+	try {
+		return await collect(file);
+	} catch (e) {
+		writeLine(process.stderr, `Failed to process: ${formatErrorMessage(e)}`);
+		return null;
+	}
+}
+//#endregion
+//#region src/command/lint.ts
+const lintCommand = buildCommand({
+	async func(flags, path) {
+		const startTime = performance.now();
+		const config = await loadVueI18nLintConfig({
+			path,
+			...flags
+		});
+		const { localeFiles, sourceFiles, parseErrors } = await collectFiles(config, this.process);
+		const result = processFiles(localeFiles, sourceFiles, config);
+		const elapsed = Math.round(performance.now() - startTime);
+		const missingSeverity = config.checks.missingKeys.severity;
+		const unusedSeverity = config.checks.unusedKeys.severity;
+		if (config.format === "text") {
+			if (parseErrors > 0) writeLine(this.process.stdout);
+			if (result.typeWarnings.length > 0) outputTypeWarnings(this.process, result.typeWarnings);
+			if (result.missing && result.missing.length > 0) outputMissingKeys(this.process, result.missing);
+			if (result.unused && result.unused.length > 0) outputUnusedKeys(this.process, result.unused);
+			const summaryParts = [];
+			if (result.missing != null) summaryParts.push(`${formatSummaryPart(result.missing.length, config.checks.missingKeys.severity)} missing`);
+			if (result.unused != null) summaryParts.push(`${formatSummaryPart(result.unused.length, config.checks.unusedKeys.severity)} unused`);
+			if (summaryParts.length > 0) writeLine(this.process.stdout, `Found ${summaryParts.join(" and ")} keys.`);
+			const errorSummary = parseErrors > 0 ? ` (${parseErrors} file${parseErrors === 1 ? "" : "s"} skipped due to errors)` : "";
+			writeLine(this.process.stdout, `Processed ${localeFiles.length} locale files and ${sourceFiles.length} source files in ${elapsed}ms${errorSummary}.`);
+		} else {
+			const outputData = {
+				missingKeys: result.missing,
+				unusedKeys: result.unused
+			};
+			if (config.format === "json") outputJson(this.process, outputData);
+			else if (config.format === "toon") outputToon(this.process, outputData);
+		}
+		const missingIsError = missingSeverity === "error" && result.missing && result.missing.length > 0;
+		const unusedIsError = unusedSeverity === "error" && result.unused && result.unused.length > 0;
+		if (missingIsError || unusedIsError || parseErrors > 0) this.process.exitCode = 1;
+	},
+	parameters: {
+		flags: {
+			format: {
+				kind: "enum",
+				values: formatEnum.options,
+				optional: true,
+				brief: "Output format"
+			},
+			localePattern: {
+				kind: "parsed",
+				parse: String,
+				optional: true,
+				brief: "Glob pattern for i18n locale files"
+			},
+			srcPattern: {
+				kind: "parsed",
+				parse: String,
+				optional: true,
+				brief: "Glob pattern for source files"
+			},
+			ignorePatterns: {
+				kind: "parsed",
+				parse: String,
+				optional: true,
+				variadic: ",",
+				brief: "Comma-separated glob patterns to ignore"
+			},
+			ignoreKeys: {
+				kind: "parsed",
+				parse: String,
+				optional: true,
+				variadic: ",",
+				brief: "Comma-separated keys to ignore in both missing and unused checks"
+			},
+			ignoreMissingKeys: {
+				kind: "parsed",
+				parse: String,
+				optional: true,
+				variadic: ",",
+				brief: "Comma-separated keys to ignore in the missing keys check"
+			},
+			ignoreUnusedKeys: {
+				kind: "parsed",
+				parse: String,
+				optional: true,
+				variadic: ",",
+				brief: "Comma-separated keys to ignore in the unused keys check"
+			},
+			missingKeysSeverity: {
+				kind: "enum",
+				values: severityEnum.options,
+				optional: true,
+				brief: "Severity for missing keys"
+			},
+			unusedKeysSeverity: {
+				kind: "enum",
+				values: severityEnum.options,
+				optional: true,
+				brief: "Severity for unused keys"
+			}
+		},
+		positional: {
+			kind: "tuple",
+			parameters: [{
+				brief: "Working directory",
+				parse: String,
+				placeholder: "path",
+				optional: true
+			}]
+		}
+	},
+	docs: { brief: "Lint i18n keys in your project" }
+});
+//#endregion
+//#region src/command/removeUnused.ts
+const removeUnusedCommand = buildCommand({
+	async func(flags, path) {
+		const config = await loadVueI18nLintConfig({
+			path,
+			localePattern: flags.localePattern,
+			srcPattern: flags.srcPattern,
+			ignorePatterns: flags.ignorePatterns,
+			ignoreKeys: flags.ignoreKeys,
+			ignoreUnusedKeys: flags.ignoreUnusedKeys
+		});
+		const { localeFiles, sourceFiles, parseErrors } = await collectFiles(config, this.process);
+		const { unused } = processFiles(localeFiles, sourceFiles, defu({ checks: {
+			missingKeys: { severity: "off" },
+			unusedKeys: { severity: "error" }
+		} }, config));
+		const unusedSet = new Set(unused?.filter((it) => it.files.some((file) => file.scope === "global")).map((it) => it.key) ?? []);
+		if (parseErrors > 0) writeLine(this.process.stdout);
+		if (unusedSet.size === 0) {
+			writeLine(this.process.stdout, "No unused keys found.");
+			return;
+		}
+		if (!flags.dryRun) await Promise.all(localeFiles.map(async (localeFile) => {
+			const stringifier = stringifiers[extname(localeFile.file)];
+			if (!stringifier) return;
+			removeKeysFromData(localeFile.rawData, unusedSet);
+			await writeFile(localeFile.file, stringifier(localeFile.rawData), "utf-8");
+		}));
+		writeLine(this.process.stdout, flags.dryRun ? `Would remove ${unusedSet.size} unused key${unusedSet.size === 1 ? "" : "s"}.` : `Removed ${unusedSet.size} unused key${unusedSet.size === 1 ? "" : "s"}.`);
+	},
+	parameters: {
+		flags: {
+			dryRun: {
+				kind: "boolean",
+				optional: true,
+				brief: "Print count without modifying files"
+			},
+			localePattern: {
+				kind: "parsed",
+				parse: String,
+				optional: true,
+				brief: "Glob pattern for i18n locale files"
+			},
+			srcPattern: {
+				kind: "parsed",
+				parse: String,
+				optional: true,
+				brief: "Glob pattern for source files"
+			},
+			ignorePatterns: {
+				kind: "parsed",
+				parse: String,
+				optional: true,
+				variadic: ",",
+				brief: "Comma-separated glob patterns to ignore"
+			},
+			ignoreKeys: {
+				kind: "parsed",
+				parse: String,
+				optional: true,
+				variadic: ",",
+				brief: "Comma-separated keys to ignore"
+			},
+			ignoreUnusedKeys: {
+				kind: "parsed",
+				parse: String,
+				optional: true,
+				variadic: ",",
+				brief: "Comma-separated keys to ignore in the unused keys check"
+			}
+		},
+		positional: {
+			kind: "tuple",
+			parameters: [{
+				brief: "Working directory",
+				parse: String,
+				placeholder: "path",
+				optional: true
+			}]
+		}
+	},
+	docs: { brief: "Remove unused i18n keys from locale files" }
+});
+const stringifiers = {
+	".json": (data) => stringifyJSON(data, { indent: 2 }),
+	".jsonc": (data) => stringifyJSONC(data, { indent: 2 }),
+	".json5": (data) => stringifyJSON5(data, { indent: 2 }),
+	".yaml": (data) => stringifyYAML(data, { indent: 2 }),
+	".yml": (data) => stringifyYAML(data, { indent: 2 })
+};
+function removeKeysFromData(data, keys, prefix = "") {
+	if (typeof data !== "object" || data == null) return false;
+	if (isPlainObject(data)) {
+		for (const key of Object.keys(data)) {
+			const fullKey = prefix ? `${prefix}.${key}` : key;
+			if (keys.has(fullKey) || removeKeysFromData(data[key], keys, fullKey)) delete data[key];
+		}
+		return Object.keys(data).length === 0;
+	}
+	if (Array.isArray(data)) {
+		for (let i = data.length - 1; i >= 0; i--) {
+			const fullKey = prefix ? `${prefix}.${i}` : String(i);
+			if (keys.has(fullKey) || removeKeysFromData(data[i], keys, fullKey)) data.splice(i, 1);
+		}
+		return data.length === 0;
+	}
+	return false;
+}
+//#endregion
+//#region src/cli.ts
+await run(buildApplication(buildRouteMap({
+	routes: {
+		lint: lintCommand,
+		init: initCommand,
+		removeUnused: removeUnusedCommand
+	},
+	defaultCommand: "lint",
+	docs: { brief: "Fast and accurate linting for Vue i18n." }
+}), {
+	name: "vue-i18n-lint",
+	scanner: { caseStyle: "allow-kebab-for-camel" },
+	documentation: { caseStyle: "convert-camel-to-kebab" },
+	localization: { text: {
+		...text_en,
+		formatException: formatErrorMessage
+	} }
+}), process.argv.slice(2), { process: {
+	stdout: process.stdout,
+	stderr: process.stderr,
+	env: process.env
+} });
+//#endregion
+export {};

package/dist/index.d.mts

@@ -0,0 +1,46 @@
+import { z } from "zod";
+
+//#region src/config/schema.d.ts
+declare const configSchema: z.ZodObject<{
+  path: z.ZodString;
+  format: z.ZodDefault<z.ZodEnum<{
+    json: "json";
+    text: "text";
+    toon: "toon";
+  }>>;
+  localePattern: z.ZodDefault<z.ZodString>;
+  srcPattern: z.ZodDefault<z.ZodString>;
+  ignorePatterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+  ignoreKeys: z.ZodDefault<z.ZodArray<z.ZodString>>;
+  checks: z.ZodDefault<z.ZodObject<{
+    missingKeys: z.ZodDefault<z.ZodUnion<readonly [z.ZodObject<{
+      severity: z.ZodDefault<z.ZodEnum<{
+        error: "error";
+        off: "off";
+        warning: "warning";
+      }>>;
+      ignore: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>, z.ZodPipe<z.ZodLiteral<false>, z.ZodTransform<{
+      severity: "off";
+      ignore: string[];
+    }, false>>]>>;
+    unusedKeys: z.ZodDefault<z.ZodUnion<readonly [z.ZodObject<{
+      severity: z.ZodDefault<z.ZodEnum<{
+        error: "error";
+        off: "off";
+        warning: "warning";
+      }>>;
+      ignore: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>, z.ZodPipe<z.ZodLiteral<false>, z.ZodTransform<{
+      severity: "off";
+      ignore: string[];
+    }, false>>]>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type ConfigInput = z.input<typeof configSchema>;
+//#endregion
+//#region src/index.d.ts
+type VueI18nLintConfig = Omit<ConfigInput, "path">;
+declare const defineConfig: import("c12").DefineConfig<VueI18nLintConfig, import("c12").ConfigLayerMeta>;
+//#endregion
+export { VueI18nLintConfig, defineConfig };

package/dist/index.mjs

@@ -0,0 +1,5 @@
+import { createDefineConfig } from "c12";
+//#region src/index.ts
+const defineConfig = createDefineConfig();
+//#endregion
+export { defineConfig };

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "vue-i18n-lint",
+  "version": "0.0.1",
+  "description": "Fast and accurate linting for Vue i18n.",
+  "keywords": [
+    "i18n",
+    "lint",
+    "vue"
+  ],
+  "license": "MIT",
+  "author": "Ruben Gees",
+  "repository": {
+    "type": "git",
+    "url": "rubengees/vue-i18n-lint"
+  },
+  "bin": {
+    "vue-i18n-lint": "./dist/cli.mjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "dist/index.mjs",
+  "types": "dist/index.d.mts",
+  "exports": {
+    ".": "./dist/index.mjs"
+  },
+  "dependencies": {
+    "@babel/code-frame": "^8.0.0",
+    "@stricli/core": "^1.2.8",
+    "@toon-format/toon": "^2.3.0",
+    "@vue/compiler-core": "^3.5.39",
+    "@vue/compiler-sfc": "^3.5.39",
+    "c12": "4.0.0-beta.5",
+    "confbox": "^0.2.4",
+    "defu": "^6.1.7",
+    "globby": "^16.2.0",
+    "jiti": "^2.7.0",
+    "oxc-parser": "^0.137.0",
+    "regexp.escape": "^2.0.1",
+    "table": "^6.9.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@tsconfig/node22": "22.0.5",
+    "@types/babel__code-frame": "7.27.0",
+    "@types/node": "22.19.21",
+    "@types/regexp.escape": "2.0.0",
+    "@vitest/coverage-v8": "4.1.9",
+    "husky": "9.1.7",
+    "lint-staged": "17.0.8",
+    "oxfmt": "0.56.0",
+    "oxlint": "1.71.0",
+    "oxlint-tsgolint": "0.23.0",
+    "tsdown": "0.22.3",
+    "typescript": "7.0.1-rc",
+    "vitest": "4.1.9"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "dev": "vitest",
+    "start": "jiti src/cli.ts",
+    "build": "tsdown",
+    "lint": "oxlint",
+    "format": "oxfmt",
+    "format:check": "oxfmt --check",
+    "check": "tsc --noEmit",
+    "test": "vitest run",
+    "bench": "vitest --run bench",
+    "verify": "pnpm format:check && pnpm lint && pnpm check && pnpm test"
+  }
+}