ztechno_core 0.0.105 → 0.0.108

package/lib/core/translate_service.js

@@ -0,0 +1,913 @@
+'use strict';
+var __importDefault =
+  (this && this.__importDefault) ||
+  function (mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.ZTranslateService = void 0;
+const translate_types_1 = require('./types/translate_types');
+const dist_1 = require('../vendor/dom-parser/dist');
+const translate_1 = __importDefault(require('translate'));
+class ZTranslateService {
+  get sql() {
+    return this.opt.sqlService;
+  }
+  getLanguages() {
+    return (
+      this.opt.languages || [
+        { lang: 'en', text: 'English' },
+        { lang: 'nl', text: 'Nederlands' },
+      ]
+    );
+  }
+  getSourceLang() {
+    return this.opt.sourceLang || 'en';
+  }
+  getDefaultLang() {
+    return this.opt.defaultLang || 'en';
+  }
+  constructor(opt) {
+    this.opt = opt;
+    this.localCache = {};
+    this.surpressErrors = true;
+    this.maxRetries = 3;
+    this.retryDelay = 1000;
+    this.fallbackText = '?';
+    this.codes = {
+      // Quotes and apostrophes
+      [`'`]: `'`,
+      [`"`]: `"`,
+      [`“`]: `"`,
+      [`”`]: `"`,
+      [`‘`]: `'`,
+      [`’`]: `'`,
+      [`‚`]: `‚`,
+      [`„`]: `„`,
+      [`«`]: `«`,
+      [`»`]: `»`,
+      [`‹`]: `‹`,
+      [`›`]: `›`,
+      // Currency symbols
+      [`©`]: `©`,
+      [`®`]: `®`,
+      [`€`]: `€`,
+      [`£`]: `£`,
+      [`¥`]: `¥`,
+      [`¢`]: `¢`,
+      [`™`]: `™`,
+      [`$`]: `$`,
+      // Mathematical and special symbols
+      [`–`]: `–`,
+      [`—`]: `—`,
+      [`…`]: `…`,
+      [`•`]: `•`,
+      [`→`]: `→`,
+      [`←`]: `←`,
+      [`↑`]: `↑`,
+      [`↓`]: `↓`,
+      [`×`]: `×`,
+      [`÷`]: `÷`,
+      [`±`]: `±`,
+      [`≤`]: `≤`,
+      [`≥`]: `≥`,
+      [`≠`]: `≠`,
+      [`∞`]: `∞`,
+      [`°`]: `°`,
+      [`‰`]: `‰`,
+      [`†`]: `†`,
+      [`‡`]: `‡`,
+      [`§`]: `§`,
+      [`¶`]: `¶`,
+      // Accented characters
+      [`À`]: `À`,
+      [`Á`]: `Á`,
+      [`Â`]: `Â`,
+      [`Ã`]: `Ã`,
+      [`Ä`]: `Ä`,
+      [`Å`]: `Å`,
+      [`Æ`]: `Æ`,
+      [`Ç`]: `Ç`,
+      [`È`]: `È`,
+      [`É`]: `É`,
+      [`Ê`]: `Ê`,
+      [`Ë`]: `Ë`,
+      [`Ì`]: `Ì`,
+      [`Í`]: `Í`,
+      [`Î`]: `Î`,
+      [`Ï`]: `Ï`,
+      [`Ð`]: `Ð`,
+      [`Ñ`]: `Ñ`,
+      [`Ò`]: `Ò`,
+      [`Ó`]: `Ó`,
+      [`Ô`]: `Ô`,
+      [`Õ`]: `Õ`,
+      [`Ö`]: `Ö`,
+      [`Ø`]: `Ø`,
+      [`Ù`]: `Ù`,
+      [`Ú`]: `Ú`,
+      [`Û`]: `Û`,
+      [`Ü`]: `Ü`,
+      [`Ý`]: `Ý`,
+      [`Þ`]: `Þ`,
+      [`ß`]: `ß`,
+      [`à`]: `à`,
+      [`á`]: `á`,
+      [`â`]: `â`,
+      [`ã`]: `ã`,
+      [`ä`]: `ä`,
+      [`å`]: `å`,
+      [`æ`]: `æ`,
+      [`ç`]: `ç`,
+      [`è`]: `è`,
+      [`é`]: `é`,
+      [`ê`]: `ê`,
+      [`ë`]: `ë`,
+      [`ì`]: `ì`,
+      [`í`]: `í`,
+      [`î`]: `î`,
+      [`ï`]: `ï`,
+      [`ð`]: `ð`,
+      [`ñ`]: `ñ`,
+      [`ò`]: `ò`,
+      [`ó`]: `ó`,
+      [`ô`]: `ô`,
+      [`õ`]: `õ`,
+      [`ö`]: `ö`,
+      [`ø`]: `ø`,
+      [`ù`]: `ù`,
+      [`ú`]: `ú`,
+      [`û`]: `û`,
+      [`ü`]: `ü`,
+      [`ý`]: `ý`,
+      [`þ`]: `þ`,
+      [`ÿ`]: `ÿ`,
+      // Common spaces and breaks
+      [` `]: ` `,
+      [`­`]: `­`,
+      [`​`]: ``,
+      // Punctuation
+      [`¡`]: `¡`,
+      [`¿`]: `¿`,
+      [`·`]: `·`,
+      [`¸`]: `¸`,
+      // Fractions
+      [`¼`]: `¼`,
+      [`½`]: `½`,
+      [`¾`]: `¾`,
+      [`⅓`]: `⅓`,
+      [`⅔`]: `⅔`,
+      [`⅕`]: `⅕`,
+      [`⅖`]: `⅖`,
+      [`⅗`]: `⅗`,
+      [`⅘`]: `⅘`,
+      [`⅙`]: `⅙`,
+      [`⅚`]: `⅚`,
+      [`⅛`]: `⅛`,
+      [`⅜`]: `⅜`,
+      [`⅝`]: `⅝`,
+      [`⅞`]: `⅞`,
+      // Greek letters (common ones)
+      [`α`]: `α`,
+      [`β`]: `β`,
+      [`γ`]: `γ`,
+      [`δ`]: `δ`,
+      [`ε`]: `ε`,
+      [`ζ`]: `ζ`,
+      [`η`]: `η`,
+      [`θ`]: `θ`,
+      [`ι`]: `ι`,
+      [`κ`]: `κ`,
+      [`λ`]: `λ`,
+      [`μ`]: `μ`,
+      [`ν`]: `ν`,
+      [`ξ`]: `ξ`,
+      [`ο`]: `ο`,
+      [`π`]: `π`,
+      [`ρ`]: `ρ`,
+      [`σ`]: `σ`,
+      [`τ`]: `τ`,
+      [`υ`]: `υ`,
+      [`φ`]: `φ`,
+      [`χ`]: `χ`,
+      [`ψ`]: `ψ`,
+      [`ω`]: `ω`,
+      // Uppercase Greek letters
+      [`Α`]: `Α`,
+      [`Β`]: `Β`,
+      [`Γ`]: `Γ`,
+      [`Δ`]: `Δ`,
+      [`Ε`]: `Ε`,
+      [`Ζ`]: `Ζ`,
+      [`Η`]: `Η`,
+      [`Θ`]: `Θ`,
+      [`Ι`]: `Ι`,
+      [`Κ`]: `Κ`,
+      [`Λ`]: `Λ`,
+      [`Μ`]: `Μ`,
+      [`Ν`]: `Ν`,
+      [`Ξ`]: `Ξ`,
+      [`Ο`]: `Ο`,
+      [`Π`]: `Π`,
+      [`Ρ`]: `Ρ`,
+      [`Σ`]: `Σ`,
+      [`Τ`]: `Τ`,
+      [`Υ`]: `Υ`,
+      [`Φ`]: `Φ`,
+      [`Χ`]: `Χ`,
+      [`Ψ`]: `Ψ`,
+      [`Ω`]: `Ω`,
+      // Additional common symbols
+      [`₺`]: `₪`,
+      [`₽`]: `₽`,
+      [`₹`]: `₹`,
+      [`¤`]: `¤`,
+      [`¦`]: `¦`,
+      [`¨`]: `¨`,
+      [`ª`]: `ª`,
+      [`¬`]: `¬`,
+      [`¯`]: `¯`,
+      [`²`]: `²`,
+      [`³`]: `³`,
+      [`¹`]: `¹`,
+      [`º`]: `º`,
+      // Card suits and misc symbols
+      [`♠`]: `♠`,
+      [`♣`]: `♣`,
+      [`♥`]: `♥`,
+      [`♦`]: `♦`,
+      [`★`]: `★`,
+      [`☆`]: `☆`,
+      [`☎`]: `☎`,
+      [`☕`]: `☕`,
+      [`☺`]: `☺`,
+      [`☻`]: `☻`,
+      [`☼`]: `☼`,
+      [`♀`]: `♀`,
+      [`♂`]: `♂`,
+      [`❤`]: `❤`,
+      // Arabic characters (U+0600 to U+06FF range)
+      [`؀`]: `؀`,
+      [`؁`]: `؁`,
+      [`؂`]: `؂`,
+      [`؃`]: `؃`,
+      [`؄`]: `؄`,
+      [`؅`]: `؅`,
+      [`؆`]: `؆`,
+      [`؇`]: `؇`,
+      [`؈`]: `؈`,
+      [`؉`]: `؉`,
+      [`؊`]: `؊`,
+      [`؋`]: `؋`,
+      [`،`]: `،`,
+      [`؍`]: `؍`,
+      [`؎`]: `؎`,
+      [`؏`]: `؏`,
+      [`ؐ`]: `ؐ`,
+      [`ؑ`]: `ؑ`,
+      [`ؒ`]: `ؒ`,
+      [`ؓ`]: `ؓ`,
+      [`ؔ`]: `ؔ`,
+      [`ؕ`]: `ؕ`,
+      [`ؖ`]: `ؖ`,
+      [`ؗ`]: `ؗ`,
+      [`ؘ`]: `ؘ`,
+      [`ؙ`]: `ؙ`,
+      [`ؚ`]: `ؚ`,
+      [`؛`]: `؛`,
+      [`؜`]: `؜`,
+      [`؝`]: `؝`,
+      [`؞`]: `؞`,
+      [`؟`]: `؟`,
+      [`ؠ`]: `ؠ`,
+      [`ء`]: `ء`,
+      [`آ`]: `آ`,
+      [`أ`]: `أ`,
+      [`ؤ`]: `ؤ`,
+      [`إ`]: `إ`,
+      [`ئ`]: `ئ`,
+      [`ا`]: `ا`,
+      [`ب`]: `ب`,
+      [`ة`]: `ة`,
+      [`ت`]: `ت`,
+      [`ث`]: `ث`,
+      [`ج`]: `ج`,
+      [`ح`]: `ح`,
+      [`خ`]: `خ`,
+      [`د`]: `د`,
+      [`ذ`]: `ذ`,
+      [`ر`]: `ر`,
+      [`ز`]: `ز`,
+      [`س`]: `س`,
+      [`ش`]: `ش`,
+      [`ص`]: `ص`,
+      [`ض`]: `ض`,
+      [`ط`]: `ط`,
+      [`ظ`]: `ظ`,
+      [`ع`]: `ع`,
+      [`غ`]: `غ`,
+      [`ػ`]: `ػ`,
+      [`ؼ`]: `ؼ`,
+      [`ؽ`]: `ؽ`,
+      [`ؾ`]: `ؾ`,
+      [`ؿ`]: `ؿ`,
+      [`ـ`]: `ـ`,
+      [`ف`]: `ف`,
+      [`ق`]: `ق`,
+      [`ك`]: `ك`,
+      [`ل`]: `ل`,
+      [`م`]: `م`,
+      [`ن`]: `ن`,
+      [`ه`]: `ه`,
+      [`و`]: `و`,
+      [`ى`]: `ى`,
+      [`ي`]: `ي`,
+      // Arabic diacritics (most common ones)
+      [`ً`]: `ً`,
+      [`ٌ`]: `ٌ`,
+      [`ٍ`]: `ٍ`,
+      [`َ`]: `َ`,
+      [`ُ`]: `ُ`,
+      [`ِ`]: `ِ`,
+      [`ّ`]: `ّ`,
+      [`ْ`]: `ْ`,
+      [`ٓ`]: `ٓ`,
+      [`ٔ`]: `ٔ`,
+      [`ٕ`]: `ٕ`,
+      // Arabic-Indic digits
+      [`٠`]: `٠`,
+      [`١`]: `١`,
+      [`٢`]: `٢`,
+      [`٣`]: `٣`,
+      [`٤`]: `٤`,
+      [`٥`]: `٥`,
+      [`٦`]: `٦`,
+      [`٧`]: `٧`,
+      [`٨`]: `٨`,
+      [`٩`]: `٩`,
+      // Extended Arabic characters (commonly used)
+      [`٪`]: `٪`,
+      [`٫`]: `٫`,
+      [`٬`]: `٬`,
+      [`٭`]: `٭`,
+      [`ٮ`]: `ٮ`,
+      [`ٯ`]: `ٯ`,
+      [`ٰ`]: `ٰ`,
+      [`ٱ`]: `ٱ`,
+      [`ٲ`]: `ٲ`,
+      [`ٳ`]: `ٳ`,
+      [`ٴ`]: `ٴ`,
+      [`ٵ`]: `ٵ`,
+      [`ٶ`]: `ٶ`,
+      [`ٷ`]: `ٷ`,
+      [`ٸ`]: `ٸ`,
+      [`ٹ`]: `ٹ`,
+      [`ٺ`]: `ٺ`,
+      [`ٻ`]: `ٻ`,
+      [`ټ`]: `ټ`,
+      [`ٽ`]: `ٽ`,
+      [`پ`]: `پ`,
+      [`ٿ`]: `ٿ`,
+      [`ڀ`]: `ڀ`,
+      [`ځ`]: `ځ`,
+      [`ڂ`]: `ڂ`,
+      [`ڃ`]: `ڃ`,
+      [`ڄ`]: `ڄ`,
+      [`څ`]: `څ`,
+      [`چ`]: `چ`,
+      [`ڇ`]: `ڇ`,
+      [`ڈ`]: `ڈ`,
+      [`ډ`]: `ډ`,
+      [`ڊ`]: `ڊ`,
+      [`ڋ`]: `ڋ`,
+      [`ڌ`]: `ڌ`,
+      [`ڍ`]: `ڍ`,
+      [`ڎ`]: `ڎ`,
+      [`ڏ`]: `ڏ`,
+      [`ڐ`]: `ڐ`,
+      [`ڑ`]: `ڑ`,
+      [`ڒ`]: `ڒ`,
+      [`ړ`]: `ړ`,
+      [`ڔ`]: `ڔ`,
+      [`ڕ`]: `ڕ`,
+      [`ږ`]: `ږ`,
+      [`ڗ`]: `ڗ`,
+      [`ژ`]: `ژ`,
+      [`ڙ`]: `ڙ`,
+      [`ښ`]: `ښ`,
+      [`ڛ`]: `ڛ`,
+      [`ڜ`]: `ڜ`,
+      [`ڝ`]: `ڝ`,
+      [`ڞ`]: `ڞ`,
+      [`ڟ`]: `ڟ`,
+      [`ڠ`]: `ڠ`,
+      [`ڡ`]: `ڡ`,
+      [`ڢ`]: `ڢ`,
+      [`ڣ`]: `ڣ`,
+      [`ڤ`]: `ڤ`,
+      [`ڥ`]: `ڥ`,
+      [`ڦ`]: `ڦ`,
+      [`ڧ`]: `ڧ`,
+      [`ڨ`]: `ڨ`,
+      [`ک`]: `ک`,
+      [`ڪ`]: `ڪ`,
+      [`ګ`]: `ګ`,
+      [`ڬ`]: `ڬ`,
+      [`ڭ`]: `ڭ`,
+      [`ڮ`]: `ڮ`,
+      [`گ`]: `گ`,
+      [`ڰ`]: `ڰ`,
+      [`ڱ`]: `ڱ`,
+      [`ڲ`]: `ڲ`,
+      [`ڳ`]: `ڳ`,
+      [`ڴ`]: `ڴ`,
+      [`ڵ`]: `ڵ`,
+      [`ڶ`]: `ڶ`,
+      [`ڷ`]: `ڷ`,
+      [`ڸ`]: `ڸ`,
+      [`ڹ`]: `ڹ`,
+      [`ں`]: `ں`,
+      [`ڻ`]: `ڻ`,
+      [`ڼ`]: `ڼ`,
+      [`ڽ`]: `ڽ`,
+      [`ھ`]: `ھ`,
+      [`ڿ`]: `ڿ`,
+      [`ۀ`]: `ۀ`,
+      [`ہ`]: `ہ`,
+      [`ۂ`]: `ۂ`,
+      [`ۃ`]: `ۃ`,
+      [`ۄ`]: `ۄ`,
+      [`ۅ`]: `ۅ`,
+      [`ۆ`]: `ۆ`,
+      [`ۇ`]: `ۇ`,
+      [`ۈ`]: `ۈ`,
+      [`ۉ`]: `ۉ`,
+      [`ۊ`]: `ۊ`,
+      [`ۋ`]: `ۋ`,
+      [`ی`]: `ی`,
+      [`ۍ`]: `ۍ`,
+      [`ێ`]: `ێ`,
+      [`ۏ`]: `ۏ`,
+      [`ې`]: `ې`,
+      [`ۑ`]: `ۑ`,
+      [`ے`]: `ے`,
+      [`ۓ`]: `ۓ`, // Arabic Letter Yeh Barree with Hamza Above
+    };
+    if (!opt.googleApiKey) {
+      throw new translate_types_1.ValidationError('googleApiKey', opt.googleApiKey);
+    }
+    if (!opt.sqlService) {
+      throw new translate_types_1.ValidationError('sqlService', opt.sqlService);
+    }
+    translate_1.default.key = opt.googleApiKey;
+    this.surpressErrors = opt.surpressErrors ?? true;
+    this.maxRetries = opt.maxRetries ?? 3;
+    this.retryDelay = opt.retryDelay ?? 1000;
+    this.fallbackText = opt.fallbackText ?? '?';
+    this.getLanguages().map((lang) => (this.localCache[lang.lang] = {}));
+    setInterval(() => this.clearLocalCache(), 1000 * 60 * 60); // Every Hour
+  }
+  getLang(cookies) {
+    try {
+      const defaultLang = this.getDefaultLang();
+      const langKey = (cookies?.lang || defaultLang).toLowerCase();
+      const foundLang = this.getLanguages().find((l) => l.lang === langKey);
+      return foundLang === undefined ? defaultLang : foundLang.lang;
+    } catch (error) {
+      this.logError(new translate_types_1.ValidationError('cookies', cookies), 'getLang');
+      return this.getDefaultLang();
+    }
+  }
+  async sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  logError(error, context) {
+    if (this.opt.log) {
+      this.opt.log(error, { context, timestamp: new Date().toISOString() });
+    }
+  }
+  async retryOperation(operation, operationName, maxRetries = this.maxRetries) {
+    let lastError;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        return await operation();
+      } catch (error) {
+        lastError = error;
+        this.logError(error, `${operationName} - Attempt ${attempt}/${maxRetries}`);
+        if (attempt < maxRetries) {
+          await this.sleep(this.retryDelay * attempt); // Exponential backoff
+        }
+      }
+    }
+    throw lastError;
+  }
+  async translateText(langOrReq, text) {
+    try {
+      // Input validation
+      if (!text || typeof text !== 'string') {
+        throw new translate_types_1.ValidationError('text', text);
+      }
+      const lang = typeof langOrReq === 'string' ? langOrReq : this.getLang(langOrReq.cookies);
+      text = text.trim();
+      if (text.length === 0) {
+        return text;
+      }
+      if (text.length === 1) {
+        return text;
+      }
+      // Process HTML entities with better error handling
+      text = await this.processHtmlEntities(text);
+      // Check local cache
+      const localCached = this.checkLocalCache(text, lang);
+      if (localCached !== false) {
+        return localCached.value;
+      }
+      // Check remote cache
+      const remoteCached = await this.fetch(text, lang);
+      if (remoteCached !== false) {
+        return remoteCached.value;
+      }
+      // Perform translation with retry logic
+      let result;
+      try {
+        result = await this.retryOperation(async () => {
+          return await (0, translate_1.default)(text, {
+            from: this.getSourceLang(),
+            to: lang,
+          });
+        }, 'translateText');
+      } catch (err) {
+        const translationError = new translate_types_1.ApiTranslationError(err, text, lang);
+        this.logError(translationError, 'translateText');
+        if (!this.surpressErrors) {
+          throw translationError;
+        }
+        result = this.fallbackText;
+      }
+      // Save translation to cache
+      try {
+        await this.insert(text, lang, { value: result });
+      } catch (err) {
+        this.logError(new translate_types_1.DatabaseError(err, 'insert translation'), 'translateText');
+        // Don't throw here, translation still succeeded
+      }
+      return result;
+    } catch (error) {
+      if (error instanceof translate_types_1.TranslateError) {
+        throw error;
+      }
+      const wrappedError = new translate_types_1.TranslateError(
+        `Unexpected error in translateText: ${error.message}`,
+        'UNEXPECTED_ERROR',
+        { originalError: error },
+      );
+      this.logError(wrappedError, 'translateText');
+      if (!this.surpressErrors) {
+        throw wrappedError;
+      }
+      return this.fallbackText;
+    }
+  }
+  async processHtmlEntities(text) {
+    let replaceCount = 0;
+    const maxReplacements = 1000;
+    while (text.includes('&#')) {
+      const codeIndexStart = text.indexOf('&#');
+      const first = text.substring(codeIndexStart);
+      const semicolonIndex = first.indexOf(';');
+      if (semicolonIndex === -1) {
+        // No closing semicolon found, break to avoid infinite loop
+        break;
+      }
+      const codeLength = semicolonIndex + 1;
+      const code = first.substring(0, codeLength);
+      if (this.codes[code] === undefined) {
+        const entityError = new translate_types_1.HtmlEntityError(code, text);
+        this.logError(entityError, 'processHtmlEntities');
+        if (!this.surpressErrors) {
+          throw entityError;
+        }
+        // Skip this entity and continue
+        text = text.substring(0, codeIndexStart) + code + text.substring(codeIndexStart + codeLength);
+        break;
+      }
+      text = text.substring(0, codeIndexStart) + this.codes[code] + text.substring(codeIndexStart + codeLength);
+      if (replaceCount++ > maxReplacements) {
+        const loopError = new translate_types_1.TranslateError(
+          `HTML entity replacement exceeded maximum count (${maxReplacements})`,
+          'MAX_REPLACEMENTS_EXCEEDED',
+          { code, text, replaceCount },
+        );
+        this.logError(loopError, 'processHtmlEntities');
+        if (!this.surpressErrors) {
+          throw loopError;
+        }
+        break;
+      }
+    }
+    return text;
+  }
+  async translateHtml(html, cookies) {
+    try {
+      if (!html || typeof html !== 'string') {
+        throw new translate_types_1.ValidationError('html', html);
+      }
+      if (!cookies) {
+        throw new translate_types_1.ValidationError('cookies', cookies);
+      }
+      const lang = this.getLang(cookies);
+      const srcLang = this.getSourceLang();
+      let dom;
+      try {
+        dom = (0, dist_1.parseFromString)(html);
+      } catch (error) {
+        const parseError = new translate_types_1.TranslateError('Failed to parse HTML', 'HTML_PARSE_ERROR', {
+          error,
+          html,
+        });
+        this.logError(parseError, 'translateHtml');
+        if (!this.surpressErrors) {
+          throw parseError;
+        }
+        return html;
+      }
+      const htmlNodes = dom.getElementsByTagName('html');
+      const mainNodes = dom.getElementsByTagName('main');
+      const isView = htmlNodes.length === 0;
+      const domNode = isView ? mainNodes[0] : htmlNodes[0];
+      if (lang !== srcLang && domNode) {
+        const node = isView ? domNode : domNode.getElementsByTagName('body')[0];
+        if (node) {
+          const promises = [];
+          this.translateHtmlRec(lang, node, promises);
+          try {
+            await Promise.all(promises);
+          } catch (error) {
+            this.logError(
+              new translate_types_1.TranslateError('Failed to translate HTML nodes', 'HTML_TRANSLATION_ERROR', {
+                error,
+              }),
+              'translateHtml',
+            );
+            if (!this.surpressErrors) {
+              throw error;
+            }
+          }
+        }
+      }
+      const output = domNode ? domNode.outerHTML : html;
+      return output.startsWith(`<!DOCTYPE html>`) ? output : `<!DOCTYPE html>\r\n${output}`;
+    } catch (error) {
+      if (error instanceof translate_types_1.TranslateError) {
+        throw error;
+      }
+      const wrappedError = new translate_types_1.TranslateError(
+        `Unexpected error in translateHtml: ${error.message}`,
+        'UNEXPECTED_ERROR',
+        { originalError: error },
+      );
+      this.logError(wrappedError, 'translateHtml');
+      if (!this.surpressErrors) {
+        throw wrappedError;
+      }
+      return html;
+    }
+  }
+  translateHtmlRec(lang, node, promises, skipTranslate = false) {
+    try {
+      if (this.opt.verbose) this.opt.verbose(node.nodeName, node);
+      if (node.getAttribute && node.getAttribute('notranslate') != null) {
+        skipTranslate = true;
+      }
+      if (node.nodeName === '#comment') {
+        // Skip HTML comments
+        return;
+      }
+      if (node.nodeName === 'script') {
+        // Skip script tags
+        return;
+      }
+      if (node.nodeName === 'style') {
+        // Skip style tags
+        return;
+      }
+      if (node.nodeName === '#text') {
+        const nodeText = node;
+        const text = nodeText.text.replace(/[\r|\n|\r\n]+/g, ' ').replace(/\s\s+/g, ' ');
+        const value = text.trim();
+        const meta = {
+          prefix: genSpaces(text.length - text.trimStart().length),
+          suffix: genSpaces(text.length - text.trimEnd().length),
+        };
+        if (skipTranslate === true || text.length === 0 || !strContainsLetters(text)) {
+          node.text = meta.prefix + text + meta.suffix;
+          return;
+        }
+        promises.push(
+          this.translateText(lang, value)
+            .then((translatedText) => {
+              node.text = meta.prefix + translatedText + meta.suffix;
+            })
+            .catch((err) => {
+              node.text = text;
+              this.logError(err, 'translateHtmlRec');
+              if (!this.surpressErrors) {
+                throw err;
+              }
+            }),
+        );
+        return;
+      }
+      // Process child nodes safely
+      if (node.childNodes && Array.isArray(node.childNodes)) {
+        for (const child of node.childNodes) {
+          this.translateHtmlRec(lang, child, promises, skipTranslate);
+        }
+      }
+    } catch (error) {
+      this.logError(
+        new translate_types_1.TranslateError(`Error processing HTML node: ${error.message}`, 'HTML_NODE_ERROR', {
+          error,
+          nodeName: node?.nodeName,
+        }),
+        'translateHtmlRec',
+      );
+      if (!this.surpressErrors) {
+        throw error;
+      }
+    }
+  }
+  async update(key, lang, data) {
+    try {
+      if (!key || !lang || !data) {
+        throw new translate_types_1.ValidationError('update parameters', { key, lang, data });
+      }
+      const res = await this.retryOperation(async () => {
+        return await this.sql.query(
+          `
+          INSERT INTO translations
+            (\`key\`, \`lang\`, \`value\`)
+          VALUES
+            (:key, :lang, :value)
+          ON DUPLICATE KEY UPDATE value=:value
+        `,
+          { key, lang, value: data.value },
+        );
+      }, 'update translation');
+      if (res.affectedRows) {
+        this.insertLocalCache(key, lang, data);
+      }
+      return res;
+    } catch (error) {
+      const dbError = new translate_types_1.DatabaseError(error, 'update translation');
+      this.logError(dbError, 'update');
+      throw dbError;
+    }
+  }
+  checkLocalCache(key, lang) {
+    try {
+      if (!key || !lang || !this.localCache[lang]) {
+        return false;
+      }
+      const hasLocal = !this.localCache[lang].hasOwnProperty(key);
+      return hasLocal ? false : this.localCache[lang][key];
+    } catch (error) {
+      this.logError(
+        new translate_types_1.TranslateError('Local cache check failed', 'CACHE_ERROR', { error, key, lang }),
+        'checkLocalCache',
+      );
+      return false;
+    }
+  }
+  insertLocalCache(key, lang, data) {
+    try {
+      if (!key || !lang || !data) {
+        return;
+      }
+      if (!this.localCache[lang]) {
+        this.localCache[lang] = {};
+      }
+      this.localCache[lang][key] = data;
+    } catch (error) {
+      this.logError(
+        new translate_types_1.TranslateError('Local cache insertion failed', 'CACHE_ERROR', { error, key, lang }),
+        'insertLocalCache',
+      );
+    }
+  }
+  clearLocalCache() {
+    try {
+      Object.keys(this.localCache).map((k) => {
+        this.localCache[k] = {};
+      });
+    } catch (error) {
+      this.logError(
+        new translate_types_1.TranslateError('Failed to clear local cache', 'CACHE_ERROR', { error }),
+        'clearLocalCache',
+      );
+    }
+  }
+  async fetch(key, lang) {
+    try {
+      if (!key || !lang) {
+        return false;
+      }
+      const results = await this.retryOperation(async () => {
+        return await this.sql.query(
+          `SELECT \`value\` FROM translations WHERE \`lang\`=? AND \`key\`=CONVERT(? USING utf8mb4)`,
+          [lang, key],
+        );
+      }, 'fetch translation');
+      if (results.length > 0) {
+        const { value } = results[0];
+        const data = { value };
+        this.insertLocalCache(key, lang, data);
+        return data;
+      }
+      return false;
+    } catch (error) {
+      const dbError = new translate_types_1.DatabaseError(error, 'fetch translation');
+      this.logError(dbError, 'fetch');
+      return false; // Don't throw, let translation proceed
+    }
+  }
+  async insert(key, lang, data) {
+    try {
+      if (!key || !lang || !data) {
+        throw new translate_types_1.ValidationError('insert parameters', { key, lang, data });
+      }
+      await this.retryOperation(async () => {
+        return await this.sql.query(`INSERT IGNORE INTO translations (\`key\`, \`lang\`, \`value\`) VALUES (?, ?, ?)`, [
+          key,
+          lang,
+          data.value,
+        ]);
+      }, 'insert translation');
+    } catch (error) {
+      const dbError = new translate_types_1.DatabaseError(error, 'insert translation');
+      this.logError(dbError, 'insert');
+      throw dbError;
+    }
+  }
+  async fetchLang(lang) {
+    try {
+      if (!lang) {
+        throw new translate_types_1.ValidationError('lang', lang);
+      }
+      return await this.retryOperation(async () => {
+        return await this.sql.query(
+          `SELECT \`key\`, \`lang\`, \`value\`, \`verified\`, \`created_at\` FROM translations WHERE \`lang\`=?`,
+          [lang],
+        );
+      }, 'fetchLang');
+    } catch (error) {
+      const dbError = new translate_types_1.DatabaseError(error, 'fetch language translations');
+      this.logError(dbError, 'fetchLang');
+      throw dbError;
+    }
+  }
+  async fetchAllGrouped() {
+    try {
+      const output = {};
+      const allTranslations = await this.fetchAll();
+      allTranslations.forEach((translation) => {
+        const { key } = translation;
+        if (!output.hasOwnProperty(key)) {
+          output[key] = [];
+        }
+        output[key].push(translation);
+      });
+      return output;
+    } catch (error) {
+      const dbError = new translate_types_1.DatabaseError(error, 'fetch all grouped translations');
+      this.logError(dbError, 'fetchAllGrouped');
+      throw dbError;
+    }
+  }
+  async fetchAll() {
+    try {
+      return await this.retryOperation(async () => {
+        return await this.sql.query(
+          `SELECT \`key\`, \`lang\`, \`value\`, \`verified\`, \`created_at\` FROM translations`,
+        );
+      }, 'fetchAll');
+    } catch (error) {
+      const dbError = new translate_types_1.DatabaseError(error, 'fetch all translations');
+      this.logError(dbError, 'fetchAll');
+      throw dbError;
+    }
+  }
+}
+exports.ZTranslateService = ZTranslateService;
+function strContainsLetters(text) {
+  // Updated regex to include Arabic characters (U+0600-U+06FF) and other scripts
+  const regExp = /[a-zA-Z\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF\uFB50-\uFDFF\uFE70-\uFEFF]/g;
+  return regExp.test(text);
+}
+function genSpaces(length) {
+  let output = '';
+  for (let i = 0; i < length; i++) {
+    output += ' ';
+  }
+  return output;
+}