@ai-translate/apple 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1262 @@
+import * as path$1 from "node:path";
+import path from "node:path";
+import { convertPathToPattern, globby } from "globby";
+import { addressToJsonPointer } from "@ai-translate/core/address";
+import { applePrintfMessageFormat } from "@ai-translate/message-formats";
+import { randomUUID } from "node:crypto";
+import { promises } from "node:fs";
+import { digestValue } from "@ai-translate/core/hash";
+import { plainMessageFormat } from "@ai-translate/core/message-format";
+import { isPluralCategory, pluralCategoriesFor, sortPluralCategories } from "@ai-translate/core/plural";
+import { defineIntegration, findProjectFiles, isLocaleTag, readStringLiteral, resolveSourceLocale } from "@ai-translate/integrations";
+import ignore from "ignore";
+//#region src/files.ts
+const pendingWrites = /* @__PURE__ */ new Map();
+/** Serializes read/merge/write operations, including separate adapter instances. */
+async function withFileLock(filePath, operation) {
+	const key = path$1.resolve(filePath);
+	const current = (pendingWrites.get(key) ?? Promise.resolve()).catch(() => void 0).then(operation);
+	pendingWrites.set(key, current);
+	try {
+		return await current;
+	} finally {
+		if (pendingWrites.get(key) === current) pendingWrites.delete(key);
+	}
+}
+async function readText(filePath) {
+	try {
+		return await promises.readFile(filePath, "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return null;
+		throw error;
+	}
+}
+async function writeTextAtomic(filePath, contents) {
+	await promises.mkdir(path$1.dirname(filePath), { recursive: true });
+	const temporaryPath = path$1.join(path$1.dirname(filePath), `.${path$1.basename(filePath)}.${randomUUID()}`);
+	let mode;
+	try {
+		mode = (await promises.stat(filePath)).mode;
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+	let handle;
+	try {
+		handle = await promises.open(temporaryPath, "wx", mode);
+		await handle.writeFile(contents);
+		if (mode !== void 0) await handle.chmod(mode);
+		await handle.sync();
+		await handle.close();
+		handle = void 0;
+		await promises.rename(temporaryPath, filePath);
+	} finally {
+		await handle?.close();
+		await promises.rm(temporaryPath, { force: true });
+	}
+}
+//#endregion
+//#region src/xcstrings-model.ts
+function isObject(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function own(object, key) {
+	return Object.hasOwn(object, key) ? object[key] : void 0;
+}
+function put(object, key, value) {
+	Object.defineProperty(object, key, {
+		configurable: true,
+		enumerable: true,
+		value,
+		writable: true
+	});
+}
+function requireObject(value, location) {
+	if (!isObject(value)) throw new Error(`Invalid String Catalog at ${location}: expected an object.`);
+	return value;
+}
+function validateNode(value, location, requireFallback, depth = 0) {
+	if (depth > 64) throw new Error(`String Catalog localization nesting exceeds 64 levels at ${location}.`);
+	const node = requireObject(value, location);
+	if (node.stringUnit === void 0 && node.variations === void 0) throw new Error(`Unsupported String Catalog localization at ${location}: expected stringUnit or variations.`);
+	if (node.stringUnit !== void 0) {
+		const unit = requireObject(node.stringUnit, `${location}.stringUnit`);
+		if (typeof unit.value !== "string" || typeof unit.state !== "string") throw new Error(`Invalid String Catalog stringUnit at ${location}: value and state must be strings.`);
+	}
+	if (node.variations !== void 0) {
+		const variations = requireObject(node.variations, `${location}.variations`);
+		if (Object.keys(variations).length === 0) throw new Error(`Empty String Catalog variations at ${location}.`);
+		for (const [dimension, rawArms] of Object.entries(variations)) {
+			if (dimension !== "plural" && dimension !== "device") throw new Error(`Unsupported String Catalog variation "${dimension}" at ${location}.`);
+			const arms = requireObject(rawArms, `${location}.variations.${dimension}`);
+			if (requireFallback && !Object.hasOwn(arms, "other")) throw new Error(`String Catalog ${dimension} variation requires an other arm at ${location}.`);
+			for (const [arm, child] of Object.entries(arms)) {
+				if (dimension === "plural" && !isPluralCategory(arm)) throw new Error(`Invalid String Catalog plural category "${arm}" at ${location}.`);
+				validateNode(child, `${location}.variations.${dimension}.${arm}`, requireFallback, depth + 1);
+			}
+		}
+	}
+	if (node.substitutions !== void 0) {
+		const substitutions = requireObject(node.substitutions, `${location}.substitutions`);
+		for (const [name, rawSubstitution] of Object.entries(substitutions)) {
+			const substitution = requireObject(rawSubstitution, `${location}.substitutions.${name}`);
+			if (!Number.isSafeInteger(substitution.argNum) || substitution.argNum < 1 || typeof substitution.formatSpecifier !== "string" || substitution.formatSpecifier.length === 0) throw new Error(`Invalid String Catalog substitution "${name}" at ${location}: expected argNum and formatSpecifier.`);
+			validateNode(substitution, `${location}.substitutions.${name}`, requireFallback, depth + 1);
+		}
+	}
+}
+function parseCatalog(text, filePath, sourceLocale) {
+	let parsed;
+	try {
+		parsed = JSON.parse(text.replace(/^\uFEFF/u, ""));
+	} catch (error) {
+		throw new Error(`Invalid JSON in String Catalog ${filePath}.`, { cause: error });
+	}
+	const catalog = requireObject(parsed, filePath);
+	if (typeof catalog.version !== "string" || ![
+		"1.0",
+		"1.1",
+		"1.2",
+		"1.3"
+	].includes(catalog.version)) throw new Error(`Unsupported String Catalog version in ${filePath}: expected "1.0", "1.1", "1.2", or "1.3".`);
+	if (catalog.sourceLanguage !== sourceLocale) throw new Error(`String Catalog ${filePath} sourceLanguage must match sourceLocale "${sourceLocale}".`);
+	const strings = requireObject(catalog.strings, `${filePath}.strings`);
+	for (const [key, rawString] of Object.entries(strings)) {
+		const string = requireObject(rawString, `${filePath}.strings[${JSON.stringify(key)}]`);
+		if (string.shouldTranslate !== void 0 && typeof string.shouldTranslate !== "boolean") throw new Error(`Invalid shouldTranslate for String Catalog key ${JSON.stringify(key)} in ${filePath}.`);
+		if (string.comment !== void 0 && typeof string.comment !== "string") throw new Error(`Invalid comment for String Catalog key ${JSON.stringify(key)} in ${filePath}.`);
+		if (string.localizations !== void 0) {
+			const localizations = requireObject(string.localizations, `${filePath}.${key}.localizations`);
+			for (const [locale, localization] of Object.entries(localizations)) validateNode(localization, `${filePath}.${key}.localizations.${locale}`, locale === sourceLocale);
+		}
+	}
+	return catalog;
+}
+function isTranslatable(key, string) {
+	return key.length > 0 && string.shouldTranslate !== false && string.extractionState !== "stale";
+}
+function localeRoots(catalog, locale) {
+	return Object.fromEntries(Object.entries(catalog.strings).flatMap(([key, rawString]) => {
+		const string = rawString;
+		if (!isTranslatable(key, string)) return [];
+		const localizations = string.localizations;
+		const node = localizations === void 0 ? void 0 : own(localizations, locale);
+		if (node !== void 0) return [[key, structuredClone(node)]];
+		return locale === catalog.sourceLanguage ? [[key, { stringUnit: {
+			state: "translated",
+			value: key
+		} }]] : [];
+	}));
+}
+function fallbackNode(node) {
+	if (isObject(node.stringUnit)) {
+		const fallback = structuredClone(node);
+		delete fallback.variations;
+		return fallback;
+	}
+	for (const arms of Object.values(isObject(node.variations) ? node.variations : {})) if (isObject(arms) && isObject(arms.other)) return fallbackNode(arms.other);
+	throw new Error("String Catalog source variation requires a string fallback.");
+}
+function assertSourceSubstitutions(source, target, location) {
+	const sourceBindings = isObject(source.substitutions) ? source.substitutions : {};
+	const targetBindings = isObject(target?.substitutions) ? target.substitutions : {};
+	for (const name of Object.keys(targetBindings)) if (!Object.hasOwn(sourceBindings, name)) throw new Error(`Unsupported target-only String Catalog substitution ${JSON.stringify(name)} at ${location}. Define the corresponding substitution in the source localization before translating; its fragment meaning cannot be derived safely from flat source text.`);
+}
+function expandNode(node, locale, target, location = "localization") {
+	assertSourceSubstitutions(node, target, `${location} (${locale})`);
+	const expanded = structuredClone(node);
+	const sourceVariations = isObject(node.variations) ? node.variations : {};
+	const targetVariations = isObject(target?.variations) ? target.variations : {};
+	const dimensions = [.../* @__PURE__ */ new Set([...Object.keys(sourceVariations), ...Object.keys(targetVariations)])];
+	if (dimensions.length > 0) {
+		const variations = {};
+		for (const dimension of dimensions) {
+			const arms = own(sourceVariations, dimension) ?? {};
+			const targetArms = own(targetVariations, dimension) ?? {};
+			const present = [.../* @__PURE__ */ new Set([
+				...Object.keys(arms),
+				...Object.keys(targetArms),
+				"other"
+			])];
+			const categories = dimension === "plural" ? sortPluralCategories([.../* @__PURE__ */ new Set([...present, ...pluralCategoriesFor(locale)])]) : present;
+			const fallback = own(arms, "other") ?? fallbackNode(node);
+			put(variations, dimension, Object.fromEntries(categories.map((category) => [category, expandNode(own(arms, category) ?? fallback, locale, own(targetArms, category), `${location}.variations.${dimension}.${category}`)])));
+		}
+		expanded.variations = variations;
+		if (Object.keys(sourceVariations).length === 0 && target?.stringUnit === void 0) delete expanded.stringUnit;
+	}
+	if (isObject(node.substitutions)) expanded.substitutions = Object.fromEntries(Object.entries(node.substitutions).map(([name, substitution]) => [name, expandNode(substitution, locale, isObject(target?.substitutions) ? own(target.substitutions, name) : void 0, `${location}.substitutions.${name}`)]));
+	return expanded;
+}
+function substitutionBindings(node) {
+	return Object.fromEntries(Object.entries(isObject(node.substitutions) ? node.substitutions : {}).map(([name, substitution]) => {
+		const binding = substitution;
+		return [name, [binding.argNum ?? null, binding.formatSpecifier ?? null]];
+	}));
+}
+function visitUnits(node, keys, visit, inheritedBindings = {}) {
+	const bindings = {
+		...inheritedBindings,
+		...substitutionBindings(node)
+	};
+	if (isObject(node.stringUnit)) visit(node.stringUnit, [
+		...keys,
+		"stringUnit",
+		"value"
+	], bindings);
+	if (isObject(node.variations)) for (const [dimension, arms] of Object.entries(node.variations)) for (const [arm, child] of Object.entries(arms)) visitUnits(child, [
+		...keys,
+		"variations",
+		dimension,
+		arm
+	], visit, bindings);
+	if (isObject(node.substitutions)) for (const [name, substitution] of Object.entries(node.substitutions)) visitUnits(substitution, [
+		...keys,
+		"substitutions",
+		name
+	], visit, bindings);
+}
+function buildCatalogEntries(catalog, roots, source, plainTextKeys) {
+	const entries = [];
+	for (const [key, root] of Object.entries(roots)) {
+		const string = own(catalog.strings, key);
+		const format = plainTextKeys?.has(key) === true ? plainMessageFormat : applePrintfMessageFormat;
+		visitUnits(root, [key], (unit, keys, unitBindings) => {
+			const bindings = JSON.stringify(Object.fromEntries(Object.entries(unitBindings).toSorted(([left], [right]) => left.localeCompare(right))));
+			const address = keys.map((part) => ({
+				kind: "key",
+				key: part
+			}));
+			const notes = [`Apple string key: ${JSON.stringify(key)}`];
+			if (typeof string.comment === "string" && string.comment.length > 0) notes.push(string.comment);
+			if (bindings !== "{}") notes.push(`Apple substitution arguments: ${bindings}.`);
+			const groupKeys = [...keys];
+			let plural = false;
+			for (let index = 1; index < keys.length; index += 1) if (keys[index] === "variations") {
+				const dimension = keys[index + 1];
+				const arm = keys[index + 2];
+				notes.push(`${dimension === "plural" ? "Plural category" : "Device"}: ${arm ?? ""}.`);
+				if (dimension === "plural") {
+					groupKeys[index + 2] = "*";
+					plural = true;
+				}
+				index += 2;
+			} else if (keys[index] === "substitutions") {
+				notes.push(`Substitution: ${keys[index + 1] ?? ""}.`);
+				index += 1;
+			}
+			const value = source || unit.state === "translated" ? unit.value : null;
+			entries.push({
+				address,
+				context: { notes: notes.join("\n") },
+				messageFormatId: format.id,
+				meta: {
+					appleSubstitutionBindings: bindings,
+					...typeof string.comment === "string" ? { comment: string.comment } : {},
+					...bindings === "{}" ? {} : { structureSignature: bindings },
+					...plural ? { structureGroup: addressToJsonPointer(groupKeys.map((part) => ({
+						kind: "key",
+						key: part
+					}))) } : {}
+				},
+				policy: "translate",
+				storage: "string",
+				...value === null ? {} : { tokens: [...format.tokenize(value)] },
+				value
+			});
+		});
+	}
+	return entries;
+}
+function structureDigest(entries) {
+	return digestValue(JSON.stringify([...new Set(entries.map((entry) => entry.meta?.structureGroup ?? addressToJsonPointer(entry.address)))].toSorted((left, right) => String(left).localeCompare(String(right)))));
+}
+function entryValues(entries) {
+	return new Map(entries.flatMap((entry) => typeof entry.value === "string" ? [[addressToJsonPointer(entry.address), entry.value]] : []));
+}
+function pendingNode(node) {
+	const pending = structuredClone(node);
+	visitUnits(pending, [], (unit) => {
+		unit.state = "new";
+	});
+	return pending;
+}
+function assertUnchanged(current, original) {
+	if (JSON.stringify(current) !== JSON.stringify(original)) throw new Error("String Catalog translation structure changed before writing.");
+}
+/** Keep target metadata, but replace structural fields removed by the source. */
+function alignNode(node, template, original = {}) {
+	assertSourceSubstitutions(template, node, "target localization");
+	for (const field of [
+		"stringUnit",
+		"variations",
+		"substitutions"
+	]) if (template[field] === void 0 && node[field] !== void 0) {
+		assertUnchanged(node[field], original[field]);
+		delete node[field];
+	}
+	if (template.argNum !== void 0) {
+		for (const field of ["argNum", "formatSpecifier"]) if (node[field] !== template[field]) assertUnchanged(node[field], original[field]);
+		node.argNum = template.argNum;
+		node.formatSpecifier = template.formatSpecifier;
+	}
+	for (const field of ["variations", "substitutions"]) {
+		if (!isObject(template[field]) || !isObject(node[field])) continue;
+		const target = node[field];
+		const source = template[field];
+		const previous = isObject(original[field]) ? original[field] : {};
+		for (const [name, child] of Object.entries(target)) {
+			const sourceChild = own(source, name);
+			if (!isObject(sourceChild)) {
+				assertUnchanged(child, own(previous, name));
+				delete target[name];
+			} else if (isObject(child)) {
+				const originalChild = own(previous, name);
+				const previousChild = isObject(originalChild) ? originalChild : {};
+				if (field === "substitutions") alignNode(child, sourceChild, previousChild);
+				else for (const [arm, armNode] of Object.entries(child)) {
+					const sourceArm = own(sourceChild, arm);
+					const originalArm = own(previousChild, arm);
+					if (isObject(armNode) && isObject(sourceArm)) alignNode(armNode, sourceArm, isObject(originalArm) ? originalArm : {});
+				}
+			}
+		}
+	}
+}
+/** Sets one leaf without copying untranslated siblings from the source shape. */
+function setUnit(root, template, keys, value, state) {
+	if (keys.length < 3 || keys.at(-2) !== "stringUnit" || keys.at(-1) !== "value") throw new Error(`Invalid String Catalog entry address ${JSON.stringify(keys)}.`);
+	let node = root;
+	let source = template;
+	for (const key of keys.slice(0, -2)) {
+		const sourceChild = own(source, key);
+		if (!isObject(sourceChild)) throw new Error(`Cannot write unknown String Catalog entry ${JSON.stringify(keys)}.`);
+		if (!isObject(own(node, key))) put(node, key, sourceChild.stringUnit !== void 0 || sourceChild.variations !== void 0 ? pendingNode(sourceChild) : {});
+		node = own(node, key);
+		source = sourceChild;
+	}
+	const sourceUnit = source.stringUnit;
+	if (!isObject(sourceUnit)) throw new Error(`Cannot write unknown String Catalog stringUnit ${JSON.stringify(keys)}.`);
+	node.stringUnit = {
+		...sourceUnit,
+		...isObject(node.stringUnit) ? node.stringUnit : {},
+		state,
+		value
+	};
+}
+//#endregion
+//#region src/xcstrings.ts
+const IGNORE = [
+	"**/node_modules/**",
+	"**/.git/**",
+	"**/.build/**",
+	"**/build/**",
+	"**/DerivedData/**",
+	"**/Pods/**",
+	"**/Carthage/**",
+	"**/release/**",
+	"**/dist/**",
+	"**/.expo/**",
+	"**/.next/**",
+	"**/.turbo/**",
+	"**/coverage/**",
+	"**/*.xcarchive/**"
+];
+function loadedDocument(ref, state, source, plainTextKeys) {
+	const entries = buildCatalogEntries(state.catalog, state.roots, source, plainTextKeys);
+	return {
+		entries,
+		ref,
+		state,
+		structureDigest: structureDigest(entries)
+	};
+}
+function localizedRoots(sourceRoots, locale, targetRoots = {}) {
+	return Object.fromEntries(Object.entries(sourceRoots).map(([key, node]) => [key, expandNode(node, locale, own(targetRoots, key), `key ${JSON.stringify(key)}`)]));
+}
+function unitAt(roots, keys) {
+	let node = roots;
+	for (const key of keys.slice(0, -1)) node = isObject(node) ? own(node, key) : void 0;
+	return node;
+}
+/** Native Xcode catalogs: one physical file, independently reconciled locales. */
+function createAppleStringCatalog(options) {
+	const rootDir = path$1.resolve(options.rootDir);
+	const id = options.id ?? "apple-xcstrings";
+	const plainTextKeys = new Set(options.plainTextKeys);
+	function refFor(filePath, locale, unitId) {
+		return {
+			catalogId: id,
+			format: "xcstrings",
+			locale,
+			path: filePath,
+			unitId: unitId ?? path$1.relative(rootDir, filePath).split(path$1.sep).join("/").replace(/\.xcstrings$/u, "")
+		};
+	}
+	async function readCatalog(filePath) {
+		const text = await readText(filePath);
+		return text === null ? null : parseCatalog(text, filePath, options.sourceLocale);
+	}
+	const adapter = {
+		id,
+		messageFormats: [applePrintfMessageFormat],
+		createDocumentRef(sourceRef, locale) {
+			return refFor(sourceRef.path, locale, sourceRef.unitId);
+		},
+		async listDocumentRefs(locale) {
+			return (await globby([...options.include ?? ["**/*.xcstrings"]], {
+				absolute: true,
+				cwd: rootDir,
+				followSymbolicLinks: false,
+				ignore: IGNORE,
+				onlyFiles: true
+			})).toSorted().map((filePath) => refFor(filePath, locale));
+		},
+		async loadDocument(ref) {
+			const catalog = await readCatalog(ref.path);
+			if (catalog === null) return null;
+			const canonicalRoots = localeRoots(catalog, options.sourceLocale);
+			const sourceRoots = ref.locale === options.sourceLocale ? canonicalRoots : localizedRoots(canonicalRoots, ref.locale, localeRoots(catalog, ref.locale));
+			const roots = ref.locale === options.sourceLocale ? sourceRoots : localeRoots(catalog, ref.locale);
+			if (ref.locale !== options.sourceLocale && Object.keys(roots).length === 0 && Object.keys(canonicalRoots).length > 0) return null;
+			return loadedDocument(ref, {
+				catalog,
+				originalValues: entryValues(buildCatalogEntries(catalog, roots, ref.locale === options.sourceLocale, plainTextKeys)),
+				roots,
+				sourceRoots
+			}, ref.locale === options.sourceLocale, plainTextKeys);
+		},
+		localizeSourceDocument({ locale, source }) {
+			const sourceState = source.state;
+			const roots = localizedRoots(sourceState.sourceRoots, locale, localeRoots(sourceState.catalog, locale));
+			return Promise.resolve(loadedDocument(source.ref, {
+				...sourceState,
+				roots,
+				sourceRoots: roots
+			}, true, plainTextKeys));
+		},
+		reconcileDocument({ ref, source, target }) {
+			const sourceState = source.state;
+			const targetState = target?.state;
+			const targetEntries = new Map(target?.entries.map((entry) => [addressToJsonPointer(entry.address), entry]));
+			const values = entryValues(source.entries.flatMap((entry) => {
+				const existing = targetEntries.get(addressToJsonPointer(entry.address));
+				return existing?.meta?.structureSignature === entry.meta?.structureSignature && existing !== void 0 ? [existing] : [];
+			}));
+			const entries = source.entries.map((entry) => ({
+				...entry,
+				value: values.get(addressToJsonPointer(entry.address)) ?? null
+			}));
+			return Promise.resolve({
+				entries,
+				ref,
+				state: {
+					catalog: sourceState.catalog,
+					originalValues: values,
+					roots: targetState?.roots ?? {},
+					sourceRoots: sourceState.sourceRoots
+				},
+				structureDigest: structureDigest(entries)
+			});
+		},
+		createScaffoldDocument({ ref, source }) {
+			if (source.entries.length === 0) return Promise.resolve(null);
+			const sourceState = source.state;
+			const roots = localizedRoots(sourceState.roots, ref.locale);
+			return Promise.resolve(loadedDocument(ref, {
+				catalog: sourceState.catalog,
+				originalValues: /* @__PURE__ */ new Map(),
+				roots,
+				sourceRoots: roots,
+				writeState: "new"
+			}, true, plainTextKeys));
+		},
+		async scaffoldLocale(scaffoldOptions) {
+			const strategy = scaffoldOptions.strategy ?? "copy-source";
+			const refs = await adapter.listDocumentRefs(options.sourceLocale);
+			let createdDocuments = 0;
+			let skippedDocuments = 0;
+			const fromLocale = strategy === "copy-source" ? options.sourceLocale : scaffoldOptions.fromLocale ?? options.sourceLocale;
+			for (const sourceRef of refs) {
+				const targetRef = adapter.createDocumentRef(sourceRef, scaffoldOptions.locale);
+				if (strategy === "empty" || await adapter.loadDocument(targetRef) !== null) {
+					skippedDocuments += 1;
+					continue;
+				}
+				const source = await adapter.loadDocument(adapter.createDocumentRef(sourceRef, fromLocale));
+				if (source === null || source.entries.length === 0) {
+					skippedDocuments += 1;
+					continue;
+				}
+				const document = await adapter.createScaffoldDocument?.({
+					ref: targetRef,
+					source,
+					strategy
+				});
+				if (document !== void 0 && document !== null) {
+					await adapter.writeDocument(document);
+					createdDocuments += 1;
+				}
+			}
+			return {
+				catalogId: id,
+				createdDocuments,
+				locale: scaffoldOptions.locale,
+				skippedDocuments,
+				strategy
+			};
+		},
+		async writeDocument(document) {
+			if (document.ref.locale === options.sourceLocale) throw new Error(`Refusing to write the source locale "${options.sourceLocale}" in a String Catalog.`);
+			const state = document.state;
+			const changed = document.entries.filter((entry) => typeof entry.value === "string" && (state.writeState !== void 0 || entry.value !== state.originalValues.get(addressToJsonPointer(entry.address))));
+			if (changed.length === 0) return;
+			await withFileLock(document.ref.path, async () => {
+				const text = await readText(document.ref.path);
+				if (text === null) throw new Error(`String Catalog disappeared before writing: ${document.ref.path}.`);
+				const catalog = parseCatalog(text, document.ref.path, options.sourceLocale);
+				const targetRoots = localeRoots(catalog, document.ref.locale);
+				const originalTargets = structuredClone(targetRoots);
+				const existingKeys = new Set(Object.keys(targetRoots));
+				const originalSources = localeRoots(state.catalog, options.sourceLocale);
+				const currentSources = localeRoots(catalog, options.sourceLocale);
+				const aligned = /* @__PURE__ */ new Set();
+				let wrote = false;
+				for (const entry of changed) {
+					const keys = entry.address.map((segment) => {
+						if (segment.kind !== "key") throw new Error("String Catalog addresses must contain only object keys.");
+						return segment.key;
+					});
+					const key = keys[0];
+					const string = key === void 0 ? void 0 : own(catalog.strings, key);
+					if (key === void 0 || !isObject(string) || !isTranslatable(key, string)) throw new Error(`String Catalog source key changed before writing ${JSON.stringify(key)}.`);
+					if (state.writeState !== void 0 && existingKeys.has(key)) continue;
+					if (JSON.stringify(own(originalSources, key)) !== JSON.stringify(own(currentSources, key))) throw new Error(`String Catalog source changed before writing ${JSON.stringify(key)}.`);
+					if (!aligned.has(key)) {
+						const node = own(targetRoots, key);
+						const template = own(state.sourceRoots, key);
+						if (isObject(node) && isObject(template)) {
+							const original = own(state.roots, key);
+							alignNode(node, template, isObject(original) ? original : {});
+						}
+						aligned.add(key);
+					}
+					const currentUnit = unitAt(originalTargets, keys);
+					if (state.writeState === void 0 && JSON.stringify(currentUnit) !== JSON.stringify(unitAt(state.roots, keys)) && (!isObject(currentUnit) || currentUnit.value !== entry.value)) throw new Error(`String Catalog translation changed before writing ${JSON.stringify(keys)}.`);
+					setUnit(targetRoots, state.sourceRoots, keys, entry.value, state.writeState ?? "translated");
+					wrote = true;
+				}
+				if (!wrote) return;
+				for (const [key, target] of Object.entries(targetRoots)) {
+					const string = own(catalog.strings, key);
+					if (!isObject(string.localizations)) string.localizations = {};
+					put(string.localizations, document.ref.locale, target);
+				}
+				const next = `${text.startsWith("") ? "" : ""}${JSON.stringify(catalog, null, 2)}\n`;
+				if (next !== text) await writeTextAtomic(document.ref.path, next);
+			});
+		}
+	};
+	return adapter;
+}
+//#endregion
+//#region src/strings-parser.ts
+const ESCAPES = {
+	a: "\x07",
+	b: "\b",
+	f: "\f",
+	n: "\n",
+	r: "\r",
+	t: "	",
+	v: "\v",
+	"\"": "\"",
+	"'": "'",
+	"\\": "\\",
+	"?": "?"
+};
+const NEXTSTEP_HIGH = "\xA0ÀÁÂÃÄÅÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖÙÚÛÜÝÞµ×÷©¡¢£⁄¥ƒ§¤’“«‹›fifl®–†‡·¦¶•‚„”»…‰¬¿¹ˋ´ˆ˜¯˘˙¨²˚¸³˝˛ˇ—±¼½¾àáâãäåçèéêëìÆíªîïðñŁØŒºòóôõöæùúûıüýłøœßþÿ";
+/** Parse Apple's textual property-list syntax while retaining source spans. */
+function parseStrings(text, label = ".strings") {
+	const records = [];
+	const keys = /* @__PURE__ */ new Set();
+	let position = 0;
+	function fail(message) {
+		const line = text.slice(0, position).split(/\r\n|[\r\n]/u).length;
+		throw new Error(`${label}:${String(line)}: ${message}`);
+	}
+	function trivia() {
+		const comments = [];
+		while (position < text.length) if (/[ \t\r\n\f\v\u2028\u2029]/u.test(text[position] ?? "")) position += 1;
+		else if (text.startsWith("//", position)) {
+			const end = /[\r\n\u2028\u2029]/u.exec(text.slice(position + 2));
+			const next = end === null ? text.length : position + 2 + end.index;
+			comments.push(text.slice(position + 2, next).trim());
+			position = next;
+		} else if (text.startsWith("/*", position)) {
+			const end = text.indexOf("*/", position + 2);
+			if (end < 0) fail("Unterminated comment.");
+			comments.push(text.slice(position + 2, end).trim());
+			position = end + 2;
+		} else break;
+		return comments.filter(Boolean).join("\n");
+	}
+	function string() {
+		const quote = text[position];
+		if (quote !== "\"" && quote !== "'") {
+			const bare = /^[A-Za-z0-9_.$/:-]+/u.exec(text.slice(position));
+			if (bare === null) fail("Expected a quoted string or property-list identifier.");
+			position += bare[0].length;
+			return bare[0];
+		}
+		position += 1;
+		let value = "";
+		while (position < text.length) {
+			const character = text[position++];
+			if (character === quote) return value;
+			if (character !== "\\") {
+				value += character;
+				continue;
+			}
+			const escaped = text[position++];
+			if (escaped === void 0) fail("Unterminated escape sequence.");
+			if (escaped === "U") {
+				const hexadecimal = /^[\da-fA-F]{1,4}/u.exec(text.slice(position))?.[0];
+				if (hexadecimal === void 0) fail("Expected hexadecimal digits after a Unicode escape.");
+				value += String.fromCharCode(Number.parseInt(hexadecimal, 16));
+				position += hexadecimal.length;
+			} else if (/[0-7]/u.test(escaped)) {
+				const suffix = /^[0-7]{0,2}/u.exec(text.slice(position))?.[0] ?? "";
+				const byte = Number.parseInt(escaped + suffix, 8) % 256;
+				if (byte >= 254) fail("Undefined NEXTSTEP octal escape.");
+				value += byte < 128 ? String.fromCharCode(byte) : NEXTSTEP_HIGH[byte - 128];
+				position += suffix.length;
+			} else value += ESCAPES[escaped] ?? escaped;
+		}
+		return fail("Unterminated quoted string.");
+	}
+	const heading = trivia();
+	const wrapped = text[position] === "{";
+	if (wrapped) position += 1;
+	else position = 0;
+	let insertionPoint;
+	while (position < text.length) {
+		const start = position;
+		const comment = [wrapped && records.length === 0 ? heading : "", trivia()].filter(Boolean).join("\n");
+		if (wrapped && text[position] === "}") {
+			insertionPoint = start;
+			position += 1;
+			trivia();
+			if (position !== text.length) fail("Unexpected content after the closing dictionary brace.");
+			break;
+		}
+		if (position === text.length) break;
+		const key = string();
+		if (keys.has(key)) fail(`Duplicate key ${JSON.stringify(key)}.`);
+		keys.add(key);
+		const keyEnd = position;
+		trivia();
+		const implicitValue = text[position] === ";";
+		let valueStart = keyEnd;
+		let valueEnd = keyEnd;
+		let value = key;
+		if (!implicitValue) {
+			if (text[position++] !== "=") fail("Expected '=' or ';' after key.");
+			trivia();
+			valueStart = position;
+			value = string();
+			valueEnd = position;
+			trivia();
+		}
+		if (text[position++] !== ";") fail("Expected ';' after value.");
+		records.push({
+			comment,
+			end: position,
+			...implicitValue ? { implicitValue: true } : {},
+			key,
+			start,
+			value,
+			valueEnd,
+			valueStart
+		});
+	}
+	if (wrapped && insertionPoint === void 0) fail("Expected '}' after dictionary entries.");
+	return {
+		...insertionPoint === void 0 ? {} : { insertionPoint },
+		records,
+		text
+	};
+}
+function quoteStrings(value) {
+	return `"${value.replace(/["\\\x00-\x1f\x7f]/gu, (character) => {
+		if (character === "\"" || character === "\\") return `\\${character}`;
+		const escape = {
+			"\n": "n",
+			"\r": "r",
+			"	": "t"
+		}[character];
+		return escape === void 0 ? `\\U${character.charCodeAt(0).toString(16).padStart(4, "0")}` : `\\${escape}`;
+	})}"`;
+}
+/** Replace only value spans, preserving comments, whitespace, and unknown keys. */
+function renderStrings(table, values, templates) {
+	const insertionPoint = table.insertionPoint ?? table.text.length;
+	let text = table.text.slice(0, insertionPoint);
+	const suffix = table.text.slice(insertionPoint);
+	const replacement = (record, value) => record.implicitValue === true ? value === record.value ? "" : ` = ${quoteStrings(value)}` : quoteStrings(value);
+	const known = new Set(table.records.map((record) => record.key));
+	for (const record of table.records.toReversed()) {
+		const value = values.get(record.key);
+		if (value !== void 0 && value !== record.value) text = text.slice(0, record.valueStart) + replacement(record, value) + text.slice(record.valueEnd);
+	}
+	const source = new Map(templates.records.map((record) => [record.key, record]));
+	for (const [key, value] of values) {
+		if (known.has(key)) continue;
+		const record = source.get(key);
+		const addition = record === void 0 ? `${quoteStrings(key)} = ${quoteStrings(value)};` : templates.text.slice(record.start, record.valueStart) + replacement(record, value) + templates.text.slice(record.valueEnd, record.end);
+		text += `${text.length > 0 && !text.endsWith("\n") ? "\n" : ""}${addition.startsWith("\n") || text.length === 0 ? "" : "\n"}${addition}\n`;
+	}
+	return text + suffix;
+}
+function decodeStrings(buffer) {
+	const encoding = buffer[0] === 255 && buffer[1] === 254 ? "utf16le" : buffer[0] === 254 && buffer[1] === 255 ? "utf16be" : buffer[0] === 239 && buffer[1] === 187 && buffer[2] === 191 ? "utf8-bom" : "utf8";
+	return {
+		encoding,
+		text: new TextDecoder(encoding === "utf16le" ? "utf-16le" : encoding === "utf16be" ? "utf-16be" : "utf-8", { fatal: true }).decode(buffer)
+	};
+}
+function encodeStrings(text, encoding) {
+	if (encoding === "utf8") return Buffer.from(text, "utf8");
+	if (encoding === "utf8-bom") return Buffer.concat([Buffer.from([
+		239,
+		187,
+		191
+	]), Buffer.from(text, "utf8")]);
+	const body = Buffer.from(text, "utf16le");
+	if (encoding === "utf16be") body.swap16();
+	return Buffer.concat([Buffer.from(encoding === "utf16le" ? [255, 254] : [254, 255]), body]);
+}
+//#endregion
+//#region src/strings.ts
+function segment(value, name) {
+	if (!/^[A-Za-z0-9][A-Za-z0-9_.-]*$/u.test(value) || value === "." || value === "..") throw new Error(`Invalid ${name}: ${JSON.stringify(value)}.`);
+	return value;
+}
+function unit(value) {
+	if (path.isAbsolute(value) || value.includes("\\") || value.split("/").some((part) => part === ".." || part === "." || part === "") || !value.endsWith(".strings")) throw new Error(`Invalid Apple strings unit: ${JSON.stringify(value)}.`);
+	return value;
+}
+async function readTable(filePath) {
+	try {
+		const decoded = decodeStrings(await promises.readFile(filePath));
+		return {
+			...parseStrings(decoded.text, filePath),
+			encoding: decoded.encoding
+		};
+	} catch (error) {
+		if (error.code === "ENOENT") return null;
+		throw error;
+	}
+}
+function entry(record, value, plainTextKeys) {
+	const format = plainTextKeys.has(record.key) ? plainMessageFormat : applePrintfMessageFormat;
+	return {
+		address: [{
+			kind: "key",
+			key: record.key
+		}],
+		...record.comment.length === 0 ? {} : { context: { notes: record.comment } },
+		messageFormatId: format.id,
+		policy: "translate",
+		storage: "string",
+		tokens: value === null ? [] : [...format.tokenize(value)],
+		value
+	};
+}
+function document(ref, state, entries) {
+	return {
+		entries,
+		ref,
+		state,
+		structureDigest: digestValue(JSON.stringify(entries.map((item) => item.address)))
+	};
+}
+/** Translate .lproj tables without replacing comments or unrelated translations. */
+function createAppleStringsCatalog(options) {
+	const id = options.id ?? "apple-strings";
+	const root = path.resolve(options.rootDir);
+	const plainTextKeys = new Set(options.plainTextKeys);
+	segment(options.sourceLocale, "source locale");
+	const sourceDirectory = segment(options.sourceLocaleDirectory ?? `${options.sourceLocale}.lproj`, "source locale directory");
+	const includes = typeof options.include === "string" ? [options.include] : [...options.include ?? ["**/*.strings"]];
+	for (const include of includes) {
+		const literalEscapesRemoved = include.replace(/\\[!()[\]{}*?+@]/gu, "_");
+		if (path.isAbsolute(include) || literalEscapesRemoved.includes("\\") || include.split("/").includes("..")) throw new Error(`Invalid Apple strings include: ${JSON.stringify(include)}.`);
+	}
+	function file(locale, unitId) {
+		const directory = locale === options.sourceLocale ? sourceDirectory : `${segment(locale, "locale")}.lproj`;
+		return path.join(root, directory, unit(unitId));
+	}
+	async function checkWithinRoot(filePath) {
+		const relative = path.relative(root, path.resolve(filePath));
+		if (relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) return;
+		const realRoot = await promises.realpath(root);
+		let existing = filePath;
+		for (;;) try {
+			const actual = await promises.realpath(existing);
+			const remainder = path.relative(realRoot, actual);
+			if (remainder === ".." || remainder.startsWith(`..${path.sep}`) || path.isAbsolute(remainder)) throw new Error(`Apple strings path escapes rootDir: ${filePath}.`);
+			return;
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+			const parent = path.dirname(existing);
+			if (parent === existing) throw error;
+			existing = parent;
+		}
+	}
+	const adapter = {
+		id,
+		messageFormats: [applePrintfMessageFormat],
+		createDocumentRef(sourceRef, locale) {
+			return {
+				catalogId: id,
+				format: "apple-strings",
+				locale,
+				path: file(locale, sourceRef.unitId),
+				unitId: sourceRef.unitId
+			};
+		},
+		createScaffoldDocument({ ref, source }) {
+			return Promise.resolve({
+				...source,
+				ref,
+				state: {
+					...source.state,
+					scaffold: true
+				}
+			});
+		},
+		async listDocumentRefs(locale) {
+			const directory = locale === options.sourceLocale ? sourceDirectory : `${segment(locale, "locale")}.lproj`;
+			const files = await globby(includes, {
+				cwd: path.join(root, directory),
+				followSymbolicLinks: false,
+				onlyFiles: true
+			});
+			const refs = [];
+			for (const unitId of files.toSorted()) {
+				const filePath = file(locale, unitId);
+				await checkWithinRoot(filePath);
+				refs.push({
+					catalogId: id,
+					format: "apple-strings",
+					locale,
+					path: filePath,
+					unitId
+				});
+			}
+			return refs;
+		},
+		async loadDocument(ref) {
+			unit(ref.unitId);
+			await checkWithinRoot(ref.path);
+			const table = await readTable(ref.path);
+			if (table === null) return null;
+			const sourcePath = file(options.sourceLocale, ref.unitId);
+			await checkWithinRoot(sourcePath);
+			const templates = ref.locale === options.sourceLocale ? table : await readTable(sourcePath) ?? table;
+			const sourceRecords = new Map(templates.records.map((record) => [record.key, record]));
+			const entries = table.records.flatMap((record) => {
+				const source = sourceRecords.get(record.key);
+				return source === void 0 ? [] : [entry(source, record.value, plainTextKeys)];
+			});
+			return document(ref, {
+				encoding: table.encoding,
+				table,
+				templates
+			}, entries);
+		},
+		reconcileDocument({ ref, source, target }) {
+			const sourceState = source.state;
+			const targetState = target?.state;
+			const values = new Map(target?.entries.map((item) => [item.address[0]?.kind === "key" ? item.address[0].key : "", item.value]));
+			const entries = sourceState.table.records.map((record) => entry(record, typeof values.get(record.key) === "string" ? values.get(record.key) : null, plainTextKeys));
+			return Promise.resolve(document(ref, {
+				encoding: targetState?.encoding ?? sourceState.encoding,
+				table: targetState?.table ?? {
+					records: [],
+					text: ""
+				},
+				templates: sourceState.table
+			}, entries));
+		},
+		async scaffoldLocale(scaffold) {
+			const strategy = scaffold.strategy ?? "copy-source";
+			const from = strategy === "copy-source" ? options.sourceLocale : scaffold.fromLocale ?? options.sourceLocale;
+			const refs = await adapter.listDocumentRefs(from);
+			let createdDocuments = 0;
+			let skippedDocuments = 0;
+			for (const ref of refs) {
+				const target = adapter.createDocumentRef(ref, scaffold.locale);
+				if (strategy === "empty") {
+					skippedDocuments += 1;
+					continue;
+				}
+				await checkWithinRoot(target.path);
+				await withFileLock(target.path, async () => {
+					if (await readTable(target.path) !== null) {
+						skippedDocuments += 1;
+						return;
+					}
+					const contents = await promises.readFile(ref.path);
+					await writeTextAtomic(target.path, contents);
+					createdDocuments += 1;
+				});
+			}
+			return {
+				catalogId: id,
+				createdDocuments,
+				locale: scaffold.locale,
+				skippedDocuments,
+				strategy
+			};
+		},
+		async writeDocument(next) {
+			await checkWithinRoot(next.ref.path);
+			const state = next.state;
+			const originalValues = new Map(state.table.records.map(({ key, value }) => [key, value]));
+			const values = /* @__PURE__ */ new Map();
+			for (const item of next.entries) {
+				const address = item.address[0];
+				if (item.address.length !== 1 || address?.kind !== "key") throw new Error("Invalid Apple strings entry address.");
+				if (typeof item.value === "string" && (state.scaffold === true || item.value !== originalValues.get(address.key))) values.set(address.key, item.value);
+			}
+			if (values.size === 0 && state.scaffold !== true) return;
+			await withFileLock(next.ref.path, async () => {
+				const current = await readTable(next.ref.path);
+				if (state.scaffold === true && current !== null) return;
+				const currentValues = new Map(current?.records.map(({ key, value }) => [key, value]));
+				for (const [key, value] of values) {
+					const currentValue = currentValues.get(key);
+					if (state.scaffold !== true && currentValue !== originalValues.get(key) && currentValue !== value) throw new Error(`Apple strings translation changed before writing ${JSON.stringify(key)}.`);
+				}
+				const text = renderStrings(current ?? state.table, values, state.templates);
+				await writeTextAtomic(next.ref.path, encodeStrings(text, current?.encoding ?? state.encoding));
+			});
+		}
+	};
+	return adapter;
+}
+//#endregion
+//#region src/integration.ts
+const APPLE_INTEGRATION_ID = "apple";
+function record(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function readCatalogMetadata(context, file) {
+	try {
+		const text = (await context.readFile(file) ?? "").replace(/^\uFEFF/u, "");
+		const parsed = JSON.parse(text);
+		if (!record(parsed) || typeof parsed.sourceLanguage !== "string" || !isLocaleTag(parsed.sourceLanguage) || !record(parsed.strings)) return null;
+		parseCatalog(text, file, parsed.sourceLanguage);
+		const locales = /* @__PURE__ */ new Set();
+		for (const entry of Object.values(parsed.strings)) if (record(entry) && record(entry.localizations)) {
+			for (const locale of Object.keys(entry.localizations)) if (isLocaleTag(locale)) locales.add(locale);
+		}
+		return {
+			file,
+			locales: [...locales],
+			sourceLocale: parsed.sourceLanguage
+		};
+	} catch {
+		return null;
+	}
+}
+function inside(file, root) {
+	return root === "." || file === root || file.startsWith(`${root}/`);
+}
+function localeIdentity(locale) {
+	return Intl.getCanonicalLocales(locale)[0]?.toLowerCase() ?? locale.toLowerCase();
+}
+/** A single configured locale must address one physical spelling everywhere.
+* Resource names take precedence over project metadata; conflicting resource
+* aliases require normalization before they can safely share a target. */
+function selectTargetLocales(resourceLocales, declaredLocales, sourceLocale, warnings) {
+	const source = localeIdentity(sourceLocale);
+	const spellings = /* @__PURE__ */ new Map();
+	for (const locale of resourceLocales) {
+		const identity = localeIdentity(locale);
+		if (identity === source) continue;
+		const names = spellings.get(identity) ?? /* @__PURE__ */ new Set();
+		names.add(locale);
+		spellings.set(identity, names);
+	}
+	const targets = /* @__PURE__ */ new Map();
+	for (const [identity, names] of spellings) {
+		const [locale] = names;
+		if (names.size > 1) warnings.push(`Locale spellings ${[...names].toSorted().join(", ")} identify the same language in existing resources. This language was omitted from targetLocales; normalize its resource names before syncing.`);
+		else if (locale !== void 0) targets.set(identity, locale);
+	}
+	for (const locale of declaredLocales) {
+		const identity = localeIdentity(locale);
+		if (identity !== source && !spellings.has(identity)) targets.set(identity, Intl.getCanonicalLocales(locale)[0] ?? locale);
+	}
+	return [...targets.values()].toSorted();
+}
+function commentsRemoved(source) {
+	let result = "";
+	let index = 0;
+	while (index < source.length) {
+		const start = index;
+		const quote = source[index];
+		if (quote === "\"" || quote === "'") {
+			index += 1;
+			while (index < source.length) {
+				const character = source[index++];
+				if (character === "\\") index += 1;
+				else if (character === quote) break;
+			}
+			result += source.slice(start, index);
+		} else if (source.startsWith("//", index)) {
+			while (index < source.length && !/[\r\n]/u.test(source[index] ?? "")) index += 1;
+			result += " ";
+		} else if (source.startsWith("/*", index)) {
+			let depth = 1;
+			index += 2;
+			while (index < source.length && depth > 0) if (source.startsWith("/*", index)) {
+				depth += 1;
+				index += 2;
+			} else if (source.startsWith("*/", index)) {
+				depth -= 1;
+				index += 2;
+			} else index += 1;
+			result += source.slice(start, index).replace(/[^\r\n]/gu, " ");
+		} else result += source[index++];
+	}
+	return result;
+}
+function projectMetadata(file, source) {
+	const tokens = [...commentsRemoved(source).matchAll(/"(?:\\.|[^"\\])*"|[A-Za-z_][A-Za-z0-9_-]*|[=;(),{}]/gu)].map(([token]) => token.replace(/^"|"$/gu, ""));
+	let sourceLocale;
+	const locales = [];
+	for (let index = 0; index < tokens.length; index += 1) {
+		if (tokens[index + 1] !== "=") continue;
+		if (tokens[index] === "developmentRegion" && tokens[index + 3] === ";") {
+			const value = tokens[index + 2];
+			if (value !== void 0 && isLocaleTag(value)) sourceLocale = value;
+		}
+		if (tokens[index] === "knownRegions" && tokens[index + 2] === "(") for (let cursor = index + 3; cursor < tokens.length && tokens[cursor] !== ")"; cursor += 1) {
+			const value = tokens[cursor];
+			if (value !== void 0 && isLocaleTag(value)) locales.push(value);
+		}
+	}
+	return {
+		file,
+		rootDir: path.posix.dirname(path.posix.dirname(file)),
+		sourceLocale,
+		locales
+	};
+}
+function nearestProjects(file, projects) {
+	const candidates = projects.filter((project) => inside(file, project.rootDir));
+	const depth = Math.max(-1, ...candidates.map((project) => project.rootDir === "." ? 0 : project.rootDir.split("/").length));
+	return candidates.filter((project) => (project.rootDir === "." ? 0 : project.rootDir.split("/").length) === depth);
+}
+async function expoDiscovery(context) {
+	const expoRoots = /* @__PURE__ */ new Set();
+	const rules = /* @__PURE__ */ new Map();
+	const ignored = (file) => {
+		let result = false;
+		for (const [root, matcher] of rules) {
+			if (!inside(file, root)) continue;
+			const relative = root === "." ? file : file.slice(root.length + 1);
+			if (relative.length === 0) continue;
+			const match = matcher.test(relative);
+			result = match.ignored || result && !match.unignored;
+		}
+		return result;
+	};
+	const generated = (file) => [...expoRoots].some((root) => inside(file, root === "." ? "ios" : `${root}/ios`)) && ignored(file);
+	const visit = async (directory) => {
+		if (generated(`${directory}/`)) return false;
+		const root = directory || ".";
+		const relative = (name) => root === "." ? name : `${root}/${name}`;
+		const [manifest, gitignore] = await Promise.all([context.readFile(relative("package.json")), context.readFile(relative(".gitignore"))]);
+		if (gitignore !== null) rules.set(root, ignore().add(gitignore));
+		try {
+			const parsed = JSON.parse((manifest ?? "").replace(/^\uFEFF/u, ""));
+			if (record(parsed) && [
+				"dependencies",
+				"devDependencies",
+				"peerDependencies",
+				"optionalDependencies"
+			].some((section) => record(parsed[section]) && Object.hasOwn(parsed[section], "expo"))) expoRoots.add(root);
+		} catch {}
+		return true;
+	};
+	await visit("");
+	return {
+		accept: (file) => !generated(file),
+		visit
+	};
+}
+function adapterPlan(factory, id, include) {
+	return {
+		factory: {
+			from: "@ai-translate/apple",
+			name: factory
+		},
+		kind: "adapter",
+		options: {
+			id,
+			rootDir: ".",
+			...include === void 0 ? {} : { include }
+		}
+	};
+}
+/** Native resources are shared by Swift, Objective-C, React Native and Expo
+* prebuild projects, so discovery follows authored resources rather than a UI framework. */
+const appleIntegration = defineIntegration({
+	async detect(context) {
+		const discovery = await expoDiscovery(context);
+		const files = await findProjectFiles(context, (file) => discovery.accept(file) && (file.endsWith(".xcstrings") || /(?:^|\/)project\.pbxproj$/u.test(file) || /(?:^|\/)Package\.swift$/u.test(file) || /\.lproj\/.+\.strings$/u.test(file)), (directory) => discovery.visit(directory));
+		const catalogFiles = files.filter((file) => file.endsWith(".xcstrings"));
+		const legacyFiles = files.filter((file) => file.endsWith(".strings"));
+		const projectFiles = files.filter((file) => file.endsWith("project.pbxproj"));
+		const packageFiles = files.filter((file) => file.endsWith("Package.swift"));
+		const projectSources = await Promise.all(projectFiles.map(async (file) => projectMetadata(file, await context.readFile(file) ?? "")));
+		const applePackages = (await Promise.all(packageFiles.map(async (file) => ({
+			file,
+			text: commentsRemoved(await context.readFile(file) ?? "")
+		})))).flatMap(({ file, text }) => {
+			const declared = readStringLiteral(text, "defaultLocalization");
+			const sourceLocale = declared !== null && isLocaleTag(declared) ? declared : void 0;
+			const code = text.replace(/"(?:\\.|[^"\\])*"/gu, "\"\"");
+			return sourceLocale !== void 0 || /\.(?:iOS|macOS|tvOS|watchOS|visionOS)\s*\(/u.test(code) ? [{
+				file,
+				rootDir: path.posix.dirname(file),
+				sourceLocale,
+				locales: []
+			}] : [];
+		});
+		const projects = [...projectSources, ...applePackages];
+		if (catalogFiles.length === 0 && legacyFiles.length === 0 && projectFiles.length === 0 && applePackages.length === 0) return null;
+		const warnings = [];
+		const metadata = (await Promise.all(catalogFiles.map((file) => readCatalogMetadata(context, file)))).filter((item) => item !== null);
+		for (const file of catalogFiles) if (!metadata.some((item) => item.file === file)) warnings.push(`Could not read a supported String Catalog or its source language from ${file}; repair its JSON, version, and localization structure, then re-run init.`);
+		const declaredSources = projects.flatMap(({ sourceLocale }) => sourceLocale === void 0 ? [] : [sourceLocale]);
+		const rootSources = projects.filter(({ rootDir }) => rootDir === ".").flatMap(({ sourceLocale }) => sourceLocale === void 0 ? [] : [sourceLocale]);
+		const legacyLocales = [...new Set(legacyFiles.flatMap((file) => {
+			const locale = /(?:^|\/)([^/]+)\.lproj\//u.exec(file)?.[1];
+			return locale !== void 0 && isLocaleTag(locale) ? [locale] : [];
+		}))];
+		const preferredSource = rootSources[0] ?? metadata[0]?.sourceLocale ?? declaredSources[0] ?? legacyLocales.find((locale) => localeIdentity(locale) === "en") ?? resolveSourceLocale(legacyLocales, null) ?? "en";
+		const sourceLocale = metadata.find((item) => localeIdentity(item.sourceLocale) === localeIdentity(preferredSource))?.sourceLocale ?? preferredSource;
+		if (metadata.length === 0 && declaredSources.length === 0) warnings.push(`No source language is declared; sourceLocale is provisionally "${sourceLocale}". Confirm it before syncing.`);
+		const matchingCatalogs = metadata.filter((item) => item.sourceLocale === sourceLocale);
+		for (const item of metadata.filter((catalog) => catalog.sourceLocale !== sourceLocale)) warnings.push(`${item.file} uses source language ${item.sourceLocale}; configure it separately from ${sourceLocale} catalogs.`);
+		for (const project of projects) if (project.sourceLocale !== void 0 && localeIdentity(project.sourceLocale) !== localeIdentity(sourceLocale)) warnings.push(`${project.file} declares source language ${project.sourceLocale}; configure its resources separately from ${sourceLocale} resources.`);
+		const resourceLanguages = new Set(matchingCatalogs.flatMap((item) => [...item.locales]));
+		const declaredLanguages = new Set(projects.filter((project) => project.sourceLocale !== void 0 && localeIdentity(project.sourceLocale) === localeIdentity(sourceLocale) || project.sourceLocale === void 0 && (project.rootDir === "." || matchingCatalogs.some((catalog) => nearestProjects(catalog.file, projects).includes(project)))).flatMap((project) => [...project.locales]));
+		const catalogs = [];
+		if (matchingCatalogs.length > 0) catalogs.push(adapterPlan("createAppleStringCatalog", "apple-catalogs", matchingCatalogs.map((item) => convertPathToPattern(item.file))));
+		const legacyRoots = /* @__PURE__ */ new Map();
+		for (const file of legacyFiles) {
+			const match = /^(?:(.*?)\/)?([^/]+)\.lproj\/(.+\.strings)$/u.exec(file);
+			if (match === null) continue;
+			const root = match[1] ?? ".";
+			const languages = legacyRoots.get(root) ?? /* @__PURE__ */ new Map();
+			const language = match[2] ?? "";
+			const tables = languages.get(language) ?? /* @__PURE__ */ new Set();
+			tables.add(match[3] ?? "");
+			languages.set(language, tables);
+			legacyRoots.set(root, languages);
+		}
+		for (const [rootDir, languages] of legacyRoots) {
+			for (const language of languages.keys()) if (language !== "Base" && !isLocaleTag(language)) warnings.push(`Unsupported locale directory ${rootDir}/${language}.lproj. Generated configs require BCP 47 language tags such as en or pt-BR; rename legacy aliases or configure these resources manually.`);
+			const owners = nearestProjects(rootDir, projects);
+			if (owners.some((project) => project.sourceLocale !== void 0 && localeIdentity(project.sourceLocale) !== localeIdentity(sourceLocale))) {
+				warnings.push(`Skipped ${rootDir} strings tables because their project declares a different source language. Run init from that project separately.`);
+				continue;
+			}
+			const sourceLanguages = [...languages.keys()].filter((locale) => isLocaleTag(locale) && localeIdentity(locale) === localeIdentity(sourceLocale));
+			if (sourceLanguages.length > 1) {
+				warnings.push(`Skipped ${rootDir} strings tables because ${sourceLanguages.join(", ")} are ambiguous spellings of source language ${sourceLocale}. Normalize these source directories before syncing.`);
+				continue;
+			}
+			const sourceLanguage = sourceLanguages[0];
+			const sourceDirectory = sourceLanguage !== void 0 ? `${sourceLanguage}.lproj` : languages.has("Base") ? "Base.lproj" : void 0;
+			if (sourceDirectory === void 0) {
+				warnings.push(`No ${sourceLocale}.lproj or Base.lproj strings table was found in ${rootDir}; add a source-language table before configuring legacy strings.`);
+				continue;
+			}
+			for (const language of languages.keys()) if (isLocaleTag(language)) resourceLanguages.add(language);
+			for (const owner of owners) for (const locale of owner.locales) declaredLanguages.add(locale);
+			const baseOnlyTables = [...languages.get("Base") ?? []].filter((table) => sourceLanguage === void 0 || !languages.get(sourceLanguage)?.has(table));
+			const mixed = sourceLanguage !== void 0 && baseOnlyTables.length > 0;
+			catalogs.push({
+				...adapterPlan("createAppleStringsCatalog", `apple-strings:${rootDir}`),
+				options: {
+					id: `apple-strings:${rootDir}`,
+					rootDir,
+					...sourceDirectory !== `${sourceLocale}.lproj` ? { sourceLocaleDirectory: sourceDirectory } : {},
+					include: [...languages.get(sourceLanguage ?? "Base") ?? []].map(convertPathToPattern)
+				}
+			});
+			if (mixed) catalogs.push({
+				...adapterPlan("createAppleStringsCatalog", `apple-strings:${rootDir}:Base`),
+				options: {
+					id: `apple-strings:${rootDir}:Base`,
+					rootDir,
+					sourceLocaleDirectory: "Base.lproj",
+					include: baseOnlyTables.map(convertPathToPattern)
+				}
+			});
+		}
+		const hasResources = catalogs.length > 0;
+		if (!hasResources) {
+			catalogs.push(adapterPlan("createAppleStringCatalog", "apple-catalogs", []));
+			warnings.push("No supported source localization resources were found. Create and populate an Xcode String Catalog (.xcstrings), or extract localized Swift strings with Xcode, then re-run init to select the authored files before syncing. Hardcoded strings are not extracted by ai-translate.");
+		}
+		const targetLocales = selectTargetLocales(resourceLanguages, declaredLanguages, sourceLocale, warnings);
+		if (targetLocales.length === 0) warnings.push("No target languages were found. Add the languages your app supports to targetLocales before syncing.");
+		const evidence = [
+			...matchingCatalogs.map((item) => ({
+				detail: `Xcode String Catalog with source language ${item.sourceLocale}`,
+				source: item.file
+			})),
+			...projectSources.map(({ file }) => ({
+				detail: "Xcode project",
+				source: file
+			})),
+			...applePackages.map(({ file }) => ({
+				detail: "Swift package with Apple platform support",
+				source: file
+			})),
+			...legacyFiles.length === 0 ? [] : [{
+				detail: `${String(legacyFiles.length)} localized strings table(s)`,
+				source: legacyFiles[0] ?? "."
+			}]
+		];
+		const [catalog, ...additionalCatalogs] = catalogs;
+		if (catalog === void 0) return null;
+		return {
+			confidence: hasResources ? .98 : .6,
+			displayName: "Apple localization",
+			evidence,
+			integrationId: APPLE_INTEGRATION_ID,
+			plan: {
+				catalog,
+				...additionalCatalogs.length === 0 ? {} : { additionalCatalogs },
+				messageFormat: "plain",
+				sourceLocale,
+				targetLocales,
+				warnings
+			}
+		};
+	},
+	displayName: "Apple localization (Xcode and Swift packages)",
+	id: APPLE_INTEGRATION_ID
+});
+//#endregion
+export { appleIntegration, createAppleStringCatalog, createAppleStringsCatalog };
+
+//# sourceMappingURL=index.mjs.map