@i18n-micro/cli 0.0.0-stage → 2.0.0

package/dist/chunks/lint-BaEIQGMl.mjs

@@ -0,0 +1,125 @@
+import { A as log, M as plural, _ as findingsError, a as flattenStrings, x as usageError } from "./json-BV_apCMu.mjs";
+import { a as readJsonIfExists, d as splitList } from "./nuxt-dKxG087V.mjs";
+import { n as relativeFile, t as Project } from "./project-DgWgr7pF.mjs";
+import { r as LINT_RULES } from "./spec-BwZlT28L.mjs";
+import { join } from "node:path";
+// src/lint-rules.ts
+/** Rules for what is wrong in any language. Whether a text ends in a period is not one of them. */
+var lintRules = {
+	"no-trailing-spaces": {
+		isValid: (value) => !/[ \t]$/m.test(value),
+		fix: (value) => value.replace(/[ \t]+$/gm, "")
+	},
+	"no-multiple-spaces": {
+		isValid: (value) => !value.includes("  "),
+		fix: (value) => value.replace(/ {2,}/g, " ")
+	},
+	"no-empty-translation": { isValid: (value) => value.trim().length > 0 }
+};
+// src/commands/lint.ts
+var stringList = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+function customRule(item) {
+	const { name, pattern, flags, description, replacement } = item;
+	if (typeof name !== "string" || typeof pattern !== "string") return [];
+	let matcher;
+	try {
+		matcher = new RegExp(pattern, typeof flags === "string" ? flags : void 0);
+	} catch {
+		log.warn(`Skipping lint rule "${name}": invalid pattern ${pattern}`);
+		return [];
+	}
+	const everywhere = new RegExp(matcher, matcher.global ? matcher.flags : `${matcher.flags}g`);
+	return [{
+		name,
+		description: typeof description === "string" ? description : `Regex rule: ${pattern}`,
+		isValid: (value) => {
+			matcher.lastIndex = 0;
+			return !matcher.test(value);
+		},
+		fix: typeof replacement === "string" ? (value) => value.replace(everywhere, replacement) : void 0
+	}];
+}
+function loadConfig(rootDir) {
+	const raw = readJsonIfExists(join(rootDir, ".i18n-lintrc.json"));
+	const custom = Array.isArray(raw.customRegexRules) ? raw.customRegexRules : [];
+	return {
+		enabledRules: stringList(raw.enabledRules),
+		disabledRules: stringList(raw.disabledRules),
+		customRules: custom.filter((item) => item !== null && typeof item === "object").flatMap((item) => customRule(item))
+	};
+}
+function selectRules(args, config) {
+	const available = [...LINT_RULES.map(({ name, description }) => ({
+		name,
+		description,
+		isValid: lintRules[name].isValid,
+		fix: lintRules[name].fix
+	})), ...config.customRules];
+	const requested = splitList(args.rules);
+	const selected = requested.length > 0 ? requested : config.enabledRules.length > 0 ? config.enabledRules : available.map((rule) => rule.name);
+	const unknown = selected.filter((name) => !available.some((rule) => rule.name === name));
+	if (unknown.length > 0) throw usageError(`Unknown lint rules: ${unknown.join(", ")}`, [`Available: ${available.map((rule) => rule.name).join(", ")}`]);
+	return available.filter((rule) => selected.includes(rule.name) && !config.disabledRules.includes(rule.name));
+}
+/** Own files only: a layer's text is the layer's to fix. */
+function lintProject(project, rules) {
+	return project.codes.flatMap((code) => {
+		const locale = project.locale(code);
+		return locale.scopes.flatMap((scope) => Object.entries(flattenStrings(locale.fileTree(scope))).flatMap(([key, value]) => rules.filter((rule) => !rule.isValid(value)).map((rule) => ({
+			file: relativeFile(code, scope),
+			locale: code,
+			scope,
+			key,
+			value,
+			rule: rule.name
+		}))));
+	});
+}
+/** Fixes stack: two rules on one value both apply, in rule order. */
+function applyFixes(project, results, rules) {
+	const fixers = new Map(rules.map((rule) => [rule.name, rule.fix]));
+	let fixed = 0;
+	for (const { locale, scope, key, rule } of results) {
+		const set = project.locale(locale);
+		const before = set.get(key, scope);
+		const after = fixers.get(rule)?.(before) ?? before;
+		if (after === before) continue;
+		set.set(key, after, scope);
+		fixed += 1;
+	}
+	project.save();
+	return fixed;
+}
+async function run(args) {
+	const project = await Project.load(args);
+	const rules = selectRules(args, loadConfig(project.config.rootDir));
+	if (rules.length === 0) {
+		log.warn("No rules to check");
+		if (args.json) log.json({
+			rulesChecked: [],
+			issueCount: 0,
+			fixedCount: 0,
+			fixApplied: false,
+			issues: []
+		});
+		return;
+	}
+	const results = lintProject(project, rules);
+	const fixedCount = args.fix ? applyFixes(project, results, rules) : 0;
+	const remaining = args.fix ? lintProject(project, rules).length : results.length;
+	if (args.json) log.json({
+		rulesChecked: rules.map((rule) => rule.name),
+		issueCount: results.length,
+		fixedCount,
+		fixApplied: Boolean(args.fix),
+		issues: results
+	});
+	else {
+		log.note(`Active rules: ${rules.map((rule) => rule.name).join(", ")}`);
+		for (const { rule, file, key, locale } of results) log.warn(`[${rule}] ${key} (${locale}) in ${file}`);
+		if (fixedCount > 0) log.success(`Fixed ${plural(fixedCount, "issue")}.`);
+		if (remaining === 0) log.success("Check completed. No issues remain.");
+	}
+	if (remaining > 0) throw findingsError(`Found ${plural(remaining, "issue")} that need${remaining === 1 ? "s" : ""} to be fixed`, ["Review the issues above, or run with --json for machine-readable output.", "Apply automatic fixes where available: i18n-micro lint --fix"]);
+}
+export { run as default };

