@yxw007/translate 0.4.1 → 0.5.0

package/dist/browser/index.cjs

@@ -1,4 +1,4 @@
-// translate v0.4.1 Copyright (c) 2025 Potter<aa4790139@gmail.com> and contributors
+// translate v0.5.0 Copyright (c) 2026 Potter<aa4790139@gmail.com> and contributors
 'use strict';
 
 Object.defineProperty(exports, '__esModule', { value: true });
@@ -14,7 +14,8 @@ class TranslationError extends Error {
     constructor(region, message) {
         super(message);
         this.region = region;
-        Error.captureStackTrace(this, this.constructor);
+        this.name = "TranslationError";
+        Error.captureStackTrace?.(this, this.constructor);
     }
 }
 class CheckLanguageError extends Error {
@@ -22,7 +23,8 @@ class CheckLanguageError extends Error {
     constructor(region, message) {
         super(message);
         this.region = region;
-        Error.captureStackTrace(this, this.constructor);
+        this.name = "CheckLanguageError";
+        Error.captureStackTrace?.(this, this.constructor);
     }
 }
 const OPEN_AI_MODELS = [
@@ -210,12 +212,299 @@ function isOverMaxCharacterNum(text, max_character_num) {
     return total > max_character_num;
 }
 
+var googleTargetLanguages = {
+    Abkhazian: "ab",
+    Acehnese: "ace",
+    "Acholi language": "ach",
+    Afar: "aa",
+    Afrikaans: "af",
+    Albanian: "sq",
+    Alur: "alz",
+    Amharic: "am",
+    Arabic: "ar",
+    Armenian: "hy",
+    Assamese: "as",
+    Avar: "av",
+    Awadhi: "awa",
+    Aymara: "ay",
+    Azerbaijani: "az",
+    Badawi: "bew",
+    Balinese: "ban",
+    Balochi: "bal",
+    Bambara: "bm",
+    Bangasinan: "pag",
+    Bashkir: "ba",
+    Basque: "eu",
+    Batakkalo: "btx",
+    "Bataksi Marungon": "bts",
+    Bataktoba: "bbc",
+    Baure: "bci",
+    Belarusian: "be",
+    Bengali: "bn",
+    Bhojpuri: "bho",
+    Bikol: "bik",
+    Bosnian: "bs",
+    Breton: "br",
+    Bulgarian: "bg",
+    Burmese: "my",
+    "Buryat language": "bua",
+    Cantonese: "yue",
+    Casey: "kha",
+    Catalan: "ca",
+    Cebuano: "ceb",
+    "Chamorro language": "ch",
+    Chechen: "ce",
+    Chevi: "ak",
+    Chicheva: "ny",
+    Chiga: "cgg",
+    Chinese: "zh-CN",
+    "Chinese (Traditional)": "zh-TW",
+    Chuk: "chk",
+    Chuvash: "cv",
+    Conga: "ts",
+    Corsican: "co",
+    "Crimean Tatar": "crh",
+    Croatian: "hr",
+    Czech: "cs",
+    Danish: "da",
+    Dari: "fa-AF",
+    Dhivehi: "dv",
+    Dinka: "din",
+    Dogra: "doi",
+    Dutch: "nl",
+    Dyula: "dyu",
+    Dzongka: "dz",
+    Elocano: "ilo",
+    English: "en",
+    Esperanto: "eo",
+    Estonian: "et",
+    Ewe: "ee",
+    "FYRO Macedonian": "mk",
+    Faroese: "fo",
+    "Feng language": "fon",
+    Fijian: "fj",
+    Filipino: "tl",
+    Finnish: "fi",
+    French: "fr",
+    Frisian: "fy",
+    Friulian: "fur",
+    Fulani: "ff",
+    Ga: "gaa",
+    Galician: "gl",
+    Georgian: "ka",
+    German: "de",
+    Gongen: "gom",
+    Gorkbojok: "trp",
+    "Grace and Taoism": "ndc-ZW",
+    Greek: "el",
+    Greenlandic: "kl",
+    Guarani: "gn",
+    Gujarati: "gu",
+    "Haitian Creole": "ht",
+    Hakachin: "cnh",
+    Hausa: "ha",
+    Hawaiian: "haw",
+    Hebrew: "iw",
+    Heligaignon: "hil",
+    Hindi: "hi",
+    Hmong: "hmn",
+    Hungarian: "hu",
+    Hunsrück: "hrx",
+    Iban: "iba",
+    Icelandic: "is",
+    Igbo: "ig",
+    Indonesian: "id",
+    Irish: "ga",
+    Italian: "it",
+    "Jamaica vernacular": "jam",
+    Japanese: "ja",
+    Javanese: "jw",
+    "Jingpo language": "kac",
+    Kannada: "kn",
+    Kanuri: "kr",
+    Kazakh: "kk",
+    Kekchi: "kek",
+    Khmer: "km",
+    Kikwanda: "rw",
+    Kithuba: "ktu",
+    "Komi language": "kv",
+    Kongo: "kg",
+    Korean: "ko",
+    "Kurdish (Kurmanji)": "ku",
+    "Kurdish (Solani)": "ckb",
+    Kyrgyz: "ky",
+    Lao: "lo",
+    Latin: "la",
+    Latvian: "lv",
+    Ligurian: "lij",
+    Limburg: "li",
+    Lingala: "ln",
+    Lithuanian: "lt",
+    Lombard: "lmo",
+    Luganda: "lg",
+    Luo: "luo",
+    Luxembourg: "lb",
+    Madura: "mad",
+    Maithili: "mai",
+    Makassar: "mak",
+    Malagasian: "mg",
+    Malay: "ms",
+    "Malay, Jawi": "ms-Arab",
+    Malayalam: "ml",
+    Maltese: "mt",
+    "Malwadi language": "mwr",
+    Mamu: "mam",
+    Manx: "gv",
+    Marathi: "mr",
+    Marshallese: "mh",
+    "Mauritius Scrio whispers": "mfe",
+    "Meitei (Manipur)": "mni-Mtei",
+    Minan: "min",
+    Mizo: "lus",
+    Mongolian: "mn",
+    Māori: "mi",
+    "Nahuatl (Eastern Vastka)": "nhe",
+    "Ndebele (Southern)": "nr",
+    Ndombe: "dov",
+    "Nepal Language (Newar)": "new",
+    Nepali: "ne",
+    "Nko alphabet (West African written script)": "bm-Nkoo",
+    "Northern Sotho": "nso",
+    Norwegian: "no",
+    Nuer: "nus",
+    Occitan: "oc",
+    Oriya: "or",
+    "Oromo language": "om",
+    Ossetian: "os",
+    Pampangja: "pam",
+    Papiamento: "pap",
+    Pashto: "ps",
+    Pemba: "bem",
+    Persian: "fa",
+    Polish: "pl",
+    "Portugal (Brazil)": "pt",
+    "Portugal (Portugal)": "pt-PT",
+    "Punjabi (Gurumuchi)": "pa",
+    "Punjabi (Shamuki)": "pa-Arab",
+    Quechua: "qu",
+    Ratgale: "ltg",
+    Romani: "rom",
+    Romanian: "ro",
+    Rondi: "rn",
+    Russian: "ru",
+    Sabatec: "zap",
+    Sakha: "sah",
+    Samoan: "sm",
+    Sango: "sg",
+    Sanskrit: "sa",
+    Santali: "sat-Latn",
+    "Schuna language": "sn",
+    "Scottish Gaelic": "gd",
+    Serbian: "sr",
+    "Seychellois Creole": "crs",
+    Shan: "shn",
+    Sicilian: "scn",
+    "Sierra Leonean Creole": "kri",
+    Silesian: "szl",
+    Sindhi: "sd",
+    Sinhalese: "si",
+    Slovak: "sk",
+    Slovenian: "sl",
+    Somali: "so",
+    "South Sotho": "st",
+    Spanish: "es",
+    "Steppe Mali": "chm",
+    Sundanese: "su",
+    "Susu language": "sus",
+    Swahili: "sw",
+    Swat: "ss",
+    Swedish: "sv",
+    "Sámi (North)": "se",
+    Tahiti: "ty",
+    Tajik: "tg",
+    Tamaset: "ber-Latn",
+    "Tamazight (Tifinaven)": "ber",
+    Tamil: "ta",
+    Tatar: "tt",
+    Telugu: "te",
+    Tetum: "tet",
+    Thai: "th",
+    Tibetan: "bo",
+    "Tiff language": "tiv",
+    Tigrinya: "ti",
+    "Tok Pisin": "tpi",
+    Tongan: "to",
+    Tswana: "tn",
+    Tulu: "tcy",
+    "Tumbuka language": "tum",
+    Turkish: "tr",
+    Turkmen: "tk",
+    Tuvan: "tyv",
+    Udmurtic: "udm",
+    Uighur: "ug",
+    Ukrainian: "uk",
+    Urdu: "ur",
+    Uzbek: "uz",
+    Venda: "ve",
+    Venetian: "vec",
+    Vietnamese: "vi",
+    "Wari language": "war",
+    Welsh: "cy",
+    "Wolof language": "wo",
+    Xhosa: "xh",
+    Yiddish: "yi",
+    Yoruba: "yo",
+    "Yucatan Maya": "yua",
+    Zulu: "zu",
+};
+
+const googleLanguages = {
+    from: {
+        Auto: "auto",
+        ...googleTargetLanguages,
+    },
+    to: googleTargetLanguages,
+};
+
+function normalizeEngineLanguage(language, languages, allowAuto = false) {
+    if (!language) {
+        return allowAuto ? "auto" : "";
+    }
+    if (allowAuto && language === "auto") {
+        return "auto";
+    }
+    const entries = Object.entries(languages);
+    const matchedByKey = entries.find(([name]) => name.toLowerCase() === language.toLowerCase());
+    if (matchedByKey) {
+        return matchedByKey[1];
+    }
+    const matchedByValue = entries.find(([, value]) => value.toLowerCase() === language.toLowerCase());
+    if (matchedByValue) {
+        return matchedByValue[1];
+    }
+    return "";
+}
+
 function google(options) {
     const base = "https://translate.googleapis.com/translate_a/single";
+    const fromLanguages = googleLanguages.from;
+    const toLanguages = googleLanguages.to;
     return {
         name: "google",
-        async translate(text, opts) {
-            const { from = "auto", to } = opts;
+        getFromLanguages() {
+            return fromLanguages;
+        },
+        getToLanguages() {
+            return toLanguages;
+        },
+        normalFromLanguage(language) {
+            return normalizeEngineLanguage(language, fromLanguages, true);
+        },
+        normalToLanguage(language) {
+            return normalizeEngineLanguage(language, toLanguages);
+        },
+        async translate(text, opts) {
+            const { from = "auto", to } = opts;
             if (!Array.isArray(text)) {
                 text = [text];
             }
@@ -258,11 +547,157 @@ function google(options) {
     };
 }
 
+var azureTargetLanguages = {
+    Afrikaans: "af",
+    Albanian: "sq",
+    Amharic: "am",
+    Arabic: "ar",
+    Armenian: "hy",
+    Assamese: "as",
+    Azerbaijani: "az",
+    Bashkir: "ba",
+    Basque: "eu",
+    Bengali: "bn",
+    Bhojpuri: "bho",
+    Bosnian: "bs",
+    Bulgarian: "bg",
+    Burmese: "my",
+    "Cantonese (Traditional)": "yue",
+    Catalan: "ca",
+    Chhattisgarhi: "hne",
+    Chinese: "zh-Hans",
+    "Chinese (Literary)": "lzh",
+    "Chinese (Traditional)": "zh-Hant",
+    Croatian: "hr",
+    Czech: "cs",
+    Danish: "da",
+    Dari: "prs",
+    Dhivehi: "dv",
+    Dogri: "doi",
+    Double: "lug",
+    Dutch: "nl",
+    English: "en",
+    Estonian: "et",
+    "FYRO Macedonian": "mk",
+    Faroese: "fo",
+    Fijian: "fj",
+    Filipino: "fil",
+    Finnish: "fi",
+    French: "fr",
+    "French (Canada)": "fr-CA",
+    Galician: "gl",
+    Georgian: "ka",
+    German: "de",
+    Greek: "el",
+    Gujarati: "gu",
+    "Haitian Creole": "ht",
+    Hausa: "ha",
+    Hebrew: "he",
+    Hindi: "hi",
+    Hmong: "mww",
+    Hungarian: "hu",
+    Icelandic: "is",
+    Igbo: "ig",
+    Indonesian: "id",
+    Inuinnaqtun: "ikt",
+    Inuktitut: "iu",
+    "Inuktitut (Latin)": "iu-Latn",
+    Irish: "ga",
+    Italian: "it",
+    Japanese: "ja",
+    Kannada: "kn",
+    Kashmiri: "ks",
+    Kazakh: "kk",
+    Khmer: "km",
+    Kikwanda: "rw",
+    "Klingon (Latin)": "tlh-Latn",
+    "Klingon (pIqaD)": "tlh-Piqd",
+    Konkani: "gom",
+    Korean: "ko",
+    "Kurdish (Medium)": "ku",
+    "Kurdish (North)": "kmr",
+    Kyrgyz: "ky",
+    Lao: "lo",
+    Latvian: "lv",
+    Lingala: "ln",
+    Lithuanian: "lt",
+    "Lower Sorbian language": "dsb",
+    Maithili: "mai",
+    Malagasian: "mg",
+    Malay: "ms",
+    Malayalam: "ml",
+    Maltese: "mt",
+    Manipuri: "mni",
+    Marathi: "mr",
+    "Mongolian (Cyrillic)": "mn-Cyrl",
+    "Mongolian (Traditional)": "mn-Mong",
+    Māori: "mi",
+    Nepali: "ne",
+    "Norwegian Bokmål": "nb",
+    Nyanja: "nya",
+    Oriya: "or",
+    Pashto: "ps",
+    Persian: "fa",
+    Polish: "pl",
+    "Portugal (Brazil)": "pt",
+    "Portugal (Portugal)": "pt-PT",
+    Punjabi: "pa",
+    "Querétaro Ottomi": "otq",
+    Romanian: "ro",
+    Rounds: "run",
+    Russian: "ru",
+    Samoan: "sm",
+    "Serbia (Latin)": "sr-Latn",
+    "Serbian (Cyrillic)": "sr-Cyrl",
+    Sesotho: "st",
+    "Sesotho at Leboa": "nso",
+    Setswana: "tn",
+    Shona: "sn",
+    Sindhi: "sd",
+    Sinhalese: "si",
+    Slovak: "sk",
+    Slovenian: "sl",
+    Somali: "so",
+    Spanish: "es",
+    Swahili: "sw",
+    Swedish: "sv",
+    Tahiti: "ty",
+    Tamil: "ta",
+    Tatar: "tt",
+    Telugu: "te",
+    Thai: "th",
+    Tibetan: "bo",
+    Tigrinya: "ti",
+    Tongan: "to",
+    Turkish: "tr",
+    Turkmen: "tk",
+    Uighur: "ug",
+    Ukrainian: "uk",
+    "Upper Sorbian": "hsb",
+    Urdu: "ur",
+    Uzbek: "uz",
+    Vietnamese: "vi",
+    Welsh: "cy",
+    Will: "brx",
+    Xhosa: "xh",
+    Yoruba: "yo",
+    "Yucatec Maya": "yua",
+    Zulu: "zu",
+};
+
+const azureLanguages = {
+    from: {
+        Auto: "auto",
+        ...azureTargetLanguages,
+    },
+    to: azureTargetLanguages,
+};
+
 /**
  * Azure translate documentation: https://learn.microsoft.com/zh-cn/azure/ai-services/translator/reference/v3-0-translate
  */
-function azure$1(options) {
-    const { key, region } = options;
+function azure(options) {
+    const { key, region, fromLanguages = azureLanguages.from, toLanguages = azureLanguages.to } = options;
     const name = "azure";
     const checkOptions = () => {
         if (!key || !region) {
@@ -273,6 +708,18 @@ function azure$1(options) {
     const base = "https://api.cognitive.microsofttranslator.com/translate?api-version=3.0";
     return {
         name,
+        getFromLanguages() {
+            return fromLanguages;
+        },
+        getToLanguages() {
+            return toLanguages;
+        },
+        normalFromLanguage(language) {
+            return normalizeEngineLanguage(language, fromLanguages, true);
+        },
+        normalToLanguage(language) {
+            return normalizeEngineLanguage(language, toLanguages);
+        },
         async translate(text, opts) {
             checkOptions();
             const { from, to } = opts;
@@ -340,8 +787,94 @@ function azure$1(options) {
     };
 }
 
-function amazon$1(options) {
-    const { region, accessKeyId, secretAccessKey } = options;
+var amazonTargetLanguages = {
+    Afrikaans: "af",
+    Albanian: "sq",
+    Amharic: "am",
+    Arabic: "ar",
+    Armenian: "hy",
+    Azerbaijani: "az",
+    Bengali: "bn",
+    Bosnian: "bs",
+    Bulgarian: "bg",
+    Catalan: "ca",
+    "Chinese (Simplified)": "zh",
+    "Chinese (Traditional)": "zh-TW",
+    Croatian: "hr",
+    Czech: "cs",
+    Danish: "da",
+    Dari: "fa-AF",
+    Dutch: "nl",
+    English: "en",
+    Estonian: "et",
+    "Farsi (Persian)": "fa",
+    "Filipino, Tagalog": "tl",
+    Finnish: "fi",
+    French: "fr",
+    "French (Canada)": "fr-CA",
+    Georgian: "ka",
+    German: "de",
+    Greek: "el",
+    Gujarati: "gu",
+    "Haitian Creole": "ht",
+    Hausa: "ha",
+    Hebrew: "he",
+    Hindi: "hi",
+    Hungarian: "hu",
+    Icelandic: "is",
+    Indonesian: "id",
+    Irish: "ga",
+    Italian: "it",
+    Japanese: "ja",
+    Kannada: "kn",
+    Kazakh: "kk",
+    Korean: "ko",
+    Latvian: "lv",
+    Lithuanian: "lt",
+    Macedonian: "mk",
+    Malay: "ms",
+    Malayalam: "ml",
+    Maltese: "mt",
+    Marathi: "mr",
+    Mongolian: "mn",
+    "Norwegian (Bokmål)": "no",
+    Pashto: "ps",
+    Polish: "pl",
+    "Portuguese (Brazil)": "pt",
+    "Portuguese (Portugal)": "pt-PT",
+    Punjabi: "pa",
+    Romanian: "ro",
+    Russian: "ru",
+    Serbian: "sr",
+    Sinhala: "si",
+    Slovak: "sk",
+    Slovenian: "sl",
+    Somali: "so",
+    Spanish: "es",
+    "Spanish (Mexico)": "es-MX",
+    Swahili: "sw",
+    Swedish: "sv",
+    Tamil: "ta",
+    Telugu: "te",
+    Thai: "th",
+    Turkish: "tr",
+    Ukrainian: "uk",
+    Urdu: "ur",
+    Uzbek: "uz",
+    Vietnamese: "vi",
+    Welsh: "cy",
+};
+
+const amazonLanguages = {
+    from: {
+        Auto: "auto",
+        ...amazonTargetLanguages,
+    },
+    to: amazonTargetLanguages,
+};
+
+function amazon(options) {
+    const { region, accessKeyId, secretAccessKey, fromLanguages = amazonLanguages.from, toLanguages = amazonLanguages.to } = options;
     const name = "amazon";
     const checkOptions = () => {
         if (!region || !accessKeyId || !secretAccessKey) {
@@ -351,6 +884,18 @@ function amazon$1(options) {
     checkOptions();
     return {
         name,
+        getFromLanguages() {
+            return fromLanguages;
+        },
+        getToLanguages() {
+            return toLanguages;
+        },
+        normalFromLanguage(language) {
+            return normalizeEngineLanguage(language, fromLanguages, true);
+        },
+        normalToLanguage(language) {
+            return normalizeEngineLanguage(language, toLanguages);
+        },
         async translate(text, opts) {
             checkOptions();
             const { from = "auto", to } = opts;
@@ -1313,1010 +1858,213 @@ function requireCore () {
 		            var M_offset_4  = M[offset + 4];
 		            var M_offset_5  = M[offset + 5];
 		            var M_offset_6  = M[offset + 6];
-		            var M_offset_7  = M[offset + 7];
-		            var M_offset_8  = M[offset + 8];
-		            var M_offset_9  = M[offset + 9];
-		            var M_offset_10 = M[offset + 10];
-		            var M_offset_11 = M[offset + 11];
-		            var M_offset_12 = M[offset + 12];
-		            var M_offset_13 = M[offset + 13];
-		            var M_offset_14 = M[offset + 14];
-		            var M_offset_15 = M[offset + 15];
-
-		            // Working variables
-		            var a = H[0];
-		            var b = H[1];
-		            var c = H[2];
-		            var d = H[3];
-
-		            // Computation
-		            a = FF(a, b, c, d, M_offset_0,  7,  T[0]);
-		            d = FF(d, a, b, c, M_offset_1,  12, T[1]);
-		            c = FF(c, d, a, b, M_offset_2,  17, T[2]);
-		            b = FF(b, c, d, a, M_offset_3,  22, T[3]);
-		            a = FF(a, b, c, d, M_offset_4,  7,  T[4]);
-		            d = FF(d, a, b, c, M_offset_5,  12, T[5]);
-		            c = FF(c, d, a, b, M_offset_6,  17, T[6]);
-		            b = FF(b, c, d, a, M_offset_7,  22, T[7]);
-		            a = FF(a, b, c, d, M_offset_8,  7,  T[8]);
-		            d = FF(d, a, b, c, M_offset_9,  12, T[9]);
-		            c = FF(c, d, a, b, M_offset_10, 17, T[10]);
-		            b = FF(b, c, d, a, M_offset_11, 22, T[11]);
-		            a = FF(a, b, c, d, M_offset_12, 7,  T[12]);
-		            d = FF(d, a, b, c, M_offset_13, 12, T[13]);
-		            c = FF(c, d, a, b, M_offset_14, 17, T[14]);
-		            b = FF(b, c, d, a, M_offset_15, 22, T[15]);
-
-		            a = GG(a, b, c, d, M_offset_1,  5,  T[16]);
-		            d = GG(d, a, b, c, M_offset_6,  9,  T[17]);
-		            c = GG(c, d, a, b, M_offset_11, 14, T[18]);
-		            b = GG(b, c, d, a, M_offset_0,  20, T[19]);
-		            a = GG(a, b, c, d, M_offset_5,  5,  T[20]);
-		            d = GG(d, a, b, c, M_offset_10, 9,  T[21]);
-		            c = GG(c, d, a, b, M_offset_15, 14, T[22]);
-		            b = GG(b, c, d, a, M_offset_4,  20, T[23]);
-		            a = GG(a, b, c, d, M_offset_9,  5,  T[24]);
-		            d = GG(d, a, b, c, M_offset_14, 9,  T[25]);
-		            c = GG(c, d, a, b, M_offset_3,  14, T[26]);
-		            b = GG(b, c, d, a, M_offset_8,  20, T[27]);
-		            a = GG(a, b, c, d, M_offset_13, 5,  T[28]);
-		            d = GG(d, a, b, c, M_offset_2,  9,  T[29]);
-		            c = GG(c, d, a, b, M_offset_7,  14, T[30]);
-		            b = GG(b, c, d, a, M_offset_12, 20, T[31]);
-
-		            a = HH(a, b, c, d, M_offset_5,  4,  T[32]);
-		            d = HH(d, a, b, c, M_offset_8,  11, T[33]);
-		            c = HH(c, d, a, b, M_offset_11, 16, T[34]);
-		            b = HH(b, c, d, a, M_offset_14, 23, T[35]);
-		            a = HH(a, b, c, d, M_offset_1,  4,  T[36]);
-		            d = HH(d, a, b, c, M_offset_4,  11, T[37]);
-		            c = HH(c, d, a, b, M_offset_7,  16, T[38]);
-		            b = HH(b, c, d, a, M_offset_10, 23, T[39]);
-		            a = HH(a, b, c, d, M_offset_13, 4,  T[40]);
-		            d = HH(d, a, b, c, M_offset_0,  11, T[41]);
-		            c = HH(c, d, a, b, M_offset_3,  16, T[42]);
-		            b = HH(b, c, d, a, M_offset_6,  23, T[43]);
-		            a = HH(a, b, c, d, M_offset_9,  4,  T[44]);
-		            d = HH(d, a, b, c, M_offset_12, 11, T[45]);
-		            c = HH(c, d, a, b, M_offset_15, 16, T[46]);
-		            b = HH(b, c, d, a, M_offset_2,  23, T[47]);
-
-		            a = II(a, b, c, d, M_offset_0,  6,  T[48]);
-		            d = II(d, a, b, c, M_offset_7,  10, T[49]);
-		            c = II(c, d, a, b, M_offset_14, 15, T[50]);
-		            b = II(b, c, d, a, M_offset_5,  21, T[51]);
-		            a = II(a, b, c, d, M_offset_12, 6,  T[52]);
-		            d = II(d, a, b, c, M_offset_3,  10, T[53]);
-		            c = II(c, d, a, b, M_offset_10, 15, T[54]);
-		            b = II(b, c, d, a, M_offset_1,  21, T[55]);
-		            a = II(a, b, c, d, M_offset_8,  6,  T[56]);
-		            d = II(d, a, b, c, M_offset_15, 10, T[57]);
-		            c = II(c, d, a, b, M_offset_6,  15, T[58]);
-		            b = II(b, c, d, a, M_offset_13, 21, T[59]);
-		            a = II(a, b, c, d, M_offset_4,  6,  T[60]);
-		            d = II(d, a, b, c, M_offset_11, 10, T[61]);
-		            c = II(c, d, a, b, M_offset_2,  15, T[62]);
-		            b = II(b, c, d, a, M_offset_9,  21, T[63]);
-
-		            // Intermediate hash value
-		            H[0] = (H[0] + a) | 0;
-		            H[1] = (H[1] + b) | 0;
-		            H[2] = (H[2] + c) | 0;
-		            H[3] = (H[3] + d) | 0;
-		        },
-
-		        _doFinalize: function () {
-		            // Shortcuts
-		            var data = this._data;
-		            var dataWords = data.words;
-
-		            var nBitsTotal = this._nDataBytes * 8;
-		            var nBitsLeft = data.sigBytes * 8;
-
-		            // Add padding
-		            dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);
-
-		            var nBitsTotalH = Math.floor(nBitsTotal / 0x100000000);
-		            var nBitsTotalL = nBitsTotal;
-		            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = (
-		                (((nBitsTotalH << 8)  | (nBitsTotalH >>> 24)) & 0x00ff00ff) |
-		                (((nBitsTotalH << 24) | (nBitsTotalH >>> 8))  & 0xff00ff00)
-		            );
-		            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = (
-		                (((nBitsTotalL << 8)  | (nBitsTotalL >>> 24)) & 0x00ff00ff) |
-		                (((nBitsTotalL << 24) | (nBitsTotalL >>> 8))  & 0xff00ff00)
-		            );
-
-		            data.sigBytes = (dataWords.length + 1) * 4;
-
-		            // Hash final blocks
-		            this._process();
-
-		            // Shortcuts
-		            var hash = this._hash;
-		            var H = hash.words;
-
-		            // Swap endian
-		            for (var i = 0; i < 4; i++) {
-		                // Shortcut
-		                var H_i = H[i];
-
-		                H[i] = (((H_i << 8)  | (H_i >>> 24)) & 0x00ff00ff) |
-		                       (((H_i << 24) | (H_i >>> 8))  & 0xff00ff00);
-		            }
-
-		            // Return final computed hash
-		            return hash;
-		        },
-
-		        clone: function () {
-		            var clone = Hasher.clone.call(this);
-		            clone._hash = this._hash.clone();
-
-		            return clone;
-		        }
-		    });
-
-		    function FF(a, b, c, d, x, s, t) {
-		        var n = a + ((b & c) | (~b & d)) + x + t;
-		        return ((n << s) | (n >>> (32 - s))) + b;
-		    }
-
-		    function GG(a, b, c, d, x, s, t) {
-		        var n = a + ((b & d) | (c & ~d)) + x + t;
-		        return ((n << s) | (n >>> (32 - s))) + b;
-		    }
-
-		    function HH(a, b, c, d, x, s, t) {
-		        var n = a + (b ^ c ^ d) + x + t;
-		        return ((n << s) | (n >>> (32 - s))) + b;
-		    }
-
-		    function II(a, b, c, d, x, s, t) {
-		        var n = a + (c ^ (b | ~d)) + x + t;
-		        return ((n << s) | (n >>> (32 - s))) + b;
-		    }
-
-		    /**
-		     * Shortcut function to the hasher's object interface.
-		     *
-		     * @param {WordArray|string} message The message to hash.
-		     *
-		     * @return {WordArray} The hash.
-		     *
-		     * @static
-		     *
-		     * @example
-		     *
-		     *     var hash = CryptoJS.MD5('message');
-		     *     var hash = CryptoJS.MD5(wordArray);
-		     */
-		    C.MD5 = Hasher._createHelper(MD5);
-
-		    /**
-		     * Shortcut function to the HMAC's object interface.
-		     *
-		     * @param {WordArray|string} message The message to hash.
-		     * @param {WordArray|string} key The secret key.
-		     *
-		     * @return {WordArray} The HMAC.
-		     *
-		     * @static
-		     *
-		     * @example
-		     *
-		     *     var hmac = CryptoJS.HmacMD5(message, key);
-		     */
-		    C.HmacMD5 = Hasher._createHmacHelper(MD5);
-		}(Math));
-
-
-		return CryptoJS.MD5;
-
-	})); 
-} (md5$1));
-
-var md5Exports = md5$1.exports;
-var md5 = /*@__PURE__*/getDefaultExportFromCjs(md5Exports);
-
-function baidu$2(options) {
-    const { appId, secretKey } = options;
-    const url = "https://fanyi-api.baidu.com/api/trans/vip/fieldtranslate";
-    const name = "baidu";
-    const checkOptions = () => {
-        if (!appId || !secretKey) {
-            throw new TranslationError(name, `${name} appId and secretKey is required`);
-        }
-    };
-    checkOptions();
-    return {
-        name,
-        async translate(text, opts) {
-            checkOptions();
-            const { to, from = "auto", domain = "it" } = opts;
-            if (!Array.isArray(text)) {
-                text = [text];
-            }
-            const q = text.join("\n");
-            const salt = Date.now();
-            const sign = md5(`${appId}${q}${salt}${domain}${secretKey}`).toString();
-            const body = new URLSearchParams();
-            body.append("q", q);
-            body.append("from", from);
-            body.append("to", to);
-            body.append("appid", appId);
-            body.append("salt", salt.toString());
-            body.append("domain", domain);
-            body.append("sign", sign);
-            const res = await fetch(url, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/x-www-form-urlencoded",
-                },
-                body: body.toString(),
-            });
-            if (!res.ok) {
-                throw await throwResponseError(this.name, res);
-            }
-            const data = await res.json();
-            if (!data || data.error_code || !data.trans_result || data.trans_result.length === 0) {
-                throw new TranslationError(this.name, `Translate fail ! error_code:${data.error_code}, error_msg: ${data.error_msg} \n Go to https://fanyi-api.baidu.com/product/123 view details`);
-            }
-            const translations = [];
-            for (const translation of data.trans_result) {
-                if (translation.dst) {
-                    translations.push(translation.dst);
-                }
-            }
-            return translations;
-        },
-        async checkLanguage(text) {
-            checkOptions();
-            const salt = Date.now();
-            const sign = md5(`${appId}${text}${salt}${secretKey}`).toString();
-            const body = new URLSearchParams();
-            body.append("q", text);
-            body.append("appid", appId);
-            body.append("salt", salt.toString());
-            body.append("sign", sign);
-            const res = await fetch("https://fanyi-api.baidu.com/api/trans/vip/language", {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/x-www-form-urlencoded",
-                },
-                body: body.toString(),
-            });
-            if (!res.ok) {
-                throw await throwResponseError(this.name, res);
-            }
-            const response = await res.json();
-            if (!response || response.error_code != 0) {
-                throw new CheckLanguageError(this.name, `Check language fail ! error_code:${response.error_code}, error_msg: ${response.error_msg} \n Go to https://fanyi-api.baidu.com/product/143 view details`);
-            }
-            return response.data.src;
-        },
-    };
-}
-
-function deepl$2(options) {
-    const { key } = options;
-    const name = "deepl";
-    const checkOptions = () => {
-        if (!key) {
-            throw new TranslationError(name, `${name} key is required`);
-        }
-    };
-    checkOptions();
-    const url = "https://api-free.deepl.com/v2/translate";
-    return {
-        name,
-        async translate(text, opts) {
-            checkOptions();
-            const { to, from } = opts;
-            if (!Array.isArray(text)) {
-                text = [text];
-            }
-            const res = await fetch(url, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json; charset=UTF-8",
-                    Authorization: `DeepL-Auth-Key ${key}`,
-                    Accept: "*/*",
-                    Host: "api-free.deepl.com",
-                    Connection: "keep-alive",
-                },
-                body: JSON.stringify({
-                    text: text,
-                    source_lang: from === "auto" ? undefined : from,
-                    target_lang: to,
-                }),
-            });
-            if (!res.ok) {
-                throw await throwResponseError(this.name, res);
-            }
-            const bodyRes = await res.json();
-            if (bodyRes.error) {
-                throw new TranslationError(this.name, `Translate fail ! code: ${bodyRes.error.code}, message: ${bodyRes.error.message}`);
-            }
-            const body = bodyRes.translations;
-            if (!body || body.length === 0) {
-                throw new TranslationError(this.name, "Translate fail ! translate's result is null or empty");
-            }
-            const translations = body.map((t) => t.text);
-            return translations;
-        },
-        async checkLanguage(text) {
-            checkOptions();
-            const res = await fetch(url, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json; charset=UTF-8",
-                    Authorization: `DeepL-Auth-Key ${key}`,
-                    Accept: "*/*",
-                    Host: "api-free.deepl.com",
-                    Connection: "keep-alive",
-                },
-                body: JSON.stringify({
-                    text: [text],
-                    target_lang: "EN",
-                }),
-            });
-            if (!res.ok) {
-                throw await throwResponseError(this.name, res);
-            }
-            const bodyRes = await res.json();
-            if (bodyRes.error) {
-                throw new CheckLanguageError(this.name, `Check language fail ! code: ${bodyRes.error.code}, message: ${bodyRes.error.message}`);
-            }
-            const body = bodyRes.translations;
-            if (!body || body.length === 0) {
-                throw new CheckLanguageError(this.name, "Check language fail! No result returned");
-            }
-            const detectedLanguage = body[0].detected_source_language;
-            if (!detectedLanguage) {
-                throw new CheckLanguageError(this.name, "Check language fail! Language not detected");
-            }
-            return detectedLanguage;
-        },
-    };
-}
-
-const logger$1 = useLogger("openai");
-function openai$1(options) {
-    const { apiKey, model, maxTokens = 2000, outputLog = false } = options;
-    const name = "openai";
-    const checkOptions = () => {
-        if (!apiKey) {
-            throw new TranslationError(name, `${name} apiKey is required`);
-        }
-        if (!OPEN_AI_MODELS.includes(model)) {
-            throw new TranslationError(name, `${name} model=${model} is invalid`);
-        }
-    };
-    checkOptions();
-    const base = "https://api.openai.com/v1/chat/completions";
-    return {
-        name,
-        async translate(text, opts) {
-            checkOptions();
-            const { from, to } = opts;
-            const url = `${base}`;
-            if (!Array.isArray(text)) {
-                text = [text];
-            }
-            const prompt = {
-                role: "user",
-                content: `
-          满足以下4点翻译要求：
-          1.将每段文本从${from}翻译为${to}
-          2.文本内容以换行符\n进行段落分割，并以段落分割顺序进行翻译
-          3.仅翻译分割出的段落，其他任何不相关的内容都移除，比如：段落前后的空格、所有标点符号\n
-          4.仅返回要翻译的文本内容，不要返回任何其他内容
-
-          如何提取翻译文本,满足以下2点要求:
-          1.翻译从-$s$-字符标记开始至-$e$-字符标记结束，提取-$s$-至-$e$-之间的内容
-          2.-$s$-和-$e$-这2个标记不要返回，只是用来标记翻译的起始和结束位置
-
-          -$s$-
-          ${text.join("\n")} 
-          -$e$-
-          `,
-            };
-            const res = await fetch(url, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: `Bearer ${apiKey}`,
-                },
-                body: JSON.stringify({
-                    model,
-                    messages: [{ role: "system", content: "You are a professional translator" }, prompt],
-                    max_tokens: maxTokens,
-                    temperature: 0,
-                }),
-            });
-            if (!res.ok) {
-                throw await throwResponseError(this.name, res);
-            }
-            const bodyRes = await res.json();
-            if (bodyRes.error) {
-                throw new TranslationError(this.name, `Translate fail! message: ${bodyRes.error.message}`);
-            }
-            if (!bodyRes || !bodyRes.choices || bodyRes.choices.length === 0 || !bodyRes.choices[0]?.message?.content) {
-                throw new TranslationError(this.name, "Translate fail ! translate's result is null or empty");
-            }
-            const content = bodyRes.choices[0].message.content;
-            const marks = ["-$s$-", "-$e$-"];
-            const translations = content
-                .trim()
-                .split("\n")
-                .map((item) => item.trim())
-                .filter(Boolean)
-                .filter((it) => !marks.includes(it));
-            if (outputLog) {
-                logger$1.info("prompt:", JSON.stringify(prompt, null, 2));
-                logger$1.info("translations:", JSON.stringify(translations, null, 2));
-            }
-            return translations;
-        },
-    };
-}
-
-function sha256(message, secret = "", encoding) {
-    if (encoding) {
-        return crypto.createHmac("sha256", secret).update(message).digest(encoding);
-    }
-    return crypto.createHmac("sha256", secret).update(message).digest();
-}
-function getHash(message, encoding = "hex") {
-    return crypto.createHash("sha256").update(message).digest(encoding);
-}
-function getDate(timestamp) {
-    const date = new Date(timestamp * 1000);
-    return `${date.getUTCFullYear()}-${("0" + (date.getUTCMonth() + 1)).slice(-2)}-${("0" + date.getUTCDate()).slice(-2)}`;
-}
-function buildAuthorization({ secretId, secretKey, service, host, payload, httpRequestMethod, action, apiVersion, region }) {
-    const timestamp = Math.floor(Date.now() / 1000);
-    const date = getDate(timestamp);
-    const canonicalUri = "/";
-    const canonicalQueryString = "";
-    const canonicalHeaders = "content-type:application/json; charset=utf-8\nhost:" + host + "\n";
-    const signedHeaders = "content-type;host";
-    const hashedRequestPayload = getHash(payload);
-    const canonicalRequest = [
-        httpRequestMethod,
-        canonicalUri,
-        canonicalQueryString,
-        canonicalHeaders,
-        signedHeaders,
-        hashedRequestPayload,
-    ].join("\n");
-    const algorithm = "TC3-HMAC-SHA256";
-    const credentialScope = `${date}/${service}/tc3_request`;
-    const hashedCanonicalRequest = getHash(canonicalRequest);
-    const stringToSign = [algorithm, timestamp, credentialScope, hashedCanonicalRequest].join("\n");
-    const kDate = sha256(date, "TC3" + secretKey);
-    const kService = sha256(service, kDate);
-    const kSigning = sha256("tc3_request", kService);
-    const signature = sha256(stringToSign, kSigning, "hex");
-    const authorization = `${algorithm} Credential=${secretId}/${credentialScope}, SignedHeaders=${signedHeaders}, Signature=${signature}`;
-    const headers = {
-        Authorization: authorization,
-        "Content-Type": "application/json; charset=utf-8",
-        Host: host,
-        "X-TC-Action": action,
-        "X-TC-Timestamp": timestamp,
-        "X-TC-Version": apiVersion,
-    };
-    if (region)
-        headers["X-TC-Region"] = region;
-    return headers;
-}
-function tencent$2(options) {
-    const { secretId, secretKey, region = "ap-guangzhou" } = options;
-    const name = "tencent";
-    const host = "tmt.tencentcloudapi.com";
-    const endpoint = `https://${host}/`;
-    const service = "tmt";
-    const apiVersion = "2018-03-21";
-    const action = "TextTranslate";
-    function checkOptions() {
-        if (!secretId || !secretKey) {
-            throw new TranslationError(name, `${name} secretId and secretKey are required`);
-        }
-    }
-    return {
-        name,
-        async translate(text, opts) {
-            checkOptions();
-            const { from = "auto", to } = opts;
-            const source = from === "auto" ? "auto" : from;
-            const payloadObj = {
-                SourceText: Array.isArray(text) ? text.join("\n") : text,
-                Source: source,
-                Target: to,
-                ProjectId: 0,
-            };
-            const payload = JSON.stringify(payloadObj);
-            const headers = buildAuthorization({
-                secretId,
-                secretKey,
-                service,
-                host,
-                payload,
-                httpRequestMethod: "POST",
-                action,
-                apiVersion,
-                region,
-            });
-            try {
-                const res = await fetch(endpoint, {
-                    method: "POST",
-                    headers,
-                    body: payload,
-                });
-                if (!res.ok) {
-                    throw new TranslationError(name, `HTTP ${res.status}: ${await res.text()}`);
-                }
-                const data = await res.json();
-                if (data.Response?.Error) {
-                    throw new TranslationError(name, `Tencent translate fail: ${data.Response.Error.Code}, ${data.Response.Error.Message} \n Go to https://cloud.tencent.com/document/product/551/15619 view details`);
-                }
-                const translatedResults = data.Response?.TargetText.split("\n") ?? [];
-                if (!Array.isArray(translatedResults) || translatedResults.length === 0) {
-                    throw new TranslationError(name, "Translate fail! No result returned");
-                }
-                return translatedResults;
-            }
-            catch (error) {
-                if (error instanceof TranslationError)
-                    throw error;
-                throw new TranslationError(name, `Translation failed: ${error}`);
-            }
-        },
-        async checkLanguage(text) {
-            checkOptions();
-            const payloadObj = {
-                SourceText: text,
-                Source: "auto",
-                Target: "en",
-                ProjectId: 0,
-            };
-            const payload = JSON.stringify(payloadObj);
-            const headers = buildAuthorization({
-                secretId,
-                secretKey,
-                service,
-                host,
-                payload,
-                httpRequestMethod: "POST",
-                action,
-                apiVersion,
-                region,
-            });
-            try {
-                const res = await fetch(endpoint, {
-                    method: "POST",
-                    headers,
-                    body: payload,
-                });
-                if (!res.ok) {
-                    throw new CheckLanguageError(name, `HTTP ${res.status}: ${await res.text()}`);
-                }
-                const data = await res.json();
-                if (data.Response?.Error) {
-                    throw new CheckLanguageError(name, `Tencent language detect fail: ${data.Response.Error.Code}, ${data.Response.Error.Message} \n Go to https://cloud.tencent.com/document/product/551/15619 view details`);
-                }
-                const detectedLanguage = data.Response?.Source;
-                if (!detectedLanguage) {
-                    throw new CheckLanguageError(name, "Language detect fail! No result returned");
-                }
-                return detectedLanguage;
-            }
-            catch (error) {
-                if (error instanceof CheckLanguageError)
-                    throw error;
-                throw new CheckLanguageError(name, `Language detection failed: ${error}`);
-            }
-        },
-    };
-}
-
-const engines = {
-    google,
-    azure: azure$1,
-    amazon: amazon$1,
-    baidu: baidu$2,
-    deepl: deepl$2,
-    openai: openai$1,
-    tencent: tencent$2,
-};
-
-var azure = {
-    Afrikaans: "af",
-    Albanian: "sq",
-    Amharic: "am",
-    Arabic: "ar",
-    Armenian: "hy",
-    Assamese: "as",
-    Azerbaijani: "az",
-    Bashkir: "ba",
-    Basque: "eu",
-    Bengali: "bn",
-    Bhojpuri: "bho",
-    Bosnian: "bs",
-    Bulgarian: "bg",
-    Burmese: "my",
-    "Cantonese (Traditional)": "yue",
-    Catalan: "ca",
-    Chhattisgarhi: "hne",
-    Chinese: "zh-Hans",
-    "Chinese (Literary)": "lzh",
-    "Chinese (Traditional)": "zh-Hant",
-    Croatian: "hr",
-    Czech: "cs",
-    Danish: "da",
-    Dari: "prs",
-    Dhivehi: "dv",
-    Dogri: "doi",
-    Double: "lug",
-    Dutch: "nl",
-    English: "en",
-    Estonian: "et",
-    "FYRO Macedonian": "mk",
-    Faroese: "fo",
-    Fijian: "fj",
-    Filipino: "fil",
-    Finnish: "fi",
-    French: "fr",
-    "French (Canada)": "fr-CA",
-    Galician: "gl",
-    Georgian: "ka",
-    German: "de",
-    Greek: "el",
-    Gujarati: "gu",
-    "Haitian Creole": "ht",
-    Hausa: "ha",
-    Hebrew: "he",
-    Hindi: "hi",
-    Hmong: "mww",
-    Hungarian: "hu",
-    Icelandic: "is",
-    Igbo: "ig",
-    Indonesian: "id",
-    Inuinnaqtun: "ikt",
-    Inuktitut: "iu",
-    "Inuktitut (Latin)": "iu-Latn",
-    Irish: "ga",
-    Italian: "it",
-    Japanese: "ja",
-    Kannada: "kn",
-    Kashmiri: "ks",
-    Kazakh: "kk",
-    Khmer: "km",
-    Kikwanda: "rw",
-    "Klingon (Latin)": "tlh-Latn",
-    "Klingon (pIqaD)": "tlh-Piqd",
-    Konkani: "gom",
-    Korean: "ko",
-    "Kurdish (Medium)": "ku",
-    "Kurdish (North)": "kmr",
-    Kyrgyz: "ky",
-    Lao: "lo",
-    Latvian: "lv",
-    Lingala: "ln",
-    Lithuanian: "lt",
-    "Lower Sorbian language": "dsb",
-    Maithili: "mai",
-    Malagasian: "mg",
-    Malay: "ms",
-    Malayalam: "ml",
-    Maltese: "mt",
-    Manipuri: "mni",
-    Marathi: "mr",
-    "Mongolian (Cyrillic)": "mn-Cyrl",
-    "Mongolian (Traditional)": "mn-Mong",
-    Māori: "mi",
-    Nepali: "ne",
-    "Norwegian Bokmål": "nb",
-    Nyanja: "nya",
-    Oriya: "or",
-    Pashto: "ps",
-    Persian: "fa",
-    Polish: "pl",
-    "Portugal (Brazil)": "pt",
-    "Portugal (Portugal)": "pt-PT",
-    Punjabi: "pa",
-    "Querétaro Ottomi": "otq",
-    Romanian: "ro",
-    Rounds: "run",
-    Russian: "ru",
-    Samoan: "sm",
-    "Serbia (Latin)": "sr-Latn",
-    "Serbian (Cyrillic)": "sr-Cyrl",
-    Sesotho: "st",
-    "Sesotho at Leboa": "nso",
-    Setswana: "tn",
-    Shona: "sn",
-    Sindhi: "sd",
-    Sinhalese: "si",
-    Slovak: "sk",
-    Slovenian: "sl",
-    Somali: "so",
-    Spanish: "es",
-    Swahili: "sw",
-    Swedish: "sv",
-    Tahiti: "ty",
-    Tamil: "ta",
-    Tatar: "tt",
-    Telugu: "te",
-    Thai: "th",
-    Tibetan: "bo",
-    Tigrinya: "ti",
-    Tongan: "to",
-    Turkish: "tr",
-    Turkmen: "tk",
-    Uighur: "ug",
-    Ukrainian: "uk",
-    "Upper Sorbian": "hsb",
-    Urdu: "ur",
-    Uzbek: "uz",
-    Vietnamese: "vi",
-    Welsh: "cy",
-    Will: "brx",
-    Xhosa: "xh",
-    Yoruba: "yo",
-    "Yucatec Maya": "yua",
-    Zulu: "zu",
-};
-
-var openai = {
-    Abkhazian: "ab",
-    Acehnese: "ace",
-    "Acholi language": "ach",
-    Afar: "aa",
-    Afrikaans: "af",
-    Albanian: "sq",
-    Alur: "alz",
-    Amharic: "am",
-    Arabic: "ar",
-    Armenian: "hy",
-    Assamese: "as",
-    Avar: "av",
-    Awadhi: "awa",
-    Aymara: "ay",
-    Azerbaijani: "az",
-    Badawi: "bew",
-    Balinese: "ban",
-    Balochi: "bal",
-    Bambara: "bm",
-    Bangasinan: "pag",
-    Bashkir: "ba",
-    Basque: "eu",
-    Batakkalo: "btx",
-    "Bataksi Marungon": "bts",
-    Bataktoba: "bbc",
-    Baure: "bci",
-    Belarusian: "be",
-    Bengali: "bn",
-    Bhojpuri: "bho",
-    Bikol: "bik",
-    Bosnian: "bs",
-    Breton: "br",
-    Bulgarian: "bg",
-    Burmese: "my",
-    "Buryat language": "bua",
-    Cantonese: "yue",
-    Casey: "kha",
-    Catalan: "ca",
-    Cebuano: "ceb",
-    "Chamorro language": "ch",
-    Chechen: "ce",
-    Chevi: "ak",
-    Chicheva: "ny",
-    Chiga: "cgg",
-    Chinese: "zh-CN",
-    "Chinese (Traditional)": "zh-TW",
-    Chuk: "chk",
-    Chuvash: "cv",
-    Conga: "ts",
-    Corsican: "co",
-    "Crimean Tatar": "crh",
-    Croatian: "hr",
-    Czech: "cs",
-    Danish: "da",
-    Dari: "fa-AF",
-    Dhivehi: "dv",
-    Dinka: "din",
-    Dogra: "doi",
-    Dutch: "nl",
-    Dyula: "dyu",
-    Dzongka: "dz",
-    Elocano: "ilo",
-    English: "en",
-    Esperanto: "eo",
-    Estonian: "et",
-    Ewe: "ee",
-    "FYRO Macedonian": "mk",
-    Faroese: "fo",
-    "Feng language": "fon",
-    Fijian: "fj",
-    Filipino: "tl",
-    Finnish: "fi",
-    French: "fr",
-    Frisian: "fy",
-    Friulian: "fur",
-    Fulani: "ff",
-    Ga: "gaa",
-    Galician: "gl",
-    Georgian: "ka",
-    German: "de",
-    Gongen: "gom",
-    Gorkbojok: "trp",
-    "Grace and Taoism": "ndc-ZW",
-    Greek: "el",
-    Greenlandic: "kl",
-    Guarani: "gn",
-    Gujarati: "gu",
-    "Haitian Creole": "ht",
-    Hakachin: "cnh",
-    Hausa: "ha",
-    Hawaiian: "haw",
-    Hebrew: "iw",
-    Heligaignon: "hil",
-    Hindi: "hi",
-    Hmong: "hmn",
-    Hungarian: "hu",
-    Hunsrück: "hrx",
-    Iban: "iba",
-    Icelandic: "is",
-    Igbo: "ig",
-    Indonesian: "id",
-    Irish: "ga",
-    Italian: "it",
-    "Jamaica vernacular": "jam",
-    Japanese: "ja",
-    Javanese: "jw",
-    "Jingpo language": "kac",
-    Kannada: "kn",
-    Kanuri: "kr",
-    Kazakh: "kk",
-    Kekchi: "kek",
-    Khmer: "km",
-    Kikwanda: "rw",
-    Kithuba: "ktu",
-    "Komi language": "kv",
-    Kongo: "kg",
-    Korean: "ko",
-    "Kurdish (Kurmanji)": "ku",
-    "Kurdish (Solani)": "ckb",
-    Kyrgyz: "ky",
-    Lao: "lo",
-    Latin: "la",
-    Latvian: "lv",
-    Ligurian: "lij",
-    Limburg: "li",
-    Lingala: "ln",
-    Lithuanian: "lt",
-    Lombard: "lmo",
-    Luganda: "lg",
-    Luo: "luo",
-    Luxembourg: "lb",
-    Madura: "mad",
-    Maithili: "mai",
-    Makassar: "mak",
-    Malagasian: "mg",
-    Malay: "ms",
-    "Malay, Jawi": "ms-Arab",
-    Malayalam: "ml",
-    Maltese: "mt",
-    "Malwadi language": "mwr",
-    Mamu: "mam",
-    Manx: "gv",
-    Marathi: "mr",
-    Marshallese: "mh",
-    "Mauritius Scrio whispers": "mfe",
-    "Meitei (Manipur)": "mni-Mtei",
-    Minan: "min",
-    Mizo: "lus",
-    Mongolian: "mn",
-    Māori: "mi",
-    "Nahuatl (Eastern Vastka)": "nhe",
-    "Ndebele (Southern)": "nr",
-    Ndombe: "dov",
-    "Nepal Language (Newar)": "new",
-    Nepali: "ne",
-    "Nko alphabet (West African written script)": "bm-Nkoo",
-    "Northern Sotho": "nso",
-    Norwegian: "no",
-    Nuer: "nus",
-    Occitan: "oc",
-    Oriya: "or",
-    "Oromo language": "om",
-    Ossetian: "os",
-    Pampangja: "pam",
-    Papiamento: "pap",
-    Pashto: "ps",
-    Pemba: "bem",
-    Persian: "fa",
-    Polish: "pl",
-    "Portugal (Brazil)": "pt",
-    "Portugal (Portugal)": "pt-PT",
-    "Punjabi (Gurumuchi)": "pa",
-    "Punjabi (Shamuki)": "pa-Arab",
-    Quechua: "qu",
-    Ratgale: "ltg",
-    Romani: "rom",
-    Romanian: "ro",
-    Rondi: "rn",
-    Russian: "ru",
-    Sabatec: "zap",
-    Sakha: "sah",
-    Samoan: "sm",
-    Sango: "sg",
-    Sanskrit: "sa",
-    Santali: "sat-Latn",
-    "Schuna language": "sn",
-    "Scottish Gaelic": "gd",
-    Serbian: "sr",
-    "Seychellois Creole": "crs",
-    Shan: "shn",
-    Sicilian: "scn",
-    "Sierra Leonean Creole": "kri",
-    Silesian: "szl",
-    Sindhi: "sd",
-    Sinhalese: "si",
-    Slovak: "sk",
-    Slovenian: "sl",
-    Somali: "so",
-    "South Sotho": "st",
-    Spanish: "es",
-    "Steppe Mali": "chm",
-    Sundanese: "su",
-    "Susu language": "sus",
-    Swahili: "sw",
-    Swat: "ss",
-    Swedish: "sv",
-    "Sámi (North)": "se",
-    Tahiti: "ty",
-    Tajik: "tg",
-    Tamaset: "ber-Latn",
-    "Tamazight (Tifinaven)": "ber",
-    Tamil: "ta",
-    Tatar: "tt",
-    Telugu: "te",
-    Tetum: "tet",
-    Thai: "th",
-    Tibetan: "bo",
-    "Tiff language": "tiv",
-    Tigrinya: "ti",
-    "Tok Pisin": "tpi",
-    Tongan: "to",
-    Tswana: "tn",
-    Tulu: "tcy",
-    "Tumbuka language": "tum",
-    Turkish: "tr",
-    Turkmen: "tk",
-    Tuvan: "tyv",
-    Udmurtic: "udm",
-    Uighur: "ug",
-    Ukrainian: "uk",
-    Urdu: "ur",
-    Uzbek: "uz",
-    Venda: "ve",
-    Venetian: "vec",
-    Vietnamese: "vi",
-    "Wari language": "war",
-    Welsh: "cy",
-    "Wolof language": "wo",
-    Xhosa: "xh",
-    Yiddish: "yi",
-    Yoruba: "yo",
-    "Yucatan Maya": "yua",
-    Zulu: "zu",
-};
+		            var M_offset_7  = M[offset + 7];
+		            var M_offset_8  = M[offset + 8];
+		            var M_offset_9  = M[offset + 9];
+		            var M_offset_10 = M[offset + 10];
+		            var M_offset_11 = M[offset + 11];
+		            var M_offset_12 = M[offset + 12];
+		            var M_offset_13 = M[offset + 13];
+		            var M_offset_14 = M[offset + 14];
+		            var M_offset_15 = M[offset + 15];
+
+		            // Working variables
+		            var a = H[0];
+		            var b = H[1];
+		            var c = H[2];
+		            var d = H[3];
+
+		            // Computation
+		            a = FF(a, b, c, d, M_offset_0,  7,  T[0]);
+		            d = FF(d, a, b, c, M_offset_1,  12, T[1]);
+		            c = FF(c, d, a, b, M_offset_2,  17, T[2]);
+		            b = FF(b, c, d, a, M_offset_3,  22, T[3]);
+		            a = FF(a, b, c, d, M_offset_4,  7,  T[4]);
+		            d = FF(d, a, b, c, M_offset_5,  12, T[5]);
+		            c = FF(c, d, a, b, M_offset_6,  17, T[6]);
+		            b = FF(b, c, d, a, M_offset_7,  22, T[7]);
+		            a = FF(a, b, c, d, M_offset_8,  7,  T[8]);
+		            d = FF(d, a, b, c, M_offset_9,  12, T[9]);
+		            c = FF(c, d, a, b, M_offset_10, 17, T[10]);
+		            b = FF(b, c, d, a, M_offset_11, 22, T[11]);
+		            a = FF(a, b, c, d, M_offset_12, 7,  T[12]);
+		            d = FF(d, a, b, c, M_offset_13, 12, T[13]);
+		            c = FF(c, d, a, b, M_offset_14, 17, T[14]);
+		            b = FF(b, c, d, a, M_offset_15, 22, T[15]);
+
+		            a = GG(a, b, c, d, M_offset_1,  5,  T[16]);
+		            d = GG(d, a, b, c, M_offset_6,  9,  T[17]);
+		            c = GG(c, d, a, b, M_offset_11, 14, T[18]);
+		            b = GG(b, c, d, a, M_offset_0,  20, T[19]);
+		            a = GG(a, b, c, d, M_offset_5,  5,  T[20]);
+		            d = GG(d, a, b, c, M_offset_10, 9,  T[21]);
+		            c = GG(c, d, a, b, M_offset_15, 14, T[22]);
+		            b = GG(b, c, d, a, M_offset_4,  20, T[23]);
+		            a = GG(a, b, c, d, M_offset_9,  5,  T[24]);
+		            d = GG(d, a, b, c, M_offset_14, 9,  T[25]);
+		            c = GG(c, d, a, b, M_offset_3,  14, T[26]);
+		            b = GG(b, c, d, a, M_offset_8,  20, T[27]);
+		            a = GG(a, b, c, d, M_offset_13, 5,  T[28]);
+		            d = GG(d, a, b, c, M_offset_2,  9,  T[29]);
+		            c = GG(c, d, a, b, M_offset_7,  14, T[30]);
+		            b = GG(b, c, d, a, M_offset_12, 20, T[31]);
+
+		            a = HH(a, b, c, d, M_offset_5,  4,  T[32]);
+		            d = HH(d, a, b, c, M_offset_8,  11, T[33]);
+		            c = HH(c, d, a, b, M_offset_11, 16, T[34]);
+		            b = HH(b, c, d, a, M_offset_14, 23, T[35]);
+		            a = HH(a, b, c, d, M_offset_1,  4,  T[36]);
+		            d = HH(d, a, b, c, M_offset_4,  11, T[37]);
+		            c = HH(c, d, a, b, M_offset_7,  16, T[38]);
+		            b = HH(b, c, d, a, M_offset_10, 23, T[39]);
+		            a = HH(a, b, c, d, M_offset_13, 4,  T[40]);
+		            d = HH(d, a, b, c, M_offset_0,  11, T[41]);
+		            c = HH(c, d, a, b, M_offset_3,  16, T[42]);
+		            b = HH(b, c, d, a, M_offset_6,  23, T[43]);
+		            a = HH(a, b, c, d, M_offset_9,  4,  T[44]);
+		            d = HH(d, a, b, c, M_offset_12, 11, T[45]);
+		            c = HH(c, d, a, b, M_offset_15, 16, T[46]);
+		            b = HH(b, c, d, a, M_offset_2,  23, T[47]);
+
+		            a = II(a, b, c, d, M_offset_0,  6,  T[48]);
+		            d = II(d, a, b, c, M_offset_7,  10, T[49]);
+		            c = II(c, d, a, b, M_offset_14, 15, T[50]);
+		            b = II(b, c, d, a, M_offset_5,  21, T[51]);
+		            a = II(a, b, c, d, M_offset_12, 6,  T[52]);
+		            d = II(d, a, b, c, M_offset_3,  10, T[53]);
+		            c = II(c, d, a, b, M_offset_10, 15, T[54]);
+		            b = II(b, c, d, a, M_offset_1,  21, T[55]);
+		            a = II(a, b, c, d, M_offset_8,  6,  T[56]);
+		            d = II(d, a, b, c, M_offset_15, 10, T[57]);
+		            c = II(c, d, a, b, M_offset_6,  15, T[58]);
+		            b = II(b, c, d, a, M_offset_13, 21, T[59]);
+		            a = II(a, b, c, d, M_offset_4,  6,  T[60]);
+		            d = II(d, a, b, c, M_offset_11, 10, T[61]);
+		            c = II(c, d, a, b, M_offset_2,  15, T[62]);
+		            b = II(b, c, d, a, M_offset_9,  21, T[63]);
+
+		            // Intermediate hash value
+		            H[0] = (H[0] + a) | 0;
+		            H[1] = (H[1] + b) | 0;
+		            H[2] = (H[2] + c) | 0;
+		            H[3] = (H[3] + d) | 0;
+		        },
+
+		        _doFinalize: function () {
+		            // Shortcuts
+		            var data = this._data;
+		            var dataWords = data.words;
+
+		            var nBitsTotal = this._nDataBytes * 8;
+		            var nBitsLeft = data.sigBytes * 8;
+
+		            // Add padding
+		            dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);
+
+		            var nBitsTotalH = Math.floor(nBitsTotal / 0x100000000);
+		            var nBitsTotalL = nBitsTotal;
+		            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = (
+		                (((nBitsTotalH << 8)  | (nBitsTotalH >>> 24)) & 0x00ff00ff) |
+		                (((nBitsTotalH << 24) | (nBitsTotalH >>> 8))  & 0xff00ff00)
+		            );
+		            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = (
+		                (((nBitsTotalL << 8)  | (nBitsTotalL >>> 24)) & 0x00ff00ff) |
+		                (((nBitsTotalL << 24) | (nBitsTotalL >>> 8))  & 0xff00ff00)
+		            );
+
+		            data.sigBytes = (dataWords.length + 1) * 4;
+
+		            // Hash final blocks
+		            this._process();
+
+		            // Shortcuts
+		            var hash = this._hash;
+		            var H = hash.words;
+
+		            // Swap endian
+		            for (var i = 0; i < 4; i++) {
+		                // Shortcut
+		                var H_i = H[i];
+
+		                H[i] = (((H_i << 8)  | (H_i >>> 24)) & 0x00ff00ff) |
+		                       (((H_i << 24) | (H_i >>> 8))  & 0xff00ff00);
+		            }
+
+		            // Return final computed hash
+		            return hash;
+		        },
+
+		        clone: function () {
+		            var clone = Hasher.clone.call(this);
+		            clone._hash = this._hash.clone();
+
+		            return clone;
+		        }
+		    });
+
+		    function FF(a, b, c, d, x, s, t) {
+		        var n = a + ((b & c) | (~b & d)) + x + t;
+		        return ((n << s) | (n >>> (32 - s))) + b;
+		    }
+
+		    function GG(a, b, c, d, x, s, t) {
+		        var n = a + ((b & d) | (c & ~d)) + x + t;
+		        return ((n << s) | (n >>> (32 - s))) + b;
+		    }
+
+		    function HH(a, b, c, d, x, s, t) {
+		        var n = a + (b ^ c ^ d) + x + t;
+		        return ((n << s) | (n >>> (32 - s))) + b;
+		    }
+
+		    function II(a, b, c, d, x, s, t) {
+		        var n = a + (c ^ (b | ~d)) + x + t;
+		        return ((n << s) | (n >>> (32 - s))) + b;
+		    }
+
+		    /**
+		     * Shortcut function to the hasher's object interface.
+		     *
+		     * @param {WordArray|string} message The message to hash.
+		     *
+		     * @return {WordArray} The hash.
+		     *
+		     * @static
+		     *
+		     * @example
+		     *
+		     *     var hash = CryptoJS.MD5('message');
+		     *     var hash = CryptoJS.MD5(wordArray);
+		     */
+		    C.MD5 = Hasher._createHelper(MD5);
+
+		    /**
+		     * Shortcut function to the HMAC's object interface.
+		     *
+		     * @param {WordArray|string} message The message to hash.
+		     * @param {WordArray|string} key The secret key.
+		     *
+		     * @return {WordArray} The HMAC.
+		     *
+		     * @static
+		     *
+		     * @example
+		     *
+		     *     var hmac = CryptoJS.HmacMD5(message, key);
+		     */
+		    C.HmacMD5 = Hasher._createHmacHelper(MD5);
+		}(Math));
+
+
+		return CryptoJS.MD5;
+
+	})); 
+} (md5$1));
+
+var md5Exports = md5$1.exports;
+var md5 = /*@__PURE__*/getDefaultExportFromCjs(md5Exports);
 
