@verbatra/sdk 0.9.3 → 0.10.0

package/dist/index.js

@@ -1,4 +1,4 @@
-import { dirname, resolve, join, basename, relative, isAbsolute, sep, extname } from 'path';
+import { dirname, resolve, join, basename, extname, relative, isAbsolute, sep } from 'path';
 import { z } from 'zod';
 import { randomUUID } from 'crypto';
 import { mkdir, rm, access, open, writeFile, rename } from 'fs/promises';
@@ -12,8 +12,8 @@ import * as deepl from 'deepl-node';
 import log from 'loglevel';
 import { GoogleGenAI } from '@google/genai';
 import OpenAI from 'openai';
+import { XMLSerializer, DOMParser, DOMImplementation } from '@xmldom/xmldom';
 import { parse, TYPE } from '@formatjs/icu-messageformat-parser';
-import { XMLSerializer, DOMParser } from '@xmldom/xmldom';
 import { stringify, parse as parse$1 } from 'yaml';
 import ExcelJS from 'exceljs';
 import JSZip from 'jszip';
@@ -268,9 +268,20 @@ var defaultFs = {
     await mkdir(path, { recursive: true });
   }
 };
+
+// src/locale-path/shared-catalogue-format.ts
+var SHARED_CATALOGUE_FORMATS = /* @__PURE__ */ new Set([
+  "apple-xcstrings"
+]);
+function isSharedCatalogueFormat(format) {
+  return SHARED_CATALOGUE_FORMATS.has(format);
+}
+
+// src/lock/locale-write-lock.ts
 var LOCAL_DIR_NAME = ".verbatra-local";
 var LOCK_FILE_GUARD_STEM = "_lockfile";
 var GLOSSARY_GUARD_STEM = "_glossary";
+var SHARED_CATALOGUE_STEM = "_catalogue";
 var DEFAULT_POLL_INTERVAL_MS = 100;
 var DEFAULT_ACQUIRE_TIMEOUT_MS = 10 * 6e4;
 var WAIT_NOTICE_INTERVAL_MS = 1e3;