package/dist/chunks/nuxt-dKxG087V.mjs

@@ -0,0 +1,366 @@
+import { c as hasProtoKey, h as CliError, n as findDuplicateKey, r as findUnsafeInteger } from "./json-BV_apCMu.mjs";
+import { forwardSlashes } from "@i18n-micro/utils/app-path";
+import { randomBytes } from "node:crypto";
+import { accessSync, chmodSync, constants, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, readlinkSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+// src/fs.ts
+var SKIPPED_DIRS = /* @__PURE__ */ new Set([
+	"node_modules",
+	".git",
+	".nuxt",
+	".output"
+]);
+var statOf = (path) => {
+	try {
+		return statSync(path, { throwIfNoEntry: false });
+	} catch {
+		return;
+	}
+};
+function visit(dir, accept, skipDir, seen, out) {
+	const real = realpathSync(dir);
+	if (seen.has(real)) return;
+	seen.add(real);
+	for (const entry of readdirSync(dir, { withFileTypes: true })) {
+		const full = join(dir, entry.name);
+		const stat = entry.isSymbolicLink() ? statOf(full) : entry;
+		if (stat?.isDirectory() && !skipDir(full)) visit(full, accept, skipDir, seen, out);
+		else if (stat?.isFile() && accept(full)) out.push(full);
+	}
+}
+/** `path` from `from`, as a report, a key or a glob reads it: `/` on every platform. */
+var relativePath = (from, path) => forwardSlashes(relative(from, path));
+/** Whether `path` is `dir` or below it. `relative` gives an absolute path across Windows drives. */
+function isUnder(dir, path) {
+	const rel = relative(dir, path);
+	return !rel.startsWith("..") && !isAbsolute(rel);
+}
+/** Every file under `dir` that `accept` wants, sorted, symlinks followed. A missing directory is an empty result. */
+function walkFiles(dir, accept = () => true, skipDir = (path) => SKIPPED_DIRS.has(basename(path))) {
+	const out = [];
+	if (statOf(dir)?.isDirectory()) visit(dir, accept, skipDir, /* @__PURE__ */ new Set(), out);
+	return out.sort();
+}
+/** Where a write has to land: replacing a symlink with a file would silently unshare it. */
+function realTarget(path) {
+	if (existsSync(path)) return realpathSync(path);
+	return lstatSync(path, { throwIfNoEntry: false })?.isSymbolicLink() ? resolve(dirname(path), readlinkSync(path)) : path;
+}
+var tempName = (path) => join(dirname(path), `.${basename(path)}.${randomBytes(4).toString("hex")}.tmp`);
+/** A rename needs only the directory, so it would replace a file somebody made read-only. */
+function assertWritable(target) {
+	try {
+		if (existsSync(target)) accessSync(target, constants.W_OK);
+	} catch (error) {
+		throw new CliError(`Permission denied: ${target}`, {
+			code: "PERMISSION_DENIED",
+			cause: error
+		});
+	}
+}
+/** The tail of `tempName`. Anything else with a similar name is somebody else's. */
+var TEMP_SUFFIX = /^[0-9a-f]{8}\.tmp$/;
+/** What a killed run left next to `target`. */
+function clearStaleTemps(target) {
+	const prefix = `.${basename(target)}.`;
+	for (const name of readdirSync(dirname(target))) if (name.startsWith(prefix) && TEMP_SUFFIX.test(name.slice(prefix.length))) rmSync(join(dirname(target), name), { force: true });
+}
+function writeTemps(files, options) {
+	const pending = [];
+	for (const [path] of files) {
+		const target = realTarget(path);
+		assertWritable(target);
+		if (!options.overwrite && statOf(target)?.isFile()) readUtf8(target);
+	}
+	try {
+		for (const [path, content] of files) {
+			const target = realTarget(path);
+			mkdirSync(dirname(target), { recursive: true });
+			clearStaleTemps(target);
+			const temp = tempName(target);
+			pending.push([temp, target]);
+			writeFileSync(temp, content);
+			if (existsSync(target)) chmodSync(temp, statSync(target).mode);
+		}
+	} catch (error) {
+		for (const [temp] of pending) rmSync(temp, { force: true });
+		throw error;
+	}
+	return pending;
+}
+/**
+* Hard links share an inode: a rename would leave the other name behind with the old text.
+* So a hard-linked file is written in place, and a process killed during that write can leave
+* it cut short. Every other target is replaced whole.
+*/
+function commit(temp, target) {
+	if ((statOf(target)?.nlink ?? 1) > 1) {
+		writeFileSync(target, readFileSync(temp));
+		rmSync(temp, { force: true });
+	} else renameSync(temp, target);
+}
+/** Through a temp file too: a target that turned read-only must not stop the rollback. */
+function restore(target, original) {
+	if (!original) {
+		rmSync(target, { force: true });
+		return;
+	}
+	const temp = tempName(target);
+	writeFileSync(temp, original);
+	chmodSync(temp, statSync(target).mode);
+	commit(temp, target);
+}
+/**
+* Write a set of files all-or-nothing.
+*
+* Everything lands in temp files first, so a full disk, a bad path or a read-only file fails
+* before the first real file changes. A rename that fails later puts back what the earlier ones
+* replaced. Only killing the process can leave a mix: of whole files between two renames, and
+* a cut one in a hard-linked target, see `commit`. The next save clears its temp files.
+*/
+function writeFilesAtomic(files, options = {}) {
+	const pending = writeTemps(files, options);
+	const originals = [];
+	let done = 0;
+	try {
+		for (const [, target] of pending) originals.push(statOf(target)?.isFile() ? readFileSync(target) : null);
+		for (; done < pending.length; done += 1) commit(pending[done][0], pending[done][1]);
+	} catch (error) {
+		for (const [temp] of pending) rmSync(temp, { force: true });
+		for (let index = 0; index < done; index += 1) restore(pending[index][1], originals[index]);
+		throw error;
+	}
+}
+var writeFileAtomic = (path, content) => writeFilesAtomic([[path, content]]);
+var stringifyJson = (value, indent = 2) => `${JSON.stringify(value, null, indent)}\n`;
+/** JSON text has no raw newline in a string, so every one of them is a line ending. */
+var matchLineEnding = (previous, text) => previous?.includes("\r\n") ? text.split("\n").join("\r\n") : text;
+/** Saved the way the file was written, so an edit shows up as an edit and not as a whole-file diff. */
+function stringifyLike(previous, value) {
+	const text = stringifyJson(value, /^([ \t]+)"/m.exec(previous ?? "")?.[1] ?? 2);
+	return matchLineEnding(previous, previous && !previous.endsWith("\n") ? text.trimEnd() : text);
+}
+/** Text that survives a save. Bytes that are not UTF-8 would come back as replacement characters. */
+function readUtf8(path) {
+	const raw = readFileSync(path);
+	const text = raw.toString("utf8");
+	if (!Buffer.from(text).equals(raw)) throw new CliError(`${path} is not valid UTF-8: a save would corrupt it.`, { code: "INVALID_ENCODING" });
+	return text;
+}
+var withoutBom = (text) => text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+/** For what is only read: a stray byte in a data file or a locale file costs nothing until a save. */
+var readLoose = (path) => withoutBom(readFileSync(path, "utf8"));
+/** A BOM comes from Windows editors and Excel; `JSON.parse` stops at it. */
+var readText = (path) => withoutBom(readUtf8(path));
+/**
+* Read a JSON object strictly.
+*
+* A broken file must stop the command: treating it as empty is how the next save would
+* replace somebody's translations with `{}`.
+*/
+function readJsonObject(path, options = {}) {
+	const content = readLoose(path);
+	if (content.trim() === "") return {};
+	let parsed;
+	try {
+		parsed = JSON.parse(content);
+	} catch (error) {
+		const details = options.private ? {} : { Reason: String(error.message) };
+		throw new CliError(`Invalid JSON in ${path}`, {
+			code: "INVALID_JSON",
+			details,
+			cause: options.private ? void 0 : error
+		});
+	}
+	if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) throw new CliError(`Expected a JSON object in ${path}`, { code: "INVALID_JSON" });
+	const duplicate = findDuplicateKey(content);
+	if (duplicate !== null) throw new CliError(`Duplicate key in ${path}: ${duplicate}`, { code: "INVALID_JSON" });
+	if (hasProtoKey(parsed)) throw new CliError(`A key called __proto__ in ${path} would be lost on a save.`, { code: "INVALID_JSON" });
+	const unsafe = findUnsafeInteger(parsed);
+	if (unsafe !== null) throw new CliError(`Integer too large in ${path}: ${unsafe}. A save would change it; store it as a string.`, { code: "INVALID_JSON" });
+	return parsed;
+}
+var readJsonIfExists = (path) => existsSync(path) ? readJsonObject(path) : {};
+/** `tests/**`, `*.spec.ts`. A glob without a slash matches at any depth. */
+function globToRegExp(glob) {
+	const source = (glob.includes("/") ? glob : `**/${glob}`).replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*\//g, "\0").replace(/\*\*/g, "
").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replaceAll("\0", "(?:.*/)?").replaceAll("
", ".*");
+	return new RegExp(`^${source}(?:/.*)?$`);
+}
+var splitList = (value) => (value ?? "").split(",").map((part) => part.trim()).filter(Boolean);
+// src/nuxt.ts
+var NUXT_CONFIG_FILES = [
+	"ts",
+	"js",
+	"mjs",
+	"cjs",
+	"mts",
+	"cts"
+].map((extension) => `nuxt.config.${extension}`);
+function findNuxtRoot(startDir) {
+	const start = resolve(startDir);
+	if (NUXT_CONFIG_FILES.some((file) => existsSync(join(start, file)))) return start;
+	const parent = dirname(start);
+	return parent === start ? null : findNuxtRoot(parent);
+}
+function findPackageDir(name, fromDir) {
+	const candidate = join(fromDir, "node_modules", name);
+	if (existsSync(join(candidate, "package.json"))) return realpathSync(candidate);
+	const parent = dirname(fromDir);
+	return parent === fromDir ? null : findPackageDir(name, parent);
+}
+function exportEntry(target) {
+	if (typeof target === "string") return target;
+	if (typeof target !== "object" || target === null) return null;
+	const conditions = target;
+	return exportEntry(conditions["."]) ?? exportEntry(conditions.import) ?? exportEntry(conditions.default);
+}
+/**
+* The Nuxt Kit of the project, never one of our own.
+*
+* The config has to be read by the Nuxt version that will run it. pnpm does not hoist `@nuxt/kit`
+* to the app, so when it is not next to the project it is taken from next to `nuxt`.
+*/
+async function importProjectKit(rootDir) {
+	const nuxtDir = findPackageDir("nuxt", rootDir);
+	const kitDir = findPackageDir("@nuxt/kit", rootDir) ?? (nuxtDir && findPackageDir("@nuxt/kit", nuxtDir));
+	if (!kitDir) throw new CliError("Cannot find Nuxt in this project.", {
+		code: "NUXT_LOAD_FAILED",
+		hints: ["Install the project dependencies first (npm install, pnpm install).", "Run from the app root, or pass --cwd."],
+		details: { "Project root": rootDir }
+	});
+	const manifest = JSON.parse(readFileSync(join(kitDir, "package.json"), "utf8"));
+	const entry = exportEntry(manifest.exports) ?? manifest.module ?? manifest.main ?? "index.js";
+	return await import(pathToFileURL(join(kitDir, entry)).href);
+}
+function moduleEnabled(modules = []) {
+	return modules.some((entry) => String(Array.isArray(entry) ? entry[0] : entry).includes("nuxt-i18n-micro"));
+}
+/** `modules: [['nuxt-i18n-micro', { ... }]]`. */
+function inlineOptions(modules = []) {
+	return modules.find((item) => Array.isArray(item) && String(item[0]).includes("nuxt-i18n-micro"))?.[1];
+}
+/** Layers concatenate `locales`, project first, so the first entry of a code wins, as in the module. */
+function normalizeLocales(locales = []) {
+	const byCode = /* @__PURE__ */ new Map();
+	for (const locale of locales) {
+		const entry = typeof locale === "string" ? { code: locale } : locale;
+		if (!byCode.has(entry.code)) byCode.set(entry.code, entry);
+	}
+	return [...byCode.values()].filter((entry) => !entry.disabled).map(({ code }) => ({ code }));
+}
+var layersOf = (config, rootDir) => {
+	const layers = (config._layers ?? []).flatMap((layer) => layer.config?.rootDir ? [layer.config] : []);
+	return layers.some((layer) => layer.rootDir === rootDir) ? layers : [{
+		rootDir,
+		srcDir: config.srcDir,
+		dir: config.dir
+	}, ...layers];
+};
+/** Like the module: each additional directory is relative to every layer, and sits under the layers' own files. */
+function additionalDirsOf(roots, i18n) {
+	const names = (i18n.additionalTranslationDirs ?? []).map((entry) => typeof entry === "string" ? entry : entry.path).filter(Boolean);
+	return [...new Set(names.flatMap((name) => roots.map((root) => resolve(root, name))))];
+}
+var ALIAS_PREFIX = /^(~~|@@|~|@)(?=\/)/;
+/** `../shared/*`: the folder a glob starts from. Reading all of it only finds more evidence. */
+var globBase = (path) => path.replace(/[/\\][^/\\]*[*?[{(!].*$/, "");
+/** Strings out of `components` and `imports.dirs`, in every shape Nuxt accepts them. */
+function dirNames(value) {
+	if (typeof value === "string") return [value];
+	if (Array.isArray(value)) return value.flatMap(dirNames);
+	if (typeof value !== "object" || value === null) return [];
+	const { path, dirs } = value;
+	return [...dirNames(path), ...dirNames(dirs)];
+}
+/** A folder outside the root is still this app's code when an alias or auto-import points at it. */
+function extraSourceDirsOf(config, rootDir) {
+	const srcDir = config.srcDir ?? rootDir;
+	const expand = (dir) => resolve(rootDir, dir.replace(ALIAS_PREFIX, (prefix) => prefix.length === 2 ? rootDir : srcDir));
+	const outside = [...Object.values(config.alias ?? {}).filter((name) => typeof name === "string"), ...[...dirNames(config.components), ...dirNames(config.imports?.dirs)].map(globBase)].map(expand).filter((dir) => !isUnder(rootDir, dir) && !forwardSlashes(dir).includes("/node_modules/") && existsSync(dir));
+	return [...new Set(outside.filter((dir) => statSync(dir).isDirectory()))];
+}
+async function readNuxtConfig(rootDir) {
+	const kit = await importProjectKit(rootDir);
+	try {
+		return await kit.loadNuxtConfig({
+			cwd: rootDir,
+			dotenv: { cwd: rootDir }
+		});
+	} catch (error) {
+		throw new CliError("Failed to load Nuxt configuration.", {
+			code: "NUXT_LOAD_FAILED",
+			hints: ["Verify that nuxt.config.* is valid and dependencies are installed.", "Run with --debug to see the full stack trace."],
+			details: {
+				"Project root": rootDir,
+				Reason: String(error.message)
+			},
+			cause: error
+		});
+	}
+}
+/**
+* Resolved i18n configuration of the project at or above `cwd`.
+*
+* `loadNuxtConfig`, not `loadNuxt`: the CLI needs options and layers, and booting Nuxt runs
+* every module of the app just to read them.
+*/
+async function loadProjectConfig(cwd) {
+	const requested = resolve(cwd);
+	const rootDir = findNuxtRoot(requested);
+	if (!rootDir) throw new CliError("No Nuxt project found.", {
+		code: "NOT_NUXT_PROJECT",
+		hints: ["Run inside a Nuxt app (where nuxt.config.ts exists), or pass --cwd /path/to/app."],
+		details: { "Working directory": requested }
+	});
+	const config = await readNuxtConfig(rootDir);
+	const inline = inlineOptions(config.modules);
+	const i18n = config.i18n || inline ? {
+		...config.i18n,
+		...inline
+	} : void 0;
+	if (!i18n) {
+		const enabled = moduleEnabled(config.modules);
+		throw new CliError(enabled ? "nuxt-i18n-micro is enabled, but has no i18n options." : "nuxt-i18n-micro is not enabled in this project.", {
+			code: enabled ? "I18N_NOT_CONFIGURED" : "I18N_MODULE_MISSING",
+			hints: [`Example: modules: ['nuxt-i18n-micro'], i18n: { locales: [{ code: 'en' }], defaultLocale: 'en' }`],
+			details: { "Project root": rootDir }
+		});
+	}
+	const locales = normalizeLocales(i18n.locales);
+	if (locales.length === 0) throw new CliError("i18n configuration has no locales.", {
+		code: "NO_LOCALES",
+		hints: [`Add at least one locale, e.g. i18n: { locales: [{ code: 'en' }], defaultLocale: 'en' }`],
+		details: { "Project root": rootDir }
+	});
+	const defaultLocale = process.env.DEFAULT_LOCALE ?? i18n.defaultLocale ?? "en";
+	if (!locales.some((locale) => locale.code === defaultLocale)) throw new CliError(`The default locale "${defaultLocale}" is not among the enabled locales.`, {
+		code: "NO_LOCALES",
+		hints: ["Set i18n.defaultLocale in nuxt.config."],
+		details: {
+			"Project root": rootDir,
+			Locales: locales.map((locale) => locale.code).join(", ")
+		}
+	});
+	const dirName = i18n.translationDir || "locales";
+	const layers = layersOf(config, rootDir);
+	const roots = layers.map((layer) => layer.rootDir).reverse();
+	const translationDir = resolve(rootDir, dirName);
+	const primaryDirs = [...roots.map((root) => resolve(root, dirName)), translationDir];
+	const additionalDirs = additionalDirsOf(roots, i18n).filter((dir) => !primaryDirs.includes(dir));
+	return {
+		rootDir,
+		srcDir: config.srcDir ?? rootDir,
+		translationDir,
+		translationDirs: [.../* @__PURE__ */ new Set([...additionalDirs, ...primaryDirs])].sort((a, b) => Number(a === translationDir) - Number(b === translationDir)),
+		additionalDirs,
+		layerRoots: roots,
+		pagesDirs: [...new Set(layers.map((layer) => resolve(layer.srcDir ?? layer.rootDir, layer.dir?.pages ?? "pages")))],
+		extraSourceDirs: extraSourceDirsOf(config, rootDir),
+		defaultLocale,
+		defaultLocaleOverridden: defaultLocale !== (i18n.defaultLocale ?? "en"),
+		locales,
+		disablePageLocales: Boolean(i18n.disablePageLocales)
+	};
+}
+export { readJsonIfExists as a, readText as c, splitList as d, stringifyJson as f, writeFilesAtomic as g, writeFileAtomic as h, matchLineEnding as i, readUtf8 as l, walkFiles as m, globToRegExp as n, readJsonObject as o, stringifyLike as p, isUnder as r, readLoose as s, loadProjectConfig as t, relativePath as u };

package/dist/chunks/package-f9OTcDxl.mjs

@@ -0,0 +1,3 @@
+// package.json
+var version = "2.0.0";
+export { version as t };