glotfile 0.5.4 → 0.6.1

package/dist/server/cli.js

@@ -122,6 +122,7 @@ function validate(raw) {
     if (o.indent !== void 0 && typeof o.indent !== "number") fail("config.outputs[].indent must be a number");
     if (o.finalNewline !== void 0 && typeof o.finalNewline !== "boolean") fail("config.outputs[].finalNewline must be a boolean");
     if (o.includeLocale !== void 0 && typeof o.includeLocale !== "boolean") fail("config.outputs[].includeLocale must be a boolean");
+    if (o.skipSourceLocale !== void 0 && typeof o.skipSourceLocale !== "boolean") fail("config.outputs[].skipSourceLocale must be a boolean");
     if (o.localeAliases !== void 0) {
       if (!isObject(o.localeAliases)) fail("config.outputs[].localeAliases must be an object");
       for (const [k, v] of Object.entries(o.localeAliases)) {
@@ -1574,27 +1575,41 @@ var init_vue_i18n_json = __esm({
 function xmlEscape2(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
-function renderInterpolations(text, ids) {
+function attrEscape(s) {
+  return xmlEscape2(s).replace(/"/g, "&quot;");
+}
+function angularXMeta(placeholders, name) {
+  return /^[A-Z][A-Z0-9_]*$/.test(name) ? placeholders?.[name] : void 0;
+}
+function renderInterpolations(text, ids, placeholders) {
   let out = "";
   let last = 0;
   for (const m of text.matchAll(/\{(\w+)\}/g)) {
     const name = m[1];
-    let id = ids.get(name);
-    if (id === void 0) {
-      id = ids.size === 0 ? "INTERPOLATION" : `INTERPOLATION_${ids.size}`;
-      ids.set(name, id);
+    out += xmlEscape2(text.slice(last, m.index));
+    const meta = angularXMeta(placeholders, name);
+    if (meta) {
+      const ctype = meta.type ? ` ctype="${attrEscape(meta.type)}"` : "";
+      const equiv = meta.example !== void 0 ? ` equiv-text="${attrEscape(meta.example)}"` : "";
+      out += `<x id="${attrEscape(name)}"${ctype}${equiv}/>`;
+    } else {
+      let id = ids.get(name);
+      if (id === void 0) {
+        id = ids.size === 0 ? "INTERPOLATION" : `INTERPOLATION_${ids.size}`;
+        ids.set(name, id);
+      }
+      out += `<x id="${id}" equiv-text="{{${name}}}"/>`;
     }
-    out += xmlEscape2(text.slice(last, m.index)) + `<x id="${id}" equiv-text="{{${name}}}"/>`;
     last = m.index + m[0].length;
   }
   return out + xmlEscape2(text.slice(last));
 }
-function renderPluralIcu(forms, ids) {
+function renderPluralIcu(forms, ids, placeholders) {
   const cats = [
     ...Object.keys(forms).filter((c) => c.startsWith("=")),
     ...PLURAL_CATEGORIES.filter((c) => forms[c] !== void 0)
   ];
-  const branches = cats.map((cat) => `${cat} {${renderInterpolations(forms[cat] ?? "", ids)}}`);
+  const branches = cats.map((cat) => `${cat} {${renderInterpolations(forms[cat] ?? "", ids, placeholders)}}`);
   return `{VAR_PLURAL, plural, ${branches.join(" ")}}`;
 }
 function renderEmbeddedIcu(value) {
@@ -1604,8 +1619,8 @@ function renderEmbeddedIcu(value) {
   );
   return xmlEscape2(renamed);
 }
-function renderScalar(value, ids) {
-  return isIcuPluralOrSelect(value) ? renderEmbeddedIcu(value) : renderInterpolations(value, ids);
+function renderScalar(value, ids, placeholders) {
+  return isIcuPluralOrSelect(value) ? renderEmbeddedIcu(value) : renderInterpolations(value, ids, placeholders);
 }
 var DEFAULT_LOCALE_CASE8, angularXliff;
 var init_angular_xliff = __esm({
@@ -1636,6 +1651,7 @@ var init_angular_xliff = __esm({
         const emptyAs = resolveEmptyAs(output, "source");
         const keys = Object.keys(state.keys).sort();
         for (const locale of state.config.locales) {
+          if (output.skipSourceLocale && locale === sourceLocale) continue;
           const token = resolveLocaleToken(output, locale, DEFAULT_LOCALE_CASE8);
           const units = [];
           for (const key of keys) {
@@ -1646,17 +1662,18 @@ var init_angular_xliff = __esm({
             if (entry.plural) {
               const targetForms = resolveForms(entry, locale, sourceLocale, emptyAs);
               if (targetForms === null) continue;
-              source = renderPluralIcu(entry.values[sourceLocale]?.forms ?? {}, ids);
-              target = renderPluralIcu(targetForms, ids);
+              source = renderPluralIcu(entry.values[sourceLocale]?.forms ?? {}, ids, entry.placeholders);
+              target = renderPluralIcu(targetForms, ids, entry.placeholders);
             } else {
               const targetValue = resolveScalar(entry, locale, sourceLocale, emptyAs);
               if (targetValue === null) continue;
-              source = renderScalar(entry.values[sourceLocale]?.value ?? "", ids);
-              target = renderScalar(targetValue, ids);
+              source = renderScalar(entry.values[sourceLocale]?.value ?? "", ids, entry.placeholders);
+              target = renderScalar(targetValue, ids, entry.placeholders);
             }
+            const translated = locale === sourceLocale || (entry.plural ? entry.values[locale]?.forms !== void 0 : !!entry.values[locale]?.value);
             units.push(`      <trans-unit id="${xmlEscape2(key)}" datatype="html">`);
             units.push(`        <source>${source}</source>`);
-            units.push(`        <target>${target}</target>`);
+            units.push(`        <target${translated ? "" : ' state="new"'}>${target}</target>`);
             if (entry.description) {
               units.push(`        <note priority="1" from="description">${xmlEscape2(entry.description)}</note>`);
             }
@@ -1964,7 +1981,7 @@ function buildSystemPrompt(hasPluralItems) {
     "- Preserve ICU plural/select structure verbatim (e.g. {count, plural, one {\u2026} other {\u2026}}); translate only the human-readable text inside each branch.",
     "- Glossary: a term marked do-not-translate MUST appear unchanged in the translation. A term with a forced translation for the target locale MUST use that exact translation.",
     "- Respect the max length (characters) when given; prefer a shorter natural phrasing over exceeding it.",
-    `- Quotation marks inside a translation MUST use the target language's typographic quote characters (e.g. \u201EGerman\u201C, \xABFrench\xBB, \u201CEnglish\u201D, \u2019 for apostrophes). Never emit a raw ASCII double-quote (") inside a translated string \u2014 it corrupts the JSON reply. If the source uses ASCII quotes, convert them to the target language's typographic quotes.`,
+    '- Quotation marks and apostrophes: punctuate exactly as a professional native translator instinctively would for the target language \u2014 its typographic conventions (e.g. \u201EGerman\u201C, \xABFrench\xBB, \u201CEnglish\u201D, \u2019 for apostrophes), applied with judgment about what is quoted prose versus a literal that must stay untouched. Never emit a raw ASCII double-quote (") inside a translated string \u2014 it corrupts the JSON reply.',
     "- Match the register and capitalization conventions of the target language and of UI microcopy.",
     "- Return ONLY the translated string for each item \u2014 no quotes, notes, or explanations."
   ];
@@ -2054,12 +2071,66 @@ var init_provider = __esm({
 });
 
 // src/server/ai/batch.ts
+function repairUnescapedQuotes(text) {
+  const skipWs = (from) => {
+    let i = from;
+    while (i < text.length && /\s/.test(text[i])) i++;
+    return i;
+  };
+  const stack = [];
+  let out = "";
+  let inString = false;
+  let isKey = false;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    const top = stack[stack.length - 1];
+    if (inString) {
+      if (ch === "\\") {
+        out += ch + (text[i + 1] ?? "");
+        i++;
+      } else if (ch !== '"') {
+        out += ch;
+      } else {
+        const next = text[skipWs(i + 1)];
+        const startsNextMember = () => {
+          const after = text[skipWs(skipWs(i + 1) + 1)];
+          return top?.type === "obj" ? after === '"' : after === "{" || after === "[" || after === '"';
+        };
+        const closes = isKey ? next === ":" : next === "}" || next === "]" || next === void 0 || next === "," && startsNextMember();
+        if (closes) {
+          inString = false;
+          out += ch;
+        } else {
+          out += '\\"';
+        }
+      }
+      continue;
+    }
+    out += ch;
+    if (ch === '"') {
+      inString = true;
+      isKey = top?.type === "obj" && top.expectingKey;
+    } else if (ch === "{") stack.push({ type: "obj", expectingKey: true });
+    else if (ch === "[") stack.push({ type: "arr", expectingKey: false });
+    else if (ch === "}" || ch === "]") stack.pop();
+    else if (ch === "," && top?.type === "obj") top.expectingKey = true;
+    else if (ch === ":" && top) top.expectingKey = false;
+  }
+  try {
+    JSON.parse(out);
+    return out;
+  } catch {
+    return void 0;
+  }
+}
 function parseReplyItems(text) {
   let parsed;
   try {
     parsed = JSON.parse(text);
   } catch {
-    throw new MalformedReplyError(text);
+    const repaired = repairUnescapedQuotes(text);
+    if (repaired === void 0) throw new MalformedReplyError(text);
+    parsed = JSON.parse(repaired);
   }
   if (!Array.isArray(parsed.items)) throw new MalformedReplyError(text);
   return parsed.items;
@@ -4032,7 +4103,7 @@ var init_accept = __esm({
 });
 
 // src/server/import/detect.ts
-import { existsSync as existsSync10, readdirSync as readdirSync4, statSync as statSync3 } from "fs";
+import { existsSync as existsSync10, readdirSync as readdirSync4, readFileSync as readFileSync11, statSync as statSync3 } from "fs";
 import { join as join4 } from "path";
 function safeIsDir(p) {
   try {
@@ -4119,6 +4190,110 @@ function detectApple(root) {
   }
   return best;
 }
+function detectAngularXliff(root) {
+  for (const rel of ANGULAR_DIR_CANDIDATES) {
+    const localeRoot = rel === "." ? root : join4(root, rel);
+    if (!safeIsDir(localeRoot)) continue;
+    const files = readdirSync4(localeRoot).filter((f) => /^messages(\..+)?\.xlf$/.test(f)).sort();
+    if (files.length === 0) continue;
+    const locales = files.map((f) => f.match(/^messages\.(.+)\.xlf$/)?.[1]).filter((l) => !!l && LOCALE_RE.test(l));
+    const attrFile = files.includes("messages.xlf") ? "messages.xlf" : files[0];
+    let sourceLocale;
+    try {
+      sourceLocale = readFileSync11(join4(localeRoot, attrFile), "utf8").match(/source-language="([^"]+)"/)?.[1];
+    } catch {
+    }
+    if (!sourceLocale && locales.length === 0) continue;
+    sourceLocale ??= pickSource(locales, () => 0);
+    if (!locales.includes(sourceLocale)) locales.unshift(sourceLocale);
+    return { format: "angular-xliff", localeRoot, locales, sourceLocale };
+  }
+  return null;
+}
+function detectRails(root) {
+  const localeRoot = join4(root, "config", "locales");
+  if (!safeIsDir(localeRoot)) return null;
+  const locales = [];
+  for (const file of readdirSync4(localeRoot).sort()) {
+    if (!/\.ya?ml$/.test(file)) continue;
+    let text;
+    try {
+      text = readFileSync11(join4(localeRoot, file), "utf8");
+    } catch {
+      continue;
+    }
+    for (const m of text.matchAll(/^(["']?)([A-Za-z][\w-]*)\1:\s*(?:#.*)?$/gm)) {
+      const token = m[2];
+      if (LOCALE_RE.test(token) && !locales.includes(token)) locales.push(token);
+    }
+  }
+  if (locales.length === 0) return null;
+  return { format: "rails-yaml", localeRoot, locales, sourceLocale: pickSource(locales, () => 0) };
+}
+function detectI18next(root) {
+  for (const rel of I18NEXT_DIR_CANDIDATES) {
+    const localeRoot = join4(root, rel);
+    if (!safeIsDir(localeRoot)) continue;
+    const locales = listDirs(localeRoot).filter(
+      (d) => LOCALE_RE.test(d) && readdirSync4(join4(localeRoot, d)).some((f) => f.endsWith(".json"))
+    );
+    if (locales.length === 0) continue;
+    const sourceLocale = pickSource(locales, (loc) => {
+      try {
+        return readdirSync4(join4(localeRoot, loc)).filter((f) => f.endsWith(".json")).reduce((sum, f) => sum + statSync3(join4(localeRoot, loc, f)).size, 0);
+      } catch {
+        return 0;
+      }
+    });
+    return { format: "i18next-json", localeRoot, locales, sourceLocale };
+  }
+  return null;
+}
+function gettextLocales(dir) {
+  const locales = [];
+  for (const entry of readdirSync4(dir).sort()) {
+    const flat = entry.match(/^(.+)\.po$/)?.[1];
+    if (flat && LOCALE_RE.test(flat)) {
+      if (!locales.includes(flat)) locales.push(flat);
+      continue;
+    }
+    if (!LOCALE_RE.test(entry) || !safeIsDir(join4(dir, entry))) continue;
+    const sub = join4(dir, entry);
+    const hasPo = (d) => {
+      try {
+        return readdirSync4(d).some((f) => f.endsWith(".po"));
+      } catch {
+        return false;
+      }
+    };
+    if (hasPo(join4(sub, "LC_MESSAGES")) || hasPo(sub)) {
+      if (!locales.includes(entry)) locales.push(entry);
+    }
+  }
+  return locales;
+}
+function detectGettext(root) {
+  for (const rel of GETTEXT_DIR_CANDIDATES) {
+    const localeRoot = join4(root, rel);
+    if (!safeIsDir(localeRoot)) continue;
+    const locales = gettextLocales(localeRoot);
+    if (locales.length === 0) continue;
+    return { format: "gettext-po", localeRoot, locales, sourceLocale: pickSource(locales, () => 0) };
+  }
+  return null;
+}
+function detectAppleStringsdict(root) {
+  const candidates = [root, ...listDirs(root).map((d) => join4(root, d))];
+  let best = null;
+  for (const dir of candidates) {
+    const locales = listDirs(dir).map((d) => d.match(/^(.+)\.lproj$/)?.[1]).filter((l) => !!l && LOCALE_RE.test(l) && existsSync10(join4(dir, `${l}.lproj`, "Localizable.stringsdict")));
+    if (locales.length === 0) continue;
+    if (!best || locales.length > best.locales.length) {
+      best = { format: "apple-stringsdict", localeRoot: dir, locales, sourceLocale: pickSource(locales, () => 0) };
+    }
+  }
+  return best;
+}
 function detect(root, formatOverride) {
   if (!existsSync10(root)) return null;
   if (formatOverride) {
@@ -4132,18 +4307,36 @@ function detect(root, formatOverride) {
   }
   return null;
 }
-var LOCALE_RE, VUE_DIR_CANDIDATES, DETECTORS, BY_FORMAT;
+var LOCALE_RE, VUE_DIR_CANDIDATES, ANGULAR_DIR_CANDIDATES, I18NEXT_DIR_CANDIDATES, GETTEXT_DIR_CANDIDATES, DETECTORS, BY_FORMAT;
 var init_detect = __esm({
   "src/server/import/detect.ts"() {
     "use strict";
     LOCALE_RE = /^[a-z]{2,3}([_-][A-Za-z]{2,4}){0,2}$/;
     VUE_DIR_CANDIDATES = ["src/locale", "src/locales", "src/i18n/locales", "locales", "lang"];
-    DETECTORS = [detectLaravel, detectVue, detectArb, detectApple];
+    ANGULAR_DIR_CANDIDATES = [".", "src/locale", "src/locales", "src/i18n", "locale", "locales", "i18n", "translations"];
+    I18NEXT_DIR_CANDIDATES = ["public/locales", "static/locales", "locales", "src/locales", "src/i18n/locales"];
+    GETTEXT_DIR_CANDIDATES = ["locale", "locales", "po", "translations"];
+    DETECTORS = [
+      detectLaravel,
+      detectVue,
+      detectArb,
+      detectApple,
+      detectAngularXliff,
+      detectRails,
+      detectI18next,
+      detectGettext,
+      detectAppleStringsdict
+    ];
     BY_FORMAT = {
       "laravel-php": detectLaravel,
       "vue-i18n-json": (root) => detectVue(root, true),
       "flutter-arb": detectArb,
-      "apple-strings": detectApple
+      "apple-strings": detectApple,
+      "angular-xliff": detectAngularXliff,
+      "rails-yaml": detectRails,
+      "i18next-json": detectI18next,
+      "gettext-po": detectGettext,
+      "apple-stringsdict": detectAppleStringsdict
     };
   }
 });
@@ -4176,7 +4369,7 @@ var init_flatten = __esm({
 });
 
 // src/server/import/parsers/vue-i18n-json.ts
-import { readdirSync as readdirSync5, readFileSync as readFileSync11 } from "fs";
+import { readdirSync as readdirSync5, readFileSync as readFileSync12 } from "fs";
 import { join as join5 } from "path";
 var LOCALE_RE2, vueI18nJson2;
 var init_vue_i18n_json2 = __esm({
@@ -4197,7 +4390,7 @@ var init_vue_i18n_json2 = __esm({
           if (opts?.locales && !opts.locales.includes(locale)) continue;
           let data;
           try {
-            data = JSON.parse(readFileSync11(join5(localeRoot, file), "utf8"));
+            data = JSON.parse(readFileSync12(join5(localeRoot, file), "utf8"));
           } catch (e) {
             warnings.push(`vue-i18n-json: failed to parse ${file}: ${e.message}`);
             continue;
@@ -4302,7 +4495,7 @@ var init_laravel_php2 = __esm({
 });
 
 // src/server/import/parsers/flutter-arb.ts
-import { readdirSync as readdirSync7, readFileSync as readFileSync12 } from "fs";
+import { readdirSync as readdirSync7, readFileSync as readFileSync13 } from "fs";
 import { join as join7 } from "path";
 function localeFromArbName(file) {
   const m = file.match(/^(.+)\.arb$/);
@@ -4343,7 +4536,7 @@ var init_flutter_arb2 = __esm({
           if (opts?.locales && !opts.locales.includes(locale)) continue;
           let data;
           try {
-            data = JSON.parse(readFileSync12(join7(localeRoot, file), "utf8"));
+            data = JSON.parse(readFileSync13(join7(localeRoot, file), "utf8"));
           } catch (e) {
             warnings.push(`flutter-arb: failed to parse ${file}: ${e.message}`);
             continue;
@@ -4370,7 +4563,7 @@ var init_flutter_arb2 = __esm({
 });
 
 // src/server/import/parsers/apple-strings.ts
-import { readdirSync as readdirSync8, readFileSync as readFileSync13, statSync as statSync5 } from "fs";
+import { readdirSync as readdirSync8, readFileSync as readFileSync14, statSync as statSync5 } from "fs";
 import { join as join8 } from "path";
 function localeFromLproj(dir) {
   const m = dir.match(/^(.+)\.lproj$/);
@@ -4483,7 +4676,7 @@ var init_apple_strings2 = __esm({
           let text;
           try {
             if (!statSync5(file).isFile()) continue;
-            text = readFileSync13(file, "utf8");
+            text = readFileSync14(file, "utf8");
           } catch {
             continue;
           }
@@ -4502,6 +4695,773 @@ var init_apple_strings2 = __esm({
   }
 });
 
+// src/server/import/parsers/angular-xliff.ts
+import { readdirSync as readdirSync9, readFileSync as readFileSync15 } from "fs";
+import { join as join9 } from "path";
+function decodeEntities(s) {
+  return s.replace(/&#x([0-9a-fA-F]+);/g, (_, h) => String.fromCodePoint(parseInt(h, 16))).replace(/&#(\d+);/g, (_, d) => String.fromCodePoint(Number(d))).replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&");
+}
+function parseAttrs(s) {
+  const out = {};
+  for (const m of s.matchAll(/([\w-]+)="([^"]*)"/g)) out[m[1]] = decodeEntities(m[2]);
+  return out;
+}
+function decodeInline(raw, addMeta) {
+  let out = "";
+  let last = 0;
+  for (const m of raw.matchAll(/<x\b([^>]*?)\/>/g)) {
+    out += decodeEntities(raw.slice(last, m.index));
+    const attrs = parseAttrs(m[1]);
+    const id = attrs["id"] ?? "X";
+    const equiv = attrs["equiv-text"];
+    const simple = equiv?.match(/^\{\{\s*(\w+)\s*\}\}$/);
+    if (simple) {
+      out += `{${simple[1]}}`;
+    } else {
+      out += `{${id}}`;
+      const meta = {};
+      if (attrs["ctype"]) meta.type = attrs["ctype"];
+      if (equiv !== void 0) meta.example = equiv;
+      addMeta(id, meta);
+    }
+    last = m.index + m[0].length;
+  }
+  return out + decodeEntities(raw.slice(last));
+}
+var LOCALE_RE5, FILE_RE, angularXliff2;
+var init_angular_xliff2 = __esm({
+  "src/server/import/parsers/angular-xliff.ts"() {
+    "use strict";
+    LOCALE_RE5 = /^[a-z]{2,3}([_-][A-Za-z]{2,4}){0,2}$/;
+    FILE_RE = /^messages(?:\.(.+))?\.xlf$/;
+    angularXliff2 = {
+      name: "angular-xliff",
+      parse(localeRoot, opts) {
+        const warnings = [];
+        const keys = {};
+        const locales = [];
+        const seen = (loc) => {
+          if (!locales.includes(loc)) locales.push(loc);
+        };
+        const files = readdirSync9(localeRoot).filter((f) => FILE_RE.test(f)).sort((a, b) => (a === "messages.xlf" ? -1 : 0) - (b === "messages.xlf" ? -1 : 0) || a.localeCompare(b));
+        for (const file of files) {
+          const fnameLocale = file.match(FILE_RE)[1];
+          if (fnameLocale !== void 0 && !LOCALE_RE5.test(fnameLocale)) continue;
+          let xml;
+          try {
+            xml = readFileSync15(join9(localeRoot, file), "utf8");
+          } catch (e) {
+            warnings.push(`angular-xliff: failed to read ${file}: ${e.message}`);
+            continue;
+          }
+          const sourceLocale = xml.match(/source-language="([^"]+)"/)?.[1];
+          if (!sourceLocale) {
+            warnings.push(`angular-xliff: ${file} has no source-language attribute; skipped`);
+            continue;
+          }
+          const targetLocale = xml.match(/target-language="([^"]+)"/)?.[1] ?? fnameLocale;
+          if (opts?.locales && !opts.locales.includes(targetLocale ?? sourceLocale)) continue;
+          for (const unit of xml.matchAll(/<trans-unit\b([^>]*)>([\s\S]*?)<\/trans-unit>/g)) {
+            const id = parseAttrs(unit[1])["id"];
+            if (!id) {
+              warnings.push(`angular-xliff: ${file} has a trans-unit without an id; skipped`);
+              continue;
+            }
+            const body = unit[2];
+            const src = body.match(/<source\b[^>]*>([\s\S]*?)<\/source>/);
+            let tgt = body.match(/<target\b([^>]*)>([\s\S]*?)<\/target>/);
+            if (tgt && /\bstate="new"/.test(tgt[1])) tgt = null;
+            const entry = keys[id] ??= { values: {} };
+            const addMeta = (name, meta) => {
+              (entry.placeholders ??= {})[name] ??= meta;
+            };
+            if (src && entry.values[sourceLocale] === void 0) {
+              entry.values[sourceLocale] = decodeInline(src[1], addMeta);
+              seen(sourceLocale);
+            }
+            if (tgt && tgt[2] !== "" && targetLocale !== void 0) {
+              entry.values[targetLocale] = decodeInline(tgt[2], addMeta);
+              seen(targetLocale);
+            }
+          }
+        }
+        return { locales, keys, warnings };
+      }
+    };
+  }
+});
+
+// src/server/import/parsers/gettext-po.ts
+import { readdirSync as readdirSync10, readFileSync as readFileSync16 } from "fs";
+import { join as join10 } from "path";
+function unescapePo(s) {
+  return s.replace(
+    /\\([\\"ntr])/g,
+    (_, c) => c === "n" ? "\n" : c === "t" ? "	" : c === "r" ? "\r" : c
+  );
+}
+function parseEntries(text) {
+  const entries = [];
+  let cur = null;
+  let append = null;
+  const flush = () => {
+    if (cur && cur.msgid !== void 0) entries.push(cur);
+    cur = null;
+    append = null;
+  };
+  for (const line of text.split("\n")) {
+    if (line.trim() === "") {
+      flush();
+      continue;
+    }
+    if (line.startsWith("#")) continue;
+    const m = line.match(DIRECTIVE_RE);
+    if (m) {
+      const kw = m[1];
+      const idx = m[2];
+      const body = unescapePo(m[3]);
+      if (cur && (kw === "msgctxt" || kw === "msgid" && cur.msgid !== void 0)) flush();
+      cur ??= { plurals: /* @__PURE__ */ new Map() };
+      const entry = cur;
+      if (kw === "msgctxt") {
+        entry.msgctxt = body;
+        append = (c) => {
+          entry.msgctxt = (entry.msgctxt ?? "") + c;
+        };
+      } else if (kw === "msgid") {
+        entry.msgid = body;
+        append = (c) => {
+          entry.msgid = (entry.msgid ?? "") + c;
+        };
+      } else if (kw === "msgid_plural") {
+        entry.msgidPlural = body;
+        append = (c) => {
+          entry.msgidPlural = (entry.msgidPlural ?? "") + c;
+        };
+      } else if (idx !== void 0) {
+        const i = Number(idx);
+        entry.plurals.set(i, body);
+        append = (c) => {
+          entry.plurals.set(i, (entry.plurals.get(i) ?? "") + c);
+        };
+      } else {
+        entry.msgstr = body;
+        append = (c) => {
+          entry.msgstr = (entry.msgstr ?? "") + c;
+        };
+      }
+      continue;
+    }
+    const cont = line.match(CONT_RE);
+    if (cont && append) append(unescapePo(cont[1]));
+  }
+  flush();
+  return entries;
+}
+function discoverPoFiles(root) {
+  const found = [];
+  const entries = readdirSync10(root, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+  for (const e of entries) {
+    if (e.isFile() && e.name.endsWith(".po")) {
+      const base = e.name.slice(0, -3);
+      found.push({ path: join10(root, e.name), rel: e.name, locale: LOCALE_RE6.test(base) ? base : null });
+    } else if (e.isDirectory() && LOCALE_RE6.test(e.name)) {
+      for (const sub of [join10(e.name, "LC_MESSAGES"), e.name]) {
+        let names;
+        try {
+          names = readdirSync10(join10(root, sub)).sort();
+        } catch {
+          continue;
+        }
+        for (const f of names) {
+          if (f.endsWith(".po")) found.push({ path: join10(root, sub, f), rel: join10(sub, f), locale: e.name });
+        }
+      }
+    }
+  }
+  return found;
+}
+var LOCALE_RE6, DIRECTIVE_RE, CONT_RE, gettextPo2;
+var init_gettext_po2 = __esm({
+  "src/server/import/parsers/gettext-po.ts"() {
+    "use strict";
+    init_plurals();
+    LOCALE_RE6 = /^[a-z]{2,3}([_-][A-Za-z]{2,4}){0,2}$/;
+    DIRECTIVE_RE = /^(msgctxt|msgid_plural|msgid|msgstr)(?:\[(\d+)\])?[ \t]+"(.*)"\s*$/;
+    CONT_RE = /^[ \t]*"(.*)"\s*$/;
+    gettextPo2 = {
+      name: "gettext-po",
+      parse(localeRoot, opts) {
+        const warnings = [];
+        const keys = {};
+        const locales = [];
+        for (const file of discoverPoFiles(localeRoot)) {
+          let entries;
+          try {
+            entries = parseEntries(readFileSync16(file.path, "utf8"));
+          } catch (e) {
+            warnings.push(`gettext-po: failed to parse ${file.rel}: ${e.message}`);
+            continue;
+          }
+          const header = entries.find((e) => e.msgid === "" && e.msgctxt === void 0);
+          const headerLang = header?.msgstr?.match(/^Language:[ \t]*([A-Za-z0-9_-]+)/m)?.[1];
+          const locale = file.locale ?? headerLang;
+          if (!locale) {
+            warnings.push(`gettext-po: cannot determine locale for ${file.rel}; skipped`);
+            continue;
+          }
+          if (opts?.locales && !opts.locales.includes(locale)) continue;
+          if (!locales.includes(locale)) locales.push(locale);
+          const cats = categoriesFor(locale);
+          for (const entry of entries) {
+            if (entry === header) continue;
+            const key = entry.msgctxt ?? entry.msgid;
+            if (!key) continue;
+            if (entry.msgidPlural !== void 0) {
+              const forms = {};
+              for (const [i, body] of [...entry.plurals].sort((a, b) => a[0] - b[0])) {
+                if (body === "") continue;
+                const cat = cats[i];
+                if (!cat) {
+                  warnings.push(
+                    `gettext-po: ${file.rel} "${key}": msgstr[${i}] exceeds the ${cats.length} plural forms of "${locale}"; ignored`
+                  );
+                  continue;
+                }
+                forms[cat] = body.split("%d").join("{count}");
+              }
+              if (!forms.other) continue;
+              (keys[key] ??= { values: {} }).values[locale] = formsToIcu("count", forms);
+            } else {
+              if (!entry.msgstr) continue;
+              (keys[key] ??= { values: {} }).values[locale] = entry.msgstr;
+            }
+          }
+        }
+        return { locales, keys, warnings };
+      }
+    };
+  }
+});
+
+// src/server/import/parsers/i18next-json.ts
+import { readdirSync as readdirSync11, readFileSync as readFileSync17, statSync as statSync6 } from "fs";
+import { join as join11 } from "path";
+function safeIsDir2(p) {
+  try {
+    return statSync6(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function fromI18next(value) {
+  if (isIcuPluralOrSelect(value)) return value;
+  return value.replace(/\{\{(\w+)\}\}/g, "{$1}");
+}
+function ingestFile(path, label, prefix, locale, keys, warnings) {
+  let data;
+  try {
+    data = JSON.parse(readFileSync17(path, "utf8"));
+  } catch (e) {
+    warnings.push(`i18next-json: failed to parse ${label}: ${e.message}`);
+    return false;
+  }
+  const fileWarnings = [];
+  const flat = flattenObject(data, "", fileWarnings);
+  for (const w of fileWarnings) warnings.push(`i18next-json: ${label}: ${w}`);
+  const families = /* @__PURE__ */ new Set();
+  for (const [k, v] of Object.entries(flat)) {
+    const m = PLURAL_SUFFIX_RE.exec(k);
+    if (m && m[2] === "other" && v !== "") families.add(m[1]);
+  }
+  const pluralForms = {};
+  for (const [k, raw] of Object.entries(flat)) {
+    if (raw === "") continue;
+    const value = fromI18next(raw);
+    const m = PLURAL_SUFFIX_RE.exec(k);
+    if (m && families.has(m[1])) {
+      (pluralForms[m[1]] ??= {})[m[2]] = value;
+      continue;
+    }
+    if (families.has(k)) {
+      warnings.push(
+        `i18next-json: ${label}: key "${k}" collides with its own plural suffix family; the plural wins`
+      );
+      continue;
+    }
+    (keys[prefix + k] ??= { values: {} }).values[locale] = value;
+  }
+  for (const [base, forms] of Object.entries(pluralForms)) {
+    (keys[prefix + base] ??= { values: {} }).values[locale] = formsToIcu(PLURAL_ARG, forms);
+  }
+  return true;
+}
+var LOCALE_RE7, PLURAL_SUFFIX_RE, PLURAL_ARG, DEFAULT_NAMESPACE, i18nextJson2;
+var init_i18next_json2 = __esm({
+  "src/server/import/parsers/i18next-json.ts"() {
+    "use strict";
+    init_flatten();
+    init_plurals();
+    init_placeholders();
+    LOCALE_RE7 = /^[a-z]{2,3}([_-][A-Za-z]{2,4}){0,2}$/;
+    PLURAL_SUFFIX_RE = /^(.+)_(zero|one|two|few|many|other)$/;
+    PLURAL_ARG = "count";
+    DEFAULT_NAMESPACE = "translation";
+    i18nextJson2 = {
+      name: "i18next-json",
+      parse(localeRoot, opts) {
+        const warnings = [];
+        const keys = {};
+        const locales = [];
+        for (const entry of readdirSync11(localeRoot).sort()) {
+          const full = join11(localeRoot, entry);
+          if (safeIsDir2(full)) {
+            if (!LOCALE_RE7.test(entry)) continue;
+            if (opts?.locales && !opts.locales.includes(entry)) continue;
+            let any = false;
+            for (const file of readdirSync11(full).sort()) {
+              if (!file.endsWith(".json")) continue;
+              const ns = file.slice(0, -".json".length);
+              const prefix = ns === DEFAULT_NAMESPACE ? "" : `${ns}.`;
+              if (ingestFile(join11(full, file), `${entry}/${file}`, prefix, entry, keys, warnings)) any = true;
+            }
+            if (any && !locales.includes(entry)) locales.push(entry);
+          } else if (entry.endsWith(".json")) {
+            const locale = entry.slice(0, -".json".length);
+            if (!LOCALE_RE7.test(locale)) continue;
+            if (opts?.locales && !opts.locales.includes(locale)) continue;
+            if (ingestFile(full, entry, "", locale, keys, warnings) && !locales.includes(locale)) {
+              locales.push(locale);
+            }
+          }
+        }
+        return { locales, keys, warnings };
+      }
+    };
+  }
+});
+
+// src/server/import/parsers/rails-yaml.ts
+import { readdirSync as readdirSync12, readFileSync as readFileSync18 } from "fs";
+import { join as join12 } from "path";
+function fromRuby(value) {
+  return value.replace(/%\{(\w+)\}/g, "{$1}");
+}
+function makeNode() {
+  return /* @__PURE__ */ Object.create(null);
+}
+function decodeDouble(body) {
+  let out = "";
+  for (let i = 0; i < body.length; i++) {
+    const c = body[i];
+    if (c !== "\\") {
+      out += c;
+      continue;
+    }
+    const n = body[++i];
+    if (n === void 0) break;
+    out += n === "n" ? "\n" : n === "r" ? "\r" : n === "t" ? "	" : n;
+  }
+  return out;
+}
+function scanQuoted(s, start) {
+  const q = s[start];
+  if (q === '"') {
+    for (let i = start + 1; i < s.length; i++) {
+      if (s[i] === "\\") i++;
+      else if (s[i] === '"') return { text: decodeDouble(s.slice(start + 1, i)), end: i + 1 };
+    }
+    return null;
+  }
+  let out = "";
+  for (let i = start + 1; i < s.length; i++) {
+    if (s[i] === "'") {
+      if (s[i + 1] === "'") {
+        out += "'";
+        i++;
+      } else {
+        return { text: out, end: i + 1 };
+      }
+    } else {
+      out += s[i];
+    }
+  }
+  return null;
+}
+function stripPlainComment(s) {
+  const m = /(^|\s)#/.exec(s);
+  return (m && m.index >= 0 ? s.slice(0, m.index) : s).trim();
+}
+function onlyTrailing(s) {
+  return /^\s*(#.*)?$/.test(s);
+}
+function parseYamlSubset(text, file, warnings) {
+  const roots = {};
+  const lines = text.split(/\r?\n/);
+  let stack = [];
+  let skipDeeperThan = null;
+  let lastLeafIndent = null;
+  for (let n = 0; n < lines.length; n++) {
+    const raw = lines[n];
+    const lineNo = n + 1;
+    if (raw.trim() === "" || raw.trim().startsWith("#")) continue;
+    if (raw.trim() === "---") continue;
+    const indentMatch = /^[ \t]*/.exec(raw)[0];
+    if (indentMatch.includes("	")) {
+      warnings.push(`rails-yaml: ${file}:${lineNo}: tab in indentation; line skipped`);
+      continue;
+    }
+    const indent = indentMatch.length;
+    if (skipDeeperThan !== null) {
+      if (indent > skipDeeperThan) continue;
+      skipDeeperThan = null;
+    }
+    const content = raw.slice(indent);
+    if (content.startsWith("- ") || content === "-") {
+      warnings.push(`rails-yaml: ${file}:${lineNo}: sequences are not supported; node skipped`);
+      skipDeeperThan = indent;
+      continue;
+    }
+    let key;
+    let rest;
+    if (content[0] === '"' || content[0] === "'") {
+      const k = scanQuoted(content, 0);
+      if (!k || content[k.end] !== ":") {
+        warnings.push(`rails-yaml: ${file}:${lineNo}: unparseable quoted key; line skipped`);
+        skipDeeperThan = indent;
+        continue;
+      }
+      key = k.text;
+      rest = content.slice(k.end + 1);
+    } else {
+      const m = /^(.*?):(?=\s|$)/.exec(content);
+      if (!m) {
+        warnings.push(`rails-yaml: ${file}:${lineNo}: not a "key: value" mapping line; line skipped`);
+        skipDeeperThan = indent;
+        continue;
+      }
+      key = m[1].trim();
+      rest = content.slice(m[0].length);
+    }
+    if (lastLeafIndent !== null && indent > lastLeafIndent) {
+      warnings.push(`rails-yaml: ${file}:${lineNo}: unexpected indentation under a scalar; line skipped`);
+      skipDeeperThan = indent - 1;
+      continue;
+    }
+    while (stack.length > 0 && stack[stack.length - 1].indent >= indent) stack.pop();
+    const trimmed = rest.trim();
+    let value;
+    if (trimmed === "" || trimmed.startsWith("#")) {
+      value = null;
+    } else if (trimmed[0] === "&" || trimmed[0] === "*") {
+      warnings.push(`rails-yaml: ${file}:${lineNo}: YAML anchors/aliases are not supported; node skipped`);
+      skipDeeperThan = indent;
+      continue;
+    } else if (trimmed[0] === "|" || trimmed[0] === ">") {
+      warnings.push(`rails-yaml: ${file}:${lineNo}: block scalars are not supported; node skipped`);
+      skipDeeperThan = indent;
+      continue;
+    } else if (trimmed[0] === "[" || trimmed[0] === "{") {
+      warnings.push(`rails-yaml: ${file}:${lineNo}: flow collections are not supported; node skipped`);
+      skipDeeperThan = indent;
+      continue;
+    } else if (trimmed[0] === '"' || trimmed[0] === "'") {
+      const v = scanQuoted(trimmed, 0);
+      if (!v || !onlyTrailing(trimmed.slice(v.end))) {
+        warnings.push(`rails-yaml: ${file}:${lineNo}: unterminated or trailing-garbage quoted value; line skipped`);
+        continue;
+      }
+      value = v.text;
+    } else {
+      value = stripPlainComment(trimmed);
+    }
+    if (stack.length === 0) {
+      if (value !== null) {
+        warnings.push(`rails-yaml: ${file}:${lineNo}: top-level key "${key}" has a scalar value; skipped`);
+        lastLeafIndent = indent;
+        continue;
+      }
+      const root = roots[key] ??= makeNode();
+      stack = [{ indent, node: root }];
+      lastLeafIndent = null;
+      continue;
+    }
+    const parent = stack[stack.length - 1].node;
+    if (key in parent) {
+      warnings.push(`rails-yaml: ${file}:${lineNo}: duplicate key "${key}"; later value wins`);
+    }
+    if (value === null) {
+      const child = makeNode();
+      parent[key] = child;
+      stack.push({ indent, node: child });
+      lastLeafIndent = null;
+    } else {
+      parent[key] = value;
+      lastLeafIndent = indent;
+    }
+  }
+  return { roots };
+}
+function asPluralForms(node) {
+  const entries = Object.entries(node);
+  if (entries.length === 0) return null;
+  const forms = {};
+  for (const [k, v] of entries) {
+    if (!CATEGORY_SET.has(k) || typeof v !== "string") return null;
+    if (v !== "") forms[k] = v;
+  }
+  if (!("other" in forms)) return null;
+  return forms;
+}
+function synthesizeIcu(forms, file, key, warnings) {
+  const parts = [];
+  for (const cat of PLURAL_CATEGORIES) {
+    const body = forms[cat];
+    if (body === void 0) continue;
+    if (body.includes("#")) {
+      warnings.push(
+        `rails-yaml: ${file}: plural "${key}" form "${cat}" contains "#", which ICU reads as the count placeholder`
+      );
+    }
+    parts.push(`${cat} {${fromRuby(body)}}`);
+  }
+  return `{count, plural, ${parts.join(" ")}}`;
+}
+var LOCALE_RE8, CATEGORY_SET, railsYaml2;
+var init_rails_yaml2 = __esm({
+  "src/server/import/parsers/rails-yaml.ts"() {
+    "use strict";
+    init_schema();
+    LOCALE_RE8 = /^[a-z]{2,3}([_-][A-Za-z]{2,4}){0,2}$/i;
+    CATEGORY_SET = new Set(PLURAL_CATEGORIES);
+    railsYaml2 = {
+      name: "rails-yaml",
+      parse(localeRoot, opts) {
+        const warnings = [];
+        const keys = {};
+        const locales = [];
+        const wanted = opts?.locales?.map((l) => l.toLowerCase());
+        const addValue = (key, locale, value) => {
+          (keys[key] ??= { values: {} }).values[locale] = value;
+        };
+        const flatten = (node, prefix, locale, file) => {
+          for (const [k, v] of Object.entries(node)) {
+            const key = prefix ? `${prefix}.${k}` : k;
+            if (typeof v === "string") {
+              if (v !== "") addValue(key, locale, fromRuby(v));
+              continue;
+            }
+            const forms = asPluralForms(v);
+            if (forms) addValue(key, locale, synthesizeIcu(forms, file, key, warnings));
+            else flatten(v, key, locale, file);
+          }
+        };
+        for (const file of readdirSync12(localeRoot).sort()) {
+          if (!file.endsWith(".yml") && !file.endsWith(".yaml")) continue;
+          let text;
+          try {
+            text = readFileSync18(join12(localeRoot, file), "utf8");
+          } catch (e) {
+            warnings.push(`rails-yaml: failed to read ${file}: ${e.message}`);
+            continue;
+          }
+          const { roots } = parseYamlSubset(text, file, warnings);
+          for (const token of Object.keys(roots).sort()) {
+            if (!LOCALE_RE8.test(token)) {
+              warnings.push(`rails-yaml: ${file}: top-level key "${token}" is not a locale; subtree skipped`);
+              continue;
+            }
+            if (wanted && !wanted.includes(token.toLowerCase())) continue;
+            if (!locales.includes(token)) locales.push(token);
+            flatten(roots[token], "", token, file);
+          }
+        }
+        return { locales, keys, warnings };
+      }
+    };
+  }
+});
+
+// src/server/import/parsers/apple-stringsdict.ts
+import { readdirSync as readdirSync13, readFileSync as readFileSync19, statSync as statSync7 } from "fs";
+import { join as join13 } from "path";
+function localeFromLproj2(dir) {
+  const m = dir.match(/^(.+)\.lproj$/);
+  if (!m) return null;
+  return LOCALE_RE9.test(m[1]) ? m[1] : null;
+}
+function decodeEntities2(s) {
+  return s.replace(/&#x([0-9a-fA-F]+);/g, (_, h) => String.fromCodePoint(parseInt(h, 16))).replace(/&#(\d+);/g, (_, d) => String.fromCodePoint(Number(d))).replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&");
+}
+function parsePlistDict(xml) {
+  let i = 0;
+  const n = xml.length;
+  const skipTrivia = () => {
+    for (; ; ) {
+      while (i < n && /\s/.test(xml[i])) i++;
+      if (xml.startsWith("<!--", i)) {
+        const end = xml.indexOf("-->", i + 4);
+        if (end === -1) throw new Error("unterminated comment");
+        i = end + 3;
+        continue;
+      }
+      if (xml.startsWith("<?", i) || xml.startsWith("<!", i) && !xml.startsWith("<!--", i)) {
+        const end = xml.indexOf(">", i);
+        if (end === -1) throw new Error("unterminated declaration");
+        i = end + 1;
+        continue;
+      }
+      break;
+    }
+  };
+  const readTag = () => {
+    if (xml[i] !== "<") throw new Error(`expected a tag at offset ${i}`);
+    const end = xml.indexOf(">", i);
+    if (end === -1) throw new Error("unterminated tag");
+    let body = xml.slice(i + 1, end).trim();
+    i = end + 1;
+    const closing = body.startsWith("/");
+    if (closing) body = body.slice(1).trim();
+    const selfClosing = body.endsWith("/");
+    if (selfClosing) body = body.slice(0, -1).trim();
+    const name = body.split(/\s/)[0];
+    if (!name) throw new Error(`empty tag at offset ${end}`);
+    return { name, closing, selfClosing };
+  };
+  const readElementText = (name) => {
+    const re = new RegExp(`</${name}\\s*>`, "g");
+    re.lastIndex = i;
+    const m = re.exec(xml);
+    if (!m) throw new Error(`unterminated <${name}>`);
+    const text = xml.slice(i, m.index);
+    i = m.index + m[0].length;
+    return decodeEntities2(text);
+  };
+  const readValue = (tag2) => {
+    if (tag2.name === "dict") return tag2.selfClosing ? {} : readDict();
+    if (tag2.name === "true" || tag2.name === "false") {
+      if (!tag2.selfClosing) readElementText(tag2.name);
+      return tag2.name;
+    }
+    if (["string", "integer", "real", "date", "data"].includes(tag2.name)) {
+      return tag2.selfClosing ? "" : readElementText(tag2.name);
+    }
+    throw new Error(`unsupported plist element <${tag2.name}>`);
+  };
+  const readDict = () => {
+    const out = {};
+    for (; ; ) {
+      skipTrivia();
+      const tag2 = readTag();
+      if (tag2.closing) {
+        if (tag2.name !== "dict") throw new Error(`unexpected </${tag2.name}> inside <dict>`);
+        return out;
+      }
+      if (tag2.name !== "key") throw new Error(`expected <key> inside <dict>, got <${tag2.name}>`);
+      const key = readElementText("key");
+      skipTrivia();
+      const vt = readTag();
+      if (vt.closing) throw new Error(`<key>${key}</key> has no value`);
+      out[key] = readValue(vt);
+    }
+  };
+  skipTrivia();
+  let tag = readTag();
+  if (tag.name === "plist" && !tag.closing && !tag.selfClosing) {
+    skipTrivia();
+    tag = readTag();
+  }
+  if (tag.name !== "dict" || tag.closing) throw new Error("expected a root <dict>");
+  return tag.selfClosing ? {} : readDict();
+}
+function entryToIcu(key, entry, file, warnings) {
+  const warn = (msg) => {
+    warnings.push(`apple-stringsdict: ${file}: key "${key}": ${msg}`);
+    return null;
+  };
+  if (typeof entry !== "object") return warn("value is not a dict; skipped");
+  const fmt = entry["NSStringLocalizedFormatKey"];
+  if (typeof fmt !== "string") return warn("missing NSStringLocalizedFormatKey; skipped");
+  const vars = [...fmt.matchAll(VAR_RE)];
+  if (vars.length !== 1) {
+    return warn(`format key has ${vars.length} %#@\u2026@ variables; only exactly one is supported; skipped`);
+  }
+  const arg = vars[0][1];
+  if (!/^\w+$/.test(arg)) return warn(`variable name "${arg}" is not a valid ICU argument; skipped`);
+  const prefix = fmt.slice(0, vars[0].index);
+  const suffix = fmt.slice(vars[0].index + vars[0][0].length);
+  const varDict = entry[arg];
+  if (typeof varDict !== "object") return warn(`variable "${arg}" has no dict; skipped`);
+  const specType = varDict["NSStringFormatSpecTypeKey"];
+  if (specType !== void 0 && specType !== "NSStringPluralRuleType") {
+    return warn(`variable "${arg}" is not a plural rule (${String(specType)}); skipped`);
+  }
+  const valueType = varDict["NSStringFormatValueTypeKey"];
+  const token = `%${typeof valueType === "string" && valueType ? valueType : "d"}`;
+  const forms = {};
+  for (const cat of PLURAL_CATEGORIES) {
+    const body = varDict[cat];
+    if (typeof body !== "string") continue;
+    forms[cat] = prefix + body.split(token).join(`{${arg}}`) + suffix;
+  }
+  if (forms.other === void 0) return warn(`variable "${arg}" has no "other" form; skipped`);
+  return formsToIcu(arg, forms);
+}
+var LOCALE_RE9, TABLE2, VAR_RE, appleStringsdict2;
+var init_apple_stringsdict2 = __esm({
+  "src/server/import/parsers/apple-stringsdict.ts"() {
+    "use strict";
+    init_schema();
+    init_plurals();
+    LOCALE_RE9 = /^[a-z]{2,3}([_-][A-Za-z]{2,4}){0,2}$/;
+    TABLE2 = "Localizable.stringsdict";
+    VAR_RE = /%#@([^@]*)@/g;
+    appleStringsdict2 = {
+      name: "apple-stringsdict",
+      parse(localeRoot, opts) {
+        const warnings = [];
+        const keys = {};
+        const locales = [];
+        for (const dir of readdirSync13(localeRoot).sort()) {
+          const locale = localeFromLproj2(dir);
+          if (!locale) continue;
+          if (opts?.locales && !opts.locales.includes(locale)) continue;
+          const file = join13(localeRoot, dir, TABLE2);
+          let text;
+          try {
+            if (!statSync7(file).isFile()) continue;
+            text = readFileSync19(file, "utf8");
+          } catch {
+            continue;
+          }
+          locales.push(locale);
+          const others = readdirSync13(join13(localeRoot, dir)).filter(
+            (f) => f.endsWith(".stringsdict") && f !== TABLE2
+          );
+          if (others.length) {
+            warnings.push(
+              `apple-stringsdict: ${dir} has other .stringsdict tables (${others.join(", ")}); only ${TABLE2} is imported`
+            );
+          }
+          let root;
+          try {
+            root = parsePlistDict(text);
+          } catch (e) {
+            warnings.push(`apple-stringsdict: failed to parse ${file}: ${e.message}`);
+            continue;
+          }
+          for (const key of Object.keys(root).sort()) {
+            const icu = entryToIcu(key, root[key], file, warnings);
+            if (icu === null) continue;
+            (keys[key] ??= { values: {} }).values[locale] = icu;
+          }
+        }
+        return { locales, keys, warnings };
+      }
+    };
+  }
+});
+
 // src/server/import/parsers/index.ts
 function getParser(name) {
   const p = REGISTRY[name];
@@ -4516,11 +5476,21 @@ var init_parsers = __esm({
     init_laravel_php2();
     init_flutter_arb2();
     init_apple_strings2();
+    init_angular_xliff2();
+    init_gettext_po2();
+    init_i18next_json2();
+    init_rails_yaml2();
+    init_apple_stringsdict2();
     REGISTRY = {
       [vueI18nJson2.name]: vueI18nJson2,
       [laravelPhp2.name]: laravelPhp2,
       [flutterArb2.name]: flutterArb2,
-      [appleStrings2.name]: appleStrings2
+      [appleStrings2.name]: appleStrings2,
+      [angularXliff2.name]: angularXliff2,
+      [gettextPo2.name]: gettextPo2,
+      [i18nextJson2.name]: i18nextJson2,
+      [railsYaml2.name]: railsYaml2,
+      [appleStringsdict2.name]: appleStringsdict2
     };
   }
 });
@@ -4606,7 +5576,14 @@ var init_assemble = __esm({
       "laravel-php": { adapter: "laravel-php", path: "lang/{locale}/{namespace}.php" },
       "vue-i18n-json": { adapter: "vue-i18n-json", path: "src/locale/{locale}.json" },
       "flutter-arb": { adapter: "flutter-arb", path: "lib/l10n/app_{locale}.arb" },
-      "apple-strings": { adapter: "apple-strings", path: "{locale}.lproj/Localizable.strings", rootRelative: true }
+      "apple-strings": { adapter: "apple-strings", path: "{locale}.lproj/Localizable.strings", rootRelative: true },
+      // skipSourceLocale: ng extract-i18n owns messages.xlf (the source file); glotfile
+      // only writes the translation files back next to it.
+      "angular-xliff": { adapter: "angular-xliff", path: "messages.{locale}.xlf", rootRelative: true, skipSourceLocale: true },
+      "gettext-po": { adapter: "gettext-po", path: "{locale}.po", rootRelative: true },
+      "i18next-json": { adapter: "i18next-json", path: "{locale}/translation.json", rootRelative: true },
+      "rails-yaml": { adapter: "rails-yaml", path: "config/locales/{locale}.yml" },
+      "apple-stringsdict": { adapter: "apple-stringsdict", path: "{locale}.lproj/Localizable.stringsdict", rootRelative: true }
     };
   }
 });
@@ -4917,12 +5894,12 @@ var init_checks = __esm({
 });
 
 // src/server/ui-prefs.ts
-import { readFileSync as readFileSync14 } from "fs";
+import { readFileSync as readFileSync20 } from "fs";
 import { homedir } from "os";
-import { join as join9 } from "path";
+import { join as join14 } from "path";
 function readJson2(path) {
   try {
-    const parsed = JSON.parse(readFileSync14(path, "utf8"));
+    const parsed = JSON.parse(readFileSync20(path, "utf8"));
     return parsed && typeof parsed === "object" ? parsed : {};
   } catch {
     return {};
@@ -4947,7 +5924,7 @@ var init_ui_prefs = __esm({
     THEMES = ["system", "light", "dark"];
     isThemeMode = (v) => THEMES.includes(v);
     isPanelWidth = (v) => typeof v === "number" && Number.isFinite(v) && v >= 120 && v <= 1200;
-    defaultUiPrefsPath = () => join9(homedir(), ".glotfile", "ui.json");
+    defaultUiPrefsPath = () => join14(homedir(), ".glotfile", "ui.json");
     DEFAULTS = { theme: "system" };
   }
 });
@@ -4955,13 +5932,13 @@ var init_ui_prefs = __esm({
 // src/server/api.ts
 import { Hono } from "hono";
 import { streamSSE } from "hono/streaming";
-import { readFileSync as readFileSync15, existsSync as existsSync11, readdirSync as readdirSync9, statSync as statSync6, rmSync as rmSync4 } from "fs";
+import { readFileSync as readFileSync21, existsSync as existsSync11, readdirSync as readdirSync14, statSync as statSync8, rmSync as rmSync4 } from "fs";
 import { dirname as dirname3, resolve as resolve9, basename, relative as relative4, sep as sep2 } from "path";
 function projectName(root) {
   const nameFile = resolve9(root, ".idea", ".name");
   if (existsSync11(nameFile)) {
     try {
-      const name = readFileSync15(nameFile, "utf8").trim();
+      const name = readFileSync21(nameFile, "utf8").trim();
       if (name) return name;
     } catch {
     }
@@ -5086,7 +6063,7 @@ function createApi(deps) {
       if (depth > 4) return;
       let entries = [];
       try {
-        entries = readdirSync9(dir);
+        entries = readdirSync14(dir);
       } catch {
         return;
       }
@@ -5100,7 +6077,7 @@ function createApi(deps) {
           filePath = abs;
         } else {
           try {
-            if (statSync6(abs).isDirectory()) walk(abs, depth + 1);
+            if (statSync8(abs).isDirectory()) walk(abs, depth + 1);
           } catch {
           }
           continue;
@@ -5918,7 +6895,7 @@ __export(server_exports, {
 import { Hono as Hono2 } from "hono";
 import { serve } from "@hono/node-server";
 import { fileURLToPath } from "url";
-import { dirname as dirname4, join as join10, resolve as resolve10, extname as extname3, sep as sep3 } from "path";
+import { dirname as dirname4, join as join15, resolve as resolve10, extname as extname3, sep as sep3 } from "path";
 import { readFile, stat } from "fs/promises";
 import { createServer } from "net";
 import open from "open";
@@ -5961,7 +6938,7 @@ function buildApp(opts) {
         const file = await readFileResponse(target);
         if (file) return file;
       }
-      const index = await readFileResponse(join10(root, "index.html"));
+      const index = await readFileResponse(join15(root, "index.html"));
       if (index) return index;
       return c.notFound();
     });
@@ -6019,7 +6996,7 @@ var init_server = __esm({
     init_scan();
     init_scanner();
     here = dirname4(fileURLToPath(import.meta.url));
-    DEFAULT_UI_DIR = join10(here, "..", "ui");
+    DEFAULT_UI_DIR = join15(here, "..", "ui");
     MIME = {
       ".html": "text/html; charset=utf-8",
       ".js": "text/javascript; charset=utf-8",
@@ -6063,8 +7040,8 @@ init_scanner();
 init_context();
 init_run2();
 init_outputs();
-import { resolve as resolve11, dirname as dirname5, join as join11 } from "path";
-import { readFileSync as readFileSync16, existsSync as existsSync12, mkdirSync as mkdirSync4, cpSync } from "fs";
+import { resolve as resolve11, dirname as dirname5, join as join16 } from "path";
+import { readFileSync as readFileSync22, existsSync as existsSync12, mkdirSync as mkdirSync4, cpSync } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/server/lint/locate.ts
@@ -6139,6 +7116,9 @@ function parseArgs(argv) {
   if (first === "help" || first === "--help" || first === "-h") {
     return isCommand(argv[1]) ? { command: argv[1], statePath, help: true } : { command: "help", statePath };
   }
+  if (first === "version" || first === "--version" || first === "-v") {
+    return { command: "version", statePath };
+  }
   if (first !== void 0 && !first.startsWith("-") && !isCommand(first)) {
     return { command: "serve", statePath, unknownCommand: first };
   }
@@ -6372,7 +7352,7 @@ async function runLintCmd(args) {
     }
     return;
   }
-  const rawText = existsSync12(args.statePath) ? readFileSync16(args.statePath, "utf8") : "";
+  const rawText = existsSync12(args.statePath) ? readFileSync22(args.statePath, "utf8") : "";
   const report = await runLint(state, {
     locales: args.locales,
     ruleIds: args.ruleIds,
@@ -6396,7 +7376,7 @@ async function runCheck(args) {
     process.exitCode = 1;
     return;
   }
-  const rawText = existsSync12(args.statePath) ? readFileSync16(args.statePath, "utf8") : "";
+  const rawText = existsSync12(args.statePath) ? readFileSync22(args.statePath, "utf8") : "";
   const root = dirname5(resolve11(args.statePath));
   const lint = await runLint(state, {});
   const findings = sortFindings([...lint.findings, ...checkOutputs(state, root)]);
@@ -6557,10 +7537,10 @@ function runSplit(args) {
     `Split catalog into ${splitDirFor(args.statePath)}/ (config.json, keys.json, locales/ \u2014 up to ${state.config.locales.length} locale files). Removed ${args.statePath}.`
   );
 }
-var SKILL_SRC = join11(dirname5(fileURLToPath2(import.meta.url)), "..", "..", "skill");
+var SKILL_SRC = join16(dirname5(fileURLToPath2(import.meta.url)), "..", "..", "skill");
 function runSkill(args) {
   if (args.print) {
-    console.log(readFileSync16(join11(SKILL_SRC, "SKILL.md"), "utf8").trimEnd());
+    console.log(readFileSync22(join16(SKILL_SRC, "SKILL.md"), "utf8").trimEnd());
     return;
   }
   const dest = resolve11(process.cwd(), ".claude", "skills", "glotfile");
@@ -6691,12 +7671,16 @@ ${formatOpts([...options, ...GLOBAL_OPTS])}`);
       formatOpts(commands),
       "",
       "Global options:",
-      formatOpts(GLOBAL_OPTS),
+      formatOpts([...GLOBAL_OPTS, ["-v, --version", "Print the glotfile version"]]),
       "",
       "Run `glotfile <command> --help` for a command's options."
     ].join("\n")
   );
 }
+function printVersion() {
+  const pkgPath = join16(dirname5(fileURLToPath2(import.meta.url)), "..", "..", "package.json");
+  console.log(JSON.parse(readFileSync22(pkgPath, "utf8")).version);
+}
 async function main(argv) {
   const args = parseArgs(argv);
   if (args.unknownCommand) {
@@ -6705,6 +7689,7 @@ async function main(argv) {
     return;
   }
   if (args.command === "help") return printHelp();
+  if (args.command === "version") return printVersion();
   if (args.help) return printHelp(args.command);
   loadDotEnv();
   if (args.command === "export") return runExport(args);