-var baidu$1 = {
+var baiduTargetLanguages = {
     Achinese: "ach",
     Afrikaans: "afr",
     Akan: "aka",
@@ -2527,7 +2275,106 @@ var baidu$1 = {
     Zulu: "zul",
 };
 
-var deepl$1 = {
+const baiduLanguages = {
+    from: {
+        Auto: "auto",
+        ...baiduTargetLanguages,
+    },
+    to: baiduTargetLanguages,
+};
+
+function baidu$1(options) {
+    const { appId, secretKey, fromLanguages = baiduLanguages.from, toLanguages = baiduLanguages.to } = options;
+    const url = "https://fanyi-api.baidu.com/api/trans/vip/fieldtranslate";
+    const name = "baidu";
+    const checkOptions = () => {
+        if (!appId || !secretKey) {
+            throw new TranslationError(name, `${name} appId and secretKey is required`);
+        }
+    };
+    checkOptions();
+    return {
+        name,
+        getFromLanguages() {
+            return fromLanguages;
+        },
+        getToLanguages() {
+            return toLanguages;
+        },
+        normalFromLanguage(language) {
+            return normalizeEngineLanguage(language, fromLanguages, true);
+        },
+        normalToLanguage(language) {
+            return normalizeEngineLanguage(language, toLanguages);
+        },
+        async translate(text, opts) {
+            checkOptions();
+            const { to, from = "auto", domain = "it" } = opts;
+            if (!Array.isArray(text)) {
+                text = [text];
+            }
+            const q = text.join("\n");
+            const salt = Date.now();
+            const sign = md5(`${appId}${q}${salt}${domain}${secretKey}`).toString();
+            const body = new URLSearchParams();
+            body.append("q", q);
+            body.append("from", from);
+            body.append("to", to);
+            body.append("appid", appId);
+            body.append("salt", salt.toString());
+            body.append("domain", domain);
+            body.append("sign", sign);
+            const res = await fetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/x-www-form-urlencoded",
+                },
+                body: body.toString(),
+            });
+            if (!res.ok) {
+                throw await throwResponseError(this.name, res);
+            }
+            const data = await res.json();
+            if (!data || data.error_code || !data.trans_result || data.trans_result.length === 0) {
+                throw new TranslationError(this.name, `Translate fail ! error_code:${data.error_code}, error_msg: ${data.error_msg} \n Go to https://fanyi-api.baidu.com/product/123 view details`);
+            }
+            const translations = [];
+            for (const translation of data.trans_result) {
+                if (translation.dst) {
+                    translations.push(translation.dst);
+                }
+            }
+            return translations;
+        },
+        async checkLanguage(text) {
+            checkOptions();
+            const salt = Date.now();
+            const sign = md5(`${appId}${text}${salt}${secretKey}`).toString();
+            const body = new URLSearchParams();
+            body.append("q", text);
+            body.append("appid", appId);
+            body.append("salt", salt.toString());
+            body.append("sign", sign);
+            const res = await fetch("https://fanyi-api.baidu.com/api/trans/vip/language", {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/x-www-form-urlencoded",
+                },
+                body: body.toString(),
+            });
+            if (!res.ok) {
+                throw await throwResponseError(this.name, res);
+            }
+            const response = await res.json();
+            if (!response || response.error_code != 0) {
+                throw new CheckLanguageError(this.name, `Check language fail ! error_code:${response.error_code}, error_msg: ${response.error_msg} \n Go to https://fanyi-api.baidu.com/product/143 view details`);
+            }
+            return response.data.src;
+        },
+    };
+}
+
+var deeplOriginLanguages = {
     English: "en",
     Bulgarian: "bg",
     Chinese: "zh",
@@ -2563,156 +2410,272 @@ var deepl$1 = {
     Ukrainian: "uk",
 };
 
-var tencent$1 = {
-    Auto: "auto",
-    Chinese: "zh",
-    TraditionalChinese: "zh-TW",
-    English: "en",
-    Japanese: "ja",
-    Korean: "ko",
-    French: "fr",
-    Spanish: "es",
-    Italian: "it",
-    German: "de",
-    Turkish: "tr",
-    Russian: "ru",
-    Portuguese: "pt",
-    Vietnamese: "vi",
-    Indonesian: "id",
-    Thai: "th",
-    Malay: "ms",
-    Arabic: "ar",
-    Hindi: "hi",
-};
-
-var amazon = {
-    Afrikaans: "af",
-    Albanian: "sq",
-    Amharic: "am",
-    Arabic: "ar",
-    Armenian: "hy",
-    Azerbaijani: "az",
-    Bengali: "bn",
-    Bosnian: "bs",
+var deeplTargetLanguages = {
+    "American English": "en-US",
+    "Brazilian Portuguese": "pt-BR",
+    "British English": "en-GB",
     Bulgarian: "bg",
-    Catalan: "ca",
-    "Chinese (Simplified)": "zh",
-    "Chinese (Traditional)": "zh-TW",
+    Chinese: "zh",
     Croatian: "hr",
     Czech: "cs",
     Danish: "da",
-    Dari: "fa-AF",
     Dutch: "nl",
-    English: "en",
     Estonian: "et",
-    "Farsi (Persian)": "fa",
-    "Filipino, Tagalog": "tl",
+    "European Portuguese": "pt-PT",
     Finnish: "fi",
     French: "fr",
-    "French (Canada)": "fr-CA",
-    Georgian: "ka",
     German: "de",
     Greek: "el",
-    Gujarati: "gu",
-    "Haitian Creole": "ht",
-    Hausa: "ha",
-    Hebrew: "he",
-    Hindi: "hi",
     Hungarian: "hu",
     Icelandic: "is",
     Indonesian: "id",
     Irish: "ga",
     Italian: "it",
     Japanese: "ja",
-    Kannada: "kn",
-    Kazakh: "kk",
     Korean: "ko",
     Latvian: "lv",
     Lithuanian: "lt",
-    Macedonian: "mk",
-    Malay: "ms",
-    Malayalam: "ml",
     Maltese: "mt",
-    Marathi: "mr",
-    Mongolian: "mn",
-    "Norwegian (Bokmål)": "no",
-    Pashto: "ps",
+    Norwegian: "nb",
     Polish: "pl",
-    "Portuguese (Brazil)": "pt",
-    "Portuguese (Portugal)": "pt-PT",
-    Punjabi: "pa",
+    Portuguese: "pt",
     Romanian: "ro",
     Russian: "ru",
-    Serbian: "sr",
-    Sinhala: "si",
     Slovak: "sk",
     Slovenian: "sl",
-    Somali: "so",
     Spanish: "es",
-    "Spanish (Mexico)": "es-MX",
-    Swahili: "sw",
     Swedish: "sv",
-    Tamil: "ta",
-    Telugu: "te",
-    Thai: "th",
     Turkish: "tr",
     Ukrainian: "uk",
-    Urdu: "ur",
-    Uzbek: "uz",
-    Vietnamese: "vi",
-    Welsh: "cy",
 };
 
-const originLanguages = {
-    azure: azure,
-    google: openai,
-    baidu: baidu$1,
-    deepl: deepl$1,
-    amazon: amazon,
-    openai: openai,
-    tencent: tencent$1,
+const deeplLanguages = {
+    from: {
+        Auto: "auto",
+        ...deeplOriginLanguages,
+    },
+    to: deeplTargetLanguages,
+};
+
+function deepl(options) {
+    const { key, fromLanguages = deeplLanguages.from, toLanguages = deeplLanguages.to } = options;
+    const name = "deepl";
+    const checkOptions = () => {
+        if (!key) {
+            throw new TranslationError(name, `${name} key is required`);
+        }
+    };
+    checkOptions();
+    const url = "https://api-free.deepl.com/v2/translate";
+    return {
+        name,
+        getFromLanguages() {
+            return fromLanguages;
+        },
+        getToLanguages() {
+            return toLanguages;
+        },
+        normalFromLanguage(language) {
+            return normalizeEngineLanguage(language, fromLanguages, true);
+        },
+        normalToLanguage(language) {
+            return normalizeEngineLanguage(language, toLanguages);
+        },
+        async translate(text, opts) {
+            checkOptions();
+            const { to, from } = opts;
+            if (!Array.isArray(text)) {
+                text = [text];
+            }
+            const res = await fetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json; charset=UTF-8",
+                    Authorization: `DeepL-Auth-Key ${key}`,
+                    Accept: "*/*",
+                    Host: "api-free.deepl.com",
+                    Connection: "keep-alive",
+                },
+                body: JSON.stringify({
+                    text: text,
+                    source_lang: from === "auto" ? undefined : from,
+                    target_lang: to,
+                }),
+            });
+            if (!res.ok) {
+                throw await throwResponseError(this.name, res);
+            }
+            const bodyRes = await res.json();
+            if (bodyRes.error) {
+                throw new TranslationError(this.name, `Translate fail ! code: ${bodyRes.error.code}, message: ${bodyRes.error.message}`);
+            }
+            const body = bodyRes.translations;
+            if (!body || body.length === 0) {
+                throw new TranslationError(this.name, "Translate fail ! translate's result is null or empty");
+            }
+            const translations = body.map((t) => t.text);
+            return translations;
+        },
+        async checkLanguage(text) {
+            checkOptions();
+            const res = await fetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json; charset=UTF-8",
+                    Authorization: `DeepL-Auth-Key ${key}`,
+                    Accept: "*/*",
+                    Host: "api-free.deepl.com",
+                    Connection: "keep-alive",
+                },
+                body: JSON.stringify({
+                    text: [text],
+                    target_lang: "EN",
+                }),
+            });
+            if (!res.ok) {
+                throw await throwResponseError(this.name, res);
+            }
+            const bodyRes = await res.json();
+            if (bodyRes.error) {
+                throw new CheckLanguageError(this.name, `Check language fail ! code: ${bodyRes.error.code}, message: ${bodyRes.error.message}`);
+            }
+            const body = bodyRes.translations;
+            if (!body || body.length === 0) {
+                throw new CheckLanguageError(this.name, "Check language fail! No result returned");
+            }
+            const detectedLanguage = body[0].detected_source_language;
+            if (!detectedLanguage) {
+                throw new CheckLanguageError(this.name, "Check language fail! Language not detected");
+            }
+            return detectedLanguage;
+        },
+    };
+}
+
+const openaiLanguages = {
+    from: {
+        Auto: "auto",
+        ...googleTargetLanguages,
+    },
+    to: googleTargetLanguages,
 };
 
