@i18nprune/core 0.1.0

package/dist/locales.js

@@ -0,0 +1,2288 @@
+// src/shared/errors/internal.ts
+var I18nPruneError = class extends Error {
+  code;
+  issueCode;
+  constructor(message, code, options) {
+    super(message, options?.cause !== void 0 ? { cause: options.cause } : void 0);
+    this.name = "I18nPruneError";
+    this.code = code;
+    this.issueCode = options?.issueCode;
+  }
+};
+
+// src/shared/languages/normalize.ts
+function normalizeLanguageCode(code) {
+  return code.trim().toLowerCase().replace(/_/g, "-");
+}
+
+// src/locales/source.ts
+function getSourceLocaleSlug(path, sourceLocalePath) {
+  return normalizeLanguageCode(path.basename(sourceLocalePath, ".json"));
+}
+function getDisplaySourceLocaleCode(ctx) {
+  return getSourceLocaleSlug(ctx.path, ctx.paths.sourceLocale);
+}
+function buildSourceLocaleTruthLabel(displaySlug) {
+  return `(${displaySlug} - source of truth)`;
+}
+function isSourceLocaleSlug(path, candidate, sourceLocalePath) {
+  return normalizeLanguageCode(candidate) === getSourceLocaleSlug(path, sourceLocalePath);
+}
+function excludeSourceLocaleSlugs(path, slugs, sourceLocalePath) {
+  const n = getSourceLocaleSlug(path, sourceLocalePath);
+  return slugs.filter((s) => normalizeLanguageCode(s) !== n);
+}
+function assertNotSourceTargetLocale(command, lang, sourceLocalePath, ctx) {
+  if (!isSourceLocaleSlug(ctx.path, lang, sourceLocalePath)) return;
+  const display = getDisplaySourceLocaleCode(ctx);
+  throw new I18nPruneError(
+    `${command} does not apply to the source locale ${buildSourceLocaleTruthLabel(display)}. Pass a target language code.`,
+    "USAGE"
+  );
+}
+
+// src/runtime/helpers/sync/assert.ts
+function isThenable(value) {
+  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
+}
+function assertSyncPortResult(value, label, at) {
+  if (isThenable(value)) {
+    throw new I18nPruneError(
+      `Synchronous ${label} requires a plain value (got a Promise at ${at})`,
+      "USAGE"
+    );
+  }
+  return value;
+}
+
+// src/runtime/helpers/sync/fs.ts
+function readRuntimeFsTextSync(filePath, fs) {
+  return assertSyncPortResult(fs.readText(filePath), "fs.readText", filePath);
+}
+function existsRuntimeFsSync(filePath, fs) {
+  return assertSyncPortResult(fs.exists(filePath), "fs.exists", filePath);
+}
+function listRuntimeFsDirSync(dirPath, fs) {
+  return assertSyncPortResult(fs.listDir(dirPath), "fs.listDir", dirPath);
+}
+
+// src/shared/constants/issueCodes.ts
+var ISSUE_LANGUAGES_UNSUPPORTED_LANGUAGE_CODE = "i18nprune.languages.unsupported_language_code";
+var ISSUE_IO_READ_FAILED = "i18nprune.io.read_failed";
+
+// src/shared/json/parse.ts
+var I18nPruneJsonParseError = class extends I18nPruneError {
+  filePath;
+  line;
+  column;
+  offset;
+  constructor(input) {
+    const options = input.issueCode !== void 0 ? { cause: input.cause, issueCode: input.issueCode } : { cause: input.cause };
+    super(input.message, input.code, options);
+    this.name = "I18nPruneJsonParseError";
+    this.filePath = input.filePath;
+    this.line = input.location.line;
+    this.column = input.location.column;
+    this.offset = input.location.offset;
+  }
+};
+function locationFromOffset(text, offset) {
+  let line = 1;
+  let column = 1;
+  const capped = Math.max(0, Math.min(offset, text.length));
+  for (let i = 0; i < capped; i += 1) {
+    if (text.charCodeAt(i) === 10) {
+      line += 1;
+      column = 1;
+    } else {
+      column += 1;
+    }
+  }
+  return { line, column, offset };
+}
+function getJsonParseLocation(error, text) {
+  const message = error instanceof Error ? error.message : String(error);
+  const positionMatch = /\bposition\s+(\d+)\b/i.exec(message);
+  if (positionMatch?.[1]) {
+    return locationFromOffset(text, Number.parseInt(positionMatch[1], 10));
+  }
+  const lineColumnMatch = /\bline\s+(\d+)\s+column\s+(\d+)\b/i.exec(message);
+  if (lineColumnMatch?.[1] && lineColumnMatch[2]) {
+    return {
+      line: Number.parseInt(lineColumnMatch[1], 10),
+      column: Number.parseInt(lineColumnMatch[2], 10)
+    };
+  }
+  return {};
+}
+function formatJsonParseMessage(filePath, location, cause) {
+  const subject = filePath ? `Invalid JSON in ${filePath}` : "Invalid JSON";
+  const at = location.line !== void 0 && location.column !== void 0 ? ` at line ${String(location.line)}, column ${String(location.column)}` : location.offset !== void 0 ? ` at offset ${String(location.offset)}` : "";
+  const detail = cause instanceof Error ? cause.message : String(cause);
+  return `${subject}${at}: ${detail}`;
+}
+function parseJsonText(text, options = {}) {
+  try {
+    return JSON.parse(text);
+  } catch (cause) {
+    const location = getJsonParseLocation(cause, text);
+    throw new I18nPruneJsonParseError({
+      message: formatJsonParseMessage(options.filePath, location, cause),
+      code: options.code ?? "IO",
+      cause,
+      location,
+      ...options.issueCode !== void 0 ? { issueCode: options.issueCode } : {},
+      ...options.filePath !== void 0 ? { filePath: options.filePath } : {}
+    });
+  }
+}
+
+// src/locales/otherLocales.ts
+function listOtherLocaleCodes(runtime, localesDir, sourceBase) {
+  const { fs, path } = runtime;
+  if (!existsRuntimeFsSync(localesDir, fs)) return [];
+  return listRuntimeFsDirSync(localesDir, fs).filter((e) => e.kind === "file" && e.name.endsWith(".json")).map((e) => path.basename(e.name, ".json")).filter((c) => c !== sourceBase);
+}
+
+// src/shared/locales/layout/requireStructure.ts
+function localesMode(config) {
+  return config.mode ?? "flat_file";
+}
+function resolveLocalesStructure(config) {
+  if (config.structure !== void 0) {
+    return config.structure;
+  }
+  if (localesMode(config) === "flat_file") {
+    return "locale_file";
+  }
+  throw new Error("locales.structure is required when locales.mode is locale_directory");
+}
+
+// src/shared/locales/layout/resolveLayout.ts
+function resolveLocalesLayout(config, directoryAbsolute) {
+  const mode = localesMode(config);
+  const structure = resolveLocalesStructure(config);
+  return { mode, structure, directoryAbsolute, config };
+}
+function resolveLocalesLayoutFromContext(ctx) {
+  return resolveLocalesLayout(ctx.config.locales, ctx.paths.localesDir);
+}
+function isLocalesLayoutReadSupported(layout) {
+  return layout.mode === "flat_file" && layout.structure === "locale_file" || layout.mode === "locale_directory" && (layout.structure === "locale_per_dir" || layout.structure === "feature_bundle");
+}
+
+// src/shared/locales/enumerate/parseSegmentLocale.ts
+function localeCodeForSegment(structure, path, segment) {
+  if (structure === "locale_file") {
+    if (segment.relativePath.includes("/")) return null;
+    return path.basename(segment.absolutePath, ".json");
+  }
+  if (structure === "locale_per_dir") {
+    const slash = segment.relativePath.indexOf("/");
+    if (slash < 0) return null;
+    const locale = segment.relativePath.slice(0, slash);
+    return locale.length > 0 ? locale : null;
+  }
+  if (structure === "feature_bundle") {
+    return path.basename(segment.absolutePath, ".json");
+  }
+  return null;
+}
+
+// src/shared/locales/leaves/segmentSource/localeSegmentSourceForFile.ts
+function localeSegmentSourceForFile(input) {
+  const { path, absoluteFile, localesDir, structure } = input;
+  let relativePath = path.relative(localesDir, absoluteFile);
+  if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
+    relativePath = path.basename(absoluteFile);
+  }
+  relativePath = relativePath.replace(/\\/g, "/");
+  const locale = localeCodeForSegment(structure, path, { absolutePath: absoluteFile, relativePath });
+  if (locale === null) return null;
+  return { file: absoluteFile, locale, relativePath };
+}
+
+// src/shared/locales/leaves/walk/translationSurfaceWalk.ts
+function isPlainObject(x) {
+  return typeof x === "object" && x !== null && !Array.isArray(x);
+}
+function isStructuredLocaleLeafNode(x) {
+  return isPlainObject(x) && typeof x.value === "string";
+}
+function readOptionalStatus(o) {
+  const s = o.status;
+  if (typeof s !== "string" || !s.trim()) return void 0;
+  return s;
+}
+function readOptionalLeafSource(o) {
+  const s = o.source;
+  if (typeof s !== "string" || !s.trim()) return void 0;
+  return s;
+}
+function readConfidence(o) {
+  const c = o.confidence;
+  if (c === null || c === void 0) return null;
+  if (typeof c !== "number" || !Number.isFinite(c)) return null;
+  const clamped = Math.max(0, Math.min(1, c));
+  return Math.round(clamped * 100) / 100;
+}
+function readNeedsReview(o) {
+  if (!("needsReview" in o)) return null;
+  return typeof o.needsReview === "boolean" ? o.needsReview : null;
+}
+function readNeedsTranslationAgain(o) {
+  if (!("needsTranslationAgain" in o)) return null;
+  return typeof o.needsTranslationAgain === "boolean" ? o.needsTranslationAgain : null;
+}
+function isCompleteStructuredLocaleLeafMeta(node) {
+  if (!isStructuredLocaleLeafNode(node)) return false;
+  const o = node;
+  if (typeof o.status !== "string" || !o.status.trim()) return false;
+  if (!(o.confidence === null || typeof o.confidence === "number" && Number.isFinite(o.confidence))) return false;
+  if (typeof o.needsReview !== "boolean") return false;
+  if (typeof o.needsTranslationAgain !== "boolean") return false;
+  if (typeof o.source !== "string" || !o.source.trim()) return false;
+  return true;
+}
+function pushStructuredRow(out, prefix, root, fileOrigin) {
+  out.push({
+    path: prefix,
+    value: root.value,
+    shape: "structured",
+    status: readOptionalStatus(root),
+    confidence: readConfidence(root),
+    needsReview: readNeedsReview(root),
+    needsTranslationAgain: readNeedsTranslationAgain(root),
+    source: readOptionalLeafSource(root),
+    structuredMetaComplete: isCompleteStructuredLocaleLeafMeta(root),
+    ...fileOrigin ? { fileOrigin } : {}
+  });
+}
+function collectTranslationSurfaceLeaves(root, prefix = "", out = [], fileOrigin) {
+  if (typeof root === "string") {
+    if (prefix) {
+      out.push({
+        path: prefix,
+        value: root,
+        shape: "legacy_string",
+        confidence: null,
+        needsReview: null,
+        ...fileOrigin ? { fileOrigin } : {}
+      });
+    }
+    return out;
+  }
+  if (isStructuredLocaleLeafNode(root)) {
+    if (prefix) pushStructuredRow(out, prefix, root, fileOrigin);
+    return out;
+  }
+  if (Array.isArray(root)) {
+    root.forEach((item, i) => {
+      const p = prefix ? `${prefix}[${i}]` : `[${i}]`;
+      collectTranslationSurfaceLeaves(item, p, out, fileOrigin);
+    });
+    return out;
+  }
+  if (isPlainObject(root)) {
+    for (const k of Object.keys(root)) {
+      const p = prefix ? `${prefix}.${k}` : k;
+      collectTranslationSurfaceLeaves(root[k], p, out, fileOrigin);
+    }
+  }
+  return out;
+}
+
+// src/shared/locales/read/flatFileSurface.ts
+function readFlatLocaleJsonSurface(input) {
+  const diagnostics = [];
+  const emit = (d) => {
+    diagnostics.push(d);
+  };
+  try {
+    const text = readRuntimeFsTextSync(input.absoluteFile, input.fs);
+    let json;
+    try {
+      json = parseJsonText(text, {
+        filePath: input.absoluteFile,
+        code: "IO",
+        issueCode: ISSUE_IO_READ_FAILED
+      });
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      emit({ level: "error", code: "locale_json_parse_failed", message, path: input.absoluteFile });
+      return { ok: false, leaves: [], diagnostics };
+    }
+    const fileOrigin = localeSegmentSourceForFile({
+      path: input.path,
+      absoluteFile: input.absoluteFile,
+      localesDir: input.localesDir,
+      structure: input.structure
+    });
+    const leaves = collectTranslationSurfaceLeaves(json, "", [], fileOrigin ?? void 0);
+    return { ok: true, document: json, leaves, text, diagnostics };
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    emit({ level: "error", code: "locale_fs_read_failed", message, path: input.absoluteFile });
+    return { ok: false, leaves: [], diagnostics };
+  }
+}
+
+// src/shared/path/posix.ts
+function toPosixPath(value) {
+  return value.replace(/\\/g, "/");
+}
+
+// src/shared/locales/enumerate/resolveSegmentPath.ts
+function localeSegmentRefFromAbsolute(input) {
+  const { layout, path, absolutePath } = input;
+  let relativePath = path.relative(layout.directoryAbsolute, absolutePath);
+  if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
+    return null;
+  }
+  relativePath = relativePath.replace(/\\/g, "/");
+  if (!relativePath.endsWith(".json")) {
+    return null;
+  }
+  const locale = localeCodeForSegment(layout.structure, path, { absolutePath, relativePath });
+  if (locale === null) return null;
+  return { locale, relativePath, absolutePath: toPosixPath(absolutePath) };
+}
+
+// src/shared/locales/read/bundle.ts
+function readLocaleBundle(input) {
+  const diagnostics = [];
+  const emit = (d) => {
+    diagnostics.push(d);
+  };
+  if (!isLocalesLayoutReadSupported(input.layout)) {
+    emit({
+      level: "error",
+      code: "locale_layout_unsupported",
+      message: `locale read is not implemented for mode=${input.layout.mode} structure=${input.layout.structure}`,
+      path: input.absoluteFile
+    });
+    return { ok: false, leaves: [], diagnostics };
+  }
+  const segmentRef = localeSegmentRefFromAbsolute({
+    layout: input.layout,
+    path: input.path,
+    absolutePath: input.absoluteFile
+  });
+  if (segmentRef === null) {
+    emit({
+      level: "warn",
+      code: "locale_read_path_layout_mismatch",
+      message: `path does not match configured layout mode=${input.layout.mode} structure=${input.layout.structure}`,
+      path: input.absoluteFile
+    });
+    return { ok: false, leaves: [], diagnostics };
+  }
+  return readFlatLocaleJsonSurface({
+    fs: input.fs,
+    path: input.path,
+    absoluteFile: input.absoluteFile,
+    localesDir: input.layout.directoryAbsolute,
+    structure: input.layout.structure,
+    onDiagnostic: input.onDiagnostic
+  });
+}
+
+// src/shared/locales/diagnostics/structuralParity.ts
+function localeStructuralSlot(structure, relativePath) {
+  if (structure === "locale_per_dir") {
+    const slash = relativePath.indexOf("/");
+    if (slash < 0) return null;
+    const slot = relativePath.slice(slash + 1);
+    return slot.length > 0 ? slot : null;
+  }
+  if (structure === "feature_bundle") {
+    const slash = relativePath.lastIndexOf("/");
+    if (slash < 0) return null;
+    const slot = relativePath.slice(0, slash);
+    return slot.length > 0 ? slot : null;
+  }
+  return null;
+}
+function slotsByLocale(structure, segments) {
+  const byLocale = /* @__PURE__ */ new Map();
+  for (const segment of segments) {
+    const slot = localeStructuralSlot(structure, segment.relativePath);
+    if (slot === null) continue;
+    let set = byLocale.get(segment.locale);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      byLocale.set(segment.locale, set);
+    }
+    set.add(slot);
+  }
+  return byLocale;
+}
+function pickReferenceLocale(byLocale, preferred) {
+  if (preferred !== void 0 && byLocale.has(preferred)) return preferred;
+  let best = null;
+  let bestSize = -1;
+  for (const [locale, slots] of byLocale) {
+    if (slots.size > bestSize) {
+      best = locale;
+      bestSize = slots.size;
+    }
+  }
+  return best;
+}
+function collectLocaleStructuralParityDiagnostics(input) {
+  const { structure, segments } = input;
+  if (structure !== "locale_per_dir" && structure !== "feature_bundle") {
+    return [];
+  }
+  const byLocale = slotsByLocale(structure, segments);
+  if (byLocale.size < 2) return [];
+  const reference = pickReferenceLocale(byLocale, input.referenceLocale);
+  if (reference === null) return [];
+  const referenceSlots = byLocale.get(reference);
+  if (!referenceSlots || referenceSlots.size === 0) return [];
+  const diagnostics = [];
+  for (const [locale, slots] of byLocale) {
+    if (locale === reference) continue;
+    for (const slot of referenceSlots) {
+      if (!slots.has(slot)) {
+        diagnostics.push({
+          level: "warn",
+          code: "locale_structure_slot_missing",
+          message: `locale ${locale} is missing segment slot ${slot} (present for reference locale ${reference})`
+        });
+      }
+    }
+    for (const slot of slots) {
+      if (!referenceSlots.has(slot)) {
+        diagnostics.push({
+          level: "warn",
+          code: "locale_structure_slot_extra",
+          message: `locale ${locale} has extra segment slot ${slot} (not present for reference locale ${reference})`
+        });
+      }
+    }
+  }
+  diagnostics.sort((a, b) => a.message.localeCompare(b.message));
+  return diagnostics;
+}
+
+// src/shared/constants/locales.ts
+var MAX_LOCALE_SEGMENT_TREE_DEPTH = 16;
+
+// src/shared/locales/enumerate/walkJsonTree.ts
+function posixRelative(pathApi, root, absolute) {
+  let rel = pathApi.relative(root, absolute);
+  if (rel.startsWith("..") || pathApi.isAbsolute(rel)) {
+    rel = pathApi.basename(absolute);
+  }
+  return rel.replace(/\\/g, "/");
+}
+function walkLocaleJsonSegments(input) {
+  const { fs, path, rootAbsolute, recursive } = input;
+  const maxDepth = input.maxDepth ?? MAX_LOCALE_SEGMENT_TREE_DEPTH;
+  const out = [];
+  function visit(dirAbsolute, depth) {
+    if (!existsRuntimeFsSync(dirAbsolute, fs)) return;
+    const entries = listRuntimeFsDirSync(dirAbsolute, fs);
+    for (const entry of entries) {
+      const childAbsolute = path.join(dirAbsolute, entry.name);
+      if (entry.kind === "file" && entry.name.endsWith(".json")) {
+        out.push({
+          absolutePath: childAbsolute,
+          relativePath: posixRelative(path, rootAbsolute, childAbsolute)
+        });
+      } else if (recursive && entry.kind === "directory" && depth < maxDepth) {
+        visit(childAbsolute, depth + 1);
+      }
+    }
+  }
+  visit(rootAbsolute, 0);
+  return out;
+}
+
+// src/shared/locales/enumerate/listLocaleSegments.ts
+function listLocaleSegments(input) {
+  const diagnostics = [];
+  const { layout, fs, path } = input;
+  const recursive = layout.structure !== "locale_file";
+  const walked = walkLocaleJsonSegments({
+    fs,
+    path,
+    rootAbsolute: layout.directoryAbsolute,
+    recursive
+  });
+  const segments = [];
+  for (const segment of walked) {
+    const locale = localeCodeForSegment(layout.structure, path, segment);
+    if (locale === null) continue;
+    segments.push({
+      locale,
+      relativePath: segment.relativePath,
+      absolutePath: segment.absolutePath
+    });
+  }
+  segments.sort((a, b) => {
+    const byLocale = a.locale.localeCompare(b.locale);
+    if (byLocale !== 0) return byLocale;
+    return a.relativePath.localeCompare(b.relativePath);
+  });
+  diagnostics.push(
+    ...collectLocaleStructuralParityDiagnostics({
+      structure: layout.structure,
+      segments
+    })
+  );
+  return { segments, diagnostics };
+}
+
+// src/shared/locales/enumerate/listLocaleCodes.ts
+function listLocaleCodes(input) {
+  const { segments, diagnostics } = listLocaleSegments(input);
+  const codes = [...new Set(segments.map((s) => s.locale))].sort((a, b) => a.localeCompare(b));
+  return { codes, diagnostics };
+}
+
+// src/shared/locales/enumerate/fromContext.ts
+function listLocaleSegmentsFromContext(ctx) {
+  return listLocaleSegments({
+    layout: resolveLocalesLayoutFromContext(ctx),
+    fs: ctx.adapters.fs,
+    path: ctx.adapters.path
+  });
+}
+function listLocaleCodesFromContext(ctx) {
+  return listLocaleCodes({
+    layout: resolveLocalesLayoutFromContext(ctx),
+    fs: ctx.adapters.fs,
+    path: ctx.adapters.path
+  });
+}
+
+// src/shared/locales/targets/context.ts
+function normalizeCode(code) {
+  return normalizeLanguageCode(code);
+}
+function listLocaleSegmentTargets(ctx) {
+  const { segments } = listLocaleSegmentsFromContext(ctx);
+  return segments.map((segment) => ({
+    ...segment,
+    reportKey: segment.relativePath
+  }));
+}
+function sourceLocaleCodeFromContext(ctx) {
+  const layout = resolveLocalesLayoutFromContext(ctx);
+  const ref = localeSegmentRefFromAbsolute({
+    layout,
+    path: ctx.adapters.path,
+    absolutePath: ctx.paths.sourceLocale
+  });
+  if (ref !== null) {
+    return normalizeCode(ref.locale);
+  }
+  return normalizeCode(ctx.adapters.path.basename(ctx.paths.sourceLocale, ".json"));
+}
+function localeCodesFromContext(ctx) {
+  return listLocaleCodesFromContext(ctx).codes.map((c) => normalizeCode(c));
+}
+function targetLocaleCodesFromContext(ctx) {
+  const source = sourceLocaleCodeFromContext(ctx);
+  return localeCodesFromContext(ctx).filter((c) => c !== source);
+}
+function segmentsForLocaleCode(ctx, localeCode) {
+  const want = normalizeCode(localeCode);
+  return listLocaleSegmentTargets(ctx).filter((s) => normalizeCode(s.locale) === want);
+}
+function primarySegmentForLocale(ctx, localeCode) {
+  const segments = segmentsForLocaleCode(ctx, localeCode);
+  if (segments.length === 0) return void 0;
+  const sourceResolved = ctx.adapters.path.resolve(ctx.paths.sourceLocale);
+  const sourceMatch = segments.find((s) => ctx.adapters.path.resolve(s.absolutePath) === sourceResolved);
+  if (sourceMatch) return sourceMatch;
+  return segments.slice().sort((a, b) => a.relativePath.localeCompare(b.relativePath))[0];
+}
+
+// src/shared/locales/read/cache.ts
+function dropLocaleCodeReadCache(ctx, localeCode) {
+  ctx.localeRead.localeCodes.delete(normalizeLanguageCode(localeCode));
+}
+
+// src/shared/locales/read/fromContext.ts
+function storeSegmentSnapshot(ctx, absoluteFile, snapshot) {
+  ctx.localeRead.segments.set(absoluteFile, snapshot);
+  if (snapshot.ok) {
+    const layout = resolveLocalesLayoutFromContext(ctx);
+    const ref = localeSegmentRefFromAbsolute({
+      layout,
+      path: ctx.adapters.path,
+      absolutePath: absoluteFile
+    });
+    if (ref !== null) {
+      dropLocaleCodeReadCache(ctx, ref.locale);
+    }
+  }
+}
+function segmentSnapshotToResult(snapshot) {
+  if (snapshot.ok) {
+    return {
+      ok: true,
+      document: snapshot.document,
+      leaves: snapshot.leaves,
+      text: snapshot.text,
+      diagnostics: []
+    };
+  }
+  return { ok: false, leaves: [], diagnostics: snapshot.diagnostics };
+}
+function readLocaleSegmentFromContext(ctx, absoluteFile, onDiagnostic) {
+  const cached = ctx.localeRead.segments.get(absoluteFile);
+  if (cached !== void 0) {
+    return segmentSnapshotToResult(cached);
+  }
+  const result = readLocaleBundle({
+    layout: resolveLocalesLayoutFromContext(ctx),
+    fs: ctx.adapters.fs,
+    path: ctx.adapters.path,
+    absoluteFile,
+    onDiagnostic
+  });
+  if (result.ok) {
+    storeSegmentSnapshot(ctx, absoluteFile, {
+      ok: true,
+      absolutePath: absoluteFile,
+      document: result.document,
+      leaves: result.leaves,
+      text: result.text
+    });
+  } else {
+    storeSegmentSnapshot(ctx, absoluteFile, {
+      ok: false,
+      absolutePath: absoluteFile,
+      diagnostics: result.diagnostics
+    });
+  }
+  return result;
+}
+
+// src/shared/projects/localeSurfaceMap.ts
+function translationSurfacePathValueMapFromLeaves(leaves) {
+  return new Map(leaves.map((row) => [row.path, row.value]));
+}
+
+// src/locales/summary.ts
+function toLeafMap(ctx, absoluteFile) {
+  if (!isLocalesLayoutReadSupported(resolveLocalesLayoutFromContext(ctx))) {
+    return /* @__PURE__ */ new Map();
+  }
+  const read = readLocaleSegmentFromContext(ctx, absoluteFile);
+  if (!read.ok) return /* @__PURE__ */ new Map();
+  return translationSurfacePathValueMapFromLeaves(read.leaves);
+}
+function buildLocaleListRows(ctx, localeCodes) {
+  const { sourceLocale } = ctx.paths;
+  const pathApi = ctx.adapters.path;
+  const sourceMap = toLeafMap(ctx, sourceLocale);
+  const sourceCode = sourceLocaleCodeFromContext(ctx);
+  return localeCodes.slice().sort((a, b) => a.localeCompare(b)).map((code) => {
+    const normalized = normalizeLanguageCode(code);
+    const segments = segmentsForLocaleCode(ctx, normalized);
+    const primary = primarySegmentForLocale(ctx, normalized);
+    const localePath = toPosixPath(
+      primary?.absolutePath ?? pathApi.join(ctx.paths.localesDir, `${normalized}.json`)
+    );
+    const isSourceLocale = normalized === sourceCode;
+    const leafMaps = segments.map((s) => toLeafMap(ctx, s.absolutePath));
+    const leafCount = leafMaps.reduce((sum, m) => sum + m.size, 0);
+    let englishIdenticalLeafCount = null;
+    if (!isSourceLocale) {
+      let identical = 0;
+      for (const localeMap of leafMaps) {
+        for (const [leafPath, value] of localeMap) {
+          if (sourceMap.get(leafPath) === value) identical += 1;
+        }
+      }
+      englishIdenticalLeafCount = identical;
+    }
+    const segmentRelativePaths = segments.map((s) => s.relativePath).sort((a, b) => a.localeCompare(b));
+    return {
+      code: normalized,
+      localePath,
+      segmentCount: segments.length,
+      segmentRelativePaths,
+      leafCount,
+      englishIdenticalLeafCount,
+      isSourceLocale
+    };
+  });
+}
+
+// src/shared/languages/catalog/languages.json
+var languages_default = [
+  {
+    code: "ab",
+    english: "Abkhazian",
+    native: "Abkhazian",
+    direction: "ltr"
+  },
+  {
+    code: "ace",
+    english: "Acehnese",
+    native: "Acehnese",
+    direction: "ltr"
+  },
+  {
+    code: "ach",
+    english: "Acoli",
+    native: "Acoli",
+    direction: "ltr"
+  },
+  {
+    code: "af",
+    english: "Afrikaans",
+    native: "Afrikaans",
+    direction: "ltr"
+  },
+  {
+    code: "ak",
+    english: "Akan",
+    native: "Akan",
+    direction: "ltr"
+  },
+  {
+    code: "alz",
+    english: "alz",
+    native: "alz",
+    direction: "ltr"
+  },
+  {
+    code: "am",
+    english: "Amharic",
+    native: "\u12A0\u121B\u122D\u129B",
+    direction: "ltr"
+  },
+  {
+    code: "ar",
+    english: "Arabic",
+    native: "\u0627\u0644\u0639\u0631\u0628\u064A\u0629",
+    direction: "rtl"
+  },
+  {
+    code: "ar-sa",
+    english: "Arabic (Saudi Arabia)",
+    native: "\u0627\u0644\u0639\u0631\u0628\u064A\u0629 (\u0627\u0644\u0645\u0645\u0644\u0643\u0629 \u0627\u0644\u0639\u0631\u0628\u064A\u0629 \u0627\u0644\u0633\u0639\u0648\u062F\u064A\u0629)",
+    direction: "rtl"
+  },
+  {
+    code: "as",
+    english: "Assamese",
+    native: "\u0985\u09B8\u09AE\u09C0\u09AF\u09BC\u09BE",
+    direction: "ltr"
+  },
+  {
+    code: "awa",
+    english: "Awadhi",
+    native: "Awadhi",
+    direction: "ltr"
+  },
+  {
+    code: "ay",
+    english: "Aymara",
+    native: "Aymara",
+    direction: "ltr"
+  },
+  {
+    code: "az",
+    english: "Azerbaijani",
+    native: "az\u0259rbaycan",
+    direction: "ltr"
+  },
+  {
+    code: "ba",
+    english: "Bashkir",
+    native: "Bashkir",
+    direction: "ltr"
+  },
+  {
+    code: "ban",
+    english: "Balinese",
+    native: "Balinese",
+    direction: "ltr"
+  },
+  {
+    code: "bbc",
+    english: "Batak Toba",
+    native: "Batak Toba",
+    direction: "ltr"
+  },
+  {
+    code: "be",
+    english: "Belarusian",
+    native: "\u0431\u0435\u043B\u0430\u0440\u0443\u0441\u043A\u0430\u044F",
+    direction: "ltr"
+  },
+  {
+    code: "bem",
+    english: "Bemba",
+    native: "Ichibemba",
+    direction: "ltr"
+  },
+  {
+    code: "bew",
+    english: "Betawi",
+    native: "Betawi",
+    direction: "ltr"
+  },
+  {
+    code: "bg",
+    english: "Bulgarian",
+    native: "\u0431\u044A\u043B\u0433\u0430\u0440\u0441\u043A\u0438",
+    direction: "ltr"
+  },
+  {
+    code: "bho",
+    english: "Bhojpuri",
+    native: "\u092D\u094B\u091C\u092A\u0941\u0930\u0940",
+    direction: "ltr"
+  },
+  {
+    code: "bik",
+    english: "Bikol",
+    native: "Bikol",
+    direction: "ltr"
+  },
+  {
+    code: "bm",
+    english: "Bambara",
+    native: "bamanakan",
+    direction: "ltr"
+  },
+  {
+    code: "bn",
+    english: "Bangla",
+    native: "\u09AC\u09BE\u0982\u09B2\u09BE",
+    direction: "ltr"
+  },
+  {
+    code: "bn-in",
+    english: "Bangla (India)",
+    native: "\u09AC\u09BE\u0982\u09B2\u09BE (\u09AD\u09BE\u09B0\u09A4)",
+    direction: "ltr"
+  },
+  {
+    code: "br",
+    english: "Breton",
+    native: "brezhoneg",
+    direction: "ltr"
+  },
+  {
+    code: "bs",
+    english: "Bosnian",
+    native: "bosanski",
+    direction: "ltr"
+  },
+  {
+    code: "bs-cyrl",
+    english: "Bosnian (Cyrillic)",
+    native: "\u0431\u043E\u0441\u0430\u043D\u0441\u043A\u0438 (\u045B\u0438\u0440\u0438\u043B\u0438\u0446\u0430)",
+    direction: "ltr"
+  },
+  {
+    code: "bts",
+    english: "bts",
+    native: "bts",
+    direction: "ltr"
+  },
+  {
+    code: "btx",
+    english: "btx",
+    native: "btx",
+    direction: "ltr"
+  },
+  {
+    code: "bua",
+    english: "Buriat",
+    native: "Buriat",
+    direction: "ltr"
+  },
+  {
+    code: "ca",
+    english: "Catalan",
+    native: "catal\xE0",
+    direction: "ltr"
+  },
+  {
+    code: "ceb",
+    english: "Cebuano",
+    native: "Cebuano",
+    direction: "ltr"
+  },
+  {
+    code: "cgg",
+    english: "Chiga",
+    native: "Rukiga",
+    direction: "ltr"
+  },
+  {
+    code: "chm",
+    english: "Mari",
+    native: "Mari",
+    direction: "ltr"
+  },
+  {
+    code: "ckb",
+    english: "Central Kurdish",
+    native: "\u06A9\u0648\u0631\u062F\u06CC\u06CC \u0646\u0627\u0648\u06D5\u0646\u062F\u06CC",
+    direction: "rtl"
+  },
+  {
+    code: "cnh",
+    english: "cnh",
+    native: "cnh",
+    direction: "ltr"
+  },
+  {
+    code: "co",
+    english: "Corsican",
+    native: "Corsican",
+    direction: "ltr"
+  },
+  {
+    code: "crh",
+    english: "Crimean Tatar",
+    native: "Crimean Tatar",
+    direction: "ltr"
+  },
+  {
+    code: "crs",
+    english: "Seselwa Creole French",
+    native: "Seselwa Creole French",
+    direction: "ltr"
+  },
+  {
+    code: "cs",
+    english: "Czech",
+    native: "\u010De\u0161tina",
+    direction: "ltr"
+  },
+  {
+    code: "cv",
+    english: "Chuvash",
+    native: "\u0447\u04D1\u0432\u0430\u0448",
+    direction: "ltr"
+  },
+  {
+    code: "cy",
+    english: "Welsh",
+    native: "Cymraeg",
+    direction: "ltr"
+  },
+  {
+    code: "da",
+    english: "Danish",
+    native: "dansk",
+    direction: "ltr"
+  },
+  {
+    code: "de",
+    english: "German",
+    native: "Deutsch",
+    direction: "ltr"
+  },
+  {
+    code: "din",
+    english: "Dinka",
+    native: "Dinka",
+    direction: "ltr"
+  },
+  {
+    code: "doi",
+    english: "Dogri",
+    native: "\u0921\u094B\u0917\u0930\u0940",
+    direction: "ltr"
+  },
+  {
+    code: "dov",
+    english: "dov",
+    native: "dov",
+    direction: "ltr"
+  },
+  {
+    code: "dv",
+    english: "Divehi",
+    native: "Divehi",
+    direction: "rtl"
+  },
+  {
+    code: "dz",
+    english: "Dzongkha",
+    native: "\u0F62\u0FAB\u0F7C\u0F44\u0F0B\u0F41",
+    direction: "ltr"
+  },
+  {
+    code: "ee",
+    english: "Ewe",
+    native: "E\u028Begbe",
+    direction: "ltr"
+  },
+  {
+    code: "el",
+    english: "Greek",
+    native: "\u0395\u03BB\u03BB\u03B7\u03BD\u03B9\u03BA\u03AC",
+    direction: "ltr"
+  },
+  {
+    code: "en",
+    english: "English",
+    native: "English",
+    direction: "ltr"
+  },
+  {
+    code: "en-au",
+    english: "Australian English",
+    native: "Australian English",
+    direction: "ltr"
+  },
+  {
+    code: "en-ca",
+    english: "Canadian English",
+    native: "Canadian English",
+    direction: "ltr"
+  },
+  {
+    code: "en-gb",
+    english: "British English",
+    native: "British English",
+    direction: "ltr"
+  },
+  {
+    code: "en-nz",
+    english: "English (New Zealand)",
+    native: "English (New Zealand)",
+    direction: "ltr"
+  },
+  {
+    code: "en-ph",
+    english: "English (Philippines)",
+    native: "English (Philippines)",
+    direction: "ltr"
+  },
+  {
+    code: "en-us",
+    english: "American English",
+    native: "American English",
+    direction: "ltr"
+  },
+  {
+    code: "en-za",
+    english: "English (South Africa)",
+    native: "English (South Africa)",
+    direction: "ltr"
+  },
+  {
+    code: "eo",
+    english: "Esperanto",
+    native: "Esperanto",
+    direction: "ltr"
+  },
+  {
+    code: "es",
+    english: "Spanish",
+    native: "espa\xF1ol",
+    direction: "ltr"
+  },
+  {
+    code: "es-419",
+    english: "Latin American Spanish",
+    native: "espa\xF1ol latinoamericano",
+    direction: "ltr"
+  },
+  {
+    code: "es-ar",
+    english: "Spanish (Argentina)",
+    native: "espa\xF1ol (Argentina)",
+    direction: "ltr"
+  },
+  {
+    code: "es-cl",
+    english: "Spanish (Chile)",
+    native: "espa\xF1ol (Chile)",
+    direction: "ltr"
+  },
+  {
+    code: "es-co",
+    english: "Spanish (Colombia)",
+    native: "espa\xF1ol (Colombia)",
+    direction: "ltr"
+  },
+  {
+    code: "es-cr",
+    english: "Spanish (Costa Rica)",
+    native: "espa\xF1ol (Costa Rica)",
+    direction: "ltr"
+  },
+  {
+    code: "es-ec",
+    english: "Spanish (Ecuador)",
+    native: "espa\xF1ol (Ecuador)",
+    direction: "ltr"
+  },
+  {
+    code: "es-es",
+    english: "European Spanish",
+    native: "espa\xF1ol de Espa\xF1a",
+    direction: "ltr"
+  },
+  {
+    code: "es-gt",
+    english: "Spanish (Guatemala)",
+    native: "espa\xF1ol (Guatemala)",
+    direction: "ltr"
+  },
+  {
+    code: "es-hn",
+    english: "Spanish (Honduras)",
+    native: "espa\xF1ol (Honduras)",
+    direction: "ltr"
+  },
+  {
+    code: "es-ht",
+    english: "Spanish (Haiti)",
+    native: "espa\xF1ol (Hait\xED)",
+    direction: "ltr"
+  },
+  {
+    code: "es-mx",
+    english: "Mexican Spanish",
+    native: "espa\xF1ol de M\xE9xico",
+    direction: "ltr"
+  },
+  {
+    code: "es-ni",
+    english: "Spanish (Nicaragua)",
+    native: "espa\xF1ol (Nicaragua)",
+    direction: "ltr"
+  },
+  {
+    code: "es-pa",
+    english: "Spanish (Panama)",
+    native: "espa\xF1ol (Panam\xE1)",
+    direction: "ltr"
+  },
+  {
+    code: "es-pe",
+    english: "Spanish (Peru)",
+    native: "espa\xF1ol (Per\xFA)",
+    direction: "ltr"
+  },
+  {
+    code: "es-pr",
+    english: "Spanish (Puerto Rico)",
+    native: "espa\xF1ol (Puerto Rico)",
+    direction: "ltr"
+  },
+  {
+    code: "es-py",
+    english: "Spanish (Paraguay)",
+    native: "espa\xF1ol (Paraguay)",
+    direction: "ltr"
+  },
+  {
+    code: "es-sv",
+    english: "Spanish (El Salvador)",
+    native: "espa\xF1ol (El Salvador)",
+    direction: "ltr"
+  },
+  {
+    code: "es-us",
+    english: "Spanish (United States)",
+    native: "espa\xF1ol (Estados Unidos)",
+    direction: "ltr"
+  },
+  {
+    code: "es-uy",
+    english: "Spanish (Uruguay)",
+    native: "espa\xF1ol (Uruguay)",
+    direction: "ltr"
+  },
+  {
+    code: "es-ve",
+    english: "Spanish (Venezuela)",
+    native: "espa\xF1ol (Venezuela)",
+    direction: "ltr"
+  },
+  {
+    code: "et",
+    english: "Estonian",
+    native: "eesti",
+    direction: "ltr"
+  },
+  {
+    code: "eu",
+    english: "Basque",
+    native: "euskara",
+    direction: "ltr"
+  },
+  {
+    code: "fa",
+    english: "Persian",
+    native: "\u0641\u0627\u0631\u0633\u06CC",
+    direction: "rtl"
+  },
+  {
+    code: "ff",
+    english: "Fula",
+    native: "Pulaar",
+    direction: "rtl"
+  },
+  {
+    code: "fi",
+    english: "Finnish",
+    native: "suomi",
+    direction: "ltr"
+  },
+  {
+    code: "fil",
+    english: "Filipino",
+    native: "Filipino",
+    direction: "ltr"
+  },
+  {
+    code: "fj",
+    english: "Fijian",
+    native: "Fijian",
+    direction: "ltr"
+  },
+  {
+    code: "fr",
+    english: "French",
+    native: "fran\xE7ais",
+    direction: "ltr"
+  },
+  {
+    code: "fr-ca",
+    english: "Canadian French",
+    native: "fran\xE7ais canadien",
+    direction: "ltr"
+  },
+  {
+    code: "fr-ch",
+    english: "Swiss French",
+    native: "fran\xE7ais suisse",
+    direction: "ltr"
+  },
+  {
+    code: "fr-fr",
+    english: "French (France)",
+    native: "fran\xE7ais (France)",
+    direction: "ltr"
+  },
+  {
+    code: "fy",
+    english: "Western Frisian",
+    native: "Frysk",
+    direction: "ltr"
+  },
+  {
+    code: "ga",
+    english: "Irish",
+    native: "Gaeilge",
+    direction: "ltr"
+  },
+  {
+    code: "gaa",
+    english: "Ga",
+    native: "Ga",
+    direction: "ltr"
+  },
+  {
+    code: "gd",
+    english: "Scottish Gaelic",
+    native: "G\xE0idhlig",
+    direction: "ltr"
+  },
+  {
+    code: "gl",
+    english: "Galician",
+    native: "galego",
+    direction: "ltr"
+  },
+  {
+    code: "gn",
+    english: "Guarani",
+    native: "Guarani",
+    direction: "ltr"
+  },
+  {
+    code: "gom",
+    english: "Goan Konkani",
+    native: "Goan Konkani",
+    direction: "ltr"
+  },
+  {
+    code: "gu",
+    english: "Gujarati",
+    native: "\u0A97\u0AC1\u0A9C\u0AB0\u0ABE\u0AA4\u0AC0",
+    direction: "ltr"
+  },
+  {
+    code: "ha",
+    english: "Hausa",
+    native: "Hausa",
+    direction: "rtl"
+  },
+  {
+    code: "haw",
+    english: "Hawaiian",
+    native: "\u02BB\u014Clelo Hawai\u02BBi",
+    direction: "ltr"
+  },
+  {
+    code: "he",
+    english: "Hebrew",
+    native: "\u05E2\u05D1\u05E8\u05D9\u05EA",
+    direction: "rtl"
+  },
+  {
+    code: "hi",
+    english: "Hindi",
+    native: "\u0939\u093F\u0928\u094D\u0926\u0940",
+    direction: "ltr"
+  },
+  {
+    code: "hil",
+    english: "Hiligaynon",
+    native: "Hiligaynon",
+    direction: "ltr"
+  },
+  {
+    code: "hmn",
+    english: "Hmong",
+    native: "Hmong",
+    direction: "ltr"
+  },
+  {
+    code: "hr",
+    english: "Croatian",
+    native: "hrvatski",
+    direction: "ltr"
+  },
+  {
+    code: "hrx",
+    english: "hrx",
+    native: "hrx",
+    direction: "ltr"
+  },
+  {
+    code: "ht",
+    english: "Haitian Creole",
+    native: "Haitian Creole",
+    direction: "ltr"
+  },
+  {
+    code: "hu",
+    english: "Hungarian",
+    native: "magyar",
+    direction: "ltr"
+  },
+  {
+    code: "hy",
+    english: "Armenian",
+    native: "\u0570\u0561\u0575\u0565\u0580\u0565\u0576",
+    direction: "ltr"
+  },
+  {
+    code: "id",
+    english: "Indonesian",
+    native: "Indonesia",
+    direction: "ltr"
+  },
+  {
+    code: "ig",
+    english: "Igbo",
+    native: "Igbo",
+    direction: "ltr"
+  },
+  {
+    code: "ilo",
+    english: "Iloko",
+    native: "Iloko",
+    direction: "ltr"
+  },
+  {
+    code: "is",
+    english: "Icelandic",
+    native: "\xEDslenska",
+    direction: "ltr"
+  },
+  {
+    code: "it",
+    english: "Italian",
+    native: "italiano",
+    direction: "ltr"
+  },
+  {
+    code: "iw",
+    english: "Hebrew",
+    native: "\u05E2\u05D1\u05E8\u05D9\u05EA",
+    direction: "rtl"
+  },
+  {
+    code: "ja",
+    english: "Japanese",
+    native: "\u65E5\u672C\u8A9E",
+    direction: "ltr"
+  },
+  {
+    code: "jv",
+    english: "Javanese",
+    native: "Jawa",
+    direction: "ltr"
+  },
+  {
+    code: "jw",
+    english: "Javanese",
+    native: "Jawa",
+    direction: "ltr"
+  },
+  {
+    code: "ka",
+    english: "Georgian",
+    native: "\u10E5\u10D0\u10E0\u10D7\u10E3\u10DA\u10D8",
+    direction: "ltr"
+  },
+  {
+    code: "kk",
+    english: "Kazakh",
+    native: "\u049B\u0430\u0437\u0430\u049B \u0442\u0456\u043B\u0456",
+    direction: "ltr"
+  },
+  {
+    code: "km",
+    english: "Khmer",
+    native: "\u1781\u17D2\u1798\u17C2\u179A",
+    direction: "ltr"
+  },
+  {
+    code: "kn",
+    english: "Kannada",
+    native: "\u0C95\u0CA8\u0CCD\u0CA8\u0CA1",
+    direction: "ltr"
+  },
+  {
+    code: "ko",
+    english: "Korean",
+    native: "\uD55C\uAD6D\uC5B4",
+    direction: "ltr"
+  },
+  {
+    code: "kri",
+    english: "Krio",
+    native: "Krio",
+    direction: "ltr"
+  },
+  {
+    code: "ktu",
+    english: "ktu",
+    native: "ktu",
+    direction: "ltr"
+  },
+  {
+    code: "ku",
+    english: "Kurdish",
+    native: "kurd\xEE (kurmanc\xEE)",
+    direction: "ltr"
+  },
+  {
+    code: "ky",
+    english: "Kyrgyz",
+    native: "\u043A\u044B\u0440\u0433\u044B\u0437\u0447\u0430",
+    direction: "ltr"
+  },
+  {
+    code: "la",
+    english: "Latin",
+    native: "Latin",
+    direction: "ltr"
+  },
+  {
+    code: "lb",
+    english: "Luxembourgish",
+    native: "L\xEBtzebuergesch",
+    direction: "ltr"
+  },
+  {
+    code: "lg",
+    english: "Ganda",
+    native: "Luganda",
+    direction: "ltr"
+  },
+  {
+    code: "li",
+    english: "Limburgish",
+    native: "Limburgish",
+    direction: "ltr"
+  },
+  {
+    code: "lij",
+    english: "Ligurian",
+    native: "ligure",
+    direction: "ltr"
+  },
+  {
+    code: "lmo",
+    english: "Lombard",
+    native: "Lombard",
+    direction: "ltr"
+  },
+  {
+    code: "ln",
+    english: "Lingala",
+    native: "ling\xE1la",
+    direction: "ltr"
+  },
+  {
+    code: "lo",
+    english: "Lao",
+    native: "\u0EA5\u0EB2\u0EA7",
+    direction: "ltr"
+  },
+  {
+    code: "lt",
+    english: "Lithuanian",
+    native: "lietuvi\u0173",
+    direction: "ltr"
+  },
+  {
+    code: "ltg",
+    english: "Latgalian",
+    native: "Latgalian",
+    direction: "ltr"
+  },
+  {
+    code: "luo",
+    english: "Luo",
+    native: "Dholuo",
+    direction: "ltr"
+  },
+  {
+    code: "lus",
+    english: "Mizo",
+    native: "Mizo",
+    direction: "ltr"
+  },
+  {
+    code: "lv",
+    english: "Latvian",
+    native: "latvie\u0161u",
+    direction: "ltr"
+  },
+  {
+    code: "mai",
+    english: "Maithili",
+    native: "\u092E\u0948\u0925\u093F\u0932\u0940",
+    direction: "ltr"
+  },
+  {
+    code: "mak",
+    english: "Makasar",
+    native: "Makasar",
+    direction: "ltr"
+  },
+  {
+    code: "mg",
+    english: "Malagasy",
+    native: "Malagasy",
+    direction: "ltr"
+  },
+  {
+    code: "mi",
+    english: "M\u0101ori",
+    native: "M\u0101ori",
+    direction: "ltr"
+  },
+  {
+    code: "min",
+    english: "Minangkabau",
+    native: "Minangkabau",
+    direction: "ltr"
+  },
+  {
+    code: "mk",
+    english: "Macedonian",
+    native: "\u043C\u0430\u043A\u0435\u0434\u043E\u043D\u0441\u043A\u0438",
+    direction: "ltr"
+  },
+  {
+    code: "ml",
+    english: "Malayalam",
+    native: "\u0D2E\u0D32\u0D2F\u0D3E\u0D33\u0D02",
+    direction: "ltr"
+  },
+  {
+    code: "mn",
+    english: "Mongolian",
+    native: "\u043C\u043E\u043D\u0433\u043E\u043B",
+    direction: "ltr"
+  },
+  {
+    code: "mni-mtei",
+    english: "Manipuri (Meitei Mayek)",
+    native: "\u09AE\u09C8\u09A4\u09C8\u09B2\u09CB\u09A8\u09CD (\u09AE\u09C0\u09A4\u09C8 \u09AE\u09AF\u09BC\u09C7\u0995)",
+    direction: "ltr"
+  },
+  {
+    code: "mr",
+    english: "Marathi",
+    native: "\u092E\u0930\u093E\u0920\u0940",
+    direction: "ltr"
+  },
+  {
+    code: "ms",
+    english: "Malay",
+    native: "Melayu",
+    direction: "ltr"
+  },
+  {
+    code: "ms-arab",
+    english: "Malay (Arabic)",
+    native: "Melayu (Arab)",
+    direction: "ltr"
+  },
+  {
+    code: "mt",
+    english: "Maltese",
+    native: "Malti",
+    direction: "ltr"
+  },
+  {
+    code: "my",
+    english: "Burmese",
+    native: "\u1019\u103C\u1014\u103A\u1019\u102C",
+    direction: "ltr"
+  },
+  {
+    code: "nb",
+    english: "Norwegian Bokm\xE5l",
+    native: "norsk bokm\xE5l",
+    direction: "ltr"
+  },
+  {
+    code: "ne",
+    english: "Nepali",
+    native: "\u0928\u0947\u092A\u093E\u0932\u0940",
+    direction: "ltr"
+  },
+  {
+    code: "new",
+    english: "Newari",
+    native: "Newari",
+    direction: "ltr"
+  },
+  {
+    code: "nl",
+    english: "Dutch",
+    native: "Nederlands",
+    direction: "ltr"
+  },
+  {
+    code: "nl-be",
+    english: "Flemish",
+    native: "Vlaams",
+    direction: "ltr"
+  },
+  {
+    code: "no",
+    english: "Norwegian",
+    native: "norsk",
+    direction: "ltr"
+  },
+  {
+    code: "nr",
+    english: "South Ndebele",
+    native: "South Ndebele",
+    direction: "ltr"
+  },
+  {
+    code: "nso",
+    english: "Northern Sotho",
+    native: "Northern Sotho",
+    direction: "ltr"
+  },
+  {
+    code: "nus",
+    english: "Nuer",
+    native: "Thok Nath",
+    direction: "ltr"
+  },
+  {
+    code: "ny",
+    english: "Nyanja",
+    native: "Nyanja",
+    direction: "ltr"
+  },
+  {
+    code: "oc",
+    english: "Occitan",
+    native: "occitan",
+    direction: "ltr"
+  },
+  {
+    code: "om",
+    english: "Oromo",
+    native: "Oromoo",
+    direction: "ltr"
+  },
+  {
+    code: "or",
+    english: "Odia",
+    native: "\u0B13\u0B21\u0B3C\u0B3F\u0B06",
+    direction: "ltr"
+  },
+  {
+    code: "pa",
+    english: "Punjabi",
+    native: "\u0A2A\u0A70\u0A1C\u0A3E\u0A2C\u0A40",
+    direction: "ltr"
+  },
+  {
+    code: "pa-arab",
+    english: "Punjabi (Arabic)",
+    native: "\u067E\u0646\u062C\u0627\u0628\u06CC (\u0639\u0631\u0628\u06CC)",
+    direction: "ltr"
+  },
+  {
+    code: "pa-pk",
+    english: "Punjabi (Pakistan)",
+    native: "\u067E\u0646\u062C\u0627\u0628\u06CC (\u067E\u0627\u06A9\u0633\u062A\u0627\u0646)",
+    direction: "ltr"
+  },
+  {
+    code: "pag",
+    english: "Pangasinan",
+    native: "Pangasinan",
+    direction: "ltr"
+  },
+  {
+    code: "pam",
+    english: "Pampanga",
+    native: "Pampanga",
+    direction: "ltr"
+  },
+  {
+    code: "pap",
+    english: "Papiamento",
+    native: "Papiamento",
+    direction: "ltr"
+  },
+  {
+    code: "pl",
+    english: "Polish",
+    native: "polski",
+    direction: "ltr"
+  },
+  {
+    code: "ps",
+    english: "Pashto",
+    native: "\u067E\u069A\u062A\u0648",
+    direction: "rtl"
+  },
+  {
+    code: "pt",
+    english: "Portuguese",
+    native: "portugu\xEAs",
+    direction: "ltr"
+  },
+  {
+    code: "pt-br",
+    english: "Brazilian Portuguese",
+    native: "portugu\xEAs (Brasil)",
+    direction: "ltr"
+  },
+  {
+    code: "pt-pt",
+    english: "European Portuguese",
+    native: "portugu\xEAs europeu",
+    direction: "ltr"
+  },
+  {
+    code: "qu",
+    english: "Quechua",
+    native: "Runasimi",
+    direction: "ltr"
+  },
+  {
+    code: "rn",
+    english: "Rundi",
+    native: "Ikirundi",
+    direction: "ltr"
+  },
+  {
+    code: "ro",
+    english: "Romanian",
+    native: "rom\xE2n\u0103",
+    direction: "ltr"
+  },
+  {
+    code: "rom",
+    english: "Romany",
+    native: "Romany",
+    direction: "ltr"
+  },
+  {
+    code: "ru",
+    english: "Russian",
+    native: "\u0440\u0443\u0441\u0441\u043A\u0438\u0439",
+    direction: "ltr"
+  },
+  {
+    code: "rw",
+    english: "Kinyarwanda",
+    native: "Kinyarwanda",
+    direction: "ltr"
+  },
+  {
+    code: "sa",
+    english: "Sanskrit",
+    native: "\u0938\u0902\u0938\u094D\u0915\u0943\u0924 \u092D\u093E\u0937\u093E",
+    direction: "ltr"
+  },
+  {
+    code: "scn",
+    english: "Sicilian",
+    native: "Sicilian",
+    direction: "ltr"
+  },
+  {
+    code: "sd",
+    english: "Sindhi",
+    native: "\u0633\u0646\u068C\u064A",
+    direction: "rtl"
+  },
+  {
+    code: "sg",
+    english: "Sango",
+    native: "S\xE4ng\xF6",
+    direction: "ltr"
+  },
+  {
+    code: "shn",
+    english: "Shan",
+    native: "Shan",
+    direction: "ltr"
+  },
+  {
+    code: "si",
+    english: "Sinhala",
+    native: "\u0DC3\u0DD2\u0D82\u0DC4\u0DBD",
+    direction: "ltr"
+  },
+  {
+    code: "sk",
+    english: "Slovak",
+    native: "sloven\u010Dina",
+    direction: "ltr"
+  },
+  {
+    code: "sl",
+    english: "Slovenian",
+    native: "sloven\u0161\u010Dina",
+    direction: "ltr"
+  },
+  {
+    code: "sm",
+    english: "Samoan",
+    native: "Samoan",
+    direction: "ltr"
+  },
+  {
+    code: "sn",
+    english: "Shona",
+    native: "chiShona",
+    direction: "ltr"
+  },
+  {
+    code: "so",
+    english: "Somali",
+    native: "Soomaali",
+    direction: "ltr"
+  },
+  {
+    code: "sq",
+    english: "Albanian",
+    native: "shqip",
+    direction: "ltr"
+  },
+  {
+    code: "sr",
+    english: "Serbian",
+    native: "\u0441\u0440\u043F\u0441\u043A\u0438",
+    direction: "ltr"
+  },
+  {
+    code: "ss",
+    english: "Swati",
+    native: "Swati",
+    direction: "ltr"
+  },
+  {
+    code: "st",
+    english: "Southern Sotho",
+    native: "Southern Sotho",
+    direction: "ltr"
+  },
+  {
+    code: "su",
+    english: "Sundanese",
+    native: "Basa Sunda",
+    direction: "ltr"
+  },
+  {
+    code: "sv",
+    english: "Swedish",
+    native: "svenska",
+    direction: "ltr"
+  },
+  {
+    code: "sw",
+    english: "Swahili",
+    native: "Kiswahili",
+    direction: "ltr"
+  },
+  {
+    code: "szl",
+    english: "Silesian",
+    native: "\u015Bl\u014Dnski",
+    direction: "ltr"
+  },
+  {
+    code: "ta",
+    english: "Tamil",
+    native: "\u0BA4\u0BAE\u0BBF\u0BB4\u0BCD",
+    direction: "ltr"
+  },
+  {
+    code: "te",
+    english: "Telugu",
+    native: "\u0C24\u0C46\u0C32\u0C41\u0C17\u0C41",
+    direction: "ltr"
+  },
+  {
+    code: "tet",
+    english: "Tetum",
+    native: "Tetum",
+    direction: "ltr"
+  },
+  {
+    code: "tg",
+    english: "Tajik",
+    native: "\u0442\u043E\u04B7\u0438\u043A\u04E3",
+    direction: "ltr"
+  },
+  {
+    code: "th",
+    english: "Thai",
+    native: "\u0E44\u0E17\u0E22",
+    direction: "ltr"
+  },
+  {
+    code: "ti",
+    english: "Tigrinya",
+    native: "\u1275\u130D\u122D\u129B",
+    direction: "ltr"
+  },
+  {
+    code: "tk",
+    english: "Turkmen",
+    native: "t\xFCrkmen dili",
+    direction: "ltr"
+  },
+  {
+    code: "tl",
+    english: "Filipino",
+    native: "Filipino",
+    direction: "ltr"
+  },
+  {
+    code: "tn",
+    english: "Tswana",
+    native: "Tswana",
+    direction: "ltr"
+  },
+  {
+    code: "tr",
+    english: "Turkish",
+    native: "T\xFCrk\xE7e",
+    direction: "ltr"
+  },
+  {
+    code: "ts",
+    english: "Tsonga",
+    native: "Tsonga",
+    direction: "ltr"
+  },
+  {
+    code: "tt",
+    english: "Tatar",
+    native: "\u0442\u0430\u0442\u0430\u0440",
+    direction: "ltr"
+  },
+  {
+    code: "ug",
+    english: "Uyghur",
+    native: "\u0626\u06C7\u064A\u063A\u06C7\u0631\u0686\u06D5",
+    direction: "rtl"
+  },
+  {
+    code: "uk",
+    english: "Ukrainian",
+    native: "\u0443\u043A\u0440\u0430\u0457\u043D\u0441\u044C\u043A\u0430",
+    direction: "ltr"
+  },
+  {
+    code: "ur",
+    english: "Urdu",
+    native: "\u0627\u0631\u062F\u0648",
+    direction: "rtl"
+  },
+  {
+    code: "uz",
+    english: "Uzbek",
+    native: "o\u2018zbek",
+    direction: "ltr"
+  },
+  {
+    code: "vi",
+    english: "Vietnamese",
+    native: "Ti\u1EBFng Vi\u1EC7t",
+    direction: "ltr"
+  },
+  {
+    code: "xh",
+    english: "Xhosa",
+    native: "IsiXhosa",
+    direction: "ltr"
+  },
+  {
+    code: "yi",
+    english: "Yiddish",
+    native: "\u05D9\u05D9\u05B4\u05D3\u05D9\u05E9",
+    direction: "rtl"
+  },
+  {
+    code: "yo",
+    english: "Yoruba",
+    native: "\xC8d\xE8 Yor\xF9b\xE1",
+    direction: "ltr"
+  },
+  {
+    code: "yua",
+    english: "yua",
+    native: "yua",
+    direction: "ltr"
+  },
+  {
+    code: "yue",
+    english: "Cantonese",
+    native: "\u7CB5\u8A9E",
+    direction: "ltr"
+  },
+  {
+    code: "zh",
+    english: "Chinese",
+    native: "\u4E2D\u6587",
+    direction: "ltr"
+  },
+  {
+    code: "zh-cn",
+    english: "Chinese (China)",
+    native: "\u4E2D\u6587\uFF08\u4E2D\u56FD\uFF09",
+    direction: "ltr"
+  },
+  {
+    code: "zh-hans",
+    english: "Simplified Chinese",
+    native: "\u7B80\u4F53\u4E2D\u6587",
+    direction: "ltr"
+  },
+  {
+    code: "zh-hant",
+    english: "Traditional Chinese",
+    native: "\u7E41\u9AD4\u4E2D\u6587",
+    direction: "ltr"
+  },
+  {
+    code: "zh-hk",
+    english: "Chinese (Hong Kong SAR China)",
+    native: "\u4E2D\u6587\uFF08\u4E2D\u570B\u9999\u6E2F\u7279\u5225\u884C\u653F\u5340\uFF09",
+    direction: "ltr"
+  },
+  {
+    code: "zh-tw",
+    english: "Chinese (Taiwan)",
+    native: "\u4E2D\u6587\uFF08\u53F0\u7063\uFF09",
+    direction: "ltr"
+  },
+  {
+    code: "zu",
+    english: "Zulu",
+    native: "isiZulu",
+    direction: "ltr"
+  }
+];
+
+// src/shared/languages/catalog/index.ts
+var generatedLanguageCatalog = languages_default;
+function buildLanguageCatalog(raw) {
+  return Object.freeze(raw.map((r) => ({ ...r, code: normalizeLanguageCode(r.code) })));
+}
+function filterLanguageCatalog(catalog2, filter) {
+  const all = [...catalog2];
+  const q = filter?.trim().toLowerCase();
+  if (!q) return all.sort((a, b) => a.code.localeCompare(b.code));
+  return all.filter(
+    (r) => r.code.includes(q) || r.english.toLowerCase().includes(q) || r.native.toLowerCase().includes(q)
+  ).sort((a, b) => a.code.localeCompare(b.code));
+}
+function getLanguageByCodeFromCatalog(catalog2, code) {
+  const n = normalizeLanguageCode(code);
+  return catalog2.find((r) => r.code === n);
+}
+function suggestCatalogCodesForInvalidInputFromCatalog(catalog2, code, maxCodesInCatalogHint = 5) {
+  const n = normalizeLanguageCode(code);
+  const all = [...catalog2].sort((a, b) => a.code.localeCompare(b.code));
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (c) => {
+    if (!seen.has(c)) {
+      seen.add(c);
+      out.push(c);
+    }
+  };
+  for (const r of filterLanguageCatalog(catalog2, n)) {
+    push(r.code);
+    if (out.length >= maxCodesInCatalogHint) return out;
+  }
+  if (n.length >= 2) {
+    const prefix = n.slice(0, 2);
+    for (const r of all) {
+      if (r.code.startsWith(prefix)) push(r.code);
+      if (out.length >= maxCodesInCatalogHint) return out;
+    }
+  }
+  for (const r of all) {
+    push(r.code);
+    if (out.length >= maxCodesInCatalogHint) return out;
+  }
+  return out;
+}
+
+// src/shared/languages/validateTargetCode.ts
+var MAX_HINT = 5;
+function catalog() {
+  return buildLanguageCatalog(generatedLanguageCatalog);
+}
+function assertSupportedTargetLanguageCode(code) {
+  const cat = catalog();
+  if (getLanguageByCodeFromCatalog(cat, code)) return;
+  const hints = suggestCatalogCodesForInvalidInputFromCatalog(cat, code, MAX_HINT);
+  const hintStr = hints.length > 0 ? hints.join(", ") : "run i18nprune languages for supported codes";
+  throw new I18nPruneError(`Unsupported language code "${code}" \u2014 try: ${hintStr}`, "USAGE", {
+    issueCode: ISSUE_LANGUAGES_UNSUPPORTED_LANGUAGE_CODE
+  });
+}
+
+// src/locales/targets.ts
+var ALL_LOCALES_TOKEN = "all";
+function parseLocaleCodesList(raw) {
+  return raw.split(",").map((s) => s.trim()).filter(Boolean).map((c) => normalizeLanguageCode(c));
+}
+function isAllLocaleToken(raw) {
+  return raw.trim().toLowerCase() === ALL_LOCALES_TOKEN;
+}
+function pickTargetSelector(target) {
+  const t = target?.trim();
+  if (t) return t;
+  return void 0;
+}
+function parseSyncLangSelection(lang) {
+  const primary = lang?.trim();
+  if (primary) {
+    if (isAllLocaleToken(primary)) return { mode: "all" };
+    return { mode: "codes", codes: parseLocaleCodesList(primary) };
+  }
+  return { mode: "all" };
+}
+function resolveTargetLocaleSlugs(path, localeSlugs, sourceLocalePath) {
+  return excludeSourceLocaleSlugs(path, localeSlugs, sourceLocalePath);
+}
+function resolveLocaleTargetCodes(input) {
+  const { commandName, rawTarget, localeSlugs, sourceLocalePath, path } = input;
+  const targetSlugs = resolveTargetLocaleSlugs(path, localeSlugs, sourceLocalePath);
+  if (targetSlugs.length === 0) {
+    throw new I18nPruneError(`${commandName}: no target locale files found in localesDir`, "USAGE");
+  }
+  const selected = pickTargetSelector(rawTarget);
+  if (!selected) {
+    throw new I18nPruneError(`${commandName} requires --target <code[,code]|all>`, "USAGE");
+  }
+  if (isAllLocaleToken(selected)) {
+    return targetSlugs.map((x) => normalizeLanguageCode(x));
+  }
+  const parsed = parseLocaleCodesList(selected);
+  for (const code of parsed) {
+    assertNotSourceTargetLocale(commandName, code, sourceLocalePath, {
+      paths: { sourceLocale: sourceLocalePath },
+      path
+    });
+    if (!targetSlugs.some((x) => normalizeLanguageCode(x) === code)) {
+      throw new I18nPruneError(`${commandName}: locale file not found for target "${code}"`, "USAGE");
+    }
+  }
+  return parsed;
+}
+
+// src/locales/resumeTargets.ts
+function resolveResumeAllTargetCodes(ctx, commandName) {
+  const codes = targetLocaleCodesFromContext(ctx);
+  if (codes.length === 0) {
+    throw new I18nPruneError(`${commandName}: no target locale files found in localesDir`, "USAGE");
+  }
+  return codes.map((c) => normalizeLanguageCode(c));
+}
+function resolveResumeTargetCodesFromRaw(input) {
+  const { commandName, raw, ctx } = input;
+  const sourceLocalePath = ctx.paths.sourceLocale;
+  const assertCtx = {
+    paths: { sourceLocale: sourceLocalePath },
+    path: ctx.adapters.path
+  };
+  if (isAllLocaleToken(raw)) {
+    return resolveResumeAllTargetCodes(ctx, commandName);
+  }
+  if (raw.includes(",")) {
+    const codes = parseLocaleCodesList(raw);
+    for (const c of codes) {
+      assertNotSourceTargetLocale(commandName, c, sourceLocalePath, assertCtx);
+      assertSupportedTargetLanguageCode(c);
+    }
+    return codes;
+  }
+  const code = normalizeLanguageCode(raw);
+  assertNotSourceTargetLocale(commandName, code, sourceLocalePath, assertCtx);
+  assertSupportedTargetLanguageCode(code);
+  return [code];
+}
+
+// src/locales/generateTargets.ts
+function assertGenerateTargetCodes(input) {
+  const { commandName, codes, sourceLocalePath, path } = input;
+  const ctx = {
+    paths: { sourceLocale: sourceLocalePath },
+    path
+  };
+  for (const target of codes) {
+    assertNotSourceTargetLocale(commandName, target, sourceLocalePath, ctx);
+    assertSupportedTargetLanguageCode(target);
+  }
+}
+
+export { ALL_LOCALES_TOKEN, assertGenerateTargetCodes, assertNotSourceTargetLocale, buildLocaleListRows, buildSourceLocaleTruthLabel, excludeSourceLocaleSlugs, getDisplaySourceLocaleCode, getSourceLocaleSlug, isAllLocaleToken, isSourceLocaleSlug, listOtherLocaleCodes, parseLocaleCodesList, parseSyncLangSelection, pickTargetSelector, resolveLocaleTargetCodes, resolveResumeAllTargetCodes, resolveResumeTargetCodesFromRaw, resolveTargetLocaleSlugs };