@menapo/vi18n 0.0.0-stage → 0.1.1

package/dist/sync-B9V2KFwb.js

@@ -0,0 +1,658 @@
+import { o as isDiagnosticError, t as CONFIG_FILE } from "./types-D3QGM8XO.js";
+import { s as parseIdScheme } from "./validate-BxpupdAf.js";
+import { S as entryKey, a as ownedMessages, b as emptyCatalog, f as sameCatalogText, n as libraryCoverage, o as catalogLayout, p as serializeCatalog, r as libraryIds, s as catalogPath, y as createEntry } from "./library-D5CWvTQs.js";
+import { t as VERSION } from "./version-Byqi2guX.js";
+import { n as mergeDuplicates } from "./duplicates-yuRljQ6h.js";
+import { dirname, isAbsolute, join, relative, sep } from "node:path";
+import { randomBytes } from "node:crypto";
+import { readFile, rename, rm, writeFile } from "node:fs/promises";
+//#region src/types-gen/gen.ts
+/**
+* `vi18n.gen.ts` (docs/INTERNALS.md §2.16, PLAN §5.18): the generated
+* `Register` augmentation that turns `Locale` into the configured union.
+* Written beside `vi18n.config.ts` by the plugin and by `vi18n init`/`extract`,
+* and committed like `routeTree.gen.ts`.
+*/
+/** The generated file's name, in the directory of `vi18n.config.ts`. */
+const GEN_FILE = "vi18n.gen.ts";
+/** The `locales` union: configured locales in config order, pseudo-locales left out. */
+function localesUnion(config) {
+	const pseudo = config.pseudoLocales;
+	let union = "";
+	for (const locale of config.locales) {
+		if (pseudo.includes(locale)) continue;
+		union += (union ? " | " : "") + JSON.stringify(locale);
+	}
+	return union || "never";
+}
+/**
+* `messages`: the manual-id messages of the packages `extraction.dependencies`
+* opts in (their `vi18n.messages.json`, §2.16), by id, so `msg({ id })` is
+* typed from the library's text. Empty without any.
+*/
+function messagesMember(config) {
+	if (config.extraction.dependencies.length === 0) return "";
+	const ids = [...libraryIds(config)].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+	if (ids.length === 0) return "";
+	let out = `    messages: {\n`;
+	for (const [id, message] of ids) out += `      ${JSON.stringify(id)}: ${JSON.stringify(message)};\n`;
+	return out + `    };\n`;
+}
+/**
+* The file's exact content: configured locales in config order, pseudo-locales
+* left out (they are switched on per build and never part of the app's API),
+* then the opted-in packages' manual-id messages, if any.
+*/
+function genFileContent(config) {
+	return `// Generated by @menapo/vi18n from ${CONFIG_FILE}. Do not edit; commit it.\nimport type {} from "@menapo/vi18n";\n\ndeclare module "@menapo/vi18n" {\n  interface Register {\n    locales: ${localesUnion(config)};\n` + messagesMember(config) + "  }\n}\n";
+}
+/**
+* What earlier releases wrote for the same locales (no import, `export {}`
+* last). The drift checks accept it: like the catalogs' `X-Generator` line
+* (INTERNALS §2.6.3), a vi18n upgrade alone must not fail `extract --check`
+* or make `compile` refuse. Any write replaces it with the current content.
+*/
+function previousGenFileContent(config) {
+	return `// Generated by @menapo/vi18n from ${CONFIG_FILE}. Do not edit; commit it.\ndeclare module "@menapo/vi18n" {\n  interface Register {\n    locales: ${localesUnion(config)};\n  }\n}\nexport {};\n`;
+}
+/**
+* Whether `text` (the file as read) is up to date for the drift checks: the
+* current content or an earlier release's for the same locales. CRLF line
+* ends (a checkout with `core.autocrlf`) are not drift either.
+*/
+function genFileUpToDate(config, text) {
+	const normalized = text.replace(/\r\n/g, "\n");
+	return normalized === genFileContent(config) || normalized === previousGenFileContent(config);
+}
+/**
+* Writes `vi18n.gen.ts` beside the config when its content changed; true when
+* written. Zero-config mode (no config file) writes nothing (INTERNALS
+* §2.7.1). The plugin's environments and the CLI may write concurrently, so
+* the file is replaced by an atomic rename and never seen half-written by the
+* editor's TypeScript server.
+*/
+async function writeGenFile(config) {
+	if (config.configFile === null) return false;
+	const path = join(dirname(config.configFile), GEN_FILE);
+	const content = genFileContent(config);
+	let current = null;
+	try {
+		current = await readFile(path, "utf8");
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+	if (current !== null && current.replace(/\r\n/g, "\n") === content) return false;
+	const temp = join(dirname(path), `.${GEN_FILE}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`);
+	try {
+		await writeFile(temp, content);
+		await rename(temp, path);
+	} catch (error) {
+		await rm(temp, { force: true });
+		throw error;
+	}
+	return true;
+}
+//#endregion
+//#region src/core/sync.ts
+/**
+* Catalog sync (INTERNALS §2.6.8, PLAN §5.5): what `vi18n extract` (`full`)
+* and the dev writer or `extract --watch` (`add-only`) do to each locale's
+* catalog given the scanned messages. Pure: callers read the files, write
+* the result through `updateCatalogFile` and re-run `syncCatalog` when a file
+* changed under them.
+*
+* Only a one-shot `full` sync clears or deletes, so a branch switch with the
+* dev server running can never destroy translations; `full` is in turn held
+* back by the safety limit unless the user passes `--yes`.
+*/
+/** Removals allowed without `--yes` whatever the catalog size (PLAN §5.5). */
+const LIMIT_FLOOR = 50;
+/** Share of a locale's translated entries one extract may clear or delete without `--yes`. */
+const LIMIT_SHARE = .1;
+function syncCatalogs(input) {
+	const { config, codec, messages, catalogs, options } = input;
+	const sourceCatalog = catalogs.get(config.sourceLocale)?.catalog ?? null;
+	const result = {
+		catalogs: /* @__PURE__ */ new Map(),
+		changed: [],
+		stats: {},
+		blocked: [],
+		deletedKeys: [],
+		diagnostics: []
+	};
+	const deleted = /* @__PURE__ */ new Set();
+	const limits = [];
+	let overLimit = false;
+	const coverage = libraryCoverage(catalogs, messages, config, codec);
+	for (const locale of config.locales) {
+		const loaded = catalogs.get(locale);
+		const read = loaded?.catalog ?? null;
+		const synced = syncLocale({
+			config,
+			codec,
+			messages,
+			locale,
+			catalog: read,
+			sourceCatalog,
+			options,
+			coverage
+		});
+		const file = displayPath(config.root, loaded?.path ?? catalogPath(config, locale));
+		for (const diagnostic of synced.diagnostics) {
+			diagnostic.file ??= file;
+			diagnostic.locale ??= locale;
+			result.diagnostics.push(diagnostic);
+		}
+		result.catalogs.set(locale, synced.catalog);
+		result.stats[locale] = synced.stats;
+		if (wouldChange(read, synced.catalog, locale === config.sourceLocale)) result.changed.push(locale);
+		for (const key of synced.deleted) deleted.add(key);
+		if (options.mode !== "full" || locale === config.sourceLocale) continue;
+		const limit = Math.max(LIMIT_FLOOR, Math.ceil(LIMIT_SHARE * translatedCount(read)));
+		limits.push({
+			locale,
+			removals: synced.removals,
+			limit
+		});
+		if (synced.removals > limit && !options.yes) {
+			overLimit = true;
+			result.diagnostics.push({
+				code: "catalog-safety-limit",
+				severity: "error",
+				message: `vi18n extract would clear or delete ${synced.removals} translated ${synced.removals === 1 ? "entry" : "entries"} in ${locale}, over its limit of ${limit} (10 % of its translated entries, at least ${LIMIT_FLOOR}); check the scan covers every app, then run vi18n extract --yes`,
+				file,
+				locale
+			});
+		}
+	}
+	if (overLimit) result.blocked = limits;
+	result.deletedKeys = [...deleted].sort(compareText);
+	return result;
+}
+/** One locale; what writers re-run inside `updateCatalogFile` when the file changed under them. */
+function syncCatalog(input) {
+	const { catalog, stats, removals, diagnostics } = syncLocale(input);
+	return {
+		catalog,
+		stats,
+		removals,
+		diagnostics
+	};
+}
+function syncLocale(input) {
+	const { config, codec, locale } = input;
+	const layout = catalogLayout(config);
+	const messages = ownedMessages(input.messages, locale, input.catalog, input.coverage, {
+		sourceLocale: config.sourceLocale,
+		layout,
+		codec
+	});
+	const base = input.catalog ?? emptyCatalog(locale, layout, {
+		idScheme: codec.idScheme,
+		sourceLocale: config.sourceLocale
+	});
+	const recorded = base.header.idScheme;
+	const rekey = layout !== "source" && recorded !== null && recorded !== codec.idScheme;
+	const context = {
+		config,
+		codec,
+		layout,
+		isSource: locale === config.sourceLocale,
+		messages,
+		sourceCatalog: input.sourceCatalog,
+		sourceIndex: sourceIndex(input.sourceCatalog, layout, locale === config.sourceLocale),
+		icuFlag: config.catalogs.icuFlag && layout !== "json"
+	};
+	if (input.options.mode === "add-only") {
+		if (rekey) return {
+			catalog: base,
+			stats: emptyStats(),
+			removals: 0,
+			diagnostics: [schemeDiagnostic(recorded, codec)],
+			deleted: []
+		};
+		return addOnly(base, context);
+	}
+	return full(base, context, rekey);
+}
+function emptyStats() {
+	return {
+		added: 0,
+		deleted: 0,
+		cleared: 0,
+		moved: 0,
+		rekeyed: 0,
+		updated: 0
+	};
+}
+function addOnly(catalog, context) {
+	const { codec, layout, messages } = context;
+	const stats = emptyStats();
+	const index = /* @__PURE__ */ new Map();
+	const entries = catalog.entries;
+	for (let i = 0; i < entries.length; i++) {
+		const key = entryKey(entries[i], layout, codec);
+		if (key !== null && !index.has(key)) index.set(key, i);
+	}
+	let out = null;
+	for (const message of messages.values()) {
+		const at = index.get(message.id);
+		if (at === void 0) {
+			(out ??= entries.slice()).push(newEntry(message, context));
+			stats.added++;
+			continue;
+		}
+		const entry = entries[at];
+		if (classify(entry, message, context) !== "same") continue;
+		const grown = withMissingNotes(entry, message);
+		if (grown !== entry) {
+			(out ??= entries.slice())[at] = grown;
+			stats.updated++;
+		}
+	}
+	const header = completeHeader(catalog.header, context, false);
+	if (out === null && header === catalog.header) return {
+		catalog,
+		stats,
+		removals: 0,
+		diagnostics: [],
+		deleted: []
+	};
+	return {
+		catalog: {
+			...catalog,
+			header,
+			entries: out ?? entries
+		},
+		stats,
+		removals: 0,
+		diagnostics: [],
+		deleted: []
+	};
+}
+/** Adds the scan's references and notes an entry lacks, keeping everything it has. */
+function withMissingNotes(entry, message) {
+	let refs = null;
+	for (const ref of message.refs) if (!entry.refs.includes(ref)) (refs ??= entry.refs.slice()).push(ref);
+	let contexts = null;
+	for (const note of message.contexts) if (!entry.contexts.includes(note)) (contexts ??= entry.contexts.slice()).push(note);
+	if (refs === null && contexts === null) return entry;
+	return {
+		...entry,
+		refs: refs === null ? entry.refs : refs.sort(compareText),
+		contexts: contexts ?? entry.contexts
+	};
+}
+function full(read, context, rekey) {
+	const { codec, layout, messages, isSource } = context;
+	const stats = emptyStats();
+	const diagnostics = [];
+	let catalog = read;
+	if (rekey) {
+		const rekeyed = rekeyCatalog(catalog, context);
+		catalog = rekeyed.catalog;
+		stats.rekeyed = rekeyed.count;
+	}
+	catalog = mergeDuplicates(catalog, codec);
+	const keep = new Set(context.config.extraction.keep);
+	const out = [];
+	const matched = /* @__PURE__ */ new Set();
+	const deletions = [];
+	let removals = 0;
+	for (const entry of catalog.entries) {
+		const key = entryKey(entry, layout, codec);
+		if (key === null) {
+			out.push(entry);
+			continue;
+		}
+		const message = messages.get(key);
+		if (message === void 0) {
+			if (keep.has(key)) out.push(entry);
+			else deletions.push({
+				entry,
+				key,
+				canonical: canonicalOf(sourceText(entry, context), codec),
+				movedTo: false
+			});
+			continue;
+		}
+		const kind = classify(entry, message, context);
+		if (kind === "other") {
+			deletions.push({
+				entry,
+				key,
+				canonical: canonicalOf(sourceText(entry, context), codec),
+				movedTo: false
+			});
+			continue;
+		}
+		matched.add(key);
+		if (kind === "changed") {
+			if (!isSource && hasTranslation(entry)) {
+				stats.cleared++;
+				removals++;
+			}
+			out.push(rewritten(entry, message, layout));
+			continue;
+		}
+		const refreshed = refresh(entry, message, layout);
+		if (refreshed.notesChanged) stats.updated++;
+		out.push(refreshed.entry);
+	}
+	const additions = [];
+	const addedTexts = /* @__PURE__ */ new Map();
+	for (const message of messages.values()) {
+		if (matched.has(message.id)) continue;
+		matched.add(message.id);
+		additions.push(newEntry(message, context));
+		addedTexts.set(message.canonical, (addedTexts.get(message.canonical) ?? 0) + 1);
+	}
+	let deletedTexts = null;
+	for (const deletion of deletions) {
+		if (deletion.canonical === null) continue;
+		deletedTexts ??= /* @__PURE__ */ new Map();
+		const list = deletedTexts.get(deletion.canonical);
+		if (list === void 0) deletedTexts.set(deletion.canonical, [deletion]);
+		else list.push(deletion);
+	}
+	for (let i = 0; i < additions.length; i++) {
+		const added = additions[i];
+		const canonical = added.source;
+		const from = deletedTexts?.get(canonical);
+		if (from === void 0 || from.length !== 1 || addedTexts.get(canonical) !== 1) {
+			stats.added++;
+			continue;
+		}
+		const source = from[0];
+		source.movedTo = true;
+		stats.moved++;
+		additions[i] = {
+			...added,
+			translation: source.entry.translation,
+			state: source.entry.state,
+			fuzzy: source.entry.fuzzy
+		};
+	}
+	for (const deletion of deletions) {
+		if (deletion.movedTo) continue;
+		stats.deleted++;
+		if (!isSource && hasTranslation(deletion.entry)) removals++;
+	}
+	for (const added of additions) out.push(added);
+	for (let i = 0; i < out.length; i++) out[i] = withIcuFlag(out[i], context.icuFlag);
+	let obsolete = catalog.obsolete;
+	let droppedObsolete = catalog.droppedObsolete;
+	if (obsolete.length > 0) {
+		diagnostics.push({
+			code: "catalog-obsolete-dropped",
+			severity: "info",
+			message: `dropped ${obsolete.length} obsolete #~ ${obsolete.length === 1 ? "entry" : "entries"}; git history keeps them`
+		});
+		obsolete = [];
+		droppedObsolete = 0;
+	}
+	const header = completeHeader(catalog.header, context, true);
+	return {
+		catalog: header === read.header && obsolete === read.obsolete && out.length === read.entries.length && out.every((entry, i) => entry === read.entries[i]) ? read : {
+			...catalog,
+			header,
+			entries: out,
+			obsolete,
+			droppedObsolete
+		},
+		stats,
+		removals,
+		diagnostics,
+		deleted: deletions.map((deletion) => deletion.key)
+	};
+}
+/** The matched entry with refs, notes, `maxLength` and the canonical source taken from the scan. */
+function refresh(entry, message, layout) {
+	const maxLength = message.maxLength ?? null;
+	const notesChanged = entry.maxLength !== maxLength || !sameList(entry.refs, message.refs) || !sameList(entry.contexts, message.contexts);
+	const label = layout === "id" ? message.label : entry.label;
+	if (!notesChanged && entry.source === message.canonical && entry.label === label) return {
+		entry,
+		notesChanged
+	};
+	return {
+		entry: {
+			...entry,
+			source: message.canonical,
+			label,
+			refs: message.refs.slice(),
+			contexts: message.contexts.slice(),
+			maxLength
+		},
+		notesChanged
+	};
+}
+/** A manual entry whose text changed: the new source, an empty translation, no `ai` or `fuzzy`. */
+function rewritten(entry, message, layout) {
+	return {
+		...entry,
+		source: message.canonical,
+		label: layout === "id" ? message.label : entry.label,
+		translation: "",
+		state: "untranslated",
+		fuzzy: false,
+		refs: message.refs.slice(),
+		contexts: message.contexts.slice(),
+		maxLength: message.maxLength ?? null
+	};
+}
+function newEntry(message, context) {
+	const { layout } = context;
+	return createEntry({
+		manualId: message.manual ? message.id : null,
+		label: layout === "id" ? message.label : layout === "json" && !message.manual ? message.id : null,
+		source: message.canonical,
+		refs: message.refs.slice(),
+		contexts: message.contexts.slice(),
+		maxLength: message.maxLength ?? null,
+		flags: context.icuFlag ? [{
+			name: ICU_FLAG,
+			line: "#,"
+		}] : []
+	});
+}
+const ICU_FLAG = "icu-message-format";
+/**
+* `catalogs.icuFlag` is vi18n's to set (PLAN §4.4): a full sync adds the
+* flag to every entry, or takes it off when the option is false, so the
+* file follows the config. A flag already present stays where it was read.
+*/
+function withIcuFlag(entry, on) {
+	if (entry.foreignContext !== null) return entry;
+	if (entry.flags.some((flag) => flag.name === ICU_FLAG) === on) return entry;
+	return {
+		...entry,
+		flags: on ? [{
+			name: ICU_FLAG,
+			line: "#,"
+		}, ...entry.flags] : entry.flags.filter((flag) => flag.name !== ICU_FLAG)
+	};
+}
+/**
+* Re-key after an `ids.length` change (PLAN §5.5): each entry's text comes
+* from its own source (JSON, the source locale) or, for `"id"`-layout
+* targets, from the source locale's entry for the same old key (read at the
+* recorded length), else the target's own `#. source:` note, and its
+* label is recomputed at the new length. Translations stay, and nothing here
+* counts against the safety limit. An entry whose text cannot be recovered
+* keeps its old key, so the normal rules (and the limit) apply to it.
+*/
+function rekeyCatalog(catalog, context) {
+	const { codec, layout, isSource } = context;
+	const joined = layout === "id" && !isSource ? oldLabelIndex(context.sourceCatalog, catalog.header.idScheme, codec) : null;
+	let count = 0;
+	const entries = catalog.entries.map((entry) => {
+		if (entry.foreignContext !== null) return entry;
+		if (layout === "json" && entry.manualId !== null) return entry;
+		let text = entry.source;
+		if (layout === "id" && !isSource) {
+			const key = entry.manualId ?? entry.label ?? "";
+			text = joined?.get(key) ?? context.sourceIndex?.get(key) ?? entry.source;
+		}
+		const canonical = canonicalOf(text, codec);
+		if (canonical === null) return entry;
+		const label = codec.label(canonical);
+		if (label !== entry.label) count++;
+		return {
+			...entry,
+			label,
+			source: canonical
+		};
+	});
+	return {
+		catalog: {
+			...catalog,
+			entries,
+			header: {
+				...catalog.header,
+				idScheme: codec.idScheme
+			}
+		},
+		count
+	};
+}
+/**
+* The source locale's text per key at the target's recorded length: manual
+* ids as they are, generated entries by their text's hash cut to the old
+* length. Hashing rather than reading the source file's labels keeps the
+* join working when the source locale is already at the new scheme (an
+* interrupted extract, a TMS export from before the change merged back),
+* where the target's `#. source:` notes may be all that is left otherwise and
+* a key-based TMS strips them.
+*/
+function oldLabelIndex(sourceCatalog, recorded, codec) {
+	const old = recorded === null ? null : parseIdScheme(recorded);
+	if (old === null || sourceCatalog === null) return null;
+	const index = /* @__PURE__ */ new Map();
+	for (const entry of sourceCatalog.entries) {
+		if (entry.foreignContext !== null || entry.source === null) continue;
+		let key = entry.manualId;
+		if (key === null) {
+			const canonical = canonicalOf(entry.source, codec);
+			if (canonical === null) continue;
+			key = codec.sourceHash(canonical).slice(0, old.length);
+		}
+		if (!index.has(key)) index.set(key, entry.source);
+	}
+	return index;
+}
+/**
+* How an entry found under a message's key relates to it:
+* - `same`: the entry is for the message's text;
+* - `changed`: a manual entry whose source text changed (D10);
+* - `other`: a generated entry whose recorded text is a different text with
+*   the same id, i.e. a deleted message whose id the new one took.
+*
+* A generated entry's key is a fingerprint of its text, so a recorded source
+* that no longer hashes to the key (a hand-edited JSON `source`, a stale
+* `#. source:` note) is a damaged copy of the same text, not another text.
+*/
+function classify(entry, message, context) {
+	const { codec, layout } = context;
+	if (entry.manualId !== null) {
+		if (layout === "id") return entry.label === message.label ? "same" : "changed";
+		if (entry.source === message.canonical) return "same";
+		return canonicalOf(entry.source, codec) === message.canonical ? "same" : "changed";
+	}
+	const text = sourceText(entry, context);
+	if (text === null || text === message.canonical) return "same";
+	const canonical = canonicalOf(text, codec);
+	if (canonical === null || canonical === message.canonical) return "same";
+	return codec.label(canonical) === message.id ? "other" : "same";
+}
+/**
+* An entry's source text. `"id"`-layout targets only carry a translator
+* note, so the source locale's text for the same key wins when there is one.
+*/
+function sourceText(entry, context) {
+	if (context.sourceIndex !== null) {
+		const key = entry.manualId ?? entry.label;
+		const text = key === null ? void 0 : context.sourceIndex.get(key);
+		if (text !== void 0) return text;
+	}
+	return entry.source;
+}
+function sourceIndex(sourceCatalog, layout, isSource) {
+	if (layout !== "id" || isSource || sourceCatalog === null) return null;
+	const index = /* @__PURE__ */ new Map();
+	for (const entry of sourceCatalog.entries) {
+		if (entry.foreignContext !== null || entry.source === null) continue;
+		const key = entry.manualId ?? entry.label;
+		if (key !== null && !index.has(key)) index.set(key, entry.source);
+	}
+	return index;
+}
+/** The header with the scheme (and JSON source locale) a writer records; the same object when nothing changes. */
+function completeHeader(header, context, full) {
+	const { codec, layout, config } = context;
+	const idScheme = full || header.idScheme === null ? codec.idScheme : header.idScheme;
+	const sourceLocale = layout === "json" && (full || header.sourceLocale === null) ? config.sourceLocale : header.sourceLocale;
+	if (idScheme === header.idScheme && sourceLocale === header.sourceLocale) return header;
+	return {
+		...header,
+		idScheme,
+		sourceLocale
+	};
+}
+function schemeDiagnostic(recorded, codec) {
+	const old = parseIdScheme(recorded);
+	return {
+		code: "id-scheme-mismatch",
+		severity: "error",
+		message: `${old !== null ? `ids.length changed from ${old.length} to ${codec.idLength}` : `the catalog records id scheme ${JSON.stringify(recorded)}, not ${codec.idScheme}`}: run vi18n extract to re-key (until then this catalog is left untouched)`
+	};
+}
+function canonicalOf(source, codec) {
+	if (source === null) return null;
+	try {
+		return codec.canonicalize(source);
+	} catch (error) {
+		if (isDiagnosticError(error)) return null;
+		throw error;
+	}
+}
+/** Translated or `ai`: what the safety limit protects. */
+function hasTranslation(entry) {
+	return entry.translation !== "" && entry.state !== "untranslated";
+}
+function translatedCount(catalog) {
+	if (catalog === null) return 0;
+	let count = 0;
+	for (const entry of catalog.entries) if (entry.foreignContext === null && hasTranslation(entry)) count++;
+	return count;
+}
+/**
+* Whether writing `next` would change the file `read` came from. Serialising
+* compares content, not object identity, and the writer unwraps wrapped
+* strings, so a wrapped file changes even when its content does not.
+*/
+function wouldChange(read, next, isSourceLocale) {
+	if (read === null) return true;
+	if (read.entries.some((entry) => entry.wrapped)) return true;
+	if (next === read) return false;
+	const options = {
+		isSourceLocale,
+		version: VERSION
+	};
+	return !sameCatalogText(serializeCatalog(read, options), serializeCatalog(next, options));
+}
+function sameList(a, b) {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+	return true;
+}
+function compareText(a, b) {
+	return a < b ? -1 : a > b ? 1 : 0;
+}
+function displayPath(root, file) {
+	const rel = relative(root, file);
+	if (rel === "" || rel.startsWith("..") || isAbsolute(rel)) return file.split(sep).join("/");
+	return rel.split(sep).join("/");
+}
+//#endregion
+export { writeGenFile as a, genFileUpToDate as i, syncCatalogs as n, GEN_FILE as r, syncCatalog as t };