@@ -281,6 +292,9 @@ function lockPath(cwd, stem) {
 function localeLockPath(cwd, locale) {
   return lockPath(cwd, locale);
 }
+function writeLockKeyFor(format, locale) {
+  return isSharedCatalogueFormat(format) ? SHARED_CATALOGUE_STEM : locale;
+}
 function lockFileGuardPath(cwd) {
   return lockPath(cwd, LOCK_FILE_GUARD_STEM);
 }
@@ -643,7 +657,11 @@ var SUPPORTED_FORMATS = [
   "xliff",
   "yaml",
   "arb",
-  "properties"
+  "properties",
+  "apple-strings",
+  "apple-xcstrings",
+  "android-xml",
+  "gettext-po"
 ];
 var supportedFormatSchema = z.enum(SUPPORTED_FORMATS);
 var translationEntrySchema = z.object({
@@ -1344,7 +1362,8 @@ var PROVIDER_ENV = {
   anthropic: "ANTHROPIC_API_KEY",
   openai: "OPENAI_API_KEY",
   gemini: "GEMINI_API_KEY",
-  deepl: "DEEPL_API_KEY"
+  deepl: "DEEPL_API_KEY",
+  "google-translate": "GOOGLE_TRANSLATE_API_KEY"
 };
 function readRequiredEnv(name) {
   const value = process.env[name];
@@ -1365,6 +1384,9 @@ function requireGeminiKey() {
 function requireDeepLKey() {
   return readRequiredEnv(PROVIDER_ENV.deepl);
 }
+function requireGoogleTranslateKey() {
+  return readRequiredEnv(PROVIDER_ENV["google-translate"]);
+}
 var OPENAI_COMPATIBLE_ENV_VAR = "OPENAI_COMPATIBLE_API_KEY";
 var OPENAI_COMPATIBLE_KEY_PLACEHOLDER = "local";
 function resolveOpenAiCompatibleKey(customEnvVar) {
@@ -1905,11 +1927,287 @@ function createMechanism2(client, config) {
     }
   };
 }
+var googleTranslateConfigSchema = z.object({}).extend(requestTimeoutConfigSchema.shape);
+var GOOGLE_TRANSLATE_ENDPOINT = "https://translation.googleapis.com/language/translate/v2";
+var GOOGLE_TRANSLATE_ENDPOINT_HOST = "translation.googleapis.com";
+async function parseJsonBody(response) {
+  try {
+    return await response.json();
+  } catch {
+    return void 0;
+  }
+}
+function createDefaultClient4() {
+  const apiKey = requireGoogleTranslateKey();
+  const client = {
+    translate: async (texts, sourceLang, targetLang, signal) => {
+      const response = await fetch(
+        `${GOOGLE_TRANSLATE_ENDPOINT}?key=${encodeURIComponent(apiKey)}`,
+        {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({
+            q: texts,
+            source: sourceLang,
+            target: targetLang,
+            format: "text"
+          }),
+          signal
+        }
+      );
+      return { status: response.status, body: await parseJsonBody(response) };
+    }
+  };
+  return { client };
+}
+var GOOGLE_TRANSLATE_MAX_REQUEST_BYTES = 100 * 1024;
+var GOOGLE_TRANSLATE_PAYLOAD_OVERHEAD_RESERVE_BYTES = 2 * 1024;
+var GOOGLE_TRANSLATE_MAX_TEXT_PAYLOAD_BYTES = GOOGLE_TRANSLATE_MAX_REQUEST_BYTES - GOOGLE_TRANSLATE_PAYLOAD_OVERHEAD_RESERVE_BYTES;
+var textEncoder = new TextEncoder();
+function estimateJsonBytes(text) {
+  return textEncoder.encode(JSON.stringify(text)).length;
+}
+function chunkTextsForGoogleTranslate(texts) {
+  const chunks = [];
+  let current = [];
+  let currentBytes = 0;
+  for (const text of texts) {
+    const textBytes = estimateJsonBytes(text);
+    const startsNewChunk = current.length > 0 && currentBytes + textBytes > GOOGLE_TRANSLATE_MAX_TEXT_PAYLOAD_BYTES;
+    if (startsNewChunk) {
+      chunks.push(current);
+      current = [];
+      currentBytes = 0;
+    }
+    current.push(text);
+    currentBytes += textBytes;
+  }
+  if (current.length > 0) {
+    chunks.push(current);
+  }
+  return chunks;
+}
+var BCP47_LIKE = /^[A-Za-z]{2,3}(-[A-Za-z0-9]{2,8})*$/;
+function assertValidGoogleTranslateLocale(locale, role) {
+  if (!BCP47_LIKE.test(locale)) {
+    throw new ProviderError(
+      "INVALID_REQUEST",
+      `Google Cloud Translation does not accept "${locale}" as a ${role} locale code. Use a well-formed BCP-47 language code (for example, "en" or "pt-BR").`
+    );
+  }
+}
+var PLACEHOLDER_UNSUPPORTED_MESSAGE2 = "Some entries contain placeholders or ICU syntax that Google Cloud Translation cannot preserve; they were left untranslated. Use an LLM provider to translate placeholder-bearing strings.";
+function partitionByPlaceholders2(entries) {
+  const protectable = [];
+  const unprotectable = [];
+  for (const entry of entries) {
+    if (entry.placeholders.length > 0) {
+      unprotectable.push(entry);
+    } else {
+      protectable.push(entry);
+    }
+  }
+  return { protectable, unprotectable };
+}
+var FORMALITY_DOWNGRADED_MESSAGE2 = "Formality was not applied: Cloud Translation Basic (v2) has no formality control.";
+var GLOSSARY_IGNORED_MESSAGE2 = "The supplied glossary term map was not applied: Cloud Translation Basic (v2) does not support a glossary.";
+function buildTranslateNotices(input) {
+  const notices = [];
+  if (input.tone === "formal" || input.tone === "informal") {
+    notices.push({ code: "FORMALITY_DOWNGRADED", message: FORMALITY_DOWNGRADED_MESSAGE2 });
+  }
+  if (input.genericGlossarySupplied) {
+    notices.push({ code: "GLOSSARY_IGNORED", message: GLOSSARY_IGNORED_MESSAGE2 });
+  }
+  return notices;
+}
+var successSchema = z.object({
+  data: z.object({
+    translations: z.array(z.object({ translatedText: z.string() }))
+  })
+});
+var errorDetailSchema = z.object({
+  reason: z.string().optional()
+});
+var errorSchema = z.object({
+  error: z.object({
+    errors: z.array(errorDetailSchema).optional()
+  })
+});
+var QUOTA_REASONS = /* @__PURE__ */ new Set([
+  "dailyLimitExceeded",
+  "dailyLimitExceededUnreg",
+  "userRateLimitExceeded",
+  "rateLimitExceeded",
+  "quotaExceeded"
+]);
+var AUTH_FAILED_STATUSES2 = /* @__PURE__ */ new Set([401, 403]);
+var SERVER_OUTAGE_MIN_STATUS2 = 500;
+var SERVER_OUTAGE_MAX_STATUS2 = 599;
+var RATE_LIMITED_STATUS2 = 429;
+var INVALID_REQUEST_STATUS = 400;
+var MALFORMED_RESPONSE_MESSAGE = "Google Cloud Translation returned a response verbatra could not parse.";
+var MISMATCH_MESSAGE2 = "The provider returned a mismatched number of translations.";
+var AUTH_FAILED_MESSAGE2 = "Google Cloud Translation rejected the request credentials. Check that GOOGLE_TRANSLATE_API_KEY is a valid, unrestricted API key for a Google Cloud project with the Cloud Translation API enabled.";
+var RATE_LIMITED_MESSAGE2 = "Google Cloud Translation rate-limited or quota-capped this request. Wait for the quota to reset, or raise your project's Cloud Translation quota, then retry.";
+var INVALID_REQUEST_MESSAGE = "Google Cloud Translation rejected the request as malformed or unsupported: check the source and target locale codes and retry.";
+var PROVIDER_UNAVAILABLE_MESSAGE2 = "Google Cloud Translation is currently unavailable.";
+var PROVIDER_ERROR_MESSAGE = "The translation provider request failed.";
+function extractReasons(body) {
+  const parsed = errorSchema.safeParse(body);
+  if (!parsed.success) {
+    return [];
+  }
+  return (parsed.data.error.errors ?? []).map((detail) => detail.reason).filter((reason) => reason !== void 0);
+}
+function classifyErrorStatus(status, reasons) {
+  if (status === RATE_LIMITED_STATUS2) {
+    return { code: "RATE_LIMITED", message: RATE_LIMITED_MESSAGE2 };
+  }
+  if (status === INVALID_REQUEST_STATUS) {
+    return { code: "INVALID_REQUEST", message: INVALID_REQUEST_MESSAGE };
+  }
+  if (AUTH_FAILED_STATUSES2.has(status)) {
+    if (reasons.some((reason) => QUOTA_REASONS.has(reason))) {
+      return { code: "RATE_LIMITED", message: RATE_LIMITED_MESSAGE2 };
+    }
+    return { code: "AUTH_FAILED", message: AUTH_FAILED_MESSAGE2 };
+  }
+  if (status >= SERVER_OUTAGE_MIN_STATUS2 && status <= SERVER_OUTAGE_MAX_STATUS2) {
+    return { code: "PROVIDER_UNAVAILABLE", message: PROVIDER_UNAVAILABLE_MESSAGE2 };
+  }
+  return { code: "PROVIDER_ERROR", message: PROVIDER_ERROR_MESSAGE };
+}
+function isSuccessStatus(status) {
+  return status >= 200 && status < 300;
+}
+function parseGoogleTranslateHttpResult(status, body) {
+  if (isSuccessStatus(status)) {
+    const parsed = successSchema.safeParse(body);
+    if (!parsed.success) {
+      throw new ProviderError("INVALID_RESPONSE", MALFORMED_RESPONSE_MESSAGE);
+    }
+    return parsed.data.data.translations.map((translation) => translation.translatedText);
+  }
+  const { code, message } = classifyErrorStatus(status, extractReasons(body));
+  throw new ProviderError(code, message);
+}
+function zipResults2(entries, translatedTexts) {
+  const values = /* @__PURE__ */ new Map();
+  const integrityInputs = [];
+  const resultIter = translatedTexts[Symbol.iterator]();
+  for (const entry of entries) {
+    const next = resultIter.next();
+    if (next.done === true) {
+      throw new ProviderError("INVALID_RESPONSE", MISMATCH_MESSAGE2);
+    }
+    const translatedValue = next.value;
+    values.set(entry.key, translatedValue);
+    integrityInputs.push({ key: entry.key, sourceValue: entry.value, translatedValue });
+  }
+  if (resultIter.next().done === false) {
+    throw new ProviderError("INVALID_RESPONSE", MISMATCH_MESSAGE2);
+  }
+  return { values, integrityInputs };
+}
+var PROVIDER_ID4 = "google-translate";
+function createGoogleTranslateProvider(config, deps = {}) {
+  const validConfig = googleTranslateConfigSchema.parse(config);
+  const bundle = resolveClient2(deps);
+  return {
+    id: PROVIDER_ID4,
+    kind: "machine-translation",
+    supportsGlossary: false,
+    translateBatch: (request) => translate2(bundle, validConfig, request)
+  };
+}
+function resolveClient2(deps) {
+  if (deps.client !== void 0) {
+    return { client: deps.client };
+  }
+  return createDefaultClient4();
+}
+async function translate2(bundle, config, request) {
+  const data = validateRequest(request);
+  assertValidGoogleTranslateLocale(data.sourceLocale, "source");
+  assertValidGoogleTranslateLocale(data.targetLocale, "target");
+  const { protectable, unprotectable } = partitionByPlaceholders2(data.entries);
+  const genericGlossarySupplied = request.glossary !== void 0 && Object.keys(request.glossary).length > 0;
+  const notices = buildTranslateNotices({
+    ...data.tone !== void 0 ? { tone: data.tone } : {},
+    genericGlossarySupplied
+  });
+  const { values, integrity } = await translateProtectable2(
+    bundle.client,
+    data,
+    protectable,
+    request.extractPlaceholders,
+    request.comparePlaceholders,
+    config.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS,
+    request.signal
+  );
+  if (unprotectable.length > 0) {
+    notices.push({ code: "PLACEHOLDER_UNSUPPORTED", message: PLACEHOLDER_UNSUPPORTED_MESSAGE2 });
+  }
+  const reviewFlags = applyProviderDegraded(
+    buildEntryReviewFlags(
+      protectable,
+      values,
+      integrity,
+      data.sourceLocale,
+      data.targetLocale,
+      request.glossary
+    ),
+    notices,
+    [...values.keys()]
+  );
+  return { values, integrity, notices, reviewFlags };
+}
+async function translateProtectable2(client, data, protectable, extract, compare, timeoutMs, signal) {
+  if (protectable.length === 0) {
+    return { values: /* @__PURE__ */ new Map(), integrity: /* @__PURE__ */ new Map() };
+  }
+  const texts = protectable.map((entry) => entry.value);
+  const translatedTexts = await callClientChunked2(
+    client,
+    texts,
+    data.sourceLocale,
+    data.targetLocale,
+    timeoutMs,
+    signal
+  );
+  const { values, integrityInputs } = zipResults2(protectable, translatedTexts);
+  const integrity = checkBatchIntegrity(integrityInputs, extract, compare);
+  return { values, integrity };
+}
+function callClient3(client, texts, sourceLang, targetLang, timeoutMs, signal) {
+  return withRequestTimeout(
+    timeoutMs,
+    signal,
+    (guardedSignal) => client.translate(texts, sourceLang, targetLang, guardedSignal),
+    { endpointHost: GOOGLE_TRANSLATE_ENDPOINT_HOST }
+  );
+}
+async function callClientChunked2(client, texts, sourceLang, targetLang, timeoutMs, signal) {
+  const results = [];
+  for (const chunk2 of chunkTextsForGoogleTranslate(texts)) {
+    const { status, body } = await callClient3(
+      client,
+      chunk2,
+      sourceLang,
+      targetLang,
+      timeoutMs,
+      signal
+    );
+    results.push(...parseGoogleTranslateHttpResult(status, body));
+  }
+  return results;
+}
 var openAiConfigSchema = z.object({
   model: z.string().min(1),
   maxOutputTokens: z.number().int().positive()
 }).extend(requestTimeoutConfigSchema.shape);
-function createDefaultClient4() {
+function createDefaultClient5() {
   const sdk = new OpenAI({ apiKey: requireOpenAiKey(), logLevel: "off" });
   return {
     chat: {
@@ -2032,13 +2330,13 @@ function extractOpenAiResult(completion, tolerant = false) {
   const usage = toUsage(completion.usage?.prompt_tokens, completion.usage?.completion_tokens);
   return usage === void 0 ? { raw } : { raw, usage };
 }
-var PROVIDER_ID4 = "openai";
+var PROVIDER_ID5 = "openai";
 function createOpenAiProvider(config, deps = {}) {
   const validConfig = openAiConfigSchema.parse(config);
-  const client = deps.client ?? createDefaultClient4();
+  const client = deps.client ?? createDefaultClient5();
   const mechanism = createMechanism3(client, validConfig);
   return {
-    id: PROVIDER_ID4,
+    id: PROVIDER_ID5,
     kind: "llm",
     supportsGlossary: true,
     translateBatch: (request) => runLlmTranslation(request, mechanism)
@@ -2049,12 +2347,12 @@ function createMechanism3(client, config) {
   return {
     translate: async ({ payloadJson, signal }) => {
       const body = buildOpenAiRequest(config, payloadJson);
-      const completion = await callClient3(client, body, timeoutMs, signal);
+      const completion = await callClient4(client, body, timeoutMs, signal);
       return extractOpenAiResult(completion);
     }
   };
 }
-function callClient3(client, body, timeoutMs, signal) {
+function callClient4(client, body, timeoutMs, signal) {
   return withRequestTimeout(
     timeoutMs,
     signal,
@@ -2083,7 +2381,7 @@ function endpointContextOf(baseUrl) {
     return void 0;
   }
 }
-function createDefaultClient5(config) {
+function createDefaultClient6(config) {
   const sdk = new OpenAI({
     apiKey: resolveOpenAiCompatibleKey(config.apiKeyEnvVar),
     baseURL: config.baseUrl,
@@ -2100,13 +2398,13 @@ function createDefaultClient5(config) {
     }
   };
 }
-var PROVIDER_ID5 = "openai-compatible";
+var PROVIDER_ID6 = "openai-compatible";
 function createOpenAiCompatibleProvider(config, deps = {}) {
   const validConfig = openAiCompatibleConfigSchema.parse(config);
-  const client = deps.client ?? createDefaultClient5(validConfig);
+  const client = deps.client ?? createDefaultClient6(validConfig);
   const mechanism = createMechanism4(client, validConfig);
   return {
-    id: PROVIDER_ID5,
+    id: PROVIDER_ID6,
     kind: "llm",
     supportsGlossary: true,
     translateBatch: (request) => runLlmTranslation(request, mechanism)
@@ -2118,12 +2416,12 @@ function createMechanism4(client, config) {
   return {
     translate: async ({ payloadJson, signal }) => {
       const body = buildOpenAiRequest(config, payloadJson, "strict-schema", "max_tokens");
-      const completion = await callClient4(client, body, timeoutMs, signal, endpoint);
+      const completion = await callClient5(client, body, timeoutMs, signal, endpoint);
       return extractOpenAiResult(completion, true);
     }
   };
 }
-function callClient4(client, body, timeoutMs, signal, endpoint) {
+function callClient5(client, body, timeoutMs, signal, endpoint) {
   return withRequestTimeout(
     timeoutMs,
     signal,
@@ -2146,6 +2444,10 @@ var providerConfigSchema = z.discriminatedUnion("id", [
   z.object({ id: z.literal("openai"), options: openAiConfigSchema.strict() }),
   z.object({ id: z.literal("gemini"), options: geminiConfigSchema.strict() }),
   z.object({ id: z.literal("deepl"), options: deepLConfigSchema.strict() }),
+  z.object({
+    id: z.literal("google-translate"),
+    options: googleTranslateConfigSchema.strict()
+  }),
   z.object({
     id: z.literal("openai-compatible"),
     options: openAiCompatibleConfigSchema.strict()
@@ -2156,6 +2458,7 @@ var providerFactories = {
   openai: (options) => createOpenAiProvider(options),
   gemini: (options) => createGeminiProvider(options),
   deepl: (options) => createDeepLProvider(options),
+  "google-translate": (options) => createGoogleTranslateProvider(options),
   "openai-compatible": (options) => createOpenAiCompatibleProvider(options)
 };
 var PROVIDER_IDS = Object.keys(providerFactories);
@@ -2198,10 +2501,16 @@ var verbatraConfigSchema = z.strictObject({
   maxBatchSize: z.number().int().positive().optional(),
   maxTokens: z.number().int().positive().optional(),
   budgetBehavior: z.enum(["warn", "stop"]).optional()
-}).refine((config) => !config.targetLocales.includes(config.sourceLocale), {
-  message: "targetLocales must not include the source locale",
-  path: ["targetLocales"]
-}).refine((config) => findCaseInsensitiveDuplicate(config.targetLocales) === void 0, {
+}).refine(
+  (config) => {
+    const sourceKey = config.sourceLocale.toLowerCase();
+    return !config.targetLocales.some((locale) => locale.toLowerCase() === sourceKey);
+  },
+  {
+    message: "targetLocales must not include the source locale",
+    path: ["targetLocales"]
+  }
+).refine((config) => findCaseInsensitiveDuplicate(config.targetLocales) === void 0, {
   error: (issue) => {
     const duplicate = findCaseInsensitiveDuplicate(
       issue.input.targetLocales
@@ -2403,10 +2712,17 @@ function buildForwardMap(config, pathFor) {
   }
   return forward;
 }
+function sharedCataloguePathFor(cwd, pattern) {
+  const path = resolve(cwd, expandPattern(pattern, ""));
+  return () => path;
+}
 function createLocalePathResolver(cwd, config) {
   const style = config.files.localeStyle ?? DEFAULT_LOCALE_STYLE;
   const pattern = config.files.pattern;
   validatePattern(pattern, style);
+  if (isSharedCatalogueFormat(config.format)) {
+    return { pathFor: sharedCataloguePathFor(cwd, pattern), localeFor: () => void 0 };
+  }
   const pathFor = (locale) => resolve(cwd, expandPattern(pattern, safeSpelling(locale, style, config.sourceLocale)));
   const forward = buildForwardMap(config, pathFor);
   return {
@@ -2577,64 +2893,1343 @@ var nodeAdapterFs = {
   readBounded: nodeReadBounded,
   writeFileAtomic: (path, data) => atomicWriteFile(path, data, nodeOps)
 };
-var VALID_EMPTY = { placeholders: [], isPlural: false, valid: true };
-var INVALID = { placeholders: [], isPlural: false, valid: false };
-function tokenOf(element) {
-  switch (element.type) {
-    case TYPE.argument:
-    case TYPE.number:
-    case TYPE.date:
-    case TYPE.time:
-    case TYPE.select:
-    case TYPE.plural:
-      return `{${element.value}}`;
-    case TYPE.tag:
-      return `<${element.value}>`;
-    default:
-      return void 0;
+var AdapterError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "AdapterError";
+    this.code = code;
   }
+};
+var MAX_DEPTH = 100;
+var MAX_INPUT_BYTES = 16 * 1024 * 1024;
+function stripLeadingBom(content) {
+  return content.charCodeAt(0) === 65279 ? content.slice(1) : content;
 }
-function childMessages(element) {
-  if (element.type === TYPE.plural || element.type === TYPE.select) {
-    return Object.values(element.options).map((option) => option.value);
+async function readBoundedFile(fs, filePath) {
+  const outcome = await fs.readBounded(filePath, MAX_INPUT_BYTES);
+  return outcome.kind === "ok" ? { kind: "ok", content: stripLeadingBom(outcome.content) } : outcome;
+}
+function outcomeToContent(outcome, notAFileMessage) {
+  if (outcome.kind === "not-a-file") {
+    throw new AdapterError("INVALID_STRUCTURE", notAFileMessage);
   }
-  if (element.type === TYPE.tag) {
-    return [element.children];
+  if (outcome.kind === "too-large") {
+    throw new AdapterError("INPUT_TOO_LARGE", "The file exceeds the maximum allowed size.");
   }
-  return [];
+  return outcome.content;
 }
-function addCount(target, token, count) {
-  target.set(token, (target.get(token) ?? 0) + count);
+async function readFileContent(fs, filePath) {
+  const outcome = await readBoundedFile(fs, filePath);
+  return outcomeToContent(outcome, "The path is not a regular file.");
 }
-function combineBranches(branchMultisets) {
-  const combined = /* @__PURE__ */ new Map();
-  const tokens = /* @__PURE__ */ new Set();
-  for (const branch of branchMultisets) {
-    for (const token of branch.keys()) {
-      tokens.add(token);
-    }
+var LINE_TERMINATOR_SPLIT = /\r\n|\r|\n/;
+var TRAILING_LINE_TERMINATOR = /(?:\r\n|\r|\n)$/;
+function detectLineTerminator(content) {
+  if (content.includes("\r\n")) {
+    return "\r\n";
   }
-  for (const token of tokens) {
-    const minCount = Math.min(...branchMultisets.map((branch) => branch.get(token) ?? 0));
-    if (minCount > 0) {
-      combined.set(token, minCount);
-    }
+  return content.includes("\r") ? "\r" : "\n";
+}
+function splitPhysicalLines(content) {
+  if (content === "") {
+    return [];
   }
-  return combined;
+  const lines = content.split(LINE_TERMINATOR_SPLIT);
+  if (TRAILING_LINE_TERMINATOR.test(content)) {
+    lines.pop();
+  }
+  return lines;
 }
-function collect(elements, state) {
-  const result = /* @__PURE__ */ new Map();
-  for (const element of elements) {
-    const token = tokenOf(element);
+function scanTokens(value, pattern, extract = (match) => match[0]) {
+  const result = [];
+  for (const match of value.matchAll(pattern)) {
+    const token = extract(match);
     if (token !== void 0) {
-      addCount(result, token, 1);
-    }
-    if (element.type === TYPE.plural) {
-      state.isPlural = true;
+      result.push(token);
     }
-    const branches = childMessages(element);
-    if (branches.length > 0) {
-      const branchMultisets = branches.map((branch) => collect(branch, state));
+  }
+  return result;
+}
+function namespaceOf(filePath) {
+  return basename(filePath, extname(filePath));
+}
+function isEnoent(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+function rethrowStructured(error, message) {
+  if (error instanceof AdapterError) {
+    throw error;
+  }
+  throw new AdapterError("INVALID_STRUCTURE", message);
+}
+function computeIcu(entries, compute) {
+  if (!compute) {
+    return [];
+  }
+  try {
+    return compute(entries);
+  } catch (error) {
+    rethrowStructured(error, "The file could not be analyzed for message validity.");
+  }
+}
+function buildCanHandle(extensions, sniff) {
+  return (filePath, sample) => {
+    if (!extensions.includes(extname(filePath).toLowerCase())) {
+      return false;
+    }
+    return sample === void 0 || sniff === void 0 || sniff(sample);
+  };
+}
+async function toEntries(content, namespace, filePath, fs, parseEntries) {
+  try {
+    return await parseEntries(content, namespace, filePath, fs);
+  } catch (error) {
+    rethrowStructured(error, "The file could not be parsed.");
+  }
+}
+function createFlatFileAdapter(options) {
+  const {
+    format,
+    extensions,
+    sniff,
+    parseEntries,
+    serializeEntries,
+    extractPlaceholders,
+    validateMessage,
+    computeInvalidIcuKeys,
+    fs = nodeAdapterFs
+  } = options;
+  return {
+    format,
+    canHandle: buildCanHandle(extensions, sniff),
+    extractPlaceholders,
+    validateMessage: validateMessage ?? (() => true),
+    async read(filePath, locale) {
+      const content = await readFileContent(fs, filePath);
+      const namespace = namespaceOf(filePath);
+      const entries = await toEntries(content, namespace, filePath, fs, parseEntries);
+      const resource = { locale, namespace, format, entries };
+      const invalidIcuKeys = computeIcu(entries, computeInvalidIcuKeys);
+      return { resource, invalidIcuKeys, excludedLeafPaths: [] };
+    },
+    async write(resource, filePath) {
+      const data = await serializeEntries(resource.entries, filePath, fs);
+      await fs.writeFileAtomic(filePath, data);
+    }
+  };
+}
+var UNICODE_ESCAPE = /^[0-9a-fA-F]{4}$/;
+function decodeUnicodeEscape(raw, at) {
+  const hex = raw.slice(at, at + 4);
+  if (!UNICODE_ESCAPE.test(hex)) {
+    throw new AdapterError("INVALID_STRUCTURE", "The file has a malformed \\u unicode escape.");
+  }
+  return String.fromCharCode(Number.parseInt(hex, 16));
+}
+function decodeSimpleEscape(char) {
+  switch (char) {
+    case "n":
+      return "\n";
+    case "t":
+      return "	";
+    case "'":
+      return "'";
+    case '"':
+      return '"';
+    case "\\":
+      return "\\";
+    case "@":
+      return "@";
+    case "?":
+      return "?";
+    default:
+      return char;
+  }
+}
+function decodeAndroidEscapes(raw) {
+  const pieces = [];
+  let i = 0;
+  while (i < raw.length) {
+    const char = raw[i];
+    if (char !== "\\") {
+      pieces.push(char ?? "");
+      i += 1;
+      continue;
+    }
+    const next = raw[i + 1];
+    if (next === void 0) {
+      i += 1;
+      continue;
+    }
+    if (next === "u") {
+      pieces.push(decodeUnicodeEscape(raw, i + 2));
+      i += 6;
+      continue;
+    }
+    pieces.push(decodeSimpleEscape(next));
+    i += 2;
+  }
+  return pieces.join("");
+}
+function escapeChar(char, isFirst) {
+  switch (char) {
+    case "\\":
+      return "\\\\";
+    case "'":
+      return "\\'";
+    case '"':
+      return '\\"';
+    case "\n":
+      return "\\n";
+    case "	":
+      return "\\t";
+    case "@":
+      return isFirst ? "\\@" : "@";
+    case "?":
+      return isFirst ? "\\?" : "?";
+    default:
+      return char;
+  }
+}
+function encodeAndroidEscapes(value) {
+  const pieces = [];
+  for (let i = 0; i < value.length; i += 1) {
+    const char = value[i];
+    if (char !== void 0) {
+      pieces.push(escapeChar(char, i === 0));
+    }
+  }
+  return pieces.join("");
+}
+var RESOURCE_NAME = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+function assertValidResourceName(name, tag) {
+  if (!RESOURCE_NAME.test(name)) {
+    throw new AdapterError(
+      "INVALID_STRUCTURE",
+      `The <${tag} name="${name}"> resource name is not a valid Android resource name. A resource name must start with a letter or underscore and contain only letters, digits, and underscores.`
+    );
+  }
+}
+var PRINTF_TOKEN = /%(?:(\d+)\$)?[-+0#]*(?:[1-9]\d*)?(?:\.\d+)?(?:hh|h|ll|l|q|z|j|t|L)?([A-Za-z@])|%%/g;
+function extractPrintfPlaceholders(value, options) {
+  const out = [];
+  for (const match of value.matchAll(PRINTF_TOKEN)) {
+    if (match[0] === "%%") {
+      out.push("%%");
+      continue;
+    }
+    const conversion = match[2];
+    if (conversion === void 0 || !options.conversions.has(conversion)) {
+      continue;
+    }
+    const position = match[1];
+    out.push(position === void 0 ? `%${conversion}` : `%${position}$${conversion}`);
+  }
+  return out;
+}
+var ANDROID_PRINTF_CONVERSIONS = /* @__PURE__ */ new Set([
+  "s",
+  "S",
+  "d",
+  "f",
+  "x",
+  "X",
+  "o",
+  "c",
+  "C",
+  "b",
+  "B",
+  "e",
+  "E",
+  "g",
+  "G"
+]);
+function extractAndroidPlaceholders(value) {
+  return extractPrintfPlaceholders(value, { conversions: ANDROID_PRINTF_CONVERSIONS });
+}
+var ANDROID_PLURAL_CATEGORIES = [
+  "zero",
+  "one",
+  "two",
+  "few",
+  "many",
+  "other"
+];
+var ANDROID_PLURAL_CATEGORY_SET = new Set(ANDROID_PLURAL_CATEGORIES);
+var PLURAL_KEY = /^(.*)\[(zero|one|two|few|many|other)\]$/;
+function isAndroidPluralCategory(value) {
+  return ANDROID_PLURAL_CATEGORY_SET.has(value);
+}
+function makeAndroidPluralKey(baseKey, category) {
+  return `${baseKey}[${category}]`;
+}
+function androidPluralBaseKey(key) {
+  return PLURAL_KEY.exec(key)?.[1];
+}
+function androidPluralCategoryOf(key) {
+  const category = PLURAL_KEY.exec(key)?.[2];
+  return category === void 0 ? void 0 : category;
+}
+var ELEMENT_NODE = 1;
+var TEXT_NODE = 3;
+var ROOT_TAG = "resources";
+function onFatal(level, message) {
+  if (level === "fatalError") {
+    throw new Error(message);
+  }
+}
+function assertNoDoctype(content) {
+  if (/<!DOCTYPE/i.test(content) || /<!ENTITY/i.test(content)) {
+    throw new AdapterError(
+      "INVALID_XML",
+      "strings.xml with a DTD or entity declaration is rejected."
+    );
+  }
+}
+function parseErrorDetail(error) {
+  return error instanceof Error && error.message.length > 0 ? `: ${error.message}` : "";
+}
+function parseAndroidXml(content) {
+  assertNoDoctype(content);
+  let doc;
+  try {
+    doc = new DOMParser({ onError: onFatal }).parseFromString(content, "text/xml");
+  } catch (error) {
+    throw new AdapterError("INVALID_XML", `The file is not valid XML${parseErrorDetail(error)}.`);
+  }
+  const root = doc.documentElement;
+  if (root === null || root.localName !== ROOT_TAG) {
+    throw new AdapterError(
+      "INVALID_STRUCTURE",
+      `The file is not an Android resources file: the root element must be <${ROOT_TAG}>.`
+    );
+  }
+  return { doc, root };
+}
+function createAndroidXmlDocument() {
+  const doc = new DOMImplementation().createDocument(null, ROOT_TAG, null);
+  const root = doc.documentElement;
+  if (root === null) {
+    throw new AdapterError("INVALID_STRUCTURE", "Could not synthesize a new resources document.");
+  }
+  return { doc, root };
+}
+function isElement(node) {
+  return node.nodeType === ELEMENT_NODE;
+}
+function elementChildren(parent, tag) {
+  const children = Array.from(parent.childNodes).filter(isElement);
+  return tag === void 0 ? children : children.filter((el) => el.localName === tag);
+}
+function singleTextValue(element) {
+  const children = element.childNodes;
+  if (children.length === 0) {
+    return "";
+  }
+  if (children.length === 1) {
+    const only = children.item(0);
+    if (only !== null && only.nodeType === TEXT_NODE) {
+      return only.nodeValue ?? "";
+    }
+  }
+  return void 0;
+}
+function setSingleTextValue(doc, element, value) {
+  while (element.firstChild !== null) {
+    element.removeChild(element.firstChild);
+  }
+  element.appendChild(doc.createTextNode(value));
+}
+function isTranslatable(element) {
+  return element.getAttribute("translatable") !== "false";
+}
+function setEntry(out, key, namespace, value, isPlural) {
+  if (out.has(key)) {
+    throw new AdapterError(
+      "INVALID_STRUCTURE",
+      `The resolved key "${key}" is defined more than once in the file.`
+    );
+  }
+  out.set(key, {
+    key,
+    namespace,
+    value,
+    placeholders: extractAndroidPlaceholders(value),
+    isPlural
+  });
+}
+function parseStringElement(element, namespace, out) {
+  const name = element.getAttribute("name") ?? "";
+  assertValidResourceName(name, "string");
+  if (!isTranslatable(element)) {
+    return;
+  }
+  const raw = singleTextValue(element);
+  if (raw === void 0) {
+    return;
+  }
+  setEntry(out, name, namespace, decodeAndroidEscapes(raw), false);
+}
+function assertUniqueQuantities(items, name) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of items) {
+    const quantity = item.getAttribute("quantity") ?? "";
+    if (seen.has(quantity)) {
+      throw new AdapterError(
+        "INVALID_STRUCTURE",
+        `The <plurals name="${name}"> element has more than one item for quantity "${quantity}".`
+      );
+    }
+    seen.add(quantity);
+  }
+}
+function parsePluralsElement(element, namespace, out) {
+  const name = element.getAttribute("name") ?? "";
+  assertValidResourceName(name, "plurals");
+  if (!isTranslatable(element)) {
+    return;
+  }
+  const items = elementChildren(element, "item");
+  assertUniqueQuantities(items, name);
+  const values = [];
+  for (const item of items) {
+    const quantity = item.getAttribute("quantity") ?? "";
+    if (!isAndroidPluralCategory(quantity)) {
+      throw new AdapterError(
+        "INVALID_STRUCTURE",
+        `The <plurals name="${name}"> element has an item with quantity="${quantity}", which is not one of ${ANDROID_PLURAL_CATEGORIES.join(", ")}.`
+      );
+    }
+    const raw = singleTextValue(item);
+    if (raw === void 0) {
+      return;
+    }
+    values.push([quantity, raw]);
+  }
+  for (const [quantity, raw] of values) {
+    setEntry(
+      out,
+      makeAndroidPluralKey(name, quantity),
+      namespace,
+      decodeAndroidEscapes(raw),
+      true
+    );
+  }
+}
+function parseAndroidXmlEntries(content, namespace) {
+  const { root } = parseAndroidXml(content);
+  const out = /* @__PURE__ */ new Map();
+  for (const element of elementChildren(root)) {
+    if (element.localName === "string") {
+      parseStringElement(element, namespace, out);
+    } else if (element.localName === "plurals") {
+      parsePluralsElement(element, namespace, out);
+    }
+  }
+  return out;
+}
+var XML_PROLOG = '<?xml version="1.0" encoding="utf-8"?>\n';
+function groupEntries(entries) {
+  const singular = /* @__PURE__ */ new Map();
+  const plural = /* @__PURE__ */ new Map();
+  for (const [key, entry] of entries) {
+    const baseKey = androidPluralBaseKey(key);
+    const category = androidPluralCategoryOf(key);
+    if (baseKey !== void 0 && category !== void 0) {
+      const group = plural.get(baseKey) ?? /* @__PURE__ */ new Map();
+      group.set(category, entry);
+      plural.set(baseKey, group);
+    } else {
+      singular.set(key, entry);
+    }
+  }
+  return { singular, plural };
+}
+function isTranslatable2(element) {
+  return element.getAttribute("translatable") !== "false";
+}
+function appendStringElement(doc, root, name, value) {
+  const element = doc.createElement("string");
+  element.setAttribute("name", name);
+  element.appendChild(doc.createTextNode(encodeAndroidEscapes(value)));
+  root.appendChild(element);
+}
+function appendPluralsElement(doc, root, name, categories) {
+  const plurals = doc.createElement("plurals");
+  plurals.setAttribute("name", name);
+  for (const category of ANDROID_PLURAL_CATEGORIES) {
+    const entry = categories.get(category);
+    if (entry === void 0) {
+      continue;
+    }
+    const item = doc.createElement("item");
+    item.setAttribute("quantity", category);
+    item.appendChild(doc.createTextNode(encodeAndroidEscapes(entry.value)));
+    plurals.appendChild(item);
+  }
+  root.appendChild(plurals);
+}
+function appendUnmatched(doc, root, grouped, matched) {
+  for (const [key, entry] of grouped.singular) {
+    if (!matched.has(key)) {
+      appendStringElement(doc, root, key, entry.value);
+    }
+  }
+  for (const [baseKey, categories] of grouped.plural) {
+    if (!matched.has(baseKey)) {
+      appendPluralsElement(doc, root, baseKey, categories);
+    }
+  }
+}
+function isReadThroughString(element) {
+  return !isTranslatable2(element) || singleTextValue(element) === void 0;
+}
+function patchStringElement(doc, element, grouped, matched) {
+  const name = element.getAttribute("name") ?? "";
+  assertValidResourceName(name, "string");
+  const entry = grouped.singular.get(name);
+  if (entry !== void 0) {
+    matched.add(name);
+    element.removeAttribute("translatable");
+    setSingleTextValue(doc, element, encodeAndroidEscapes(entry.value));
+    return;
+  }
+  if (isReadThroughString(element)) {
+    return;
+  }
+  matched.add(name);
+  element.parentNode?.removeChild(element);
+}
+function isReadThroughPlurals(items) {
+  return items.some((item) => singleTextValue(item) === void 0);
+}
+function patchTranslatablePlurals(doc, element, items, categories) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of items) {
+    const quantity = item.getAttribute("quantity") ?? "";
+    const entry = categories.get(quantity);
+    if (entry === void 0) {
+      element.removeChild(item);
+      continue;
+    }
+    setSingleTextValue(doc, item, encodeAndroidEscapes(entry.value));
+    seen.add(quantity);
+  }
+  for (const category of ANDROID_PLURAL_CATEGORIES) {
+    const entry = categories.get(category);
+    if (entry === void 0 || seen.has(category)) {
+      continue;
+    }
+    const item = doc.createElement("item");
+    item.setAttribute("quantity", category);
+    item.appendChild(doc.createTextNode(encodeAndroidEscapes(entry.value)));
+    element.appendChild(item);
+  }
+}
+function patchPluralsElement(doc, element, grouped, matched) {
+  const name = element.getAttribute("name") ?? "";
+  assertValidResourceName(name, "plurals");
+  const items = elementChildren(element, "item");
+  const categories = grouped.plural.get(name);
+  if (categories !== void 0) {
+    matched.add(name);
+    element.removeAttribute("translatable");
+    patchTranslatablePlurals(doc, element, items, categories);
+    if (elementChildren(element, "item").length === 0) {
+      element.parentNode?.removeChild(element);
+    }
+    return;
+  }
+  if (!isTranslatable2(element) || isReadThroughPlurals(items)) {
+    return;
+  }
+  matched.add(name);
+  element.parentNode?.removeChild(element);
+}
+function patchDocument(doc, root, grouped) {
+  const matched = /* @__PURE__ */ new Set();
+  for (const element of elementChildren(root)) {
+    if (element.localName === "string") {
+      patchStringElement(doc, element, grouped, matched);
+    } else if (element.localName === "plurals") {
+      patchPluralsElement(doc, element, grouped, matched);
+    }
+  }
+  appendUnmatched(doc, root, grouped, matched);
+}
+async function readDestination(filePath, fs) {
+  try {
+    const outcome = await readBoundedFile(fs, filePath);
+    return outcomeToContent(outcome, "The destination path is not a regular file.");
+  } catch (error) {
+    if (isEnoent(error)) {
+      return void 0;
+    }
+    throw error;
+  }
+}
+async function serializeAndroidXmlEntries(entries, filePath, fs) {
+  const grouped = groupEntries(entries);
+  const existing = await readDestination(filePath, fs);
+  if (existing === void 0) {
+    const { doc: doc2, root: root2 } = createAndroidXmlDocument();
+    appendUnmatched(doc2, root2, grouped, /* @__PURE__ */ new Set());
+    return XML_PROLOG + new XMLSerializer().serializeToString(doc2);
+  }
+  const { doc, root } = parseAndroidXml(existing);
+  patchDocument(doc, root, grouped);
+  return new XMLSerializer().serializeToString(doc);
+}
+function createAndroidXmlAdapter(fs = nodeAdapterFs) {
+  return createFlatFileAdapter({
+    fs,
+    format: "android-xml",
+    extensions: [".xml"],
+    parseEntries: parseAndroidXmlEntries,
+    serializeEntries: serializeAndroidXmlEntries,
+    extractPlaceholders: extractAndroidPlaceholders
+  });
+}
+var APPLE_PRINTF_CONVERSIONS = /* @__PURE__ */ new Set([
+  "@",
+  "d",
+  "i",
+  "u",
+  "x",
+  "X",
+  "o",
+  "f",
+  "e",
+  "E",
+  "g",
+  "G",
+  "c",
+  "s"
+]);
+function extractAppleStringsPlaceholders(value) {
+  return extractPrintfPlaceholders(value, { conversions: APPLE_PRINTF_CONVERSIONS });
+}
+var UNICODE_ESCAPE2 = /^[0-9a-fA-F]{4}$/;
+var TRAILING_BLOCK_COMMENT = /\/\*([\s\S]*?)\*\//g;
+var ATTACHED_TAIL = /^[ \t]*\r?\n?[ \t]*$/;
+function isInlineWhitespace(char) {
+  return char === " " || char === "	" || char === "\r" || char === "\n";
+}
+function skipInlineWhitespace(content, from) {
+  let i = from;
+  while (isInlineWhitespace(content[i])) {
+    i += 1;
+  }
+  return i;
+}
+function lineOf(content, position) {
+  return content.slice(0, position).split("\n").length;
+}
+function hasUtf16Bom(content) {
+  return content.charCodeAt(0) === 65533 && content.charCodeAt(1) === 65533;
+}
+function assertNotUtf16(content) {
+  if (hasUtf16Bom(content)) {
+    throw new AdapterError(
+      "INVALID_STRUCTURE",
+      "The file appears to be UTF-16 encoded. Apple .strings files must be UTF-8."
+    );
+  }
+}
+function decodeUnicodeEscape2(content, at) {
+  const hex = content.slice(at, at + 4);
+  if (!UNICODE_ESCAPE2.test(hex)) {
+    throw new AdapterError(
+      "INVALID_STRUCTURE",
+      `The file has a malformed \\U unicode escape (line ${lineOf(content, at)}).`
+    );
+  }
+  return { char: String.fromCharCode(Number.parseInt(hex, 16)), next: at + 4 };
+}
+function decodeEscape(content, at) {
+  const escaped = content[at];
+  switch (escaped) {
+    case '"':
+      return { char: '"', next: at + 1 };
+    case "\\":
+      return { char: "\\", next: at + 1 };
+    case "n":
+      return { char: "\n", next: at + 1 };
+    case "t":
+      return { char: "	", next: at + 1 };
+    case "U":
+      return decodeUnicodeEscape2(content, at + 1);
+    default:
+      throw new AdapterError(
+        "INVALID_STRUCTURE",
+        `The file has an unknown escape sequence "\\${escaped ?? ""}" (line ${lineOf(content, at)}).`
+      );
+  }
+}
+function parseQuotedString(content, start) {
+  let i = start + 1;
+  let decoded = "";
+  while (true) {
+    const char = content[i];
+    if (char === void 0) {
+      throw new AdapterError(
+        "INVALID_STRUCTURE",
+        `The file has an unterminated quoted string (line ${lineOf(content, start)}).`
+      );
+    }
+    if (char === '"') {
+      i += 1;
+      break;
+    }
+    if (char === "\\") {
+      const token = decodeEscape(content, i + 1);
+      decoded += token.char;
+      i = token.next;
+      continue;
+    }
+    decoded += char;
+    i += 1;
+  }
+  return { raw: content.slice(start, i), decoded, end: i };
+}
+function parseStatement(content, start) {
+  const keyToken = parseQuotedString(content, start);
+  const afterKey = skipInlineWhitespace(content, keyToken.end);
+  if (content[afterKey] !== "=") {
+    throw new AdapterError(
+      "INVALID_STRUCTURE",
+      `The file has a statement missing its = separator (line ${lineOf(content, afterKey)}).`
+    );
+  }
+  const valueStart = skipInlineWhitespace(content, afterKey + 1);
+  if (content[valueStart] !== '"') {
+    throw new AdapterError(
+      "INVALID_STRUCTURE",
+      `The file has a statement with no quoted value (line ${lineOf(content, valueStart)}).`
+    );
+  }
+  const valueToken = parseQuotedString(content, valueStart);
+  const semicolonAt = skipInlineWhitespace(content, valueToken.end);
+  if (content[semicolonAt] !== ";") {
+    throw new AdapterError(
+      "INVALID_STRUCTURE",
+      `The file has a statement missing its ; terminator (line ${lineOf(content, semicolonAt)}).`
+    );
+  }
+  return {
+    key: keyToken.decoded,
+    keyRaw: keyToken.raw,
+    value: valueToken.decoded,
+    betweenKeyAndValue: content.slice(keyToken.end, valueStart),
+    afterValueBeforeSemicolon: content.slice(valueToken.end, semicolonAt),
+    end: semicolonAt + 1
+  };
+}
+function skipComment(content, at) {
+  if (content[at + 1] === "*") {
+    const closeAt = content.indexOf("*/", at + 2);
+    return closeAt === -1 ? content.length : closeAt + 2;
+  }
+  let i = at + 2;
+  while (i < content.length && content[i] !== "\n") {
+    i += 1;
+  }
+  return i;
+}
+function isCommentStart(content, at) {
+  return content[at] === "/" && (content[at + 1] === "*" || content[at + 1] === "/");
+}
+function splitLeading(leading) {
+  let lastMatch = null;
+  for (const match of leading.matchAll(TRAILING_BLOCK_COMMENT)) {
+    lastMatch = match;
+  }
+  if (lastMatch === null) {
+    return { alwaysPreserved: "", ownedByEntry: leading };
+  }
+  const commentEnd = lastMatch.index + lastMatch[0].length;
+  const tail = leading.slice(commentEnd);
+  if (!ATTACHED_TAIL.test(tail)) {
+    return { alwaysPreserved: leading.slice(0, commentEnd), ownedByEntry: tail };
+  }
+  const inner = (lastMatch[1] ?? "").trim();
+  return {
+    alwaysPreserved: "",
+    ownedByEntry: leading,
+    ...inner !== "" ? { description: inner } : {}
+  };
+}
+function scanAppleStrings(content) {
+  const nodes = [];
+  let rawStart = 0;
+  let i = 0;
+  while (i < content.length) {
+    const char = content[i];
+    if (char === '"') {
+      const split = splitLeading(content.slice(rawStart, i));
+      const statement = parseStatement(content, i);
+      nodes.push({
+        kind: "entry",
+        alwaysPreserved: split.alwaysPreserved,
+        ownedByEntry: split.ownedByEntry,
+        ...split.description !== void 0 ? { description: split.description } : {},
+        key: statement.key,
+        keyRaw: statement.keyRaw,
+        value: statement.value,
+        betweenKeyAndValue: statement.betweenKeyAndValue,
+        afterValueBeforeSemicolon: statement.afterValueBeforeSemicolon
+      });
+      i = statement.end;
+      rawStart = i;
+      continue;
+    }
+    if (isCommentStart(content, i)) {
+      i = skipComment(content, i);
+      continue;
+    }
+    i += 1;
+  }
+  if (rawStart < content.length) {
+    nodes.push({ kind: "text", text: content.slice(rawStart) });
+  }
+  return nodes;
+}
+function parseAppleStringsEntries(content, namespace) {
+  assertNotUtf16(content);
+  const map = /* @__PURE__ */ new Map();
+  for (const node of scanAppleStrings(content)) {
+    if (node.kind === "text") {
+      continue;
+    }
+    map.set(node.key, {
+      key: node.key,
+      namespace,
+      value: node.value,
+      placeholders: extractAppleStringsPlaceholders(node.value),
+      isPlural: false,
+      ...node.description !== void 0 ? { description: node.description } : {}
+    });
+  }
+  return map;
+}
+function escapeChar2(char) {
+  switch (char) {
+    case "\\":
+      return "\\\\";
+    case '"':
+      return '\\"';
+    case "\n":
+      return "\\n";
+    case "	":
+      return "\\t";
+    default:
+      return char;
+  }
+}
+function escapeValue(value) {
+  let out = "";
+  for (const char of value) {
+    out += escapeChar2(char);
+  }
+  return out;
+}
+async function readDestinationNodes(filePath, fs) {
+  let outcome;
+  try {
+    outcome = await readBoundedFile(fs, filePath);
+  } catch (error) {
+    if (isEnoent(error)) {
+      return { nodes: [], terminator: "\n" };
+    }
+    throw new AdapterError("INVALID_STRUCTURE", "The destination file could not be read.");
+  }
+  const content = outcomeToContent(outcome, "The destination path is not a regular file.");
+  assertNotUtf16(content);
+  return { nodes: scanAppleStrings(content), terminator: detectLineTerminator(content) };
+}
+function endsWithNewline(text) {
+  return text === "" || text.endsWith("\n") || text.endsWith("\r");
+}
+async function serializeAppleStringsEntries(entries, filePath, fs) {
+  const { nodes, terminator } = await readDestinationNodes(filePath, fs);
+  const emitted = /* @__PURE__ */ new Set();
+  const parts = [];
+  for (const node of nodes) {
+    if (node.kind === "text") {
+      parts.push(node.text);
+      continue;
+    }
+    parts.push(node.alwaysPreserved);
+    const entry = entries.get(node.key);
+    if (entry === void 0 || emitted.has(node.key)) {
+      continue;
+    }
+    parts.push(
+      `${node.ownedByEntry}${node.keyRaw}${node.betweenKeyAndValue}"${escapeValue(entry.value)}"${node.afterValueBeforeSemicolon};`
+    );
+    emitted.add(node.key);
+  }
+  let result = parts.join("");
+  const appended = [];
+  for (const [key, entry] of entries) {
+    if (!emitted.has(key)) {
+      appended.push(`"${escapeValue(key)}" = "${escapeValue(entry.value)}";${terminator}`);
+    }
+  }
+  if (appended.length > 0) {
+    if (!endsWithNewline(result)) {
+      result += terminator;
+    }
+    result += appended.join("");
+  }
+  return result;
+}
+var PLURAL_SUFFIX = /_(zero|one|two|few|many|other)$/;
+function isPluralKey(key) {
+  return PLURAL_SUFFIX.test(key);
+}
+function pluralCategoryOf(key) {
+  const match = PLURAL_SUFFIX.exec(key);
+  return match?.[1];
+}
+function pluralBaseKey(key) {
+  if (!isPluralKey(key)) {
+    return void 0;
+  }
+  return key.replace(PLURAL_SUFFIX, "");
+}
+function makePluralKey(baseKey, category) {
+  return `${baseKey}_${category}`;
+}
+var ELEMENT_NODE2 = 1;
+var PLURAL_CATEGORIES = [
+  "zero",
+  "one",
+  "two",
+  "few",
+  "many",
+  "other"
+];
+var PLURAL_CATEGORY_SET = new Set(PLURAL_CATEGORIES);
+var FORMAT_KEY = "NSStringLocalizedFormatKey";
+var SPEC_TYPE_KEY = "NSStringFormatSpecTypeKey";
+var VALUE_TYPE_KEY = "NSStringFormatValueTypeKey";
+var PLURAL_RULE_TYPE = "NSStringPluralRuleType";
+var VARIABLE_REF = /%#@(\w+)@/;
+var PLIST_HEADER = '<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n';
+function isElement2(node) {
+  return node.nodeType === ELEMENT_NODE2;
+}
+function elementChildren2(parent) {
+  return Array.from(parent.childNodes).filter(isElement2);
+}
+function doctypeHasInternalSubset(content) {
+  const start = content.search(/<!DOCTYPE/i);
+  if (start === -1) {
+    return false;
+  }
+  for (let i = start; i < content.length; i += 1) {
+    const char = content[i];
+    if (char === "[") {
+      return true;
+    }
+    if (char === ">") {
+      return false;
+    }
+  }
+  return false;
+}
+function assertSafePlist(content, filePath) {
+  if (/<!ENTITY/i.test(content)) {
+    throw new AdapterError(
+      "INVALID_XML",
+      `${filePath}: the plist contains an <!ENTITY> declaration, which is rejected before parsing.`
+    );
+  }
+  if (doctypeHasInternalSubset(content)) {
+    throw new AdapterError(
+      "INVALID_XML",
+      `${filePath}: the plist's <!DOCTYPE> declares an internal subset, which is rejected before parsing.`
+    );
+  }
+}
+function onFatal2(level) {
+  if (level === "fatalError") {
+    throw new Error("malformed XML");
+  }
+}
+function parsePlistRoot(content, filePath) {
+  assertSafePlist(content, filePath);
+  let doc;
+  try {
+    doc = new DOMParser({ onError: onFatal2 }).parseFromString(content, "text/xml");
+  } catch {
+    throw new AdapterError("INVALID_XML", `${filePath}: the file is not valid XML.`);
+  }
+  const plistEl = doc.documentElement;
+  if (plistEl === null || plistEl.localName !== "plist") {
+    throw new AdapterError("INVALID_STRUCTURE", `${filePath}: the file is not a plist document.`);
+  }
+  const root = elementChildren2(plistEl).find((el) => el.localName === "dict");
+  if (root === void 0) {
+    throw new AdapterError("INVALID_STRUCTURE", `${filePath}: the plist has no top-level <dict>.`);
+  }
+  return { doc, root };
+}
+function dictPairs(dict, filePath, where) {
+  const children = elementChildren2(dict);
+  const pairs = [];
+  for (let i = 0; i < children.length; i += 2) {
+    const keyEl = children[i];
+    const valueEl = children[i + 1];
+    if (keyEl === void 0 || keyEl.localName !== "key" || valueEl === void 0) {
+      throw new AdapterError(
+        "INVALID_STRUCTURE",
+        `${filePath}: ${where} has a <dict> with an odd or malformed key/value structure.`
+      );
+    }
+    pairs.push({ keyText: keyEl.textContent ?? "", valueEl });
+  }
+  return pairs;
+}
+function stringValue(el, filePath, where) {
+  if (el.localName !== "string") {
+    throw new AdapterError("INVALID_STRUCTURE", `${filePath}: ${where} expected a <string> value.`);
+  }
+  return el.textContent ?? "";
+}
+function parseRuleDict(rulePairs, filePath, pluralKey, variableName) {
+  const specPair = rulePairs.find((pair) => pair.keyText === SPEC_TYPE_KEY);
+  const specType = specPair === void 0 ? void 0 : stringValue(specPair.valueEl, filePath, `${pluralKey}'s ${SPEC_TYPE_KEY}`);
+  if (specType !== PLURAL_RULE_TYPE) {
+    throw new AdapterError(
+      "INVALID_STRUCTURE",
+      `${filePath}: the stringsdict entry "${pluralKey}" has an unsupported ${SPEC_TYPE_KEY} (expected "${PLURAL_RULE_TYPE}", found ${specType === void 0 ? "none" : `"${specType}"`}).`
+    );
+  }
+  const valueTypePair = rulePairs.find((pair) => pair.keyText === VALUE_TYPE_KEY);
+  const valueType = valueTypePair === void 0 ? void 0 : stringValue(valueTypePair.valueEl, filePath, `${pluralKey}'s ${VALUE_TYPE_KEY}`);
+  const categories = /* @__PURE__ */ new Map();
+  for (const pair of rulePairs) {
+    if (pair.keyText === SPEC_TYPE_KEY || pair.keyText === VALUE_TYPE_KEY) {
+      continue;
+    }
+    if (!PLURAL_CATEGORY_SET.has(pair.keyText)) {
+      throw new AdapterError(
+        "INVALID_STRUCTURE",
+        `${filePath}: the stringsdict entry "${pluralKey}" has an unsupported plural category "${pair.keyText}" (variable "${variableName}"); expected one of zero, one, two, few, many, other.`
+      );
+    }
+    categories.set(
+      pair.keyText,
+      stringValue(pair.valueEl, filePath, `${pluralKey}'s "${pair.keyText}" category`)
+    );
+  }
+  if (categories.size === 0) {
+    throw new AdapterError(
+      "INVALID_STRUCTURE",
+      `${filePath}: the stringsdict entry "${pluralKey}" has no plural categories.`
+    );
+  }
+  return { valueType, categories };
+}
+function parseEntryDict(entryDict, filePath, pluralKey) {
+  const pairs = dictPairs(entryDict, filePath, `the stringsdict entry "${pluralKey}"`);
+  const formatPair = pairs.find((pair) => pair.keyText === FORMAT_KEY);
+  if (formatPair === void 0) {
+    throw new AdapterError(
+      "INVALID_STRUCTURE",
+      `${filePath}: the stringsdict entry "${pluralKey}" is missing ${FORMAT_KEY}.`
+    );
+  }
+  const formatKey = stringValue(
+    formatPair.valueEl,
+    filePath,
+    `the stringsdict entry "${pluralKey}"'s ${FORMAT_KEY}`
+  );
+  const variableMatch = VARIABLE_REF.exec(formatKey);
+  if (variableMatch === null) {
+    throw new AdapterError(
+      "INVALID_STRUCTURE",
+      `${filePath}: the stringsdict entry "${pluralKey}" is missing a plural rule: its ${FORMAT_KEY} does not reference a %#@variable@ substitution.`
+    );
+  }
+  const variableName = variableMatch[1];
+  const rulePair = pairs.find((pair) => pair.keyText === variableName);
+  if (rulePair === void 0) {
+    throw new AdapterError(
+      "INVALID_STRUCTURE",
+      `${filePath}: the stringsdict entry "${pluralKey}" references variable "${variableName}" in its ${FORMAT_KEY} but has no matching rule dictionary.`
+    );
+  }
+  if (rulePair.valueEl.localName !== "dict") {
+    throw new AdapterError(
+      "INVALID_STRUCTURE",
+      `${filePath}: the stringsdict entry "${pluralKey}"'s "${variableName}" rule must be a <dict>.`
+    );
+  }
+  const rulePairs = dictPairs(
+    rulePair.valueEl,
+    filePath,
+    `the stringsdict entry "${pluralKey}"'s "${variableName}" rule`
+  );
+  const { valueType, categories } = parseRuleDict(rulePairs, filePath, pluralKey, variableName);
+  return { formatKey, variableName, valueType, categories };
+}
+function parseStringsDictGroups(content, filePath) {
+  const { root } = parsePlistRoot(content, filePath);
+  const pairs = dictPairs(root, filePath, "the stringsdict document");
+  const out = /* @__PURE__ */ new Map();
+  for (const pair of pairs) {
+    const pluralKey = pair.keyText;
+    if (pair.valueEl.localName !== "dict") {
+      throw new AdapterError(
+        "INVALID_STRUCTURE",
+        `${filePath}: the stringsdict entry "${pluralKey}" must be a <dict>.`
+      );
+    }
+    if (out.has(pluralKey)) {
+      throw new AdapterError(
+        "INVALID_STRUCTURE",
+        `${filePath}: the stringsdict file has two entries with the key "${pluralKey}".`
+      );
+    }
+    out.set(pluralKey, parseEntryDict(pair.valueEl, filePath, pluralKey));
+  }
+  return out;
+}
+function parseAppleStringsDictEntries(content, namespace, filePath) {
+  const groups = parseStringsDictGroups(content, filePath);
+  const out = /* @__PURE__ */ new Map();
+  for (const [pluralKey, group] of groups) {
+    for (const category of PLURAL_CATEGORIES) {
+      const text = group.categories.get(category);
+      if (text === void 0) {
+        continue;
+      }
+      const key = makePluralKey(pluralKey, category);
+      out.set(key, {
+        key,
+        namespace,
+        value: text,
+        placeholders: extractAppleStringsPlaceholders(text),
+        isPlural: true
+      });
+    }
+  }
+  return out;
+}
+async function readExistingGroups(filePath, fs, strict) {
+  try {
+    const outcome = await readBoundedFile(fs, filePath);
+    const content = outcomeToContent(
+      outcome,
+      `${filePath}: the destination path is not a regular file.`
+    );
+    return parseStringsDictGroups(content, filePath);
+  } catch (error) {
+    if (isEnoent(error) || !strict) {
+      return /* @__PURE__ */ new Map();
+    }
+    if (error instanceof AdapterError) {
+      throw error;
+    }
+    throw new AdapterError(
+      "INVALID_STRUCTURE",
+      `${filePath}: the destination stringsdict file could not be read.`
+    );
+  }
+}
+function groupTargets(entries) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const [key, entry] of entries) {
+    const baseKey = pluralBaseKey(key);
+    const category = pluralCategoryOf(key);
+    if (baseKey === void 0 || category === void 0) {
+      continue;
+    }
+    const group = groups.get(baseKey) ?? /* @__PURE__ */ new Map();
+    group.set(category, entry.value);
+    groups.set(baseKey, group);
+  }
+  return groups;
+}
+var DEFAULT_VALUE_TYPE = "d";
+function appendTextEl(doc, parent, tag, text) {
+  const el = doc.createElement(tag);
+  el.appendChild(doc.createTextNode(text));
+  parent.appendChild(el);
+}
+function buildEntryPair(doc, baseKey, entry, categories) {
+  const keyEl = doc.createElement("key");
+  keyEl.appendChild(doc.createTextNode(baseKey));
+  const entryDict = doc.createElement("dict");
+  appendTextEl(doc, entryDict, "key", FORMAT_KEY);
+  appendTextEl(doc, entryDict, "string", entry.formatKey);
+  appendTextEl(doc, entryDict, "key", entry.variableName);
+  const ruleDict = doc.createElement("dict");
+  appendTextEl(doc, ruleDict, "key", SPEC_TYPE_KEY);
+  appendTextEl(doc, ruleDict, "string", PLURAL_RULE_TYPE);
+  appendTextEl(doc, ruleDict, "key", VALUE_TYPE_KEY);
+  appendTextEl(doc, ruleDict, "string", entry.valueType ?? DEFAULT_VALUE_TYPE);
+  for (const category of PLURAL_CATEGORIES) {
+    const text = categories.get(category);
+    if (text === void 0) {
+      continue;
+    }
+    appendTextEl(doc, ruleDict, "key", category);
+    appendTextEl(doc, ruleDict, "string", text);
+  }
+  entryDict.appendChild(ruleDict);
+  return { keyEl, dictEl: entryDict };
+}
+function synthesizeEntry(baseKey) {
+  return {
+    formatKey: `%#@${baseKey}@`,
+    variableName: baseKey,
+    valueType: void 0,
+    categories: /* @__PURE__ */ new Map()
+  };
+}
+async function serializeAppleStringsDictEntries(entries, filePath, fs) {
+  const targets = groupTargets(entries);
+  const existing = await readExistingGroups(filePath, fs, targets.size > 0);
+  if (targets.size === 0 && existing.size === 0) {
+    return void 0;
+  }
+  const doc = new DOMParser().parseFromString('<plist version="1.0"><dict/></plist>', "text/xml");
+  const plistEl = doc.documentElement;
+  const dictEl = elementChildren2(plistEl)[0];
+  const orderedKeys = [
+    ...[...existing.keys()].filter((key) => targets.has(key)),
+    ...[...targets.keys()].filter((key) => !existing.has(key))
+  ];
+  for (const baseKey of orderedKeys) {
+    const categories = targets.get(baseKey);
+    if (categories === void 0) {
+      continue;
+    }
+    const base = existing.get(baseKey) ?? synthesizeEntry(baseKey);
+    const { keyEl, dictEl: entryDictEl } = buildEntryPair(doc, baseKey, base, categories);
+    dictEl.appendChild(keyEl);
+    dictEl.appendChild(entryDictEl);
+  }
+  return `${PLIST_HEADER}${new XMLSerializer().serializeToString(doc)}`;
+}
+function stringsDictSiblingPath(filePath) {
+  return join(dirname(filePath), `${basename(filePath, extname(filePath))}.stringsdict`);
+}
+function partitionEntries(entries) {
+  const singular = /* @__PURE__ */ new Map();
+  const plural = /* @__PURE__ */ new Map();
+  for (const [key, entry] of entries) {
+    (entry.isPlural ? plural : singular).set(key, entry);
+  }
+  return { singular, plural };
+}
+async function parseAppleEntries(content, namespace, filePath, fs) {
+  const singular = parseAppleStringsEntries(content, namespace);
+  const siblingPath = stringsDictSiblingPath(filePath);
+  let siblingContent;
+  try {
+    siblingContent = await readFileContent(fs, siblingPath);
+  } catch (error) {
+    if (isEnoent(error)) {
+      return singular;
+    }
+    throw error;
+  }
+  const plural = parseAppleStringsDictEntries(siblingContent, namespace, siblingPath);
+  const merged = new Map(singular);
+  for (const [key, entry] of plural) {
+    if (merged.has(key)) {
+      throw new AdapterError(
+        "INVALID_STRUCTURE",
+        `The key "${key}" is defined both in ${filePath} and as a plural category in ${siblingPath}. Rename one of them to avoid ambiguity.`
+      );
+    }
+    merged.set(key, entry);
+  }
+  return merged;
+}
+async function serializeAppleEntries(entries, filePath, fs) {
+  const { singular, plural } = partitionEntries(entries);
+  const siblingPath = stringsDictSiblingPath(filePath);
+  const xml = await serializeAppleStringsDictEntries(plural, siblingPath, fs);
+  if (xml !== void 0) {
+    await fs.writeFileAtomic(siblingPath, xml);
+  }
+  return serializeAppleStringsEntries(singular, filePath, fs);
+}
+function createAppleStringsAdapter(fs = nodeAdapterFs) {
+  return createFlatFileAdapter({
+    fs,
+    format: "apple-strings",
+    extensions: [".strings"],
+    parseEntries: parseAppleEntries,
+    serializeEntries: serializeAppleEntries,
+    extractPlaceholders: extractAppleStringsPlaceholders
+  });
+}
+var VALID_EMPTY = { placeholders: [], isPlural: false, valid: true };
+var INVALID = { placeholders: [], isPlural: false, valid: false };
+function tokenOf(element) {
+  switch (element.type) {
+    case TYPE.argument:
+    case TYPE.number:
+    case TYPE.date:
+    case TYPE.time:
+    case TYPE.select:
+    case TYPE.plural:
+      return `{${element.value}}`;
+    case TYPE.tag:
+      return `<${element.value}>`;
+    default:
+      return void 0;
+  }
+}
+function childMessages(element) {
+  if (element.type === TYPE.plural || element.type === TYPE.select) {
+    return Object.values(element.options).map((option) => option.value);
+  }
+  if (element.type === TYPE.tag) {
+    return [element.children];
+  }
+  return [];
+}
+function addCount(target, token, count) {
+  target.set(token, (target.get(token) ?? 0) + count);
+}
+function combineBranches(branchMultisets) {
+  const combined = /* @__PURE__ */ new Map();
+  const tokens = /* @__PURE__ */ new Set();
+  for (const branch of branchMultisets) {
+    for (const token of branch.keys()) {
+      tokens.add(token);
+    }
+  }
+  for (const token of tokens) {
+    const minCount = Math.min(...branchMultisets.map((branch) => branch.get(token) ?? 0));
+    if (minCount > 0) {
+      combined.set(token, minCount);
+    }
+  }
+  return combined;
+}
+function collect(elements, state) {
+  const result = /* @__PURE__ */ new Map();
+  for (const element of elements) {
+    const token = tokenOf(element);
+    if (token !== void 0) {
+      addCount(result, token, 1);
+    }
+    if (element.type === TYPE.plural) {
+      state.isPlural = true;
+    }
+    const branches = childMessages(element);
+    if (branches.length > 0) {
+      const branchMultisets = branches.map((branch) => collect(branch, state));
       for (const [branchToken, branchCount] of combineBranches(branchMultisets)) {
         addCount(result, branchToken, branchCount);
       }
@@ -2812,16 +4407,6 @@ function compareIcuPlaceholders(sourceValue, targetValue) {
     return checkPlaceholders(icuPlaceholders(sourceValue), icuPlaceholders(targetValue));
   }
 }
-var AdapterError = class extends Error {
-  code;
-  constructor(code, message) {
-    super(message);
-    this.name = "AdapterError";
-    this.code = code;
-  }
-};
-var MAX_DEPTH = 100;
-var MAX_INPUT_BYTES = 16 * 1024 * 1024;
 var SENTINEL_ESCAPE = "\\u0001";
 function isJsonWhitespace(char) {
   return char === " " || char === "	" || char === "\n" || char === "\r";
@@ -2994,77 +4579,17 @@ function assertJsonRecord(value) {
   assertNodesValid(value);
   return value;
 }
-function parseJsonObject(content) {
-  return assertJsonRecord(parseOrderedJson(content));
-}
-function serializeJsonTree(tree) {
-  return serializeOrderedJson(tree);
-}
-function isJsonNode(value) {
-  return value instanceof Map;
-}
-function sniffJsonObject(sample) {
-  return sample.trimStart().startsWith("{");
-}
-function scanTokens(value, pattern, extract = (match) => match[0]) {
-  const result = [];
-  for (const match of value.matchAll(pattern)) {
-    const token = extract(match);
-    if (token !== void 0) {
-      result.push(token);
-    }
-  }
-  return result;
-}
-function namespaceOf(filePath) {
-  return basename(filePath, extname(filePath));
-}
-function isEnoent(error) {
-  return error instanceof Error && "code" in error && error.code === "ENOENT";
-}
-function rethrowStructured(error, message) {
-  if (error instanceof AdapterError) {
-    throw error;
-  }
-  throw new AdapterError("INVALID_STRUCTURE", message);
-}
-function computeIcu(entries, compute) {
-  if (!compute) {
-    return [];
-  }
-  try {
-    return compute(entries);
-  } catch (error) {
-    rethrowStructured(error, "The file could not be analyzed for message validity.");
-  }
-}
-function buildCanHandle(extensions, sniff) {
-  return (filePath, sample) => {
-    if (!extensions.includes(extname(filePath).toLowerCase())) {
-      return false;
-    }
-    return sample === void 0 || sniff === void 0 || sniff(sample);
-  };
-}
-function stripLeadingBom(content) {
-  return content.charCodeAt(0) === 65279 ? content.slice(1) : content;
-}
-async function readBoundedFile(fs, filePath) {
-  const outcome = await fs.readBounded(filePath, MAX_INPUT_BYTES);
-  return outcome.kind === "ok" ? { kind: "ok", content: stripLeadingBom(outcome.content) } : outcome;
+function parseJsonObject(content) {
+  return assertJsonRecord(parseOrderedJson(content));
 }
-function outcomeToContent(outcome, notAFileMessage) {
-  if (outcome.kind === "not-a-file") {
-    throw new AdapterError("INVALID_STRUCTURE", notAFileMessage);
-  }
-  if (outcome.kind === "too-large") {
-    throw new AdapterError("INPUT_TOO_LARGE", "The file exceeds the maximum allowed size.");
-  }
-  return outcome.content;
+function serializeJsonTree(tree) {
+  return serializeOrderedJson(tree);
 }
-async function readFileContent(fs, filePath) {
-  const outcome = await readBoundedFile(fs, filePath);
-  return outcomeToContent(outcome, "The path is not a regular file.");
+function isJsonNode(value) {
+  return value instanceof Map;
+}
+function sniffJsonObject(sample) {
+  return sample.trimStart().startsWith("{");
 }
 var BACKSLASH = "\\";
 var DOT = ".";
@@ -3248,7 +4773,7 @@ function mergeDescriptions(entries, content, deriveDescriptions) {
     }
   }
 }
-function toEntries(content, namespace, parse3, deriveEntry, keyMode, validateTree, deriveDescriptions) {
+function toEntries2(content, namespace, parse3, deriveEntry, keyMode, validateTree, deriveDescriptions) {
   try {
     const tree = parse3(content);
     validateTree?.(tree);
@@ -3286,7 +4811,7 @@ function createTreeFileAdapter(options) {
     async read(filePath, locale) {
       const content = await readFileContent(fs, filePath);
       const namespace = namespaceOf(filePath);
-      const { entries, excludedLeafPaths } = toEntries(
+      const { entries, excludedLeafPaths } = toEntries2(
         content,
         namespace,
         parse3,
@@ -3305,114 +4830,781 @@ function createTreeFileAdapter(options) {
     }
   };
 }
-function isMetadataKey(key) {
-  return key.startsWith("@");
+function isMetadataKey(key) {
+  return key.startsWith("@");
+}
+function parseArbObject(content) {
+  const parsed = parseOrderedJson(content);
+  if (!(parsed instanceof Map)) {
+    throw new AdapterError(
+      "INVALID_STRUCTURE",
+      "The file is not a valid object (expected nested objects of string values)."
+    );
+  }
+  return parsed;
+}
+function stripArbMetadata(tree) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [key, value] of tree) {
+    if (!isMetadataKey(key)) {
+      out.set(key, value);
+    }
+  }
+  return out;
+}
+function originalKey(encoded) {
+  return decodeKeyToSegments(encoded).join(".");
+}
+function messageKeyForMetadata(key) {
+  return isMetadataKey(key) && !key.startsWith("@@") ? key.slice(1) : null;
+}
+function descriptionOf(value) {
+  if (!(value instanceof Map)) {
+    return void 0;
+  }
+  const description = value.get("description");
+  return typeof description === "string" ? description : void 0;
+}
+function extractArbDescriptions(content) {
+  const tree = parseArbObject(content);
+  const out = /* @__PURE__ */ new Map();
+  for (const [key, value] of tree) {
+    const messageKey = messageKeyForMetadata(key);
+    if (messageKey === null) {
+      continue;
+    }
+    const description = descriptionOf(value);
+    if (description !== void 0) {
+      out.set(encodeSegment(messageKey), description);
+    }
+  }
+  return out;
+}
+function messagesFromEntries(entries) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [key, entry] of entries) {
+    out.set(originalKey(key), entry.value);
+  }
+  return out;
+}
+async function readDestinationPairs(filePath, fs) {
+  let content;
+  try {
+    content = await readFileContent(fs, filePath);
+  } catch (error) {
+    if (isEnoent(error)) {
+      return null;
+    }
+    throw error;
+  }
+  return [...parseArbObject(content)];
+}
+async function buildArbWriteTree(entries, filePath, fs) {
+  const messages = messagesFromEntries(entries);
+  const pairs = await readDestinationPairs(filePath, fs);
+  const out = /* @__PURE__ */ new Map();
+  const consumed = /* @__PURE__ */ new Set();
+  for (const [key, value] of pairs ?? []) {
+    const translated = isMetadataKey(key) ? void 0 : messages.get(key);
+    if (translated !== void 0) {
+      consumed.add(key);
+      out.set(key, translated);
+    } else if (isMetadataKey(key) || typeof value === "string") {
+      out.set(key, value);
+    }
+  }
+  for (const [key, value] of messages) {
+    if (!consumed.has(key)) {
+      out.set(key, value);
+    }
+  }
+  return out;
+}
+function parseArb(content) {
+  return assertJsonRecord(stripArbMetadata(parseArbObject(content)));
+}
+function createArbAdapter(fs = nodeAdapterFs) {
+  return createTreeFileAdapter({
+    fs,
+    format: "arb",
+    extensions: [".arb"],
+    sniff: sniffJsonObject,
+    parse: parseArb,
+    serialize: serializeJsonTree,
+    extractPlaceholders: icuPlaceholders,
+    deriveEntry: icuDeriveEntry,
+    computeInvalidIcuKeys: icuInvalidKeys,
+    validateMessage: icuIsValid,
+    comparePlaceholders: compareIcuPlaceholders,
+    buildWriteTree: buildArbWriteTree,
+    deriveDescriptions: extractArbDescriptions
+  });
+}
+var SIMPLE_ESCAPES = {
+  n: "\n",
+  t: "	",
+  r: "\r",
+  a: "\x07",
+  b: "\b",
+  f: "\f",
+  v: "\v",
+  "0": "\0",
+  '"': '"',
+  "\\": "\\"
+};
+var OCTAL_DIGIT = /[0-7]/;
+function decodeHexEscape(raw, at, line) {
+  let hex = "";
+  let i = at;
+  while (i < raw.length && hex.length < 2 && /[0-9a-fA-F]/.test(raw[i] ?? "")) {
+    hex += raw[i];
+    i += 1;
+  }
+  if (hex === "") {
+    throw new AdapterError(
+      "INVALID_STRUCTURE",
+      `The .po/.pot file has a malformed \\x escape (line ${line}).`
+    );
+  }
+  return { char: String.fromCharCode(Number.parseInt(hex, 16)), next: i };
+}
+function decodeOctalEscape(raw, at) {
+  let octal = "";
+  let i = at;
+  while (i < raw.length && octal.length < 3 && OCTAL_DIGIT.test(raw[i] ?? "")) {
+    octal += raw[i];
+    i += 1;
+  }
+  return { char: String.fromCharCode(Number.parseInt(octal, 8)), next: i };
+}
+function decodeCString(raw, line) {
+  let out = "";
+  let i = 0;
+  while (i < raw.length) {
+    const char = raw[i];
+    if (char !== "\\") {
+      out += char;
+      i += 1;
+      continue;
+    }
+    const next = raw[i + 1];
+    if (next === void 0) {
+      throw new AdapterError(
+        "INVALID_STRUCTURE",
+        `The .po/.pot file has a trailing, unterminated escape (line ${line}).`
+      );
+    }
+    if (next === "x") {
+      const hex = decodeHexEscape(raw, i + 2, line);
+      out += hex.char;
+      i = hex.next;
+      continue;
+    }
+    if (OCTAL_DIGIT.test(next)) {
+      const octal = decodeOctalEscape(raw, i + 1);
+      out += octal.char;
+      i = octal.next;
+      continue;
+    }
+    const simple = SIMPLE_ESCAPES[next];
+    if (simple === void 0) {
+      throw new AdapterError(
+        "INVALID_STRUCTURE",
+        `The .po/.pot file has an unknown escape sequence "\\${next}" (line ${line}).`
+      );
+    }
+    out += simple;
+    i += 2;
+  }
+  return out;
+}
+function escapeChar3(char) {
+  switch (char) {
+    case "\\":
+      return "\\\\";
+    case '"':
+      return '\\"';
+    case "\n":
+      return "\\n";
+    case "	":
+      return "\\t";
+    case "\r":
+      return "\\r";
+  }
+  const code = char.charCodeAt(0);
+  return code < 32 ? `\\x${code.toString(16).padStart(2, "0")}` : char;
+}
+function encodeCString(value) {
+  let out = "";
+  for (const char of value) {
+    out += escapeChar3(char);
+  }
+  return out;
+}
+var CONTEXT_SEPARATOR = "\uE000";
+var PLURAL_SUFFIX2 = /^\[(\d+)\]$/;
+function assertNoReservedChar(raw, field) {
+  if (raw.includes(CONTEXT_SEPARATOR)) {
+    throw new AdapterError(
+      "INVALID_STRUCTURE",
+      `The ${field} value contains a reserved private-use character (U+E000) that verbatra uses internally to combine msgctxt and msgid into one key. Remove it from the source file.`
+    );
+  }
+}
+function escapeBase(raw) {
+  return raw.replace(/\\/g, "\\\\").replace(/\[/g, "\\[");
+}
+function unescapeBase(escaped) {
+  let out = "";
+  let i = 0;
+  while (i < escaped.length) {
+    const char = escaped[i];
+    if (char === "\\" && i + 1 < escaped.length) {
+      out += escaped[i + 1];
+      i += 2;
+      continue;
+    }
+    out += char;
+    i += 1;
+  }
+  return out;
+}
+function findUnescapedBracket(base) {
+  let i = 0;
+  while (i < base.length) {
+    if (base[i] === "\\") {
+      i += 2;
+      continue;
+    }
+    if (base[i] === "[") {
+      return i;
+    }
+    i += 1;
+  }
+  return -1;
+}
+function composeKey(msgctxt, msgid, pluralIndex) {
+  assertNoReservedChar(msgid, "msgid");
+  if (msgctxt !== void 0) {
+    assertNoReservedChar(msgctxt, "msgctxt");
+  }
+  const base = msgctxt === void 0 ? escapeBase(msgid) : `${escapeBase(msgctxt)}${CONTEXT_SEPARATOR}${escapeBase(msgid)}`;
+  return pluralIndex === void 0 ? base : `${base}[${pluralIndex}]`;
+}
+function decomposeKey(key) {
+  const bracketAt = findUnescapedBracket(key);
+  let base = key;
+  let pluralIndex;
+  if (bracketAt !== -1) {
+    const suffix = key.slice(bracketAt);
+    const match = PLURAL_SUFFIX2.exec(suffix);
+    if (!match) {
+      throw new AdapterError(
+        "INVALID_STRUCTURE",
+        `The key "${key}" has a malformed plural-index suffix.`
+      );
+    }
+    base = key.slice(0, bracketAt);
+    pluralIndex = Number(match[1]);
+  }
+  const separatorAt = base.indexOf(CONTEXT_SEPARATOR);
+  if (separatorAt === -1) {
+    return { msgctxt: void 0, msgid: unescapeBase(base), pluralIndex };
+  }
+  return {
+    msgctxt: unescapeBase(base.slice(0, separatorAt)),
+    msgid: unescapeBase(base.slice(separatorAt + 1)),
+    pluralIndex
+  };
+}
+var GETTEXT_PLACEHOLDER = /%(?:\((\w+)\))?(?:(\d+)\$)?[-+0 #]*(?:[1-9]\d*)?(?:\.\d+)?([disuoxXfFeEgGc])|%%/g;
+function extractGettextPlaceholders(value) {
+  const out = [];
+  for (const match of value.matchAll(GETTEXT_PLACEHOLDER)) {
+    if (match[0] === "%%") {
+      out.push("%%");
+      continue;
+    }
+    const [, name, position, conversion] = match;
+    if (conversion === void 0) {
+      continue;
+    }
+    if (name !== void 0) {
+      out.push(`%(${name})${conversion}`);
+    } else if (position !== void 0) {
+      out.push(`%${position}$${conversion}`);
+    } else {
+      out.push(`%${conversion}`);
+    }
+  }
+  return out;
+}
+var HEADER_FIELD = /^([\w-]+):\s?(.*)$/;
+var NPLURALS = /nplurals\s*=\s*(\d+)/;
+function parseHeaderFields(headerText) {
+  const fields = /* @__PURE__ */ new Map();
+  for (const line of headerText.split("\n")) {
+    const match = HEADER_FIELD.exec(line);
+    if (match?.[1] !== void 0 && match[2] !== void 0) {
+      fields.set(match[1], match[2]);
+    }
+  }
+  return fields;
+}
+function parseNplurals(pluralFormsValue) {
+  const match = NPLURALS.exec(pluralFormsValue);
+  return match?.[1] === void 0 ? void 0 : Number(match[1]);
+}
+function defaultPluralFormsExpression(nplurals) {
+  if (nplurals <= 1) {
+    return "nplurals=1; plural=0;";
+  }
+  if (nplurals === 2) {
+    return "nplurals=2; plural=(n != 1);";
+  }
+  return `nplurals=${nplurals}; plural=(n < ${nplurals - 1} ? n : ${nplurals - 1});`;
+}
+function joinSelfTerminated(lines, terminator) {
+  return lines.map((line) => `${line}${terminator}`).join("");
+}
+function isCommentLine(line) {
+  return line.trimStart().startsWith("#");
+}
+function isObsoleteLine(line) {
+  return line.trimStart().startsWith("#~");
+}
+function isExtractedCommentLine(line) {
+  return line.trimStart().startsWith("#.");
+}
+function extractedCommentText(line) {
+  const rest = line.trimStart().slice(2);
+  return rest.startsWith(" ") ? rest.slice(1) : rest;
+}
+function parseQuotedOnLine(line, lineNo) {
+  const trimmed = line.trim();
+  if (trimmed[0] !== '"') {
+    throw new AdapterError(
+      "INVALID_STRUCTURE",
+      `The .po/.pot file expected a quoted string (line ${lineNo}).`
+    );
+  }
+  let i = 1;
+  let raw = "";
+  while (i < trimmed.length && trimmed[i] !== '"') {
+    if (trimmed[i] === "\\") {
+      const next = trimmed[i + 1];
+      if (next === void 0) {
+        throw new AdapterError(
+          "INVALID_STRUCTURE",
+          `The .po/.pot file has an unterminated escape in a quoted string (line ${lineNo}).`
+        );
+      }
+      raw += trimmed[i] + next;
+      i += 2;
+      continue;
+    }
+    raw += trimmed[i];
+    i += 1;
+  }
+  if (trimmed[i] !== '"') {
+    throw new AdapterError(
+      "INVALID_STRUCTURE",
+      `The .po/.pot file has an unterminated quoted string (line ${lineNo}).`
+    );
+  }
+  if (i !== trimmed.length - 1) {
+    throw new AdapterError(
+      "INVALID_STRUCTURE",
+      `The .po/.pot file has unexpected content after a quoted string (line ${lineNo}).`
+    );
+  }
+  return decodeCString(raw, lineNo);
+}
+function isBareQuotedLine(line) {
+  return line.trim().startsWith('"');
+}
+function gatherStringValue(lines, start, keyword) {
+  const firstLine = (lines[start] ?? "").trim();
+  const rest = firstLine.slice(keyword.length).trim();
+  let decoded = parseQuotedOnLine(rest, start + 1);
+  let i = start + 1;
+  while (i < lines.length && isBareQuotedLine(lines[i] ?? "")) {
+    decoded += parseQuotedOnLine((lines[i] ?? "").trim(), i + 1);
+    i += 1;
+  }
+  return { decoded, nextIndex: i };
+}
+var MSGSTR_INDEX = /^msgstr\[(\d+)\]/;
+function parseLeadingComments(lines, start) {
+  const descriptionParts = [];
+  let i = start;
+  while (i < lines.length && isCommentLine(lines[i] ?? "")) {
+    const line = lines[i] ?? "";
+    if (isExtractedCommentLine(line)) {
+      descriptionParts.push(extractedCommentText(line));
+    }
+    i += 1;
+  }
+  return {
+    description: descriptionParts.length > 0 ? descriptionParts.join("\n") : void 0,
+    next: i
+  };
+}
+function parseOptionalMsgctxt(lines, start) {
+  if (!/^msgctxt\s+"/.test((lines[start] ?? "").trim())) {
+    return { msgctxt: void 0, next: start };
+  }
+  const result = gatherStringValue(lines, start, "msgctxt");
+  return { msgctxt: result.decoded, next: result.nextIndex };
 }
-function parseArbObject(content) {
-  const parsed = parseOrderedJson(content);
-  if (!(parsed instanceof Map)) {
+function parsePluralMsgstrs(lines, start, msgid) {
+  const values = /* @__PURE__ */ new Map();
+  let i = start;
+  while (/^msgstr\[\d+\]\s*"/.test((lines[i] ?? "").trim())) {
+    const trimmed = (lines[i] ?? "").trim();
+    const match = MSGSTR_INDEX.exec(trimmed);
+    const index = Number(match?.[1] ?? "0");
+    if (index !== values.size) {
+      throw new AdapterError(
+        "INVALID_STRUCTURE",
+        `The .po/.pot file has a non-contiguous plural index for msgid "${msgid}": expected msgstr[${values.size}], found msgstr[${index}] (line ${i + 1}).`
+      );
+    }
+    const result = gatherStringValue(lines, i, `msgstr[${index}]`);
+    values.set(index, result.decoded);
+    i = result.nextIndex;
+  }
+  if (values.size === 0) {
     throw new AdapterError(
       "INVALID_STRUCTURE",
-      "The file is not a valid object (expected nested objects of string values)."
+      `The .po/.pot file is missing msgstr[n] forms for the plural msgid "${msgid}" (line ${start + 1}).`
     );
   }
-  return parsed;
+  return { values, next: i };
 }
-function stripArbMetadata(tree) {
-  const out = /* @__PURE__ */ new Map();
-  for (const [key, value] of tree) {
-    if (!isMetadataKey(key)) {
-      out.set(key, value);
+function parseRecord(lines, start, terminator) {
+  const comments = parseLeadingComments(lines, start);
+  let i = comments.next;
+  if (i >= lines.length) {
+    throw new AdapterError(
+      "INVALID_STRUCTURE",
+      `The .po/.pot file ends after a comment block with no entry following it (line ${i}).`
+    );
+  }
+  const ctx = parseOptionalMsgctxt(lines, i);
+  i = ctx.next;
+  if (!/^msgid\s+"/.test((lines[i] ?? "").trim())) {
+    throw new AdapterError(
+      "INVALID_STRUCTURE",
+      `The .po/.pot file expected "msgid" (line ${i + 1}).`
+    );
+  }
+  const msgidResult = gatherStringValue(lines, i, "msgid");
+  i = msgidResult.nextIndex;
+  let msgidPlural;
+  if (/^msgid_plural\s+"/.test((lines[i] ?? "").trim())) {
+    const result = gatherStringValue(lines, i, "msgid_plural");
+    msgidPlural = result.decoded;
+    i = result.nextIndex;
+  }
+  const prefixRaw = joinSelfTerminated(lines.slice(start, i), terminator);
+  if (msgidPlural !== void 0) {
+    const plural = parsePluralMsgstrs(lines, i, msgidResult.decoded);
+    return {
+      msgctxt: ctx.msgctxt,
+      msgid: msgidResult.decoded,
+      msgidPlural,
+      description: comments.description,
+      prefixRaw,
+      singularValue: void 0,
+      pluralValues: plural.values,
+      entryEndIndex: plural.next
+    };
+  }
+  if (!/^msgstr\s+"/.test((lines[i] ?? "").trim())) {
+    throw new AdapterError(
+      "INVALID_STRUCTURE",
+      `The .po/.pot file expected "msgstr" for msgid "${msgidResult.decoded}" (line ${i + 1}).`
+    );
+  }
+  const msgstrResult = gatherStringValue(lines, i, "msgstr");
+  return {
+    msgctxt: ctx.msgctxt,
+    msgid: msgidResult.decoded,
+    msgidPlural: void 0,
+    description: comments.description,
+    prefixRaw,
+    singularValue: msgstrResult.decoded,
+    pluralValues: void 0,
+    entryEndIndex: msgstrResult.nextIndex
+  };
+}
+function isHeaderRecord(record) {
+  return record.msgctxt === void 0 && record.msgid === "" && record.msgidPlural === void 0;
+}
+function scanPo(content) {
+  const terminator = detectLineTerminator(content);
+  const lines = splitPhysicalLines(content);
+  const nodes = [];
+  let raw = [];
+  let headerFields;
+  const flushRaw = () => {
+    if (raw.length > 0) {
+      nodes.push({ kind: "raw", text: joinSelfTerminated(raw, terminator) });
+      raw = [];
+    }
+  };
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i] ?? "";
+    if (line.trim() === "") {
+      raw.push(line);
+      i += 1;
+      continue;
+    }
+    if (isObsoleteLine(line)) {
+      while (i < lines.length && isObsoleteLine(lines[i] ?? "")) {
+        raw.push(lines[i] ?? "");
+        i += 1;
+      }
+      continue;
+    }
+    const record = parseRecord(lines, i, terminator);
+    if (isHeaderRecord(record)) {
+      flushRaw();
+      nodes.push({
+        kind: "raw",
+        text: joinSelfTerminated(lines.slice(i, record.entryEndIndex), terminator)
+      });
+      headerFields = parseHeaderFields(record.singularValue ?? "");
+      i = record.entryEndIndex;
+      continue;
     }
+    flushRaw();
+    nodes.push({
+      kind: "entry",
+      prefixRaw: record.prefixRaw,
+      msgctxt: record.msgctxt,
+      msgid: record.msgid,
+      msgidPlural: record.msgidPlural,
+      description: record.description,
+      singularValue: record.singularValue,
+      pluralValues: record.pluralValues
+    });
+    i = record.entryEndIndex;
   }
-  return out;
+  flushRaw();
+  return { nodes, terminator, headerFields };
 }
-function originalKey(encoded) {
-  return decodeKeyToSegments(encoded).join(".");
+function assertPluralIndicesInRange(node, pluralValues, nplurals) {
+  if (nplurals === void 0) {
+    throw new AdapterError(
+      "INVALID_STRUCTURE",
+      `The msgid "${node.msgid}" has plural forms, but the file has no "Plural-Forms" header declaring nplurals.`
+    );
+  }
+  const maxIndex = Math.max(...pluralValues.keys());
+  if (maxIndex >= nplurals) {
+    throw new AdapterError(
+      "INVALID_STRUCTURE",
+      `The msgid "${node.msgid}" has msgstr[${maxIndex}], but the header declares nplurals=${nplurals} (valid indices 0..${nplurals - 1}).`
+    );
+  }
+  return maxIndex;
 }
-function messageKeyForMetadata(key) {
-  return isMetadataKey(key) && !key.startsWith("@@") ? key.slice(1) : null;
+function addPluralEntries(entries, node, pluralValues, namespace, nplurals) {
+  assertPluralIndicesInRange(node, pluralValues, nplurals);
+  for (const [index, value] of pluralValues) {
+    const key = composeKey(node.msgctxt, node.msgid, index);
+    entries.set(key, {
+      key,
+      namespace,
+      value,
+      placeholders: extractGettextPlaceholders(value),
+      isPlural: true,
+      ...node.msgidPlural !== void 0 ? { meaning: node.msgidPlural } : {},
+      ...node.description !== void 0 ? { description: node.description } : {}
+    });
+  }
 }
-function descriptionOf(value) {
-  if (!(value instanceof Map)) {
+function addSingularEntry(entries, node, namespace) {
+  const key = composeKey(node.msgctxt, node.msgid);
+  const value = node.singularValue ?? "";
+  entries.set(key, {
+    key,
+    namespace,
+    value,
+    placeholders: extractGettextPlaceholders(value),
+    isPlural: false,
+    ...node.description !== void 0 ? { description: node.description } : {}
+  });
+}
+function headerNplurals(doc) {
+  if (doc.headerFields === void 0) {
     return void 0;
   }
-  const description = value.get("description");
-  return typeof description === "string" ? description : void 0;
+  return parseNplurals(doc.headerFields.get("Plural-Forms") ?? "");
 }
-function extractArbDescriptions(content) {
-  const tree = parseArbObject(content);
-  const out = /* @__PURE__ */ new Map();
-  for (const [key, value] of tree) {
-    const messageKey = messageKeyForMetadata(key);
-    if (messageKey === null) {
+function parsePoEntries(content, namespace) {
+  const doc = scanPo(content);
+  const nplurals = headerNplurals(doc);
+  const entries = /* @__PURE__ */ new Map();
+  for (const node of doc.nodes) {
+    if (node.kind !== "entry") {
       continue;
     }
-    const description = descriptionOf(value);
-    if (description !== void 0) {
-      out.set(encodeSegment(messageKey), description);
+    if (node.pluralValues !== void 0) {
+      addPluralEntries(entries, node, node.pluralValues, namespace, nplurals);
+      continue;
     }
+    addSingularEntry(entries, node, namespace);
   }
-  return out;
+  return entries;
 }
-function messagesFromEntries(entries) {
-  const out = /* @__PURE__ */ new Map();
+function groupEntries2(entries) {
+  const groups = /* @__PURE__ */ new Map();
   for (const [key, entry] of entries) {
-    out.set(originalKey(key), entry.value);
+    const decomposed = decomposeKey(key);
+    const groupKey = composeKey(decomposed.msgctxt, decomposed.msgid);
+    let group = groups.get(groupKey);
+    if (group === void 0) {
+      group = {
+        msgctxt: decomposed.msgctxt,
+        msgid: decomposed.msgid,
+        msgidPlural: void 0,
+        values: /* @__PURE__ */ new Map()
+      };
+      groups.set(groupKey, group);
+    }
+    if (decomposed.pluralIndex !== void 0 && entry.meaning !== void 0) {
+      group.msgidPlural = entry.meaning;
+    }
+    group.values.set(decomposed.pluralIndex, entry.value);
   }
-  return out;
+  return groups;
 }
-async function readDestinationPairs(filePath, fs) {
-  let content;
-  try {
-    content = await readFileContent(fs, filePath);
-  } catch (error) {
-    if (isEnoent(error)) {
-      return null;
+function renderNewGroup(group, terminator) {
+  const lines = [];
+  if (group.msgctxt !== void 0) {
+    lines.push(`msgctxt "${encodeCString(group.msgctxt)}"`);
+  }
+  lines.push(`msgid "${encodeCString(group.msgid)}"`);
+  const pluralPairs = [...group.values.entries()].filter((pair) => pair[0] !== void 0).sort((a, b) => a[0] - b[0]);
+  if (pluralPairs.length > 0) {
+    lines.push(`msgid_plural "${encodeCString(group.msgidPlural ?? group.msgid)}"`);
+    for (const [index, value] of pluralPairs) {
+      lines.push(`msgstr[${index}] "${encodeCString(value)}"`);
     }
-    throw error;
+  } else {
+    const singular = group.values.get(void 0);
+    lines.push(`msgstr "${encodeCString(singular ?? "")}"`);
   }
-  return [...parseArbObject(content)];
+  return `${joinSelfTerminated(lines, terminator)}${terminator}`;
 }
-async function buildArbWriteTree(entries, filePath, fs) {
-  const messages = messagesFromEntries(entries);
-  const pairs = await readDestinationPairs(filePath, fs);
-  const out = /* @__PURE__ */ new Map();
-  const consumed = /* @__PURE__ */ new Set();
-  for (const [key, value] of pairs ?? []) {
-    const translated = isMetadataKey(key) ? void 0 : messages.get(key);
-    if (translated !== void 0) {
-      consumed.add(key);
-      out.set(key, translated);
-    } else if (isMetadataKey(key) || typeof value === "string") {
-      out.set(key, value);
+function renderMsgstrLine(index, value, terminator) {
+  const keyword = index === void 0 ? "msgstr" : `msgstr[${index}]`;
+  return `${keyword} "${encodeCString(value)}"${terminator}`;
+}
+function appendNewEntries(entries, emitted, terminator) {
+  const pending = /* @__PURE__ */ new Map();
+  for (const [key, entry] of entries) {
+    if (!emitted.has(key)) {
+      pending.set(key, entry);
     }
   }
-  for (const [key, value] of messages) {
-    if (!consumed.has(key)) {
-      out.set(key, value);
+  if (pending.size === 0) {
+    return "";
+  }
+  let out = "";
+  for (const group of groupEntries2(pending).values()) {
+    out += renderNewGroup(group, terminator);
+  }
+  return out;
+}
+function rewriteDocument(doc, entries) {
+  const emitted = /* @__PURE__ */ new Set();
+  const parts = [];
+  for (const node of doc.nodes) {
+    if (node.kind === "raw") {
+      parts.push(node.text);
+      continue;
+    }
+    if (node.pluralValues !== void 0) {
+      const survivors = [...node.pluralValues.keys()].map((index) => ({ index, key: composeKey(node.msgctxt, node.msgid, index) })).map(({ index, key: key2 }) => ({ index, key: key2, entry: entries.get(key2) })).filter(
+        (candidate) => candidate.entry !== void 0
+      ).sort((a, b) => a.index - b.index);
+      if (survivors.length === 0) {
+        continue;
+      }
+      parts.push(node.prefixRaw);
+      for (const { index, key: key2, entry: entry2 } of survivors) {
+        parts.push(renderMsgstrLine(index, entry2.value, doc.terminator));
+        emitted.add(key2);
+      }
+      continue;
+    }
+    const key = composeKey(node.msgctxt, node.msgid);
+    const entry = entries.get(key);
+    if (entry === void 0) {
+      continue;
+    }
+    parts.push(node.prefixRaw);
+    parts.push(renderMsgstrLine(void 0, entry.value, doc.terminator));
+    emitted.add(key);
+  }
+  return parts.join("") + appendNewEntries(entries, emitted, doc.terminator);
+}
+function synthesizeFromScratch(entries) {
+  const terminator = "\n";
+  const groups = groupEntries2(entries);
+  let maxIndex = -1;
+  for (const group of groups.values()) {
+    for (const index of group.values.keys()) {
+      if (index !== void 0 && index > maxIndex) {
+        maxIndex = index;
+      }
     }
   }
+  const headerLines = [
+    'msgid ""',
+    'msgstr ""',
+    '"Content-Type: text/plain; charset=UTF-8\\n"',
+    '"Content-Transfer-Encoding: 8bit\\n"'
+  ];
+  if (maxIndex >= 0) {
+    headerLines.push(`"Plural-Forms: ${defaultPluralFormsExpression(maxIndex + 1)}\\n"`);
+  }
+  let out = `${joinSelfTerminated(headerLines, terminator)}${terminator}`;
+  for (const group of groups.values()) {
+    out += renderNewGroup(group, terminator);
+  }
   return out;
 }
-function parseArb(content) {
-  return assertJsonRecord(stripArbMetadata(parseArbObject(content)));
+async function readDestination2(filePath, fs) {
+  let outcome;
+  try {
+    outcome = await readBoundedFile(fs, filePath);
+  } catch (error) {
+    if (isEnoent(error)) {
+      return void 0;
+    }
+    throw new AdapterError("INVALID_STRUCTURE", "The destination file could not be read.");
+  }
+  const content = outcomeToContent(outcome, "The destination path is not a regular file.");
+  return scanPo(content);
 }
-function createArbAdapter(fs = nodeAdapterFs) {
-  return createTreeFileAdapter({
+async function serializePoEntries(entries, filePath, fs) {
+  const doc = await readDestination2(filePath, fs);
+  return doc === void 0 ? synthesizeFromScratch(entries) : rewriteDocument(doc, entries);
+}
+function createGettextAdapter(fs = nodeAdapterFs) {
+  return createFlatFileAdapter({
     fs,
-    format: "arb",
-    extensions: [".arb"],
-    sniff: sniffJsonObject,
-    parse: parseArb,
-    serialize: serializeJsonTree,
-    extractPlaceholders: icuPlaceholders,
-    deriveEntry: icuDeriveEntry,
-    computeInvalidIcuKeys: icuInvalidKeys,
-    validateMessage: icuIsValid,
-    comparePlaceholders: compareIcuPlaceholders,
-    buildWriteTree: buildArbWriteTree,
-    deriveDescriptions: extractArbDescriptions
+    format: "gettext-po",
+    extensions: [".po", ".pot"],
+    parseEntries: parsePoEntries,
+    serializeEntries: serializePoEntries,
+    extractPlaceholders: extractGettextPlaceholders
   });
 }
 function createJsonFileAdapter(options) {
@@ -3464,23 +5656,6 @@ function extractDoubleBracePlaceholders(value) {
 function extractI18nextPlaceholders(value) {
   return scanTokens(value, I18NEXT_PATTERN);
 }
-var PLURAL_SUFFIX = /_(zero|one|two|few|many|other)$/;
-function isPluralKey(key) {
-  return PLURAL_SUFFIX.test(key);
-}
-function pluralCategoryOf(key) {
-  const match = PLURAL_SUFFIX.exec(key);
-  return match?.[1];
-}
-function pluralBaseKey(key) {
-  if (!isPluralKey(key)) {
-    return void 0;
-  }
-  return key.replace(PLURAL_SUFFIX, "");
-}
-function makePluralKey(baseKey, category) {
-  return `${baseKey}_${category}`;
-}
 function createI18nextJsonAdapter(fs = nodeAdapterFs) {
   return createJsonFileAdapter({
     fs,
@@ -3583,44 +5758,6 @@ function createNgxTranslateJsonAdapter(fs = nodeAdapterFs) {
     keyMode: "path-notation"
   });
 }
-function toEntries2(content, namespace, parseEntries) {
-  try {
-    return parseEntries(content, namespace);
-  } catch (error) {
-    rethrowStructured(error, "The file could not be parsed.");
-  }
-}
-function createFlatFileAdapter(options) {
-  const {
-    format,
-    extensions,
-    sniff,
-    parseEntries,
-    serializeEntries,
-    extractPlaceholders,
-    validateMessage,
-    computeInvalidIcuKeys,
-    fs = nodeAdapterFs
-  } = options;
-  return {
-    format,
-    canHandle: buildCanHandle(extensions, sniff),
-    extractPlaceholders,
-    validateMessage: validateMessage ?? (() => true),
-    async read(filePath, locale) {
-      const content = await readFileContent(fs, filePath);
-      const namespace = namespaceOf(filePath);
-      const entries = toEntries2(content, namespace, parseEntries);
-      const resource = { locale, namespace, format, entries };
-      const invalidIcuKeys = computeIcu(entries, computeInvalidIcuKeys);
-      return { resource, invalidIcuKeys, excludedLeafPaths: [] };
-    },
-    async write(resource, filePath) {
-      const data = await serializeEntries(resource.entries, filePath, fs);
-      await fs.writeFileAtomic(filePath, data);
-    }
-  };
-}
 var SUBMESSAGE_TYPES = /* @__PURE__ */ new Set(["plural", "select", "selectordinal", "choice"]);
 var ARGUMENT_NAME = /^(?:\d+|[A-Za-z_$][\w$-]*)$/;
 function matchingBraces(value) {
@@ -3719,28 +5856,11 @@ function extractPropertiesPlaceholders(value) {
   scanRange(value, matchingBraces(value), 0, value.length, true, out);
   return out;
 }
-var UNICODE_ESCAPE = /^[0-9a-fA-F]{4}$/;
+var UNICODE_ESCAPE3 = /^[0-9a-fA-F]{4}$/;
 var LEADING_WHITESPACE = /^[ \t\f]+/;
-var TRAILING_TERMINATOR = /(?:\r\n|\r|\n)$/;
-function detectLineTerminator(content) {
-  if (content.includes("\r\n")) {
-    return "\r\n";
-  }
-  return content.includes("\r") ? "\r" : "\n";
-}
 function isPropertiesWhitespace(char) {
   return char === " " || char === "	" || char === "\f";
 }
-function splitPhysicalLines(content) {
-  if (content === "") {
-    return [];
-  }
-  const lines = content.split(/\r\n|\r|\n/);
-  if (TRAILING_TERMINATOR.test(content)) {
-    lines.pop();
-  }
-  return lines;
-}
 function countTrailingBackslashes(line) {
   let count = 0;
   for (let i = line.length - 1; i >= 0 && line[i] === "\\"; i -= 1) {
@@ -3754,7 +5874,7 @@ function isContinued(line) {
 function isBlankLine(line) {
   return line.trim() === "";
 }
-function isCommentLine(line) {
+function isCommentLine2(line) {
   const trimmed = line.replace(LEADING_WHITESPACE, "");
   return trimmed.startsWith("#") || trimmed.startsWith("!");
 }
@@ -3773,7 +5893,7 @@ function joinContinuation(lines, start) {
   pieces.push(current);
   return { logical: pieces.join(""), nextIndex: index + 1 };
 }
-function decodeSimpleEscape(char) {
+function decodeSimpleEscape2(char) {
   switch (char) {
     case "t":
       return "	";
@@ -3787,9 +5907,9 @@ function decodeSimpleEscape(char) {
       return char;
   }
 }
-function decodeUnicodeEscape(raw, at) {
+function decodeUnicodeEscape3(raw, at) {
   const hex = raw.slice(at, at + 4);
-  if (!UNICODE_ESCAPE.test(hex)) {
+  if (!UNICODE_ESCAPE3.test(hex)) {
     throw new AdapterError("INVALID_STRUCTURE", "The file has a malformed unicode escape.");
   }
   return String.fromCharCode(Number.parseInt(hex, 16));
@@ -3809,11 +5929,11 @@ function decodeEscapes(raw) {
       break;
     }
     if (next === "u") {
-      out += decodeUnicodeEscape(raw, i + 2);
+      out += decodeUnicodeEscape3(raw, i + 2);
       i += 6;
       continue;
     }
-    out += decodeSimpleEscape(next);
+    out += decodeSimpleEscape2(next);
     i += 2;
   }
   return out;
@@ -3861,7 +5981,7 @@ function parseItems(content) {
   let i = 0;
   while (i < lines.length) {
     const line = lines[i] ?? "";
-    if (isBlankLine(line) || isCommentLine(line)) {
+    if (isBlankLine(line) || isCommentLine2(line)) {
       items.push({ kind: "raw", text: line });
       i += 1;
       continue;
@@ -3890,7 +6010,7 @@ function parsePropertiesEntries(content, namespace) {
 function unicodeEscape(code) {
   return `\\u${code.toString(16).toUpperCase().padStart(4, "0")}`;
 }
-function escapeChar(char, isFirst, isKey) {
+function escapeChar4(char, isFirst, isKey) {
   switch (char) {
     case "\\":
       return "\\\\";
@@ -3916,7 +6036,7 @@ function escapeString(input, isKey) {
   for (let i = 0; i < input.length; i += 1) {
     const char = input[i];
     if (char !== void 0) {
-      out += escapeChar(char, i === 0, isKey);
+      out += escapeChar4(char, i === 0, isKey);
     }
   }
   return out;
@@ -4038,20 +6158,354 @@ function createVueI18nJsonAdapter(fs = nodeAdapterFs) {
     })
   });
 }
+var PLURAL_CATEGORIES2 = [
+  "zero",
+  "one",
+  "two",
+  "few",
+  "many",
+  "other"
+];
+var PLURAL_CATEGORY_SET2 = new Set(PLURAL_CATEGORIES2);
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseXcstringsDocument(content, filePath) {
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    throw new AdapterError("INVALID_JSON", `${filePath} is not valid JSON.`);
+  }
+  if (!isRecord3(parsed)) {
+    throw new AdapterError(
+      "INVALID_STRUCTURE",
+      `${filePath}: the top level of an .xcstrings catalogue must be a JSON object.`
+    );
+  }
+  const sourceLanguage = parsed.sourceLanguage;
+  if (typeof sourceLanguage !== "string" || sourceLanguage.length === 0) {
+    throw new AdapterError(
+      "INVALID_STRUCTURE",
+      `${filePath}: the catalogue has no "sourceLanguage" string field.`
+    );
+  }
+  const strings = parsed.strings;
+  if (!isRecord3(strings)) {
+    throw new AdapterError(
+      "INVALID_STRUCTURE",
+      `${filePath}: the catalogue has no "strings" object field.`
+    );
+  }
+  return { raw: parsed, sourceLanguage, strings };
+}
+function entryObjectOf(rawEntry, filePath, key) {
+  if (!isRecord3(rawEntry)) {
+    throw new AdapterError(
+      "INVALID_STRUCTURE",
+      `${filePath}: the entry "${key}" must be a JSON object.`
+    );
+  }
+  return rawEntry;
+}
+function localizationsOf(entry, filePath, key) {
+  const localizations = entry.localizations;
+  if (localizations === void 0) {
+    return {};
+  }
+  if (!isRecord3(localizations)) {
+    throw new AdapterError(
+      "INVALID_STRUCTURE",
+      `${filePath}: the entry "${key}" has a "localizations" field that is not a JSON object.`
+    );
+  }
+  return localizations;
+}
+function shouldTranslate(entry) {
+  return entry.shouldTranslate !== false;
+}
+function stringUnitValueOf(stringUnit, filePath, where) {
+  if (!isRecord3(stringUnit) || typeof stringUnit.value !== "string") {
+    throw new AdapterError(
+      "INVALID_STRUCTURE",
+      `${filePath}: ${where} has a "stringUnit" without a string "value" field.`
+    );
+  }
+  return stringUnit.value;
+}
+function pluralVariationsOf(loc) {
+  const variations = loc.variations;
+  if (!isRecord3(variations)) {
+    return void 0;
+  }
+  return variations.plural;
+}
+function localizationValueOf(loc, filePath, key, locale) {
+  if (!isRecord3(loc)) {
+    throw new AdapterError(
+      "INVALID_STRUCTURE",
+      `${filePath}: the entry "${key}"'s "${locale}" localization must be a JSON object.`
+    );
+  }
+  const plural = pluralVariationsOf(loc);
+  if (plural !== void 0) {
+    if (!isRecord3(plural)) {
+      throw new AdapterError(
+        "INVALID_STRUCTURE",
+        `${filePath}: the entry "${key}"'s "${locale}" localization has a "variations.plural" field that is not a JSON object.`
+      );
+    }
+    const categories = /* @__PURE__ */ new Map();
+    for (const [category, variation] of Object.entries(plural)) {
+      if (!PLURAL_CATEGORY_SET2.has(category)) {
+        throw new AdapterError(
+          "INVALID_STRUCTURE",
+          `${filePath}: the entry "${key}"'s "${locale}" localization has an unsupported plural category "${category}"; expected one of ${PLURAL_CATEGORIES2.join(", ")}.`
+        );
+      }
+      const value = stringUnitValueOf(
+        isRecord3(variation) ? variation.stringUnit : void 0,
+        filePath,
+        `the entry "${key}"'s "${locale}" "${category}" plural category`
+      );
+      categories.set(category, value);
+    }
+    if (categories.size === 0) {
+      throw new AdapterError(
+        "INVALID_STRUCTURE",
+        `${filePath}: the entry "${key}"'s "${locale}" localization has a "variations.plural" object with no plural categories.`
+      );
+    }
+    return { kind: "plural", categories };
+  }
+  if (loc.stringUnit !== void 0) {
+    return {
+      kind: "plain",
+      value: stringUnitValueOf(
+        loc.stringUnit,
+        filePath,
+        `the entry "${key}"'s "${locale}" localization`
+      )
+    };
+  }
+  throw new AdapterError(
+    "INVALID_STRUCTURE",
+    `${filePath}: the entry "${key}"'s "${locale}" localization has neither a "stringUnit" nor a "variations.plural" field; verbatra does not support device-class or width variants without one of those as a fallback.`
+  );
+}
+function plainEntry(key, namespace, value, extractPlaceholders) {
+  return { key, namespace, value, placeholders: extractPlaceholders(value), isPlural: false };
+}
+function pluralEntry(baseKey, category, namespace, value, extractPlaceholders) {
+  const key = makePluralKey(baseKey, category);
+  return [key, { key, namespace, value, placeholders: extractPlaceholders(value), isPlural: true }];
+}
+function addPresentEntry(out, loc, key, namespace, locale, filePath, extractPlaceholders) {
+  const content = localizationValueOf(loc, filePath, key, locale);
+  if (content.kind === "plain") {
+    out.set(key, plainEntry(key, namespace, content.value, extractPlaceholders));
+    return;
+  }
+  for (const [category, value] of content.categories) {
+    const [pluralKey, entry] = pluralEntry(key, category, namespace, value, extractPlaceholders);
+    out.set(pluralKey, entry);
+  }
+}
+function readXcstringsLocale(doc, locale, namespace, filePath, extractPlaceholders) {
+  const entries = /* @__PURE__ */ new Map();
+  const excludedLeafPaths = [];
+  for (const [key, rawEntry] of Object.entries(doc.strings)) {
+    const entryObject = entryObjectOf(rawEntry, filePath, key);
+    if (!shouldTranslate(entryObject)) {
+      excludedLeafPaths.push(key);
+      continue;
+    }
+    const localizations = localizationsOf(entryObject, filePath, key);
+    const loc = localizations[locale];
+    if (loc === void 0) {
+      if (locale === doc.sourceLanguage) {
+        entries.set(key, plainEntry(key, namespace, key, extractPlaceholders));
+      }
+      continue;
+    }
+    addPresentEntry(entries, loc, key, namespace, locale, filePath, extractPlaceholders);
+  }
+  return { entries, excludedLeafPaths };
+}
+function groupByKey(entries) {
+  const singular = /* @__PURE__ */ new Map();
+  const plural = /* @__PURE__ */ new Map();
+  for (const [key, entry] of entries) {
+    const baseKey = entry.isPlural ? pluralBaseKey(key) : void 0;
+    const category = entry.isPlural ? pluralCategoryOf(key) : void 0;
+    if (baseKey !== void 0 && category !== void 0) {
+      const group = plural.get(baseKey) ?? /* @__PURE__ */ new Map();
+      group.set(category, entry.value);
+      plural.set(baseKey, group);
+    } else {
+      singular.set(key, entry.value);
+    }
+  }
+  return { singular, plural };
+}
+function currentPlainValue(loc) {
+  if (typeof loc !== "object" || loc === null) {
+    return void 0;
+  }
+  const stringUnit = loc.stringUnit;
+  if (typeof stringUnit !== "object" || stringUnit === null) {
+    return void 0;
+  }
+  const value = stringUnit.value;
+  return typeof value === "string" ? value : void 0;
+}
+function currentPluralValues(loc) {
+  if (typeof loc !== "object" || loc === null) {
+    return void 0;
+  }
+  const variations = loc.variations;
+  if (typeof variations !== "object" || variations === null) {
+    return void 0;
+  }
+  const plural = variations.plural;
+  if (typeof plural !== "object" || plural === null) {
+    return void 0;
+  }
+  const out = /* @__PURE__ */ new Map();
+  for (const [category, variation] of Object.entries(plural)) {
+    const value = currentPlainValue(variation);
+    if (value === void 0) {
+      return void 0;
+    }
+    out.set(category, value);
+  }
+  return out;
+}
+function pluralValuesEqual(current, wanted) {
+  if (current === void 0 || current.size !== wanted.size) {
+    return false;
+  }
+  for (const [category, value] of wanted) {
+    if (current.get(category) !== value) {
+      return false;
+    }
+  }
+  return true;
+}
+function buildPluralLocalization(categories) {
+  const plural = {};
+  for (const [category, value] of categories) {
+    plural[category] = { stringUnit: { state: "translated", value } };
+  }
+  return { variations: { plural } };
+}
+function buildPlainLocalization(value) {
+  return { stringUnit: { state: "translated", value } };
+}
+function deleteLocalization(entry, locale) {
+  const localizations = entry.localizations;
+  if (typeof localizations !== "object" || localizations === null) {
+    return;
+  }
+  delete localizations[locale];
+}
+function writeLocalization(entry, locale, filePath, key, content) {
+  const localizations = localizationsOf(entry, filePath, key);
+  if (entry.localizations === void 0) {
+    entry.localizations = localizations;
+  }
+  localizations[locale] = content;
+}
+function patchKey(entry, key, locale, filePath, touched) {
+  const loc = localizationsOf(entry, filePath, key)[locale];
+  const singularValue = touched.singular.get(key);
+  if (singularValue !== void 0) {
+    const isPlural = currentPluralValues(loc) !== void 0;
+    const currentValue = isPlural ? void 0 : currentPlainValue(loc) ?? "";
+    if (currentValue === singularValue) {
+      return;
+    }
+    writeLocalization(entry, locale, filePath, key, buildPlainLocalization(singularValue));
+    return;
+  }
+  const pluralCategories = touched.plural.get(key);
+  if (pluralCategories !== void 0) {
+    if (pluralValuesEqual(currentPluralValues(loc), pluralCategories)) {
+      return;
+    }
+    writeLocalization(entry, locale, filePath, key, buildPluralLocalization(pluralCategories));
+    return;
+  }
+  deleteLocalization(entry, locale);
+}
+function patchXcstringsDocument(doc, locale, resource, filePath) {
+  const touched = groupByKey(resource.entries);
+  for (const [key, rawEntry] of Object.entries(doc.strings)) {
+    const entry = entryObjectOf(rawEntry, filePath, key);
+    if (!shouldTranslate(entry)) {
+      continue;
+    }
+    patchKey(entry, key, locale, filePath, touched);
+  }
+}
+var EXTENSIONS = [".xcstrings"];
+function createAppleXcstringsAdapter(fs = nodeAdapterFs) {
+  return {
+    format: "apple-xcstrings",
+    canHandle: buildCanHandle(EXTENSIONS),
+    extractPlaceholders: extractAppleStringsPlaceholders,
+    validateMessage: () => true,
+    async read(filePath, locale) {
+      const content = await readFileContent(fs, filePath);
+      const doc = parseXcstringsDocument(content, filePath);
+      const namespace = namespaceOf(filePath);
+      const { entries, excludedLeafPaths } = readXcstringsLocale(
+        doc,
+        locale,
+        namespace,
+        filePath,
+        extractAppleStringsPlaceholders
+      );
+      return {
+        resource: { locale, namespace, format: "apple-xcstrings", entries },
+        invalidIcuKeys: [],
+        excludedLeafPaths
+      };
+    },
+    async write(resource, filePath) {
+      let content;
+      try {
+        content = await readFileContent(fs, filePath);
+      } catch (error) {
+        if (isEnoent(error)) {
+          throw new AdapterError(
+            "INVALID_STRUCTURE",
+            `${filePath}: the catalogue does not exist. verbatra does not create a new .xcstrings catalogue; create it in Xcode first.`
+          );
+        }
+        throw error;
+      }
+      const doc = parseXcstringsDocument(content, filePath);
+      patchXcstringsDocument(doc, resource.locale, resource, filePath);
+      await fs.writeFileAtomic(filePath, `${JSON.stringify(doc.raw, null, 2)}
+`);
+    }
+  };
+}
 var XLIFF_PATTERN = /<(?:x|g|bx|ex|ph|it|mrk)\b[^>]*>|\{[^{}]+\}/g;
 function extractXliffPlaceholders(value) {
   return scanTokens(value, XLIFF_PATTERN);
 }
-var ELEMENT_NODE = 1;
-var TEXT_NODE = 3;
-function isElement(node) {
-  return node.nodeType === ELEMENT_NODE;
+var ELEMENT_NODE3 = 1;
+var TEXT_NODE2 = 3;
+function isElement3(node) {
+  return node.nodeType === ELEMENT_NODE3;
 }
-function elementChildren(parent) {
-  return Array.from(parent.childNodes).filter(isElement);
+function elementChildren3(parent) {
+  return Array.from(parent.childNodes).filter(isElement3);
 }
 function childByName(parent, name) {
-  return elementChildren(parent).find((el) => el.localName === name) ?? null;
+  return elementChildren3(parent).find((el) => el.localName === name) ?? null;
 }
 function collectByTag(root, name) {
   return Array.from(root.getElementsByTagName(name));
@@ -4059,21 +6513,21 @@ function collectByTag(root, name) {
 function unitKey(element, index) {
   return element.getAttribute("id") ?? element.getAttribute("resname") ?? `unit-${index}`;
 }
-function onFatal(level) {
+function onFatal3(level) {
   if (level === "fatalError") {
     throw new Error("malformed XML");
   }
 }
-function assertNoDoctype(content) {
+function assertNoDoctype2(content) {
   if (/<!DOCTYPE/i.test(content) || /<!ENTITY/i.test(content)) {
     throw new AdapterError("INVALID_XML", "XLIFF with a DTD or entity declaration is rejected.");
   }
 }
 function parseXml(content) {
-  assertNoDoctype(content);
+  assertNoDoctype2(content);
   let doc;
   try {
-    doc = new DOMParser({ onError: onFatal }).parseFromString(content, "text/xml");
+    doc = new DOMParser({ onError: onFatal3 }).parseFromString(content, "text/xml");
   } catch {
     throw new AdapterError("INVALID_XML", "The file is not valid XML.");
   }
@@ -4120,7 +6574,7 @@ function walkXliff20(root) {
   collectByTag(root, "unit").forEach((unit, index) => {
     const baseKey = unitKey(unit, index);
     const description = unitDescription(unit);
-    const segments = elementChildren(unit).filter((el) => el.localName === "segment");
+    const segments = elementChildren3(unit).filter((el) => el.localName === "segment");
     segments.forEach((segment, segIndex) => {
       const source = childByName(segment, "source");
       if (source !== null) {
@@ -4176,12 +6630,19 @@ function parseXliffEntries(content, namespace) {
   }
   return out;
 }
-async function readDestination(filePath, fs) {
+function destinationReadErrorMessage(error) {
+  if (isEnoent(error)) {
+    return "The destination XLIFF file does not exist.";
+  }
+  const reason = error instanceof Error ? error.message : String(error);
+  return `The destination XLIFF file could not be read: ${reason}`;
+}
+async function readDestination3(filePath, fs) {
   let outcome;
   try {
     outcome = await readBoundedFile(fs, filePath);
-  } catch {
-    throw new AdapterError("INVALID_STRUCTURE", "The destination XLIFF file does not exist.");
+  } catch (error) {
+    throw new AdapterError("INVALID_STRUCTURE", destinationReadErrorMessage(error));
   }
   return outcomeToContent(outcome, "The destination path is not a regular file.");
 }
@@ -4205,14 +6666,31 @@ function isAllowedInlineElement(element) {
   return hasAllowedNamespace && XLIFF_INLINE_ELEMENTS.has(element.localName ?? "");
 }
 function isAllowedFragmentNode(node) {
-  if (node.nodeType === TEXT_NODE) {
+  if (node.nodeType === TEXT_NODE2) {
     return true;
   }
-  return isElement(node) && isAllowedInlineElement(node);
+  return isElement3(node) && isAllowedInlineElement(node);
 }
 function allDescendantNodes(node) {
-  const children = Array.from(node.childNodes);
-  return children.flatMap((child) => [child, ...allDescendantNodes(child)]);
+  const result = [];
+  const stack = [{ node, depth: 1 }];
+  while (stack.length > 0) {
+    const top = stack.pop();
+    if (top === void 0) {
+      break;
+    }
+    if (top.depth > MAX_DEPTH) {
+      throw new AdapterError(
+        "MAX_DEPTH_EXCEEDED",
+        "The translated value nests inline elements too deeply."
+      );
+    }
+    for (const child of Array.from(top.node.childNodes)) {
+      result.push(child);
+      stack.push({ node: child, depth: top.depth + 1 });
+    }
+  }
+  return result;
 }
 function hasDisallowedNode(root) {
   return allDescendantNodes(root).some((node) => !isAllowedFragmentNode(node));
@@ -4238,7 +6716,7 @@ function sanitizeInlineAttributes(root) {
   }
 }
 function fragmentNodes(parser, value) {
-  assertNoDoctype(value);
+  assertNoDoctype2(value);
   try {
     const root = parser.parseFromString(`<wrapper>${value}</wrapper>`, "text/xml").documentElement;
     if (root === null || hasDisallowedNode(root)) {
@@ -4246,7 +6724,10 @@ function fragmentNodes(parser, value) {
     }
     sanitizeInlineAttributes(root);
     return Array.from(root.childNodes);
-  } catch {
+  } catch (error) {
+    if (error instanceof AdapterError) {
+      throw error;
+    }
     return null;
   }
 }
@@ -4264,8 +6745,8 @@ function setTargetValue(doc, parser, element, value) {
   }
 }
 async function serializeXliffEntries(entries, filePath, fs) {
-  const { doc, root } = parseXml(await readDestination(filePath, fs));
-  const parser = new DOMParser({ onError: onFatal });
+  const { doc, root } = parseXml(await readDestination3(filePath, fs));
+  const parser = new DOMParser({ onError: onFatal3 });
   for (const unit of walkUnits(root)) {
     const entry = entries.get(unit.key);
     if (entry !== void 0) {
@@ -4338,7 +6819,7 @@ function createYamlAdapter(fs = nodeAdapterFs) {
   });
 }
 function createDefaultRegistry(fs = nodeAdapterFs) {
-  return new AdapterRegistry().register(createI18nextJsonAdapter(fs)).register(createVueI18nJsonAdapter(fs)).register(createNextIntlJsonAdapter(fs)).register(createNgxTranslateJsonAdapter(fs)).register(createXliffAdapter(fs)).register(createYamlAdapter(fs)).register(createArbAdapter(fs)).register(createPropertiesAdapter(fs));
+  return new AdapterRegistry().register(createI18nextJsonAdapter(fs)).register(createVueI18nJsonAdapter(fs)).register(createNextIntlJsonAdapter(fs)).register(createNgxTranslateJsonAdapter(fs)).register(createXliffAdapter(fs)).register(createYamlAdapter(fs)).register(createArbAdapter(fs)).register(createPropertiesAdapter(fs)).register(createAppleStringsAdapter(fs)).register(createAppleXcstringsAdapter(fs)).register(createAndroidXmlAdapter(fs)).register(createGettextAdapter(fs));
 }
 function enoent(path) {
   return Object.assign(new Error(`ENOENT: no such file or directory, open '${path}'`), {
@@ -4725,7 +7206,7 @@ async function editEntry(input, deps = {}) {
       `The key "${input.key}" was not found in the source resource.`
     );
   }
-  return withLocaleWriteLock(cwd, locale, fs, async () => {
+  return withLocaleWriteLock(cwd, writeLockKeyFor(config.format, locale), fs, async () => {
     const target = await readTarget(cwd, config, adapter, fs, locale);
     const gate = gateCandidateValue(sourceEntry, input.value, adapter);
     if (!gate.accepted) {
@@ -4870,6 +7351,41 @@ function diffLocaleSnapshots(previous, current) {
   return { added, changed, removed };
 }
 
+// src/flow/locale-values.ts
+function mergeValues(source, target) {
+  const keys = /* @__PURE__ */ new Set([...source.entries.keys(), ...target.entries.keys()]);
+  const values = {};
+  for (const key of keys) {
+    const sourceEntry = source.entries.get(key);
+    const targetEntry = target.entries.get(key);
+    values[key] = {
+      ...sourceEntry !== void 0 ? { source: sourceEntry.value } : {},
+      ...targetEntry !== void 0 ? { target: targetEntry.value } : {}
+    };
+  }
+  return values;
+}
+async function localeValues(input, deps = {}) {
+  const config = input.config;
+  const cwd = input.cwd ?? process.cwd();
+  const fs = deps.fs ?? defaultFs;
+  const adapter = selectAdapter(config.format, deps.adapterRegistry, deps.fs);
+  const resolver = createLocalePathResolver(cwd, config);
+  const source = await readSourceResource(config, resolver, fs, adapter);
+  return Promise.all(
+    selectLocales(config, input.locales).map(async (locale) => {
+      const target = await readTargetResource({
+        resolver,
+        format: config.format,
+        locale,
+        adapter,
+        fs
+      });
+      return { locale, values: mergeValues(source.resource, target) };
+    })
+  );
+}
+
 // src/flow/lock-state.ts
 function toLockLocaleState(locale, keyCount, diff2) {
   return {
@@ -4949,7 +7465,7 @@ async function retranslateEntry(input, deps = {}) {
     );
   }
   const provider = selectProvider(config.provider, deps.createProvider);
-  return withLocaleWriteLock(cwd, locale, fs, async () => {
+  return withLocaleWriteLock(cwd, writeLockKeyFor(config.format, locale), fs, async () => {
     const target = await readTarget(cwd, config, adapter, fs, locale);
     const result = await provider.translateBatch(
       buildTranslateRequest(
@@ -6001,7 +8517,7 @@ async function runLiveLocale(context, targetLocale) {
   };
   return withLocaleWriteLock(
     context.cwd,
-    targetLocale,
+    writeLockKeyFor(context.config.format, targetLocale),
     context.fs,
     async () => {
       const lock = await readLockFile(lockFilePath(context.cwd), context.fs);
@@ -6116,7 +8632,7 @@ function resolveRunConcurrency(value, dryRun, config) {
   }
   return concurrency;
 }
-async function translate2(input, deps = {}) {
+async function translate3(input, deps = {}) {
   const config = input.config;
   const cwd = input.cwd ?? process.cwd();
   const dryRun = input.dryRun ?? false;
@@ -6407,14 +8923,15 @@ function applyColumnGeometry(sheet) {
 function writeRow(sheet, sheetRow) {
   const row = sheet.addRow([]);
   row.getCell(COLUMN.key).value = sheetRow.key;
-  row.getCell(COLUMN.source).value = sheetRow.source;
-  row.getCell(COLUMN.current).value = sheetRow.currentTarget;
+  row.getCell(COLUMN.source).value = escapeFormulaLead(sheetRow.source);
+  row.getCell(COLUMN.current).value = escapeFormulaLead(sheetRow.currentTarget);
   row.getCell(COLUMN.status).value = sheetRow.status;
   const translationCell = row.getCell(COLUMN.translation);
   translationCell.numFmt = TEXT_NUMBER_FORMAT;
-  translationCell.value = sheetRow.translation === "" ? null : sheetRow.translation;
+  const translation = escapeFormulaLead(sheetRow.translation);
+  translationCell.value = translation === "" ? null : translation;
   row.getCell(COLUMN.sourceHash).value = sheetRow.sourceHash;
-  row.getCell(COLUMN.context).value = sheetRow.context;
+  row.getCell(COLUMN.context).value = escapeFormulaLead(sheetRow.context);
   row.getCell(COLUMN.reviewStatus).value = sheetRow.reviewStatus;
   row.getCell(COLUMN.reviewReasons).value = sheetRow.reviewReasons;
   for (let column = COLUMN.key; column <= COLUMN.reviewReasons; column += 1) {
@@ -6725,7 +9242,7 @@ function readDelimited(input, options = {}) {
     duplicateKeys: into.duplicates
   };
 }
-function assertNoDoctype2(name, xml) {
+function assertNoDoctype3(name, xml) {
   if (/<!DOCTYPE/i.test(xml) || /<!ENTITY/i.test(xml)) {
     throw new ExchangeError(
       "WORKBOOK_INVALID",
@@ -6798,7 +9315,7 @@ async function guardWorkbookBytes(bytes, limits) {
     const remaining = limits.maxDecompressedBytes - actualTotal;
     const { raw, content } = await streamEntryBounded(file, remaining);
     actualTotal += raw;
-    assertNoDoctype2(file.name, content);
+    assertNoDoctype3(file.name, content);
   }
 }
 function cellString(cell) {
@@ -6814,19 +9331,31 @@ function cellString(cell) {
   }
   return typeof cell.text === "string" ? cell.text : "";
 }
+var FORMULA_GUARDED_COLUMNS = /* @__PURE__ */ new Set([
+  COLUMN.source,
+  COLUMN.current,
+  COLUMN.translation,
+  COLUMN.context
+]);
+var LEGACY_HEADER_COLUMN_COUNT = COLUMN.sourceHash;
 function assertHeader(sheet) {
   const header = sheet.getRow(HEADER_ROW);
-  const key = cellString(header.getCell(COLUMN.key));
-  const sourceHash = cellString(header.getCell(COLUMN.sourceHash));
-  if (key !== HEADERS[COLUMN.key - 1] || sourceHash !== HEADERS[COLUMN.sourceHash - 1]) {
-    throw new ExchangeError(
-      "WORKBOOK_INVALID",
-      `The sheet "${sheet.name}" is missing the expected Key and Source hash columns.`
-    );
+  for (let column = 1; column <= LEGACY_HEADER_COLUMN_COUNT; column += 1) {
+    const label = cellString(header.getCell(column));
+    if (label !== HEADERS[column - 1]) {
+      throw new ExchangeError(
+        "WORKBOOK_INVALID",
+        `The sheet "${sheet.name}" has an unexpected header label in column ${column} (expected "${HEADERS[column - 1]}").`
+      );
+    }
   }
 }
 function sheetRowCells(row) {
-  return HEADERS.map((_, index) => cellString(row.getCell(index + 1)));
+  return HEADERS.map((_, index) => {
+    const column = index + 1;
+    const value = cellString(row.getCell(column));
+    return FORMULA_GUARDED_COLUMNS.has(column) ? unescapeFormulaLead(value) : value;
+  });
 }
 function assertRowCellCap(row, sheetName, limits) {
   if (row.cellCount > limits.maxCellsPerRow) {
@@ -7053,6 +9582,7 @@ async function exportWorkbook(input, deps = {}) {
     await writeDelimitedFiles(fs, path, format, sheets);
   } else {
     const model = { sheets };
+    await fs.mkdir?.(dirname(path));
     await fs.writeBytes(path, await buildWorkbook(model));
   }
   return {
@@ -7213,7 +9743,12 @@ async function readDelimitedText(path, fs) {
 async function collectDelimitedSources(path, config, fs, format) {
   const single = await readDelimitedText(path, fs);
   if (single !== void 0) {
-    return { sources: [{ locale: basename(path, `.${format}`), text: single }], staleLocales: [] };
+    const locale = basename(path, `.${format}`);
+    return {
+      sources: [{ locale, text: single }],
+      staleLocales: [],
+      expectedLocales: [locale]
+    };
   }
   const exported = await readExportedLocales(fs, path, format);
   const sources = [];
@@ -7235,7 +9770,7 @@ async function collectDelimitedSources(path, config, fs, format) {
       `No ${format} file was found at ${path}, and it holds no <locale>.${format} file for any configured target locale.`
     );
   }
-  return { sources, staleLocales };
+  return { sources, staleLocales, expectedLocales: config.targetLocales };
 }
 function parseDelimitedSources(sources, format) {
   const sheets = [];
@@ -7255,10 +9790,15 @@ async function readImportData(path, config, fs, format) {
       const handoff = await collectDelimitedSources(path, config, fs, format);
       return {
         data: parseDelimitedSources(handoff.sources, format),
-        staleLocales: handoff.staleLocales
+        staleLocales: handoff.staleLocales,
+        expectedLocales: handoff.expectedLocales
       };
     }
-    return { data: await readWorkbook(await readWorkbookBytes(path, fs)), staleLocales: [] };
+    return {
+      data: await readWorkbook(await readWorkbookBytes(path, fs)),
+      staleLocales: [],
+      expectedLocales: config.targetLocales
+    };
   } catch (error) {
     if (error instanceof SdkError) {
       throw error;
@@ -7323,11 +9863,11 @@ var StaleHandoffFileError = class extends Error {
     this.name = "StaleHandoffFileError";
   }
 };
-function absentLocaleFailures(config, sheets, format, staleLocales) {
+function absentLocaleFailures(expectedLocales, sheets, format, staleLocales) {
   const present = new Set(sheets.map((sheet) => sheet.locale));
   const stale = new Set(staleLocales);
   const failures = [];
-  for (const locale of config.targetLocales) {
+  for (const locale of expectedLocales) {
     if (present.has(locale)) {
       continue;
     }
@@ -7336,7 +9876,7 @@ function absentLocaleFailures(config, sheets, format, staleLocales) {
   }
   return failures;
 }
-function lineOf(reported) {
+function lineOf2(reported) {
   return reported.line === void 0 ? {} : { line: reported.line };
 }
 async function runSheet(ctx, sheet, lock) {
@@ -7361,8 +9901,8 @@ async function runSheet(ctx, sheet, lock) {
     baseline,
     adapter: ctx.adapter,
     sourceInvalidIcuKeys: ctx.sourceInvalidIcuKeys,
-    malformedRows: ctx.malformedRows.filter((problem) => problem.locale === sheet.locale).map((problem) => ({ row: problem.row, column: problem.column, ...lineOf(problem) })),
-    duplicateKeys: ctx.duplicateKeys.filter((duplicate) => duplicate.locale === sheet.locale).map((duplicate) => ({ key: duplicate.key, row: duplicate.row, ...lineOf(duplicate) }))
+    malformedRows: ctx.malformedRows.filter((problem) => problem.locale === sheet.locale).map((problem) => ({ row: problem.row, column: problem.column, ...lineOf2(problem) })),
+    duplicateKeys: ctx.duplicateKeys.filter((duplicate) => duplicate.locale === sheet.locale).map((duplicate) => ({ key: duplicate.key, row: duplicate.row, ...lineOf2(duplicate) }))
   });
   if (ctx.dryRun) {
     return { summary, lockEntries: {}, cacheAdditions: {} };
@@ -7397,7 +9937,7 @@ async function importWorkbook(input, deps = {}) {
   const resolver = createLocalePathResolver(cwd, config);
   const source = await readSourceResource(config, resolver, fs, adapter);
   const format = input.format ?? DEFAULT_EXCHANGE_FORMAT;
-  const { data, staleLocales } = await readImportData(
+  const { data, staleLocales, expectedLocales } = await readImportData(
     resolve(cwd, input.workbook),
     config,
     fs,
@@ -7425,15 +9965,20 @@ async function importWorkbook(input, deps = {}) {
       if (dryRun) {
         summary = (await runSheet(ctx, sheet, lock)).summary;
       } else {
-        summary = await withLocaleWriteLock(cwd, sheet.locale, fs, async () => {
-          const result = await runSheet(ctx, sheet, lock);
-          await updateLockFileLocale(cwd, fs, sheet.locale, {
-            mode: "replace",
-            entries: result.lockEntries
-          });
-          collectSheetAdditions(cacheAdditions, sheet.locale, result.cacheAdditions);
-          return result.summary;
-        });
+        summary = await withLocaleWriteLock(
+          cwd,
+          writeLockKeyFor(config.format, sheet.locale),
+          fs,
+          async () => {
+            const result = await runSheet(ctx, sheet, lock);
+            await updateLockFileLocale(cwd, fs, sheet.locale, {
+              mode: "replace",
+              entries: result.lockEntries
+            });
+            collectSheetAdditions(cacheAdditions, sheet.locale, result.cacheAdditions);
+            return result.summary;
+          }
+        );
       }
       summaries.push(summary);
     } catch (error) {
@@ -7443,7 +9988,7 @@ async function importWorkbook(input, deps = {}) {
       summaries.push(failureSummary(sheet.locale, error));
     }
   }
-  summaries.push(...absentLocaleFailures(config, data.sheets, format, staleLocales));
+  summaries.push(...absentLocaleFailures(expectedLocales, data.sheets, format, staleLocales));
   if (!dryRun) {
     await feedTranslationMemory(cwd, fs, computeFingerprint(config), cacheAdditions);
   }
@@ -7458,18 +10003,57 @@ async function loadLockFile(input = {}, deps = {}) {
   return readLockFile(lockFilePath(cwd), fs);
 }
 
+// src/redact.ts
+var REDACTED2 = "[REDACTED]";
+var KEY_PATTERNS2 = [
+  /\bsk-[A-Za-z0-9_-]{8,}/g,
+  /AIza[0-9A-Za-z_-]{35}/g,
+  /[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}(?::fx)?/g
+];
+var PROVIDER_ENV_VAR_NAMES = [
+  "ANTHROPIC_API_KEY",
+  "OPENAI_API_KEY",
+  "GEMINI_API_KEY",
+  "DEEPL_API_KEY",
+  "GOOGLE_TRANSLATE_API_KEY",
+  "OPENAI_COMPATIBLE_API_KEY"
+];
+function escapeForRegExp2(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function scrubConfiguredEnvValues(text) {
+  let out = text;
+  for (const name of PROVIDER_ENV_VAR_NAMES) {
+    const value = process.env[name];
+    if (value !== void 0 && value.length > 0) {
+      out = out.replace(new RegExp(escapeForRegExp2(value), "g"), REDACTED2);
+    }
+  }
+  return out;
+}
+function redact2(text) {
+  let out = text;
+  for (const pattern of KEY_PATTERNS2) {
+    out = out.replace(pattern, REDACTED2);
+  }
+  return scrubConfiguredEnvValues(out);
+}
+
 // src/scaffolding.ts
 var scaffoldingMetadata = {
   /** The environment variable each scaffoldable provider reads its API key from. */
   providerEnv: PROVIDER_ENV,
-  /** A reasonable default model to prefill per language-model provider. DeepL has none, since it takes no model. */
+  /**
+   * A reasonable default model to prefill per language-model provider. DeepL and Google Cloud
+   * Translation have none, since neither takes a model.
+   */
   scaffoldModels: SCAFFOLD_MODELS,
   /**
    * The option key each language-model provider takes its output token limit under, since they do
    * not agree: Anthropic calls it `maxTokens` and the others `maxOutputTokens`. A generator that
    * prefills a token limit must read the key from here rather than assume one, because
    * {@link verbatraConfigSchema} validates each provider's options strictly and rejects the wrong
-   * one. DeepL has no entry, since it takes no token limit.
+   * one. DeepL and Google Cloud Translation have no entry, since neither takes a token limit.
    */
   providerTokenLimitKeys: SCAFFOLD_TOKEN_LIMIT_KEYS,
   /** Every i18n file format the SDK can read and write. */
@@ -7486,7 +10070,7 @@ var defaultCreateWatcher = (paths) => {
   };
 };
 function defaultRunTranslate(deps) {
-  return (input) => translate2(input, {
+  return (input) => translate3(input, {
     ...deps.adapterRegistry !== void 0 ? { adapterRegistry: deps.adapterRegistry } : {},
     ...deps.createProvider !== void 0 ? { createProvider: deps.createProvider } : {},
     ...deps.fs !== void 0 ? { fs: deps.fs } : {}
@@ -7586,6 +10170,6 @@ async function watch(input, deps = {}) {
   return { stop };
 }
 
-export { CACHE_FILE_NAME, DEFAULT_DELIMITED_PATH, DEFAULT_EXCHANGE_FORMAT, DEFAULT_WORKBOOK_PATH, EXCHANGE_FORMATS, LOCK_FILE_NAME, SdkError, check, createLocalePathResolver, defineConfig, diff, diffLocaleSnapshots, doctor, editEntry, exportWorkbook, importWorkbook, keyIntegrity, keyValue, loadConfig, loadConfigWithMeta, loadLockFile, lockState, readGlossaryFile, readLocaleFileSnapshot, retranslateEntry, runStatus, scaffoldingMetadata, translate2 as translate, updateGlossaryTerm, verbatraConfigSchema, watch };
+export { CACHE_FILE_NAME, DEFAULT_DELIMITED_PATH, DEFAULT_EXCHANGE_FORMAT, DEFAULT_WORKBOOK_PATH, EXCHANGE_FORMATS, LOCK_FILE_NAME, SdkError, check, createLocalePathResolver, defineConfig, diff, diffLocaleSnapshots, doctor, editEntry, exportWorkbook, importWorkbook, keyIntegrity, keyValue, loadConfig, loadConfigWithMeta, loadLockFile, localeValues, lockState, readGlossaryFile, readLocaleFileSnapshot, redact2 as redact, retranslateEntry, runStatus, scaffoldingMetadata, translate3 as translate, updateGlossaryTerm, verbatraConfigSchema, watch };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map