@djangocfg/llm 2.1.164

package/dist/translator/index.cjs

@@ -0,0 +1,794 @@
+'use strict';
+
+var crypto = require('crypto');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var crypto__default = /*#__PURE__*/_interopDefault(crypto);
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/translator/text-utils.ts
+function isTechnicalContent(text) {
+  const trimmed = text.trim();
+  if (!trimmed) return true;
+  if (/^(https?:\/\/|\/\/|www\.)/i.test(trimmed)) return true;
+  if (/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(trimmed)) return true;
+  if (/^\/[a-zA-Z]/.test(trimmed)) return true;
+  if (/\.(js|ts|tsx|jsx|json|css|scss|html|md|py|go|rs)$/i.test(trimmed)) return true;
+  if (/^[\d.,]+%?$/.test(trimmed)) return true;
+  if (/^[A-Z][A-Z0-9_]*$/.test(trimmed)) return true;
+  if (/^(\{[^}]+\}|\{\{[^}]+\}\}|%[sd]|\$\d+)$/.test(trimmed)) return true;
+  if (/^[!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?]+$/.test(trimmed)) return true;
+  return false;
+}
+function containsCJK(text) {
+  return /[\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af]/.test(text);
+}
+function containsCyrillic(text) {
+  return /[\u0400-\u04ff]/.test(text);
+}
+function containsArabic(text) {
+  return /[\u0600-\u06ff]/.test(text);
+}
+function detectScript(text) {
+  if (containsCJK(text)) return "cjk";
+  if (containsCyrillic(text)) return "cyrillic";
+  if (containsArabic(text)) return "arabic";
+  if (/[a-zA-Z]/.test(text)) return "latin";
+  return "unknown";
+}
+function extractPlaceholders(text) {
+  const patterns = [
+    /\{[^}]+\}/g,
+    // {name}
+    /\{\{[^}]+\}\}/g,
+    // {{name}}
+    /%[sd]/g,
+    // %s, %d
+    /\$\d+/g
+    // $1, $2
+  ];
+  const placeholders = [];
+  for (const pattern of patterns) {
+    const matches = text.match(pattern);
+    if (matches) {
+      placeholders.push(...matches);
+    }
+  }
+  return [...new Set(placeholders)];
+}
+function validatePlaceholders(original, translated) {
+  const originalPlaceholders = extractPlaceholders(original);
+  const translatedPlaceholders = extractPlaceholders(translated);
+  const missing = originalPlaceholders.filter(
+    (p) => !translatedPlaceholders.includes(p)
+  );
+  const extra = translatedPlaceholders.filter(
+    (p) => !originalPlaceholders.includes(p)
+  );
+  return {
+    valid: missing.length === 0 && extra.length === 0,
+    missing,
+    extra
+  };
+}
+function extractTranslatableValues(obj, path = "") {
+  const values = [];
+  if (typeof obj === "string") {
+    if (!isTechnicalContent(obj)) {
+      values.push({ path, value: obj });
+    }
+  } else if (Array.isArray(obj)) {
+    obj.forEach((item, index) => {
+      values.push(
+        ...extractTranslatableValues(item, path ? `${path}[${index}]` : `[${index}]`)
+      );
+    });
+  } else if (obj !== null && typeof obj === "object") {
+    for (const [key, value] of Object.entries(obj)) {
+      values.push(
+        ...extractTranslatableValues(value, path ? `${path}.${key}` : key)
+      );
+    }
+  }
+  return values;
+}
+
+// src/translator/validator.ts
+function validateJsonKeys(original, translated, path = "") {
+  const errors = [];
+  if (typeof original !== typeof translated) {
+    errors.push(`Type mismatch at ${path || "root"}: expected ${typeof original}, got ${typeof translated}`);
+    return { valid: false, errors };
+  }
+  if (original === null || translated === null) {
+    if (original !== translated) {
+      errors.push(`Null mismatch at ${path || "root"}`);
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  if (Array.isArray(original)) {
+    if (!Array.isArray(translated)) {
+      errors.push(`Expected array at ${path || "root"}`);
+      return { valid: false, errors };
+    }
+    if (original.length !== translated.length) {
+      errors.push(
+        `Array length mismatch at ${path || "root"}: expected ${original.length}, got ${translated.length}`
+      );
+    }
+    const minLen = Math.min(original.length, translated.length);
+    for (let i = 0; i < minLen; i++) {
+      const result = validateJsonKeys(
+        original[i],
+        translated[i],
+        `${path}[${i}]`
+      );
+      errors.push(...result.errors);
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  if (typeof original === "object") {
+    if (typeof translated !== "object" || Array.isArray(translated)) {
+      errors.push(`Expected object at ${path || "root"}`);
+      return { valid: false, errors };
+    }
+    const origKeys = Object.keys(original);
+    const transKeys = Object.keys(translated);
+    for (const key of origKeys) {
+      if (!transKeys.includes(key)) {
+        errors.push(`Missing key: ${path ? `${path}.${key}` : key}`);
+      }
+    }
+    for (const key of transKeys) {
+      if (!origKeys.includes(key)) {
+        errors.push(
+          `Unexpected key: ${path ? `${path}.${key}` : key} (key was translated?)`
+        );
+      }
+    }
+    for (const key of origKeys) {
+      if (transKeys.includes(key)) {
+        const result = validateJsonKeys(
+          original[key],
+          translated[key],
+          path ? `${path}.${key}` : key
+        );
+        errors.push(...result.errors);
+      }
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  return { valid: true, errors: [] };
+}
+function validatePlaceholders2(original, translated, path = "") {
+  const errors = [];
+  if (typeof original === "string" && typeof translated === "string") {
+    const origPlaceholders = extractPlaceholders(original);
+    const transPlaceholders = extractPlaceholders(translated);
+    for (const placeholder of origPlaceholders) {
+      if (!transPlaceholders.includes(placeholder)) {
+        errors.push(
+          `Missing placeholder "${placeholder}" at ${path || "root"}`
+        );
+      }
+    }
+    for (const placeholder of transPlaceholders) {
+      if (!origPlaceholders.includes(placeholder)) {
+        errors.push(
+          `Extra placeholder "${placeholder}" at ${path || "root"}`
+        );
+      }
+    }
+  } else if (Array.isArray(original) && Array.isArray(translated)) {
+    const minLen = Math.min(original.length, translated.length);
+    for (let i = 0; i < minLen; i++) {
+      const result = validatePlaceholders2(
+        original[i],
+        translated[i],
+        `${path}[${i}]`
+      );
+      errors.push(...result.errors);
+    }
+  } else if (typeof original === "object" && original !== null && typeof translated === "object" && translated !== null) {
+    for (const key of Object.keys(original)) {
+      if (key in translated) {
+        const result = validatePlaceholders2(
+          original[key],
+          translated[key],
+          path ? `${path}.${key}` : key
+        );
+        errors.push(...result.errors);
+      }
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+function validateTranslation(original, translated) {
+  const keyResult = validateJsonKeys(original, translated);
+  const placeholderResult = validatePlaceholders2(original, translated);
+  return {
+    valid: keyResult.valid && placeholderResult.valid,
+    errors: [...keyResult.errors, ...placeholderResult.errors]
+  };
+}
+
+// src/utils/json.ts
+function extractJson(text) {
+  let jsonStr = text.trim();
+  if (jsonStr.startsWith("```json")) {
+    jsonStr = jsonStr.slice(7);
+  } else if (jsonStr.startsWith("```")) {
+    jsonStr = jsonStr.slice(3);
+  }
+  if (jsonStr.endsWith("```")) {
+    jsonStr = jsonStr.slice(0, -3);
+  }
+  jsonStr = jsonStr.trim();
+  const jsonStart = jsonStr.search(/[\[{]/);
+  const jsonEndBracket = jsonStr.lastIndexOf("]");
+  const jsonEndBrace = jsonStr.lastIndexOf("}");
+  const jsonEnd = Math.max(jsonEndBracket, jsonEndBrace);
+  if (jsonStart !== -1 && jsonEnd !== -1) {
+    jsonStr = jsonStr.slice(jsonStart, jsonEnd + 1);
+  }
+  try {
+    return JSON.parse(jsonStr);
+  } catch (error) {
+    throw new Error(
+      `Failed to parse JSON from LLM response: ${error instanceof Error ? error.message : "Unknown error"}
+
+Response:
+${text}`
+    );
+  }
+}
+
+// src/translator/types.ts
+var LANGUAGE_NAMES = {
+  en: "English",
+  ru: "Russian",
+  ko: "Korean",
+  ja: "Japanese",
+  zh: "Chinese",
+  de: "German",
+  fr: "French",
+  es: "Spanish",
+  it: "Italian",
+  pt: "Portuguese",
+  "pt-BR": "Brazilian Portuguese",
+  ar: "Arabic",
+  nl: "Dutch",
+  tr: "Turkish",
+  pl: "Polish",
+  sv: "Swedish",
+  no: "Norwegian",
+  da: "Danish",
+  uk: "Ukrainian",
+  hi: "Hindi"
+};
+
+// src/translator/prompts.ts
+function getLanguageName(code) {
+  return LANGUAGE_NAMES[code] ?? code;
+}
+function buildJsonTranslationPrompt(json, sourceLanguage, targetLanguage) {
+  const sourceName = getLanguageName(sourceLanguage);
+  const targetName = getLanguageName(targetLanguage);
+  return `Translate all string VALUES in this JSON from ${sourceName} to ${targetName}.
+
+Rules:
+- Translate ALL string values to ${targetName}
+- Keep JSON keys unchanged (English)
+- Skip: URLs, emails, numbers, "SKIP"
+- Keep placeholders: {name}, {{var}}, %s
+
+${json}
+
+Return ONLY the JSON with all values translated to ${targetName}:`;
+}
+function buildTextTranslationPrompt(text, sourceLanguage, targetLanguage) {
+  const sourceName = getLanguageName(sourceLanguage);
+  const targetName = getLanguageName(targetLanguage);
+  return `Translate from ${sourceName} to ${targetName}.
+
+RULES:
+1. Translate ONLY the text provided
+2. Preserve formatting, numbers, URLs
+3. Keep placeholders like {name}, {{var}} unchanged
+4. Return ONLY the translation, no explanations
+
+Text: ${text}
+
+Translation:`;
+}
+function buildRetryPrompt(originalJson, wrongJson, errors, targetLanguage) {
+  const targetName = getLanguageName(targetLanguage);
+  return `Your previous translation had errors. Fix them.
+
+ERRORS FOUND:
+${errors.map((e) => `- ${e}`).join("\n")}
+
+ORIGINAL JSON:
+${originalJson}
+
+YOUR WRONG TRANSLATION:
+${wrongJson}
+
+FIX THE ERRORS. Remember:
+- JSON keys must stay in English
+- Only translate string values
+- Preserve all placeholders
+
+Return ONLY the corrected JSON translated to ${targetName}:`;
+}
+var TranslationCache = class {
+  constructor(maxMemorySize = 1e3, storage) {
+    this.maxMemorySize = maxMemorySize;
+    this.storage = storage;
+    __publicField(this, "memoryCache", /* @__PURE__ */ new Map());
+    __publicField(this, "cacheOrder", []);
+    __publicField(this, "hits", 0);
+    __publicField(this, "misses", 0);
+  }
+  /**
+   * Generate hash for text
+   */
+  getTextHash(text) {
+    return crypto__default.default.createHash("md5").update(text).digest("hex");
+  }
+  /**
+   * Get storage key for language pair
+   */
+  getStorageKey(sourceLang, targetLang) {
+    return `translator:${sourceLang}-${targetLang}`;
+  }
+  /**
+   * Load from persistent storage
+   */
+  loadFromStorage(sourceLang, targetLang) {
+    if (!this.storage) return {};
+    try {
+      const key = this.getStorageKey(sourceLang, targetLang);
+      const data = this.storage.getItem(key);
+      return data ? JSON.parse(data) : {};
+    } catch {
+      return {};
+    }
+  }
+  /**
+   * Save to persistent storage
+   */
+  saveToStorage(sourceLang, targetLang, cache) {
+    if (!this.storage) return;
+    try {
+      const key = this.getStorageKey(sourceLang, targetLang);
+      this.storage.setItem(key, JSON.stringify(cache));
+    } catch {
+    }
+  }
+  /**
+   * Evict oldest entries if memory is full
+   */
+  evictIfNeeded() {
+    while (this.memoryCache.size >= this.maxMemorySize && this.cacheOrder.length > 0) {
+      const oldestKey = this.cacheOrder.shift();
+      this.memoryCache.delete(oldestKey);
+    }
+  }
+  /**
+   * Get translation from cache
+   */
+  get(text, sourceLang, targetLang) {
+    const textHash = this.getTextHash(text);
+    const cacheKey = `${sourceLang}-${targetLang}:${textHash}`;
+    if (this.memoryCache.has(cacheKey)) {
+      this.hits++;
+      return this.memoryCache.get(cacheKey);
+    }
+    const fileCache = this.loadFromStorage(sourceLang, targetLang);
+    if (textHash in fileCache) {
+      const translation = fileCache[textHash];
+      this.evictIfNeeded();
+      this.memoryCache.set(cacheKey, translation);
+      this.cacheOrder.push(cacheKey);
+      this.hits++;
+      return translation;
+    }
+    this.misses++;
+    return void 0;
+  }
+  /**
+   * Store translation in cache
+   */
+  set(text, sourceLang, targetLang, translation) {
+    const textHash = this.getTextHash(text);
+    const cacheKey = `${sourceLang}-${targetLang}:${textHash}`;
+    this.evictIfNeeded();
+    this.memoryCache.set(cacheKey, translation);
+    if (!this.cacheOrder.includes(cacheKey)) {
+      this.cacheOrder.push(cacheKey);
+    }
+    const fileCache = this.loadFromStorage(sourceLang, targetLang);
+    fileCache[textHash] = translation;
+    this.saveToStorage(sourceLang, targetLang, fileCache);
+  }
+  /**
+   * Get multiple translations at once
+   */
+  getMany(texts, sourceLang, targetLang) {
+    const cached = /* @__PURE__ */ new Map();
+    const uncached = [];
+    for (const text of texts) {
+      const translation = this.get(text, sourceLang, targetLang);
+      if (translation !== void 0) {
+        cached.set(text, translation);
+      } else {
+        uncached.push(text);
+      }
+    }
+    return { cached, uncached };
+  }
+  /**
+   * Store multiple translations at once
+   */
+  setMany(translations, sourceLang, targetLang) {
+    for (const [text, translation] of translations) {
+      this.set(text, sourceLang, targetLang, translation);
+    }
+  }
+  /**
+   * Clear cache
+   */
+  clear(sourceLang, targetLang) {
+    if (sourceLang && targetLang) {
+      const prefix = `${sourceLang}-${targetLang}:`;
+      for (const key of [...this.memoryCache.keys()]) {
+        if (key.startsWith(prefix)) {
+          this.memoryCache.delete(key);
+          const idx = this.cacheOrder.indexOf(key);
+          if (idx !== -1) this.cacheOrder.splice(idx, 1);
+        }
+      }
+      if (this.storage) {
+        this.storage.removeItem(this.getStorageKey(sourceLang, targetLang));
+      }
+    } else {
+      this.memoryCache.clear();
+      this.cacheOrder = [];
+      this.hits = 0;
+      this.misses = 0;
+    }
+  }
+  /**
+   * Get cache statistics
+   */
+  getStats() {
+    const languagePairs = [];
+    const pairCounts = /* @__PURE__ */ new Map();
+    for (const key of this.memoryCache.keys()) {
+      const pair = key.split(":")[0];
+      pairCounts.set(pair, (pairCounts.get(pair) || 0) + 1);
+    }
+    for (const [pair, count] of pairCounts) {
+      languagePairs.push({ pair, translations: count });
+    }
+    return {
+      memorySize: this.memoryCache.size,
+      hits: this.hits,
+      misses: this.misses,
+      languagePairs
+    };
+  }
+};
+function createCache(maxMemorySize, storage) {
+  return new TranslationCache(maxMemorySize, storage);
+}
+
+// src/translator/json-translator.ts
+var DEFAULT_TRANSLATION_MODEL = "openai/gpt-4o-mini";
+var JsonTranslator = class {
+  constructor(client, cache, defaultModel) {
+    this.client = client;
+    __publicField(this, "cache");
+    __publicField(this, "defaultModel");
+    this.cache = cache ?? createCache();
+    this.defaultModel = defaultModel ?? DEFAULT_TRANSLATION_MODEL;
+  }
+  /**
+   * Detect language from text
+   */
+  detectLanguage(text) {
+    const script = detectScript(text);
+    switch (script) {
+      case "cjk":
+        return "zh";
+      case "cyrillic":
+        return "ru";
+      case "arabic":
+        return "ar";
+      default:
+        return "en";
+    }
+  }
+  /**
+   * Check if text needs translation
+   */
+  needsTranslation(text, sourceLang, targetLang) {
+    if (!text || !text.trim()) return false;
+    if (isTechnicalContent(text)) return false;
+    if (sourceLang === targetLang) return false;
+    return true;
+  }
+  /**
+   * Translate single text
+   */
+  async translateText(text, targetLanguage, options) {
+    if (!text || !text.trim()) return text;
+    const sourceLang = options?.sourceLanguage ?? "auto";
+    const actualSource = sourceLang === "auto" ? this.detectLanguage(text) : sourceLang;
+    if (!this.needsTranslation(text, actualSource, targetLanguage)) {
+      return text;
+    }
+    const cached = this.cache.get(text, actualSource, targetLanguage);
+    if (cached) return cached;
+    const response = await this.client.chat(
+      `Translate this text to ${targetLanguage}. Return ONLY the translation:
+
+${text}`,
+      {
+        ...options,
+        model: options?.model ?? this.defaultModel,
+        temperature: 0
+      }
+    );
+    const translated = response.content.trim();
+    this.cache.set(text, actualSource, targetLanguage, translated);
+    return translated;
+  }
+  /**
+   * Translate JSON object with smart text-level caching
+   *
+   * @example
+   * ```ts
+   * const translator = new JsonTranslator(llm)
+   * const result = await translator.translate(
+   *   { title: 'Hello', items: ['World', 'Earth'] },
+   *   'ru'
+   * )
+   * // { data: { title: 'Привет', items: ['Мир', 'Земля'] }, valid: true, ... }
+   * ```
+   */
+  async translate(data, targetLanguage, options) {
+    const sourceLang = options?.sourceLanguage ?? "auto";
+    const translatableTexts = this.extractTranslatableTexts(data, sourceLang, targetLanguage);
+    if (translatableTexts.size === 0) {
+      return {
+        data,
+        valid: true,
+        errors: [],
+        retries: 0,
+        sourceLanguage: sourceLang,
+        targetLanguage
+      };
+    }
+    let actualSource = sourceLang;
+    if (sourceLang === "auto") {
+      const firstText = [...translatableTexts][0];
+      actualSource = this.detectLanguage(firstText);
+    }
+    const { cached, uncached } = this.cache.getMany(
+      [...translatableTexts],
+      actualSource,
+      targetLanguage
+    );
+    if (uncached.length === 0) {
+      return {
+        data: this.applyTranslations(data, cached),
+        valid: true,
+        errors: [],
+        retries: 0,
+        sourceLanguage: actualSource,
+        targetLanguage
+      };
+    }
+    const partialJson = this.createPartialJson(data, new Set(uncached));
+    const jsonStr = JSON.stringify(partialJson, null, 2);
+    try {
+      const prompt = buildJsonTranslationPrompt(jsonStr, actualSource, targetLanguage);
+      const response = await this.client.chat(prompt, {
+        ...options,
+        model: options?.model ?? this.defaultModel,
+        temperature: 0
+      });
+      const translatedPartial = extractJson(response.content);
+      const newTranslations = this.extractTranslationsByComparison(
+        partialJson,
+        translatedPartial,
+        uncached
+      );
+      this.cache.setMany(newTranslations, actualSource, targetLanguage);
+      const allTranslations = new Map([...cached, ...newTranslations]);
+      return {
+        data: this.applyTranslations(data, allTranslations),
+        valid: true,
+        errors: [],
+        retries: 0,
+        sourceLanguage: actualSource,
+        targetLanguage
+      };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      console.error("Translation failed:", errorMsg);
+      return {
+        data: cached.size > 0 ? this.applyTranslations(data, cached) : data,
+        valid: false,
+        errors: [errorMsg],
+        retries: 0,
+        sourceLanguage: actualSource,
+        targetLanguage
+      };
+    }
+  }
+  /**
+   * Translate to multiple languages in parallel
+   */
+  async translateToMany(data, targetLanguages, options) {
+    const results = /* @__PURE__ */ new Map();
+    const promises = targetLanguages.map(async (lang) => {
+      const result = await this.translate(data, lang, options);
+      return { lang, result };
+    });
+    const settled = await Promise.all(promises);
+    for (const { lang, result } of settled) {
+      results.set(lang, result);
+    }
+    return results;
+  }
+  /**
+   * Extract all translatable texts from object
+   */
+  extractTranslatableTexts(obj, sourceLang, targetLang) {
+    const texts = /* @__PURE__ */ new Set();
+    const extract = (item) => {
+      if (typeof item === "string") {
+        if (this.needsTranslation(item, sourceLang, targetLang)) {
+          texts.add(item);
+        }
+      } else if (Array.isArray(item)) {
+        for (const i of item) extract(i);
+      } else if (item !== null && typeof item === "object") {
+        for (const v of Object.values(item)) extract(v);
+      }
+    };
+    extract(obj);
+    return texts;
+  }
+  /**
+   * Apply translations to object
+   */
+  applyTranslations(obj, translations) {
+    const apply = (item) => {
+      if (typeof item === "string") {
+        return translations.get(item) ?? item;
+      } else if (Array.isArray(item)) {
+        return item.map(apply);
+      } else if (item !== null && typeof item === "object") {
+        const result = {};
+        for (const [k, v] of Object.entries(item)) {
+          result[k] = apply(v);
+        }
+        return result;
+      }
+      return item;
+    };
+    return apply(obj);
+  }
+  /**
+   * Create partial JSON with only texts that need translation
+   */
+  createPartialJson(data, textsToInclude) {
+    const filter = (obj) => {
+      if (typeof obj === "string") {
+        return textsToInclude.has(obj) ? obj : "SKIP";
+      } else if (Array.isArray(obj)) {
+        return obj.map(filter).filter((i) => this.hasTranslatable(i, textsToInclude));
+      } else if (obj !== null && typeof obj === "object") {
+        const result = {};
+        for (const [k, v] of Object.entries(obj)) {
+          const filtered = filter(v);
+          if (this.hasTranslatable(filtered, textsToInclude)) {
+            result[k] = filtered;
+          }
+        }
+        return result;
+      }
+      return obj;
+    };
+    return filter(data);
+  }
+  /**
+   * Check if object contains translatable text
+   */
+  hasTranslatable(obj, textsSet) {
+    if (typeof obj === "string") return textsSet.has(obj);
+    if (Array.isArray(obj)) return obj.some((i) => this.hasTranslatable(i, textsSet));
+    if (obj !== null && typeof obj === "object") {
+      return Object.values(obj).some((v) => this.hasTranslatable(v, textsSet));
+    }
+    return false;
+  }
+  /**
+   * Extract translations by comparing original and translated JSON
+   */
+  extractTranslationsByComparison(original, translated, uncachedTexts) {
+    const translations = /* @__PURE__ */ new Map();
+    const uncachedSet = new Set(uncachedTexts);
+    const compare = (orig, trans) => {
+      if (typeof orig === "string" && typeof trans === "string") {
+        if (uncachedSet.has(orig) && trans !== "SKIP" && trans.trim()) {
+          translations.set(orig, trans);
+        }
+      } else if (Array.isArray(orig) && Array.isArray(trans)) {
+        for (let i = 0; i < Math.min(orig.length, trans.length); i++) {
+          compare(orig[i], trans[i]);
+        }
+      } else if (orig !== null && typeof orig === "object" && trans !== null && typeof trans === "object") {
+        for (const key of Object.keys(orig)) {
+          if (key in trans) {
+            compare(
+              orig[key],
+              trans[key]
+            );
+          }
+        }
+      }
+    };
+    compare(original, translated);
+    return translations;
+  }
+  /**
+   * Get translation statistics
+   */
+  getStats() {
+    return this.cache.getStats();
+  }
+  /**
+   * Clear translation cache
+   */
+  clearCache(sourceLang, targetLang) {
+    this.cache.clear(sourceLang, targetLang);
+  }
+};
+function createTranslator(client, configOrCache) {
+  if (configOrCache instanceof TranslationCache) {
+    return new JsonTranslator(client, configOrCache);
+  }
+  return new JsonTranslator(client, configOrCache?.cache, configOrCache?.model);
+}
+
+exports.JsonTranslator = JsonTranslator;
+exports.LANGUAGE_NAMES = LANGUAGE_NAMES;
+exports.TranslationCache = TranslationCache;
+exports.buildJsonTranslationPrompt = buildJsonTranslationPrompt;
+exports.buildRetryPrompt = buildRetryPrompt;
+exports.buildTextTranslationPrompt = buildTextTranslationPrompt;
+exports.containsArabic = containsArabic;
+exports.containsCJK = containsCJK;
+exports.containsCyrillic = containsCyrillic;
+exports.createCache = createCache;
+exports.createTranslator = createTranslator;
+exports.detectScript = detectScript;
+exports.extractPlaceholders = extractPlaceholders;
+exports.extractTranslatableValues = extractTranslatableValues;
+exports.getLanguageName = getLanguageName;
+exports.isTechnicalContent = isTechnicalContent;
+exports.validateJsonKeys = validateJsonKeys;
+exports.validatePlaceholders = validatePlaceholders2;
+exports.validateTextPlaceholders = validatePlaceholders;
+exports.validateTranslation = validateTranslation;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map