-var deepl = {
-    "American English": "en-US",
-    "Brazilian Portuguese": "pt-BR",
-    "British English": "en-GB",
-    Bulgarian: "bg",
+const logger$1 = useLogger("openai");
+function openai(options) {
+    const { apiKey, model, maxTokens = 2000, outputLog = false, fromLanguages = openaiLanguages.from, toLanguages = openaiLanguages.to, } = options;
+    const name = "openai";
+    const checkOptions = () => {
+        if (!apiKey) {
+            throw new TranslationError(name, `${name} apiKey is required`);
+        }
+        if (!OPEN_AI_MODELS.includes(model)) {
+            throw new TranslationError(name, `${name} model=${model} is invalid`);
+        }
+    };
+    checkOptions();
+    const base = "https://api.openai.com/v1/chat/completions";
+    return {
+        name,
+        getFromLanguages() {
+            return fromLanguages;
+        },
+        getToLanguages() {
+            return toLanguages;
+        },
+        normalFromLanguage(language) {
+            return normalizeEngineLanguage(language, fromLanguages, true);
+        },
+        normalToLanguage(language) {
+            return normalizeEngineLanguage(language, toLanguages);
+        },
+        async translate(text, opts) {
+            checkOptions();
+            const { from, to } = opts;
+            const url = `${base}`;
+            if (!Array.isArray(text)) {
+                text = [text];
+            }
+            const prompt = {
+                role: "user",
+                content: `
+          满足以下4点翻译要求：
+          1.将每段文本从${from}翻译为${to}
+          2.文本内容以换行符\n进行段落分割，并以段落分割顺序进行翻译
+          3.仅翻译分割出的段落，其他任何不相关的内容都移除，比如：段落前后的空格、所有标点符号\n
+          4.仅返回要翻译的文本内容，不要返回任何其他内容
+
+          如何提取翻译文本,满足以下2点要求:
+          1.翻译从-$s$-字符标记开始至-$e$-字符标记结束，提取-$s$-至-$e$-之间的内容
+          2.-$s$-和-$e$-这2个标记不要返回，只是用来标记翻译的起始和结束位置
+
+          -$s$-
+          ${text.join("\n")}
+          -$e$-
+          `,
+            };
+            const res = await fetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${apiKey}`,
+                },
+                body: JSON.stringify({
+                    model,
+                    messages: [{ role: "system", content: "You are a professional translator" }, prompt],
+                    max_tokens: maxTokens,
+                    temperature: 0,
+                }),
+            });
+            if (!res.ok) {
+                throw await throwResponseError(this.name, res);
+            }
+            const bodyRes = await res.json();
+            if (bodyRes.error) {
+                throw new TranslationError(this.name, `Translate fail! message: ${bodyRes.error.message}`);
+            }
+            if (!bodyRes || !bodyRes.choices || bodyRes.choices.length === 0 || !bodyRes.choices[0]?.message?.content) {
+                throw new TranslationError(this.name, "Translate fail ! translate's result is null or empty");
+            }
+            const content = bodyRes.choices[0].message.content;
+            const marks = ["-$s$-", "-$e$-"];
+            const translations = content
+                .trim()
+                .split("\n")
+                .map((item) => item.trim())
+                .filter(Boolean)
+                .filter((it) => !marks.includes(it));
+            if (outputLog) {
+                logger$1.info("prompt:", JSON.stringify(prompt, null, 2));
+                logger$1.info("translations:", JSON.stringify(translations, null, 2));
+            }
+            return translations;
+        },
+    };
+}
+
+var tencentOriginLanguages = {
+    Auto: "auto",
     Chinese: "zh",
-    Croatian: "hr",
-    Czech: "cs",
-    Danish: "da",
-    Dutch: "nl",
-    Estonian: "et",
-    "European Portuguese": "pt-PT",
-    Finnish: "fi",
-    French: "fr",
-    German: "de",
-    Greek: "el",
-    Hungarian: "hu",
-    Icelandic: "is",
-    Indonesian: "id",
-    Irish: "ga",
-    Italian: "it",
+    TraditionalChinese: "zh-TW",
+    English: "en",
     Japanese: "ja",
     Korean: "ko",
-    Latvian: "lv",
-    Lithuanian: "lt",
-    Maltese: "mt",
-    Norwegian: "nb",
-    Polish: "pl",
-    Portuguese: "pt",
-    Romanian: "ro",
-    Russian: "ru",
-    Slovak: "sk",
-    Slovenian: "sl",
+    French: "fr",
     Spanish: "es",
-    Swedish: "sv",
+    Italian: "it",
+    German: "de",
     Turkish: "tr",
-    Ukrainian: "uk",
+    Russian: "ru",
+    Portuguese: "pt",
+    Vietnamese: "vi",
+    Indonesian: "id",
+    Thai: "th",
+    Malay: "ms",
+    Arabic: "ar",
+    Hindi: "hi",
 };
 
-var tencent = {
+var tencentTargetLanguages = {
     "Simplified Chinese": "zh",
     "Traditional Chinese": "zh-TW",
     English: "en",
@@ -2733,14 +2696,203 @@ var tencent = {
     Hindi: "hi",
 };
 
-const targetLanguages = {
-    azure: azure,
-    google: openai,
+const tencentLanguages = {
+    from: {
+        ...tencentOriginLanguages,
+    },
+    to: tencentTargetLanguages,
+};
+
+function sha256(message, secret = "", encoding) {
+    if (encoding) {
+        return crypto.createHmac("sha256", secret).update(message).digest(encoding);
+    }
+    return crypto.createHmac("sha256", secret).update(message).digest();
+}
+function getHash(message, encoding = "hex") {
+    return crypto.createHash("sha256").update(message).digest(encoding);
+}
+function getDate(timestamp) {
+    const date = new Date(timestamp * 1000);
+    return `${date.getUTCFullYear()}-${("0" + (date.getUTCMonth() + 1)).slice(-2)}-${("0" + date.getUTCDate()).slice(-2)}`;
+}
+function buildAuthorization({ secretId, secretKey, service, host, payload, httpRequestMethod, action, apiVersion, region }) {
+    const timestamp = Math.floor(Date.now() / 1000);
+    const date = getDate(timestamp);
+    const canonicalUri = "/";
+    const canonicalQueryString = "";
+    const canonicalHeaders = "content-type:application/json; charset=utf-8\nhost:" + host + "\n";
+    const signedHeaders = "content-type;host";
+    const hashedRequestPayload = getHash(payload);
+    const canonicalRequest = [
+        httpRequestMethod,
+        canonicalUri,
+        canonicalQueryString,
+        canonicalHeaders,
+        signedHeaders,
+        hashedRequestPayload,
+    ].join("\n");
+    const algorithm = "TC3-HMAC-SHA256";
+    const credentialScope = `${date}/${service}/tc3_request`;
+    const hashedCanonicalRequest = getHash(canonicalRequest);
+    const stringToSign = [algorithm, timestamp, credentialScope, hashedCanonicalRequest].join("\n");
+    const kDate = sha256(date, "TC3" + secretKey);
+    const kService = sha256(service, kDate);
+    const kSigning = sha256("tc3_request", kService);
+    const signature = sha256(stringToSign, kSigning, "hex");
+    const authorization = `${algorithm} Credential=${secretId}/${credentialScope}, SignedHeaders=${signedHeaders}, Signature=${signature}`;
+    const headers = {
+        Authorization: authorization,
+        "Content-Type": "application/json; charset=utf-8",
+        Host: host,
+        "X-TC-Action": action,
+        "X-TC-Timestamp": timestamp,
+        "X-TC-Version": apiVersion,
+    };
+    if (region)
+        headers["X-TC-Region"] = region;
+    return headers;
+}
+function tencent(options) {
+    const { secretId, secretKey, region = "ap-guangzhou", fromLanguages = tencentLanguages.from, toLanguages = tencentLanguages.to, } = options;
+    const name = "tencent";
+    const host = "tmt.tencentcloudapi.com";
+    const endpoint = `https://${host}/`;
+    const service = "tmt";
+    const apiVersion = "2018-03-21";
+    const action = "TextTranslate";
+    function checkOptions() {
+        if (!secretId || !secretKey) {
+            throw new TranslationError(name, `${name} secretId and secretKey are required`);
+        }
+    }
+    return {
+        name,
+        getFromLanguages() {
+            return fromLanguages;
+        },
+        getToLanguages() {
+            return toLanguages;
+        },
+        normalFromLanguage(language) {
+            return normalizeEngineLanguage(language, fromLanguages, true);
+        },
+        normalToLanguage(language) {
+            return normalizeEngineLanguage(language, toLanguages);
+        },
+        async translate(text, opts) {
+            checkOptions();
+            const { from = "auto", to } = opts;
+            const source = from === "auto" ? "auto" : from;
+            const payloadObj = {
+                SourceText: Array.isArray(text) ? text.join("\n") : text,
+                Source: source,
+                Target: to,
+                ProjectId: 0,
+            };
+            const payload = JSON.stringify(payloadObj);
+            const headers = buildAuthorization({
+                secretId,
+                secretKey,
+                service,
+                host,
+                payload,
+                httpRequestMethod: "POST",
+                action,
+                apiVersion,
+                region,
+            });
+            try {
+                const res = await fetch(endpoint, {
+                    method: "POST",
+                    headers,
+                    body: payload,
+                });
+                if (!res.ok) {
+                    throw new TranslationError(name, `HTTP ${res.status}: ${await res.text()}`);
+                }
+                const data = await res.json();
+                if (data.Response?.Error) {
+                    throw new TranslationError(name, `Tencent translate fail: ${data.Response.Error.Code}, ${data.Response.Error.Message} \n Go to https://cloud.tencent.com/document/product/551/15619 view details`);
+                }
+                const translatedResults = data.Response?.TargetText.split("\n") ?? [];
+                if (!Array.isArray(translatedResults) || translatedResults.length === 0) {
+                    throw new TranslationError(name, "Translate fail! No result returned");
+                }
+                return translatedResults;
+            }
+            catch (error) {
+                if (error instanceof TranslationError)
+                    throw error;
+                throw new TranslationError(name, `Translation failed: ${error}`);
+            }
+        },
+        async checkLanguage(text) {
+            checkOptions();
+            const payloadObj = {
+                SourceText: text,
+                Source: "auto",
+                Target: "en",
+                ProjectId: 0,
+            };
+            const payload = JSON.stringify(payloadObj);
+            const headers = buildAuthorization({
+                secretId,
+                secretKey,
+                service,
+                host,
+                payload,
+                httpRequestMethod: "POST",
+                action,
+                apiVersion,
+                region,
+            });
+            try {
+                const res = await fetch(endpoint, {
+                    method: "POST",
+                    headers,
+                    body: payload,
+                });
+                if (!res.ok) {
+                    throw new CheckLanguageError(name, `HTTP ${res.status}: ${await res.text()}`);
+                }
+                const data = await res.json();
+                if (data.Response?.Error) {
+                    throw new CheckLanguageError(name, `Tencent language detect fail: ${data.Response.Error.Code}, ${data.Response.Error.Message} \n Go to https://cloud.tencent.com/document/product/551/15619 view details`);
+                }
+                const detectedLanguage = data.Response?.Source;
+                if (!detectedLanguage) {
+                    throw new CheckLanguageError(name, "Language detect fail! No result returned");
+                }
+                return detectedLanguage;
+            }
+            catch (error) {
+                if (error instanceof CheckLanguageError)
+                    throw error;
+                throw new CheckLanguageError(name, `Language detection failed: ${error}`);
+            }
+        },
+    };
+}
+
+const engines = {
+    google: google(),
+    azure,
+    amazon,
     baidu: baidu$1,
-    deepl: deepl,
-    amazon: amazon,
-    openai: openai,
-    tencent: tencent,
+    deepl,
+    openai,
+    tencent,
+};
+
+const builtinEngineLanguages = {
+    amazon: amazonLanguages,
+    azure: azureLanguages,
+    baidu: baiduLanguages,
+    deepl: deeplLanguages,
+    google: googleLanguages,
+    openai: openaiLanguages,
+    tencent: tencentLanguages,
 };
 
 var baidu = {
@@ -2752,47 +2904,34 @@ var baidu = {
     Russian: "ru",
 };
 
-const checkLanguages = Object.assign(Object.assign({}, originLanguages), {
-    baidu: baidu,
-});
+const checkLanguages = {
+    amazon: builtinEngineLanguages.amazon.from,
+    azure: builtinEngineLanguages.azure.from,
+    baidu,
+    deepl: builtinEngineLanguages.deepl.from,
+    google: builtinEngineLanguages.google.from,
+    openai: builtinEngineLanguages.openai.from,
+    tencent: builtinEngineLanguages.tencent.from,
+};
 
-function normalFromLanguage(from, engine) {
-    if (from === "auto") {
-        return "auto";
-    }
-    const engineLanguages = originLanguages[engine];
-    if (!engineLanguages) {
-        throw new Error(`Engine ${engine} not found`);
-    }
-    const keys = Object.keys(originLanguages[engine]);
-    if (keys.includes(from)) {
-        return engineLanguages[from];
-    }
-    const values = Object.values(originLanguages[engine]);
-    if (values.includes(from)) {
-        return from;
-    }
-    throw new Error(`Invalid from language ${engine} ${from}`);
-}
-function normalToLanguage(to, engine) {
-    const engineLanguages = targetLanguages[engine];
-    if (!engineLanguages) {
-        throw new Error(`Engine ${engine} not found`);
-    }
-    const keys = Object.keys(targetLanguages[engine]);
-    if (keys.includes(to)) {
-        return engineLanguages[to];
-    }
-    const values = Object.values(targetLanguages[engine]);
-    if (values.includes(to)) {
-        return to;
+function resolveLanguageSource(engine) {
+    if (typeof engine === "string") {
+        const languages = builtinEngineLanguages[engine];
+        if (!languages) {
+            throw new Error(`Engine ${engine} not found`);
+        }
+        return languages;
     }
-    throw new Error(`Invalid to language ${engine} ${to}`);
+    return {
+        from: engine.getFromLanguages(),
+        to: engine.getToLanguages(),
+    };
 }
 function getLanguage(engine) {
+    const languages = resolveLanguageSource(engine);
     return {
-        from: originLanguages[engine],
-        to: targetLanguages[engine],
+        from: languages.from,
+        to: languages.to,
     };
 }
 
@@ -2833,6 +2972,23 @@ class Translator {
             return false;
         }
         this.engines.delete(engineName);
+        return true;
+    }
+    getFromLanguages(engineName) {
+        const engine = this.engines.get(engineName);
+        if (!engine) {
+            logger.warn(`Engine ${engineName} not found`);
+            return {};
+        }
+        return engine.getFromLanguages();
+    }
+    getToLanguages(engineName) {
+        const engine = this.engines.get(engineName);
+        if (!engine) {
+            logger.warn(`Engine ${engineName} not found`);
+            return {};
+        }
+        return engine.getToLanguages();
     }
     isSupportCheckLanguage(engineName) {
         if (!engineName || !this.engines.has(engineName)) {
@@ -2872,9 +3028,7 @@ class Translator {
     }
     async translate(text, options) {
         const { engine = "google", cache_time = 60 * 1000 } = options;
-        let { from = "auto", to } = options;
-        from = options.from = normalFromLanguage(from, engine);
-        to = options.to = normalToLanguage(to, engine);
+        const { from = "auto", to } = options;
         //1. Check if engine exists
         if (!this.engines.has(engine)) {
             throw new TranslationError(appName, `Engine ${engine} not found`);
@@ -2883,24 +3037,32 @@ class Translator {
         if (!engineInstance) {
             throw new TranslationError(appName, `Engine ${engine} is null`);
         }
-        if (!from) {
+        const normalizedFrom = engineInstance.normalFromLanguage(from);
+        const normalizedTo = engineInstance.normalToLanguage(to);
+        const normalizedOptions = {
+            ...options,
+            engine,
+            from: normalizedFrom,
+            to: normalizedTo,
+        };
+        if (!normalizedFrom) {
             throw new TranslationError(appName, `Invalid origin language ${from}`);
         }
-        if (!to) {
+        if (!normalizedTo) {
             throw new TranslationError(appName, `Invalid target language ${to}`);
         }
-        const key = `${from}:${to}:${engine}:${text}`;
+        const key = `${normalizedFrom}:${normalizedTo}:${engine}:${text}`;
         //3. If the cache is matched, the cache is used directly
         if (cache.get(key)) {
             return Promise.resolve(cache.get(key)?.value);
         }
-        return this.concurrencyHandle(engineInstance, text, options)
+        return this.concurrencyHandle(engineInstance, text, normalizedOptions)
             .then((translated) => {
             cache.set(key, translated, cache_time ?? this.cache_time);
             return translated;
         })
             .catch((e) => {
-            logger.error(`${appName} Failed: from=${from},to=${to},engine=${engine},translate text: \n${getGapLine()}\n${text}\n${getGapLine()}\n error: ${getErrorMessages(e)}`);
+            logger.error(`${appName} Failed: from=${normalizedFrom},to=${normalizedTo},engine=${engine},translate text: \n${getGapLine()}\n${text}\n${getGapLine()}\n error: ${getErrorMessages(e)}`);
             if (e instanceof TranslationError) {
                 throw e;
             }
@@ -2960,6 +3122,7 @@ class Translator {
     }
 }
 const translator = new Translator();
+translator.addEngine(engines.google);
 var index = {
     engines,
     translator,
@@ -2977,8 +3140,4 @@ exports.checkLanguages = checkLanguages;
 exports.default = index;
 exports.engines = engines;
 exports.getLanguage = getLanguage;
-exports.normalFromLanguage = normalFromLanguage;
-exports.normalToLanguage = normalToLanguage;
-exports.originLanguages = originLanguages;
-exports.targetLanguages = targetLanguages;
 exports.translator = translator;