@menapo/vi18n 0.0.0-stage → 0.1.0

package/dist/project-pXipT8iG.js

@@ -0,0 +1,1046 @@
+import { D as dependencyRef, E as dependencyOf, O as listDependencyFiles, r as libraryIds } from "./library-D5CWvTQs.js";
+import { n as cacheVersion } from "./version-BlyLGlOa.js";
+import { i as scanSource, n as WORKER_MARKER, r as scanConfig, t as ABORT_CODES } from "./worker-84U6uYB3.js";
+import { dirname, join, relative, resolve, sep } from "node:path";
+import { hash, randomBytes } from "node:crypto";
+import { existsSync, readFileSync, readdirSync, realpathSync, statSync } from "node:fs";
+import { mkdir, open, readFile, readdir, realpath, rename, stat, unlink, writeFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { availableParallelism } from "node:os";
+import { Worker } from "node:worker_threads";
+//#region src/core/config/hash.ts
+/**
+* `configHash` (INTERNALS §2.7.1): the key every cache derived from a config
+* carries (scan cache, transform cache), so any config or version change
+* invalidates them and nothing else does.
+*/
+function configHash(config, version) {
+	const { provider } = config.ai;
+	const hashed = {
+		...config,
+		routing: {
+			...config.routing,
+			routeStrategies: Object.entries(config.routing.routeStrategies)
+		},
+		ssr: {
+			...config.ssr,
+			timeZoneFrom: Object.entries(config.ssr.timeZoneFrom)
+		},
+		ai: typeof provider === "string" ? config.ai : {
+			...config.ai,
+			provider: {
+				name: provider.name,
+				model: provider.model
+			}
+		},
+		...config.extraction.dependencies.length === 0 ? {} : { libraryIds: libraryIdList(config) }
+	};
+	return hash("sha256", stableJson(hashed) + "\0" + version, "hex");
+}
+/**
+* JSON with object keys sorted at every depth, so the hash does not depend
+* on the order in which a config was written or resolved. Array order is
+* kept: strategy chains and fallbacks are ordered.
+*/
+function stableJson(value) {
+	if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
+	if (Array.isArray(value)) {
+		let out = "[";
+		for (let i = 0; i < value.length; i++) out += (i === 0 ? "" : ",") + stableJson(value[i]);
+		return out + "]";
+	}
+	const record = value;
+	let out = "{";
+	let first = true;
+	for (const key of Object.keys(record).sort()) {
+		const item = record[key];
+		if (item === void 0 || typeof item === "function" || typeof item === "symbol") continue;
+		out += (first ? "" : ",") + JSON.stringify(key) + ":" + stableJson(item);
+		first = false;
+	}
+	return out + "}";
+}
+/**
+* The opted-in packages' manual ids, or none while one is not installed:
+* hashing never fails, loading the config does (§2.5.7).
+*/
+function libraryIdList(config) {
+	try {
+		return [...libraryIds(config)];
+	} catch {
+		return [];
+	}
+}
+//#endregion
+//#region src/core/extract/aggregate.ts
+/**
+* Groups occurrences by id. Contexts are split into single-line notes
+* (trimmed, empty ones dropped, deduplicated, sorted by code unit); `maxLength`
+* is the smallest given (§6 D15: the strictest limit is the safe one); `refs`
+* and `sources` are sorted and unique; `locations` keep scan order. When
+* occurrences share an id but not a canonical text — a collision callers
+* report through `findCollisions` — the first one wins and the others are
+* left out entirely.
+*/
+function aggregateOccurrences(occurrences) {
+	const pending = /* @__PURE__ */ new Map();
+	for (const occurrence of occurrences) {
+		let entry = pending.get(occurrence.id);
+		if (entry === void 0) {
+			entry = {
+				message: {
+					id: occurrence.id,
+					manual: occurrence.manual,
+					canonical: occurrence.canonical,
+					sourceHash: occurrence.sourceHash,
+					label: occurrence.label,
+					contexts: [],
+					refs: [],
+					sources: [],
+					locations: []
+				},
+				contexts: /* @__PURE__ */ new Set(),
+				refs: /* @__PURE__ */ new Set(),
+				sources: /* @__PURE__ */ new Set()
+			};
+			pending.set(occurrence.id, entry);
+		} else if (entry.message.canonical !== occurrence.canonical) continue;
+		const { message } = entry;
+		if (occurrence.context !== void 0) for (const line of occurrence.context.split("\n")) {
+			const note = line.trim();
+			if (note !== "") entry.contexts.add(note);
+		}
+		if (occurrence.maxLength !== void 0 && (message.maxLength === void 0 || occurrence.maxLength < message.maxLength)) message.maxLength = occurrence.maxLength;
+		entry.refs.add(occurrence.file);
+		entry.sources.add(occurrence.source);
+		message.locations.push({
+			file: occurrence.file,
+			line: occurrence.line,
+			column: occurrence.column
+		});
+	}
+	const messages = /* @__PURE__ */ new Map();
+	for (const [id, { message, contexts, refs, sources }] of pending) {
+		message.contexts = [...contexts].sort();
+		message.refs = [...refs].sort();
+		message.sources = [...sources].sort();
+		messages.set(id, message);
+	}
+	return messages;
+}
+//#endregion
+//#region src/core/extract/cache.ts
+/**
+* The CLI scan cache (INTERNALS §2.5.6): per absolute file, what the last
+* scan found, keyed by mtime + size or else content hash, and invalidated by
+* any config change and any change of vi18n's code (`configHash` over
+* `cacheVersion()`, the version and a fingerprint of the code: the version
+* alone stays `0.0.0` in the workspace and in vendored tarballs). It lives
+* in `node_modules/.cache/vi18n/scan-v1.json` under the config root's
+* nearest `node_modules`, so a clean install drops it.
+*/
+const SCAN_CACHE_FILE = "scan-v1.json";
+/** sha256 of the file text, the fallback key when mtime or size moved (checkouts, `touch`). */
+function contentHash(text) {
+	return hash("sha256", text, "base64url");
+}
+/** `node_modules/.cache/vi18n/scan-v1.json` under the nearest `node_modules` at or above `root`. */
+function scanCachePath(root) {
+	for (let dir = root;; dir = dirname(dir)) {
+		const modules = join(dir, "node_modules");
+		if (existsSync(modules)) return join(modules, ".cache", "vi18n", SCAN_CACHE_FILE);
+		if (dirname(dir) === dir) break;
+	}
+	return join(root, "node_modules", ".cache", "vi18n", SCAN_CACHE_FILE);
+}
+/** How long a save waits for another writer's lock, and when a lock counts as abandoned. */
+const LOCK_WAIT_MS = 5e3;
+const LOCK_STALE_MS = 3e4;
+/** Saves of one cache file in this process, chained so each re-reads what the last wrote. */
+const saving = /* @__PURE__ */ new Map();
+let temps = 0;
+const pause = (ms) => new Promise((done) => setTimeout(done, ms));
+/**
+* Takes `<cache>.lock` for a read-merge-write against other processes (a
+* workspace's packages scanned in parallel share one cache file). Resolves
+* to the release function, or null when the lock stayed taken: the caller
+* skips the write rather than drop another writer's section.
+*/
+async function lock(path) {
+	const file = path + ".lock";
+	const deadline = Date.now() + LOCK_WAIT_MS;
+	for (;;) {
+		try {
+			await (await open(file, "wx")).close();
+			return () => unlink(file).catch(() => {});
+		} catch (error) {
+			if (error.code !== "EEXIST") throw error;
+		}
+		const info = await stat(file).catch(() => null);
+		if (info !== null && Date.now() - info.mtimeMs > LOCK_STALE_MS) {
+			await unlink(file).catch(() => {});
+			continue;
+		}
+		if (Date.now() > deadline) return null;
+		await pause(10 + Math.random() * 40);
+	}
+}
+function isEntry(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const e = value;
+	return typeof e.mtimeMs === "number" && typeof e.size === "number" && typeof e.contentHash === "string" && typeof e.configHash === "string" && typeof e.version === "string" && Array.isArray(e.occurrences) && Array.isArray(e.diagnostics);
+}
+async function readCacheFile(path) {
+	try {
+		const parsed = JSON.parse(await readFile(path, "utf8"));
+		if (parsed.format === 1 && typeof parsed.roots === "object" && parsed.roots !== null) return parsed;
+	} catch {}
+	return {
+		format: 1,
+		roots: {}
+	};
+}
+var ScanCache = class ScanCache {
+	path;
+	/** `configHash(config, version)`: entries with another key are misses. */
+	key;
+	/** `cacheVersion()` unless a caller names another: entries of other code are misses. */
+	version;
+	#root;
+	#entries;
+	#dirty = false;
+	constructor(path, root, key, version, entries) {
+		this.path = path;
+		this.#root = root;
+		this.key = key;
+		this.version = version;
+		this.#entries = entries;
+	}
+	/**
+	* Reads the cache for `config` (empty when there is none or it is
+	* corrupt). `version` defaults to the running code's `cacheVersion()`.
+	*/
+	static async open(config, path = scanCachePath(config.root), version = cacheVersion()) {
+		const file = await readCacheFile(path);
+		const entries = /* @__PURE__ */ new Map();
+		const section = file.roots[config.root];
+		if (typeof section === "object" && section !== null) {
+			for (const [name, entry] of Object.entries(section)) if (isEntry(entry)) entries.set(name, entry);
+		}
+		return new ScanCache(path, config.root, configHash(config, version), version, entries);
+	}
+	get size() {
+		return this.#entries.size;
+	}
+	#current(file) {
+		const entry = this.#entries.get(file);
+		return entry !== void 0 && entry.configHash === this.key && entry.version === this.version ? entry : void 0;
+	}
+	/** A hit by file metadata alone: no read needed. */
+	byStat(file, mtimeMs, size) {
+		const entry = this.#current(file);
+		return entry !== void 0 && entry.mtimeMs === mtimeMs && entry.size === size ? entry : void 0;
+	}
+	/**
+	* A hit by content after the metadata moved; the entry is refreshed with
+	* the new metadata so the next run hits by stat again.
+	*/
+	byContent(file, hashOfText, mtimeMs, size) {
+		const entry = this.#current(file);
+		if (entry === void 0 || entry.contentHash !== hashOfText) return void 0;
+		if (entry.mtimeMs !== mtimeMs || entry.size !== size) {
+			this.#entries.set(file, {
+				...entry,
+				mtimeMs,
+				size
+			});
+			this.#dirty = true;
+		}
+		return entry;
+	}
+	set(file, entry) {
+		this.#entries.set(file, {
+			...entry,
+			configHash: this.key,
+			version: this.version
+		});
+		this.#dirty = true;
+	}
+	delete(file) {
+		if (this.#entries.delete(file)) this.#dirty = true;
+	}
+	/** Drops entries of files that are no longer part of the project. */
+	retain(files) {
+		for (const file of this.#entries.keys()) if (!files.has(file)) {
+			this.#entries.delete(file);
+			this.#dirty = true;
+		}
+	}
+	/**
+	* Writes the cache when it changed: under a lock, re-read, replace this
+	* root's section, write a temporary file and rename it over the old one,
+	* so a concurrent scan of another root keeps its section and readers never
+	* see half a file. Returns false when the cache was not written (a
+	* read-only checkout, a lock held too long): a cache never fails a scan.
+	*/
+	save() {
+		if (!this.#dirty) return Promise.resolve(true);
+		const run = (saving.get(this.path) ?? Promise.resolve()).then(() => this.#write());
+		const tail = run.catch(() => {});
+		saving.set(this.path, tail);
+		tail.then(() => {
+			if (saving.get(this.path) === tail) saving.delete(this.path);
+		});
+		return run;
+	}
+	async #write() {
+		if (!this.#dirty) return true;
+		const temp = `${this.path}.${process.pid}.${++temps}.${randomBytes(4).toString("hex")}.tmp`;
+		let release = null;
+		try {
+			await mkdir(dirname(this.path), { recursive: true });
+			release = await lock(this.path);
+			if (release === null) return false;
+			const file = await readCacheFile(this.path);
+			for (const root of Object.keys(file.roots)) if (!existsSync(root)) delete file.roots[root];
+			const section = {};
+			for (const [name, entry] of this.#entries) section[name] = entry;
+			file.roots[this.#root] = section;
+			await writeFile(temp, JSON.stringify(file));
+			await rename(temp, this.path);
+			this.#dirty = false;
+			return true;
+		} catch {
+			await unlink(temp).catch(() => {});
+			return false;
+		} finally {
+			await release?.();
+		}
+	}
+};
+//#endregion
+//#region src/core/extract/files.ts
+/** Directories read at once while walking: enough to keep the disk busy, few enough for any fd limit. */
+const READDIR_CONCURRENCY = 32;
+/** Posix form of a native path; `\` never occurs in posix names worth keeping. */
+function toPosix(path) {
+	return sep === "/" ? path : path.replaceAll("\\", "/");
+}
+function escapeRegExp(ch) {
+	return /[\\^$.*+?()[\]{}|]/.test(ch) ? "\\" + ch : ch;
+}
+/**
+* A gitignore glob (`*` one segment, `**` any depth, `?` one character) as a
+* regular expression body over a posix path.
+*/
+function globBody(pattern) {
+	let out = "";
+	for (let i = 0; i < pattern.length; i++) {
+		const ch = pattern[i];
+		if (ch === "*") {
+			const atSegmentStart = i === 0 || pattern[i - 1] === "/";
+			if (pattern[i + 1] === "*" && atSegmentStart) {
+				if (pattern[i + 2] === "/") {
+					out += "(?:.*/)?";
+					i += 2;
+					continue;
+				}
+				if (i + 2 === pattern.length) {
+					out += ".*";
+					i += 1;
+					continue;
+				}
+			}
+			while (pattern[i + 1] === "*") i++;
+			out += "[^/]*";
+		} else if (ch === "?") out += "[^/]";
+		else out += escapeRegExp(ch);
+	}
+	return out;
+}
+const matchers = /* @__PURE__ */ new WeakMap();
+/**
+* One alternation per kind of path, so deciding a path is one regex test
+* whatever the number of patterns. A pattern also matches everything below
+* what it matches (gitignore excludes a directory's contents with it).
+*/
+function compileExcludes(patterns) {
+	const file = [];
+	const dir = [];
+	for (const raw of patterns) {
+		let pattern = raw.trim();
+		if (pattern === "" || pattern.startsWith("#")) continue;
+		const dirOnly = pattern.endsWith("/");
+		if (dirOnly) pattern = pattern.replace(/\/+$/, "");
+		if (pattern === "") continue;
+		if (!pattern.includes("/")) {
+			const segment = globBody(pattern);
+			file.push(`(?:^|/)${segment}${dirOnly ? "/" : "(?:/|$)"}`);
+			dir.push(`(?:^|/)${segment}(?:/|$)`);
+			continue;
+		}
+		const anchored = globBody(pattern.replace(/^\/+/, ""));
+		file.push(`^${anchored}${dirOnly ? "/" : "(?:/|$)"}`);
+		const pruned = !dirOnly && anchored.endsWith("/.*") ? anchored.slice(0, -3) : anchored;
+		dir.push(`^${pruned}(?:/|$)`);
+	}
+	return {
+		file: file.length === 0 ? null : new RegExp(file.join("|")),
+		dir: dir.length === 0 ? null : new RegExp(dir.join("|"))
+	};
+}
+function matcherFor(config) {
+	const project = config.project;
+	const known = matchers.get(project);
+	if (known !== void 0 && known.include === project.include && known.exclude === project.exclude && known.extensions === project.extensions) return known;
+	const roots = project.include.map((entry) => toPosix(entry).replace(/\/+$/, ""));
+	const realRoots = project.include.map((entry, i) => {
+		try {
+			const real = toPosix(realpathSync(entry));
+			return real === roots[i] ? null : real;
+		} catch {
+			return null;
+		}
+	});
+	const matcher = {
+		include: project.include,
+		exclude: project.exclude,
+		extensions: project.extensions,
+		roots,
+		realRoots,
+		links: project.include.map(() => null),
+		...compileExcludes(project.exclude)
+	};
+	matchers.set(project, matcher);
+	return matcher;
+}
+/** Declaration files: a `.ts`-family extension, never a call. */
+const DECLARATION = /\.d\.[cm]?ts$/;
+/** Whether a file name carries a scanned extension (config extensions are single, like `.tsx`). */
+function hasExtension(name, extensions) {
+	for (const ext of extensions) if (name.endsWith(ext) && name.length > ext.length) return !DECLARATION.test(name);
+	return false;
+}
+/** Config-relative posix path, `../` allowed. */
+function relativeTo(root, path) {
+	const rootPosix = toPosix(root);
+	if (path.startsWith(rootPosix) && path[rootPosix.length] === "/") return path.slice(rootPosix.length + 1);
+	return toPosix(relative(root, path));
+}
+function isExcluded(m, rel, directory) {
+	const re = directory ? m.dir : m.file;
+	return re !== null && re.test(rel);
+}
+function under(path, dir) {
+	return path === dir || path.startsWith(dir) && path[dir.length] === "/";
+}
+/**
+* Whether the plugin and the CLI extract `file` (absolute; a `?query` or `\0`
+* prefix is ignored): under an include entry, by its path, by the entry's
+* realpath, or by a realpath the walk reached through a link inside the
+* entry, with a scanned extension and no exclude match. Excludes see the
+* path as the walk reached it, so a realpath module id (what Vite gives the
+* plugin) gets the walk's answer.
+*/
+function isIncluded(file, config) {
+	if (dependencyOf(file, config) !== null) return true;
+	const m = matcherFor(config);
+	let path = file.startsWith("\0") ? file.slice(1) : file;
+	const query = path.indexOf("?");
+	if (query !== -1) path = path.slice(0, query);
+	path = toPosix(path);
+	if (!hasExtension(path.slice(path.lastIndexOf("/") + 1), m.extensions)) return false;
+	for (let i = 0; i < m.roots.length; i++) {
+		const root = m.roots[i];
+		const real = m.realRoots[i];
+		let logical = null;
+		if (under(path, root)) logical = path;
+		else if (real != null && under(path, real)) logical = root + path.slice(real.length);
+		else logical = throughLink(path, linksOf(m, config, i));
+		if (logical !== null && !isExcluded(m, relativeTo(config.root, logical), false)) return true;
+	}
+	return false;
+}
+/** The path the walk reached a realpath by through a link: the file itself if linked, else its directory. */
+function throughLink(path, links) {
+	const linked = links.get(path);
+	if (linked !== void 0) return linked;
+	const slash = path.lastIndexOf("/");
+	const dir = links.get(path.slice(0, slash));
+	return dir === void 0 ? null : dir + path.slice(slash);
+}
+/**
+* The links of include entry `i`. A module outside every entry's tree may
+* still be reached through a link, which only a walk can tell; the first
+* such question walks the entry's directories once (the plugin asks only for
+* modules with messages), and `listProjectFiles` refreshes the answer.
+*/
+function linksOf(m, config, i) {
+	let links = m.links[i];
+	if (links == null) {
+		links = /* @__PURE__ */ new Map();
+		const entry = config.project.include[i];
+		try {
+			if (statSync(entry).isDirectory() && enterable(m, config, entry)) {
+				const walk = new Walk(m, config, {
+					logical: entry,
+					real: realpathSync(entry)
+				}, null);
+				while (walk.level.length > 0) walk.step(walk.level.map(listSync));
+				links = walk.links;
+			}
+		} catch (error) {
+			if (!isMissing$1(error)) throw error;
+		}
+		m.links[i] = links;
+	}
+	return links;
+}
+function isMissing$1(error) {
+	const code = error.code;
+	return code === "ENOENT" || code === "ENOTDIR" || code === "ELOOP";
+}
+function listed(entry) {
+	return {
+		name: entry.name,
+		isDir: entry.isDirectory(),
+		isFile: entry.isFile(),
+		real: null
+	};
+}
+async function listAsync(dir) {
+	let entries;
+	try {
+		entries = await readdir(dir.logical, { withFileTypes: true });
+	} catch (error) {
+		if (isMissing$1(error)) return null;
+		throw error;
+	}
+	const out = [];
+	for (const entry of entries) {
+		if (!entry.isSymbolicLink()) {
+			out.push(listed(entry));
+			continue;
+		}
+		const logical = dir.logical + sep + entry.name;
+		try {
+			const target = await stat(logical);
+			out.push({
+				name: entry.name,
+				isDir: target.isDirectory(),
+				isFile: target.isFile(),
+				real: await realpath(logical)
+			});
+		} catch (error) {
+			if (!isMissing$1(error)) throw error;
+		}
+	}
+	return out;
+}
+function listSync(dir) {
+	let entries;
+	try {
+		entries = readdirSync(dir.logical, { withFileTypes: true });
+	} catch (error) {
+		if (isMissing$1(error)) return null;
+		throw error;
+	}
+	const out = [];
+	for (const entry of entries) {
+		if (!entry.isSymbolicLink()) {
+			out.push(listed(entry));
+			continue;
+		}
+		const logical = dir.logical + sep + entry.name;
+		try {
+			const target = statSync(logical);
+			out.push({
+				name: entry.name,
+				isDir: target.isDirectory(),
+				isFile: target.isFile(),
+				real: realpathSync(logical)
+			});
+		} catch (error) {
+			if (!isMissing$1(error)) throw error;
+		}
+	}
+	return out;
+}
+/** Whether a native path is `dir` or below it. */
+function within(path, dir) {
+	return path === dir || path.startsWith(dir) && path[dir.length] === sep;
+}
+/**
+* One include directory, walked breadth-first by `step` (the listing is the
+* caller's, async for the walk and sync for `isIncluded`, so both decide
+* alike). Symlinks are followed by their realpath once, so a link cycle ends
+* and a directory linked twice is read once. A link into the entry's own
+* tree is not followed: its target is walked where it is, under its own
+* path, which is the path a realpath module id names.
+*/
+var Walk = class {
+	links = /* @__PURE__ */ new Map();
+	/** Whether any file matched (also when an earlier entry already listed it: such an entry is not empty). */
+	found = false;
+	level;
+	#m;
+	#config;
+	#start;
+	#files;
+	#visited;
+	constructor(m, config, start, files) {
+		this.#m = m;
+		this.#config = config;
+		this.#start = start;
+		this.#files = files;
+		this.#visited = /* @__PURE__ */ new Set([start.real]);
+		this.level = [start];
+	}
+	/** Applies the listings of the current level (index-aligned with `level`). */
+	step(listings) {
+		const m = this.#m;
+		const candidates = [];
+		for (let i = 0; i < this.level.length; i++) {
+			const dir = this.level[i];
+			for (const entry of listings[i] ?? []) {
+				if (entry.real !== null && within(entry.real, this.#start.real)) continue;
+				const logical = dir.logical + sep + entry.name;
+				const real = entry.real ?? dir.real + sep + entry.name;
+				const rel = relativeTo(this.#config.root, toPosix(logical));
+				if (entry.isDir) {
+					if (!isExcluded(m, rel, true)) candidates.push({
+						logical,
+						real
+					});
+				} else if (entry.isFile && hasExtension(entry.name, m.extensions)) {
+					if (isExcluded(m, rel, false)) continue;
+					this.found = true;
+					this.#files?.add(real);
+					if (entry.real !== null) this.links.set(toPosix(real), toPosix(logical));
+				}
+			}
+		}
+		candidates.sort((a, b) => a.logical < b.logical ? -1 : a.logical > b.logical ? 1 : 0);
+		const next = [];
+		for (const dir of candidates) {
+			if (this.#visited.has(dir.real)) continue;
+			this.#visited.add(dir.real);
+			next.push(dir);
+			if (!within(dir.real, this.#start.real)) this.links.set(toPosix(dir.real), toPosix(dir.logical));
+		}
+		this.level = next;
+	}
+};
+async function mapLimit$1(items, limit, run) {
+	let next = 0;
+	const lanes = [];
+	for (let lane = 0; lane < Math.min(limit, items.length); lane++) lanes.push((async () => {
+		while (next < items.length) await run(items[next++]);
+	})());
+	await Promise.all(lanes);
+}
+async function walk(walker) {
+	while (walker.level.length > 0) {
+		const level = walker.level;
+		const listings = Array.from({ length: level.length }, () => null);
+		await mapLimit$1(level.map((_, i) => i), READDIR_CONCURRENCY, async (i) => {
+			listings[i] = await listAsync(level[i]);
+		});
+		walker.step(listings);
+	}
+}
+/**
+* Whether an include directory is walked at all: its own path must pass the
+* directory excludes too (excluding `legacy` excludes an entry `src/legacy`).
+*/
+function enterable(m, config, entry) {
+	const rel = relativeTo(config.root, toPosix(entry));
+	return rel === "" || !isExcluded(m, rel, true);
+}
+/**
+* Lists the project's files by realpath, sorted by code unit so scans are
+* deterministic, and the include entries that matched no file (missing,
+* empty, or wholly excluded), which `vi18n extract` reports as
+* `extract-empty-root`. Overlapping entries list a file once.
+*/
+async function listProjectFiles(config) {
+	const m = matcherFor(config);
+	const files = /* @__PURE__ */ new Set();
+	const emptyRoots = [];
+	for (let i = 0; i < config.project.include.length; i++) {
+		const entry = config.project.include[i];
+		const rel = relativeTo(config.root, toPosix(entry));
+		let found = false;
+		let links = /* @__PURE__ */ new Map();
+		try {
+			const info = await stat(entry);
+			if (info.isDirectory()) {
+				if (enterable(m, config, entry)) {
+					const walker = new Walk(m, config, {
+						logical: entry,
+						real: await realpath(entry)
+					}, files);
+					await walk(walker);
+					found = walker.found;
+					links = walker.links;
+				}
+			} else if (info.isFile()) {
+				if (hasExtension(entry.slice(entry.lastIndexOf(sep) + 1), m.extensions) && !isExcluded(m, rel, false)) {
+					files.add(await realpath(entry));
+					found = true;
+				}
+			}
+		} catch (error) {
+			if (!isMissing$1(error)) throw error;
+		}
+		m.links[i] = links;
+		if (!found) emptyRoots.push(entry);
+	}
+	for (const file of await listDependencyFiles(config)) files.add(file);
+	return {
+		files: [...files].sort(),
+		emptyRoots
+	};
+}
+//#endregion
+//#region src/core/extract/project.ts
+/**
+* The project scan (INTERNALS §2.5.6): what `vi18n extract` and the plugin's
+* build seed know about every message in the code. Files come from the
+* include walk, hits from the scan cache, and misses are scanned in-process
+* or, past 200 of them, in a `worker_threads` pool. Results are in file
+* order whichever path produced them, so a scan is deterministic.
+*/
+/** Misses above which the pool pays for its start-up (each worker loads the parser and compilers). */
+const POOL_THRESHOLD = 200;
+const POOL_MAX = 8;
+/** Files per worker message: large enough to amortise messaging, small enough to balance load. */
+const BATCH = 16;
+/** Explicit files resolved at once. */
+const RESOLVE_CONCURRENCY = 64;
+/**
+* The worker entry next to this module: the source file in the workspace
+* (Node strips its types), `scan-worker.js` beside the packed CLI chunk.
+*/
+const WORKER_URL = new URL(import.meta.url.endsWith(".ts") ? "./worker.ts" : "./scan-worker.js", import.meta.url);
+function isMissing(error) {
+	const code = error.code;
+	return code === "ENOENT" || code === "ENOTDIR" || code === "EISDIR";
+}
+async function mapLimit(items, limit, run) {
+	let next = 0;
+	const lanes = [];
+	for (let lane = 0; lane < Math.min(limit, items.length); lane++) lanes.push((async () => {
+		while (next < items.length) await run(items[next++]);
+	})());
+	await Promise.all(lanes);
+}
+/** Maps an absolute file to its `#:` reference: posix, relative to the config root. */
+function refMapper(config) {
+	const roots = [toPosix(config.root)];
+	let realRoot = null;
+	try {
+		realRoot = realpathSync(config.root);
+		if (toPosix(realRoot) !== roots[0]) roots.unshift(toPosix(realRoot));
+	} catch {}
+	return (file) => {
+		const posix = toPosix(file);
+		const dependency = dependencyRef(posix, config);
+		if (dependency !== null) return dependency;
+		for (const root of roots) if (posix.startsWith(root) && posix[root.length] === "/") return posix.slice(root.length + 1);
+		if (realRoot !== null) try {
+			return toPosix(relative(realRoot, realpathSync(file)));
+		} catch {}
+		return toPosix(relative(config.root, file));
+	};
+}
+async function explicitFiles(config, files) {
+	const out = /* @__PURE__ */ new Set();
+	await mapLimit(files, RESOLVE_CONCURRENCY, async (file) => {
+		const logical = resolve(config.root, file);
+		let real;
+		try {
+			real = await realpath(logical);
+		} catch (error) {
+			if (isMissing(error)) return;
+			throw error;
+		}
+		if (isIncluded(real, config) || isIncluded(logical, config)) out.add(real);
+	});
+	return [...out].sort();
+}
+function emptyRootDiagnostic(root, ref) {
+	const file = ref(root);
+	return {
+		code: "extract-empty-root",
+		severity: "error",
+		message: `The include entry ${file} matches no file; fix project.include or project.exclude in the config`,
+		file
+	};
+}
+/**
+* A missing compiler fails every file of its kind with the same message;
+* the project-level list names it once, with the other files as `related`.
+*/
+function projectDiagnostics(scans, leading) {
+	const out = leading;
+	const missing = /* @__PURE__ */ new Map();
+	for (const scan of scans) for (const diagnostic of scan.diagnostics) {
+		if (diagnostic.code !== "extract-missing-compiler") {
+			out.push(diagnostic);
+			continue;
+		}
+		const first = missing.get(diagnostic.message);
+		if (first === void 0) {
+			const copy = { ...diagnostic };
+			missing.set(diagnostic.message, copy);
+			out.push(copy);
+		} else (first.related ??= []).push({
+			file: scan.refFile,
+			message: "also needs it"
+		});
+	}
+	return out;
+}
+/**
+* A `worker_threads` pool, started before the files are read so the
+* workers load the parser while the main thread reads. `run` hands out
+* batches as workers finish, so one slow file (a large SFC) does not idle
+* the rest.
+*/
+var ScanPool = class {
+	#workers = [];
+	/** Set while a run is active: how a dead worker ends it. */
+	#fail = null;
+	#failed = false;
+	constructor(size, config, codec) {
+		const init = {
+			marker: WORKER_MARKER,
+			config: scanConfig(config),
+			idLength: codec.idLength
+		};
+		const onFailure = () => {
+			this.#failed = true;
+			this.#fail?.();
+		};
+		for (let i = 0; i < size; i++) {
+			const worker = new Worker(WORKER_URL, { workerData: init });
+			worker.on("error", onFailure);
+			worker.on("exit", (code) => {
+				if (code !== 0) onFailure();
+			});
+			this.#workers.push(worker);
+		}
+	}
+	/**
+	* Scans `misses` into `results` by file index. Resolves false when a
+	* worker could not start or died: the caller scans what is left
+	* in-process. A scan error inside a worker rejects, as it would
+	* in-process.
+	*/
+	run(misses, results) {
+		if (this.#failed) return Promise.resolve(false);
+		const batches = [];
+		for (let i = 0; i < misses.length; i += BATCH) batches.push(misses.slice(i, i + BATCH));
+		let next = 0;
+		let pending = batches.length;
+		return new Promise((resolveRun, rejectRun) => {
+			let settled = false;
+			const finish = (outcome) => {
+				if (settled) return;
+				settled = true;
+				this.#fail = null;
+				for (const worker of this.#workers) worker.removeAllListeners("message");
+				if (outcome instanceof Error) rejectRun(outcome);
+				else resolveRun(outcome);
+			};
+			this.#fail = () => finish(false);
+			const send = (worker) => {
+				if (next >= batches.length) return;
+				const batch = next++;
+				const tasks = batches[batch].map((miss) => miss.task);
+				worker.postMessage({
+					batch,
+					tasks
+				});
+			};
+			if (pending === 0) finish(true);
+			for (const worker of this.#workers) {
+				worker.on("message", (response) => {
+					if (settled) return;
+					if ("error" in response) {
+						const error = new Error(response.error.message);
+						if (response.error.stack !== void 0) error.stack = response.error.stack;
+						finish(error);
+						return;
+					}
+					const batch = batches[response.batch];
+					for (let j = 0; j < batch.length; j++) results[batch[j].index] = response.results[j];
+					poolStats.files += batch.length;
+					if (--pending === 0) finish(true);
+					else send(worker);
+				});
+				send(worker);
+				send(worker);
+			}
+		});
+	}
+	close() {
+		for (const worker of this.#workers) worker.terminate();
+	}
+};
+function poolSize(misses, option) {
+	if (option !== void 0) return Math.max(0, Math.min(Math.floor(option), misses));
+	if (misses <= POOL_THRESHOLD) return 0;
+	return Math.max(0, Math.min(POOL_MAX, availableParallelism() - 1));
+}
+let workerEntryExists;
+let warnedMissingEntry = false;
+/** A pool for `misses` files, or null to scan in-process (also when the worker entry was not packed). */
+function startPool(misses, option, config, codec) {
+	const size = poolSize(misses, option);
+	if (size === 0) return null;
+	workerEntryExists ??= existsSync(fileURLToPath(WORKER_URL));
+	return workerEntryExists ? new ScanPool(size, config, codec) : null;
+}
+/**
+* A build that lost the worker entry still scans correctly, only slower:
+* counted once per scan so tests of the packed layout see it, and said once
+* when the caller asked for workers by number and would otherwise never
+* learn why the scan did not speed up.
+*/
+function missingEntryFallback(option) {
+	poolStats.fallbacks++;
+	if (option !== void 0 && option > 0 && !warnedMissingEntry) {
+		warnedMissingEntry = true;
+		console.warn(`[vi18n] The scan worker entry ${fileURLToPath(WORKER_URL)} is missing; scanning in-process`);
+	}
+}
+function cachedScan(file, refFile, entry) {
+	return {
+		file,
+		refFile,
+		occurrences: entry.occurrences,
+		diagnostics: entry.diagnostics,
+		fromCache: true
+	};
+}
+/**
+* Files scanned by pool workers, and scans that wanted a pool but fell back
+* in-process (a worker died, or the worker entry was not packed), since the
+* process started. Diagnostics for tests and benchmarks; nothing reads
+* them to decide anything.
+*/
+const poolStats = {
+	files: 0,
+	fallbacks: 0
+};
+/**
+* Scans the project (§2.5.6). `aborted` is true when an include entry
+* matched no file, a file failed to parse or compile, or a compiler is
+* missing; the scan still covers every other file so all problems are
+* reported at once, but `vi18n extract` must not write.
+*/
+async function scanProject(config, codec, options = {}) {
+	const ref = refMapper(config);
+	const leading = [];
+	let files;
+	if (options.files === void 0) {
+		const listed = await listProjectFiles(config);
+		files = listed.files;
+		for (const root of listed.emptyRoots) leading.push(emptyRootDiagnostic(root, ref));
+	} else files = await explicitFiles(config, options.files);
+	const cache = options.cache === true ? await ScanCache.open(config) : null;
+	let pool = null;
+	if (cache === null || cache.size === 0) pool = startPool(files.length, options.workers, config, codec);
+	const scans = Array.from({ length: files.length });
+	try {
+		const misses = [];
+		for (let index = 0; index < files.length; index++) {
+			const file = files[index];
+			const refFile = ref(file);
+			let mtimeMs = 0;
+			let size = 0;
+			let text;
+			try {
+				if (cache !== null) {
+					const info = statSync(file);
+					mtimeMs = info.mtimeMs;
+					size = info.size;
+					const hit = cache.byStat(file, mtimeMs, size);
+					if (hit !== void 0) {
+						scans[index] = cachedScan(file, refFile, hit);
+						continue;
+					}
+				}
+				text = readFileSync(file, "utf8");
+			} catch (error) {
+				if (isMissing(error)) continue;
+				throw error;
+			}
+			let hashOfText = "";
+			if (cache !== null) {
+				hashOfText = contentHash(text);
+				const hit = cache.byContent(file, hashOfText, mtimeMs, size);
+				if (hit !== void 0) {
+					scans[index] = cachedScan(file, refFile, hit);
+					continue;
+				}
+			}
+			misses.push({
+				index,
+				task: {
+					file,
+					refFile,
+					text
+				},
+				mtimeMs,
+				size,
+				contentHash: hashOfText
+			});
+		}
+		pool ??= startPool(misses.length, options.workers, config, codec);
+		if (pool === null && workerEntryExists === false && poolSize(misses.length, options.workers) > 0) missingEntryFallback(options.workers);
+		const results = [];
+		if (pool !== null && misses.length > 0 && !await pool.run(misses, results)) poolStats.fallbacks++;
+		for (const miss of misses) {
+			const result = results[miss.index] ??= await scanSource(miss.task, config, codec);
+			scans[miss.index] = {
+				file: miss.task.file,
+				refFile: miss.task.refFile,
+				occurrences: result.occurrences,
+				diagnostics: result.diagnostics,
+				fromCache: false
+			};
+			if (cache === null) continue;
+			if (result.aborted) cache.delete(miss.task.file);
+			else cache.set(miss.task.file, {
+				mtimeMs: miss.mtimeMs,
+				size: miss.size,
+				contentHash: miss.contentHash,
+				occurrences: result.occurrences,
+				diagnostics: result.diagnostics
+			});
+		}
+	} finally {
+		pool?.close();
+	}
+	const fileScans = scans.filter((scan) => scan !== void 0);
+	if (cache !== null) {
+		if (options.files === void 0) cache.retain(new Set(fileScans.map((scan) => scan.file)));
+		await cache.save();
+	}
+	const diagnostics = projectDiagnostics(fileScans, leading);
+	let aborted = false;
+	for (const diagnostic of diagnostics) if (ABORT_CODES.has(diagnostic.code)) aborted = true;
+	return {
+		files: fileScans,
+		messages: aggregateOccurrences((function* () {
+			for (const scan of fileScans) yield* scan.occurrences;
+		})()),
+		diagnostics,
+		aborted
+	};
+}
+//#endregion
+export { toPosix as a, listProjectFiles as i, scanProject as n, aggregateOccurrences as o, isIncluded as r, configHash as s, refMapper as t };