vite-gc-i18n-plugin 1.1.3 → 1.1.5

package/dist/index.cjs

@@ -597,794 +597,502 @@ const REGEX_MAP = {
   [OriginLangKeyEnum.RU]: /[йцукенгшщзхъфывапролджэячсмитьбюё .-]{1,}/ // 俄语字母
 };
 
-/*
- * @Author: xiaoshanwen
- * @Date: 2023-10-11 10:01:43
- * @LastEditTime: 2025-03-28 19:07:17
- * @FilePath: /i18n_translation_vite/packages/autoI18nPluginCore/src/utils/base.ts
- */
-function getOriginRegex() {
-  const originLang = FunctionFactoryOption.originLang;
-  return REGEX_MAP[originLang];
-}
+var allLanguage = [{
+  code: 'zh-CN',
+  name: '简体中文'
+}, {
+  code: 'zh-TW',
+  name: '繁体中文'
+}, {
+  code: 'zh-UG',
+  name: '维吾尔语'
+}, {
+  code: 'en-US',
+  name: '英文'
+}, {
+  code: 'tr-TR',
+  name: '土耳其语'
+}, {
+  code: 'es-ES',
+  name: '西班牙语'
+}, {
+  code: 'ja-JP',
+  name: '日语'
+}, {
+  code: 'ru-RU',
+  name: '俄语'
+}, {
+  code: 'fr-FR',
+  name: '法语'
+}, {
+  code: 'de-DE',
+  name: '德语'
+}, {
+  code: 'pt-BR',
+  name: '巴西葡萄牙语'
+}, {
+  code: 'pt-PT',
+  name: '葡萄牙语'
+}, {
+  code: 'ko-KR',
+  name: '韩语'
+}, {
+  code: 'vi-VN',
+  name: '越南语'
+}, {
+  code: 'sv-SE',
+  name: '瑞典语'
+}, {
+  code: 'id-ID',
+  name: '印尼语'
+}, {
+  code: 'uk-UA',
+  name: '乌克兰语'
+}, {
+  code: 'it-IT',
+  name: '意大利语'
+}, {
+  code: 'th-TH',
+  name: '泰语'
+}, {
+  code: 'hi-IN',
+  name: '印地语'
+}, {
+  code: 'fa-IR',
+  name: '波斯语'
+}, {
+  code: 'ro-RO',
+  name: '罗马尼亚语'
+}, {
+  code: 'el-GR',
+  name: '希腊语'
+}, {
+  code: 'nl-NL',
+  name: '荷兰语'
+}, {
+  code: 'cs-CZ',
+  name: '捷克语'
+}, {
+  code: 'mn-MN',
+  name: '蒙古语'
+}, {
+  code: 'mn-TR',
+  name: '传统蒙古语'
+}, {
+  code: 'fi-FI',
+  name: '芬兰语'
+}, {
+  code: 'ar-SA',
+  name: '阿拉伯语'
+}, {
+  code: 'ar-EG',
+  name: '阿拉伯语-埃及'
+}, {
+  code: 'da-DK',
+  name: '丹麦语'
+}, {
+  code: 'pl-PL',
+  name: '波兰语'
+}, {
+  code: 'nb-NO',
+  name: '挪威语'
+}, {
+  code: 'si-LK',
+  name: '僧伽罗语'
+}];
 
 /**
- * @description: 是否包含来源语言字符
- * @param {string} code
- * @return {*}
+ * JSON 格式化配置类型
  */
-function hasOriginSymbols(code) {
-  return getOriginRegex().test(code);
-}
 
-/**
- * @description: 过滤注释
- * @param {string} code
- * @return {*}
- */
-const removeComments = function (code) {
-  // 使用正则表达式匹配并删除单行注释
-  code = code.replace(/\/\/.*?\n/g, '');
-  // 使用正则表达式匹配并删除多行注释
-  code = code.replace(/\/\*[\s\S]*?\*\//g, '');
-  // 使用正则表达式匹配并删除HTML注释
-  code = code.replace(/<!--[\s\S]*?-->/g, '');
-  return code;
+// 默认的缩进配置
+const indentConfig = {
+  tab: {
+    char: '\t',
+    size: 1
+  },
+  space: {
+    char: ' ',
+    size: 4
+  }
+};
+
+// 默认格式化配置
+const configDefault = {
+  type: 'tab'
+};
+
+// 临时存储替换字符串的数组
+let placeholderStorage = [];
+
+// 临时存储处理函数
+const pushPlaceholder = match => `\\${placeholderStorage.push(match)}\\`;
+const popPlaceholder = (_match, index) => placeholderStorage[+index - 1];
+
+// 生成缩进字符
+const generateIndentation = (count, indentType) => {
+  return new Array(count + 1).join(indentType);
 };
 
 /**
- * @description: 用于判断提供的值是否符合正则表达式数组中的任一规则，符合则跳过
- * @param {*} value
- * @param {*} regexArray
- * @return {*}
+ * 格式化 JSON 字符串
+ * @param json JSON 字符串
+ * @param indentType 缩进类型
+ * @returns 格式化的 JSON 字符串
  */
-function checkAgainstRegexArray(value, regexArray) {
-  for (let i = 0; i < regexArray.length; i++) {
-    const regex = typeof regexArray[i] === 'string' ? new RegExp(regexArray[i]) : regexArray[i];
-    if (regex.test(value)) {
-      return true; // 如果符合任何一个规则，返回 true
+function formatJSON(json, indentType) {
+  placeholderStorage = [];
+  let output = '';
+  let indentLevel = 0;
+
+  // 提取反斜杠和字符串
+  json = json.replace(/\\./g, pushPlaceholder) // 处理反斜杠
+  .replace(/(".*?"|'.*?')/g, pushPlaceholder) // 处理字符串
+  .replace(/\s+/g, ''); // 去除多余空格
+
+  // 根据 JSON 内容添加换行和缩进
+  for (let i = 0; i < json.length; i++) {
+    const char = json.charAt(i);
+    switch (char) {
+      case '{':
+      case '[':
+        output += char + '\n' + generateIndentation(++indentLevel, indentType);
+        break;
+      case '}':
+      case ']':
+        output += '\n' + generateIndentation(--indentLevel, indentType) + char;
+        break;
+      case ',':
+        output += ',\n' + generateIndentation(indentLevel, indentType);
+        break;
+      case ':':
+        output += ': ';
+        break;
+      default:
+        output += char;
+        break;
     }
   }
-  return false; // 如果所有规则都不符合，返回 false
+
+  // 去除数字数组的空格，并还原反斜杠和字符串
+  output = output.replace(/\[[\d,\s]+?\]/g, match => match.replace(/\s/g, '')).replace(/\\(\d+)\\/g, popPlaceholder) // 还原填充数据
+  .replace(/\\(\d+)\\/g, popPlaceholder); // 再次还原填充数据
+
+  return output;
 }
 
 /**
- * @description: 用于解析抽象语法树中的调用表达式，并提取出调用的名称，如a.b.c() 取 c。
- * @param {any} node
- * @return {*}
+ * 格式化 JSON 的主函数
+ * @param json 需要格式化的 JSON 对象或字符串
+ * @param config 配置选项
+ * @returns 格式化后的 JSON 字符串
  */
-function extractFunctionName(node) {
-  let callName = '';
-  function callObjName(callObj, name) {
-    name += '.' + callObj.property.name;
-    if (types.isMemberExpression(callObj.object)) {
-      // isMemberExpression： 是否是成员表达式
-      return callObjName(callObj.object, name);
-    }
-    name = callObj.object.name + name;
-    return name;
-  }
-  if (types.isCallExpression(node)) {
-    // isCallExpression： 是否是调用表达式
-    if (types.isMemberExpression(node.callee)) {
-      callName = callObjName(node.callee, '');
-    } else {
-      callName = node.callee.name || '';
-    }
+function jsonFormatter(json) {
+  let config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : configDefault;
+  // 确保输入是 JSON 字符串
+  const jsonString = typeof json === 'string' ? json : JSON.stringify(json);
+
+  // 获取缩进配置
+  const indent = indentConfig[config.type];
+  if (!indent) {
+    throw new Error(`Unrecognized indent type: "${config.type}"`);
   }
-  return callName;
+
+  // 生成缩进字符
+  const indentType = generateIndentation(config.size || indent.size, indent.char);
+
+  // 格式化 JSON 字符串
+  return formatJSON(jsonString, indentType);
 }
 
-/**
- * @description: 提取文件的中文部分
- * @param {string} fileContent
- * @return {*}
+/*
+ * @Date: 2025-02-17 17:11:26
+ * @LastEditors: xiaoshan
+ * @LastEditTime: 2025-02-17 18:00:37
+ * @FilePath: /i18n_translation_vite/packages/autoI18nPluginCore/src/utils/chunk.ts
  */
-const extractCnStrings = fileContent => {
-  const regex = /[^\x00-\xff]+/g;
-  return extractStrings(fileContent, regex);
-};
 
 /**
- * @description: 提取文件指定部分内容
- * @param {string} fileContent
- * @param {any} regex
- * @return {*}
+ * 智能文本分块处理器
+ * @param values 待分块的原始文本数组
+ * @param maxChunkSize 最大分块长度
+ * @returns 包含分块文本和重组方法的对象
+ *
+ * 功能特性：
+ * 1. 自动合并小文本为最大可能块
+ * 2. 处理超长文本并给出警告
+ * 3. 保证块长度不超过限制
+ * 4. 保留原始顺序和分隔符语义
  */
-function extractStrings(fileContent, regex) {
-  const matches = fileContent.match(regex);
-  return matches ? matches.filter((item, index) => matches.indexOf(item) === index) : [];
-}
+function createTextSplitter(values, maxChunkSize) {
+  // 分隔符定义（用于合并/拆分时保持语义）
+  const SEP_LENGTH = SEPARATOR.length;
 
-/**
- * @description: 生成i8n翻译函数
- * @param {string} value
- * @param {boolean} isExpression
- * @param {string} key
- * @return {*}
- */
-function createI18nTranslator(createOption) {
-  const {
-    value,
-    isExpression = false,
-    key,
-    insertOption
-  } = createOption;
+  // 结果存储和缓冲区
+  const result = []; // 最终分块结果
+  let buffer = []; // 当前累积块缓冲区
+  let currentSize = 0; // 当前缓冲区字符数（含分隔符）
 
-  // 从全局配置对象 option 中获取命名空间
-  const nameSpace = exports.option.namespace;
-  const {
-    trimmedValue,
-    valStr
-  } = normalizeTranslateValue(value);
-  // 若 key 存在则使用 key，否则调用 generateId 函数根据 valStr 生成唯一的键
-  const generatedKey = key || generateId(valStr);
-  // 提取公共配置对象，避免重复代码
-  const config = {
-    option: exports.option,
-    hash: generatedKey,
-    value: trimmedValue,
-    uncodeValue: valStr,
-    namespace: nameSpace
+  /**
+   * 提交缓冲区内容到结果集
+   * - 将缓冲区内容用分隔符连接
+   * - 重置缓冲区和计数器
+   */
+  const commitBuffer = () => {
+    if (buffer.length > 0) {
+      // 计算实际连接长度用于验证
+      const actualLength = buffer.join(SEPARATOR).length;
+      if (actualLength > maxChunkSize) {
+        console.warn(`缓冲区提交异常：生成块长度 ${actualLength} 超过限制`);
+      }
+      result.push(buffer.join(SEPARATOR));
+      buffer = [];
+      currentSize = 0;
+    }
   };
-  if (exports.option.translateExtends) {
-    const {
-      handleCodeCall,
-      handleCodeString
-    } = exports.option.translateExtends;
-    return isExpression ? handleCodeCall(config, insertOption) : handleCodeString(config, insertOption);
-  }
-  if (isExpression) {
-    const valueExp = types.stringLiteral(trimmedValue);
-    valueExp.extra = {
-      raw: `'${valStr}'`,
-      // 防止转码为unicode
-      rawValue: trimmedValue
-    };
-    return exports.option.useValueAsKey ? types.callExpression(types.identifier(exports.option.translateKey), [valueExp]) : types.callExpression(types.identifier(exports.option.translateKey), [types.stringLiteral(generatedKey), valueExp]);
-  } else {
-    return `${exports.option.translateKey}('${generatedKey}','${valStr}')`;
+
+  // 主处理循环：遍历所有原始文本项
+  for (const value of values) {
+    // 计算需要新增的空间：文本长度 + 分隔符（非首项）
+    const neededSpace = value.length + (buffer.length > 0 ? SEP_LENGTH : 0);
+
+    // ─── 超长文本处理策略 ───
+    if (value.length > maxChunkSize) {
+      // 优先提交现有缓冲区内容
+      if (buffer.length > 0) commitBuffer();
+
+      /**
+       * 超长文本处理逻辑：
+       * - 长度超过1.5倍限制时发出强警告
+       * - 强制单独成块（即使超过限制）
+       * - 后续需要特殊处理这些异常块
+       */
+      if (value.length > maxChunkSize * 1.5) {
+        console.warn(`超长文本告警：检测到长度 ${value.length} 字符的文本项，可能影响翻译质量`);
+      }
+      // 结果直接新增一个超长文本
+      result.push(value);
+      continue;
+    }
+
+    // ─── 正常分块逻辑 ───
+    // 空间不足时提交当前缓冲区
+    if (currentSize + neededSpace > maxChunkSize) {
+      commitBuffer();
+    }
+
+    // 更新缓冲区状态（累加长度需包含分隔符）
+    currentSize += neededSpace;
+    buffer.push(value);
   }
-}
-function normalizeTranslateValue(value) {
-  const trimmedValue = exports.option.isClearSpace ? value : value.trim();
-  const valStr = trimmedValue.replace(/'/g, '"').replace(/(\n)/g, '\\n');
-  return {
-    trimmedValue,
-    valStr
-  };
+
+  // 提交最终未完成的缓冲区内容
+  commitBuffer();
+
+  // 返回分块结果
+  return result;
 }
 
-/**
- * @description: 生成唯一id
- * @param {string} key
- * @return {*}
+/*
+ * @Date: 2025-03-26 20:28:21
+ * @LastEditors: xiaoshan
+ * @LastEditTime: 2025-03-31 10:29:49
+ * @FilePath: /i18n_translation_vite/packages/autoI18nPluginCore/src/utils/split.ts
  */
-function generateId(key) {
-  let hash = 0;
-  for (let i = 0; i < key.length; i++) {
-    const charCode = key.charCodeAt(i);
-    hash = (hash << 5) - hash + charCode;
-    hash = hash & hash;
-  }
-  const id = Math.abs(hash).toString(36) + key.length.toString(36);
-  return id;
-}
+// 插件核心文件
+// 字符串切割与转换函数
+// import generate from '@babel/generator'
 
+// todo 这个切割函数可以优化，性能可能很差
 /**
- * @description: unicode转普通字符串
- * @param {string} str
- * @return {*}
+ * 根据正则表达式分割字符串，并将符合正则的连续字符拼接起来。
+ * @param str - 要分割的字符串。
+ * @param separatorRegex - 用于分割字符串的正则表达式。
+ * @returns 分割并拼接后的字符串数组。
  */
-const unicodeToString = str => {
-  return str.replace(/\\u[\dA-Fa-f]{4}/g, match => {
-    return String.fromCharCode(parseInt(match.replace(/\\u/g, ''), 16));
-  });
-};
-
 /**
- * @description: 有道翻译 标识截取
- * @param {string} q
- * @return {*}
+ * 这个函数的主要功能是根据给定的正则表达式分割字符串，并对分割结果进行特殊处理。
+ * 处理过程分为三个主要步骤：
+ *
+ * 1. 首先根据分隔符正则和标点符号正则进行初步分割
+ * 2. 然后将连续的标点符号和符合分隔符正则的部分重新连接
+ * 3. 最后将不符合分隔符正则的相邻部分合并
+ *
+ * @param str - 需要分割的源字符串
+ * @param separatorRegex - 用于分割的正则表达式
+ * @returns 处理后的字符串数组
  */
-function truncate(q) {
-  // 检查输入字符串的长度
-  if (q.length <= 20) {
-    // 如果长度小于等于20，直接返回原字符串
-    return q;
-  } else {
-    // 如果长度大于20，截取前10个字符和后10个字符，并在中间插入长度信息
-    const len = q.length;
-    return q.substring(0, 10) + len + q.substring(len - 10);
-  }
-}
+function splitByRegex(str, separatorRegex) {
+  // 定义标点符号的正则表达式
+  const punctuationRegex = /[，。？！《》,.．：!?""''；'"、0-9\n\r\t\v\f]/;
+  // 创建一个新的正则表达式，用于分割字符串
+  const splitRegex = new RegExp(`(${separatorRegex.source}|${punctuationRegex.source})`, separatorRegex.flags);
 
-// 导出一个深拷贝函数，用于克隆对象
-function cloneDeep(value) {
-  let cache = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new WeakMap();
-  // 处理基本类型和 null
-  if (typeof value !== 'object' || value === null) {
-    return value;
-  }
+  // 使用正则表达式分割字符串，并过滤掉空字符串
+  const splitArr = str.split(splitRegex).filter(Boolean);
+  const result = [];
+  let currentMatch = '';
 
-  // 处理循环引用
-  if (cache.has(value)) {
-    return cache.get(value);
-  }
+  // 定义连接标点符号的正则表达式
+  const connectPunctuationRegex = /[，。？！《》,.．：!?；'"、0-9]/;
+  // 创建一个新的正则表达式，用于检测是否需要连接
+  const connectRegex = new RegExp(`(${separatorRegex.source}|${connectPunctuationRegex.source})`, separatorRegex.flags);
 
-  // 处理特殊对象类型
-  if (value instanceof Date) {
-    return new Date(value);
-  }
-  if (value instanceof RegExp) {
-    return new RegExp(value.source, value.flags);
+  // 遍历分割后的数组
+  for (const item of splitArr) {
+    if (connectRegex.test(item)) {
+      // 如果当前项符合连接条件，则将其添加到当前匹配字符串中
+      currentMatch += item;
+    } else {
+      // 如果当前匹配字符串不为空，则将其添加到结果数组中
+      if (currentMatch) {
+        result.push(currentMatch);
+        currentMatch = '';
+      }
+      // 将当前项添加到结果数组中
+      result.push(item);
+    }
   }
 
-  // 初始化克隆容器
-  const clone = Array.isArray(value) ? [] : {};
-
-  // 缓存对象防止循环引用
-  cache.set(value, clone);
+  // 如果最后一个匹配字符串不为空，则将其添加到结果数组中
+  if (currentMatch) {
+    result.push(currentMatch);
+  }
 
-  // 处理 Symbol 和普通键的枚举
-  const keys = [...Object.keys(value), ...Object.getOwnPropertySymbols(value).filter(sym => value.propertyIsEnumerable(sym))];
-
-  // 递归克隆属性
-  for (const key of keys) {
-    clone[key] = cloneDeep(value[key], cache);
-  }
-  return clone;
-}
-
-var base = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    checkAgainstRegexArray: checkAgainstRegexArray,
-    cloneDeep: cloneDeep,
-    createI18nTranslator: createI18nTranslator,
-    extractCnStrings: extractCnStrings,
-    extractFunctionName: extractFunctionName,
-    extractStrings: extractStrings,
-    generateId: generateId,
-    getOriginRegex: getOriginRegex,
-    hasOriginSymbols: hasOriginSymbols,
-    normalizeTranslateValue: normalizeTranslateValue,
-    removeComments: removeComments,
-    truncate: truncate,
-    unicodeToString: unicodeToString
-});
-
-// 代码灵感来自https://github.com/dadidi9900/auto-plugins-json-translate/blob/main/src/services/translationService.ts
-/**
- * 火山引擎翻译器，内置豆包、deepseek等模型
- * 
- * 火山引擎大模型介绍：https://www.volcengine.com/docs/82379/1099455
- * 
- * api文档：https://www.volcengine.com/docs/82379/1298454
- * 
- * 使用方式：
- * ```ts
- * vitePluginsAutoI18n({
-    ...
-    translator: new VolcengineTranslator({
-        apiKey: '你申请的apiKey',
-        model: '你要调用的模型，如：`doubao-1-5-pro-32k-250115`，请确保使用前已在控制台开通了对应模型'
-    })
-})
- * ```
- */
-class VolcengineTranslator extends Translator {
-  constructor(option) {
-    super({
-      name: '火山引擎ai翻译',
-      fetchMethod: async (text, fromKey, toKey, separator) => {
-        let salt = new Date().getTime();
-        const textArr = text.split(separator);
-        const sourceMap = Object.fromEntries(textArr.map(text => [generateId(text), text]));
-        const data = {
-          model: option.model,
-          messages: [{
-            role: 'system',
-            content: `
-                                ###
-                                假如你是一个无情的翻译接口，你将根据一个文本组成的JSON对象，来解决将数组每个成员从源语言A翻译成目标语言B并返回翻译后的JSON对象的任务。需要注意的是，待翻译的文本均来自一个${option.desc ? option.desc + '的' : ''}web平台，遇到歧义时需要做好处理。根据以下规则一步步执行：
-                                1. 明确源语言A和目标语言B。
-                                2. 对JSON对象中数组的每个成员进行从源语言A到目标语言B的翻译。
-                                3. 将翻译后的内容以JSON对象格式返回，确保返回的内容可以被JSON.parse解析。
-
-                                参考例子：
-                                示例1：
-                                输入：zh-cn -> en { "awfgx": "你好", "qwfga": "世界" }
-                                输出：{ "awfgx": "Hello", "qwfga": "World" }
-
-                                示例2：
-                                输入：de -> fr { "gweaq": "Hallo", "wtrts": "Welt" }
-                                输出：{ "gweaq": "Bonjour", "wtrts": "Monde" }
-
-                                请回答问题：
-                                输入：源语言A -> 目标语言B { "wghhj": "XXX" }
-                                输出：
-
-                                要求：
-                                1 以JSON对象格式输出
-                                2 JSON对象中每个成员为翻译后的内容
-                                ###
-                            `
-          }, {
-            role: 'user',
-            content: `${fromKey} -> ${toKey} ${JSON.stringify(sourceMap)}`
-          }],
-          ...(option.insertOption || {})
-        };
-        const response = await axios.post(`https://ark.cn-beijing.volces.com/api/v3/chat/completions?t=${salt}`, data, {
-          headers: {
-            'Content-Type': 'application/json',
-            Authorization: `Bearer ${option.apiKey}`
-          },
-          proxy: option.proxy
-        });
-        let resultTextArr = Array.from(textArr).fill('');
-        const content = response.data.choices[0].message.content;
-        try {
-          let resultMap;
-          try {
-            resultMap = JSON.parse(content);
-          } catch (error) {
-            throw new Error('大模型返回文本解析失败');
-          }
-          if (typeof resultMap !== 'object' || !resultMap) {
-            throw new Error('大模型返回文本解析后类型不正确');
-          }
-          const isMiss = Object.keys(resultMap).some(key => !(key in sourceMap));
-          if (isMiss) {
-            throw new Error('大模型返回文本内容不完整');
-          }
-          resultTextArr = textArr.map(text => resultMap[generateId(text)]); // 用textArr遍历，保证顺序
-        } catch (error) {
-          const message = error instanceof Error ? error.message : '未知错误';
-          console.warn('⚠', message);
-          console.warn('⚠ 返回的文本内容：', content);
-          console.warn('⚠ 原文本内容：', JSON.stringify(sourceMap));
-        }
-        return resultTextArr.join(separator);
-      },
-      onError: (error, cb) => {
-        cb(error);
-        console.error('请确保在火山引擎控制台开通了对应模型，且有足够的token余额。控制台地址：https://console.volcengine.com/ark/');
-      },
-      maxChunkSize: 1000,
-      // 太长可能会导致返回文本不完整
-      interval: option.interval ?? 1000
-    });
-  }
-}
-
-/*
- * @Author: xiaoshanwen
- * @Date: 2024-04-03 18:12:45
- * @LastEditTime: 2024-04-03 18:33:53
- * @FilePath: /i18n_translation_vite/autoI18nPluginCore/src/enums/translate.ts
- */
-let TranslateApiEnum = /*#__PURE__*/function (TranslateApiEnum) {
-  TranslateApiEnum["google"] = "Google";
-  TranslateApiEnum["youdao"] = "Youdao";
-  return TranslateApiEnum;
-}({});
-
-/*
- * @Date: 2025-03-16 14:12:30
- * @LastEditors: xiaoshan
- * @LastEditTime: 2025-03-16 14:13:42
- * @FilePath: /i18n_translation_vite/packages/autoI18nPluginCore/src/enums/option.ts
- */
-/**
- * 翻译类型枚举
- */
-let TranslateTypeEnum = /*#__PURE__*/function (TranslateTypeEnum) {
-  TranslateTypeEnum["FULL_AUTO"] = "full-auto";
-  TranslateTypeEnum["SEMI_AUTO"] = "semi-auto";
-  return TranslateTypeEnum;
-}({});
-
-/*
- * @Author: xiaoshanwen
- * @Date: 2023-10-26 17:34:47
- * @LastEditTime: 2025-03-31 19:58:37
- * @FilePath: /i18n_translation_vite/packages/autoI18nPluginCore/src/option.ts
- */
-
-const EXCLUDED_CALL = ['$deepScan', 'console.info', 'console.warn', 'console.error', '$i8n', 'console.log', '$t', 'require', '$$i8n', '$$t', '_createCommentVNode'];
-/**
- * 默认插件配置选项
- */
-const DEFAULT_OPTION = {
-  appCode: '',
-  /** 是否启用插件，默认启用 */
-  enabled: true,
-  /** 翻译调用函数，默认为 $t */
-  translateKey: '$t',
-  /** 标记不翻译调用函数列表，避免某些调用被错误翻译 */
-  excludedCall: [],
-  /** 标记不用翻译的字符串模式数组，默认是匹配文件扩展名 */
-  excludedPattern: [/\.\w+$/],
-  /** 排查不需要翻译的目录下的文件路径（黑名单）, 默认不处理node_modules */
-  excludedPath: ['node_modules'],
-  /** 指定需要翻译文件的目录路径正则（白名单） */
-  includePath: [/src\//, /src\\/],
-  /** 配置文件生成位置，默认为 './lang' */
-  globalPath: './lang',
-  /** 打包后生成文件的位置，例如 './dist/assets' */
-  distPath: '',
-  /** 打包后生成文件的主文件名称，默认是 'index' */
-  distKey: 'index',
-  /** 来源语言，默认是中文 */
-  originLang: OriginLangKeyEnum.ZH,
-  /** 翻译目标语言列表，默认包含英文 */
-  targetLangList: ['en'],
-  /** 语言key，用于请求谷歌api和生成配置文件下对应语言的内容文件 */
-  langKey: [],
-  /** 命名空间，防止全局命名冲突 */
-  namespace: 'lang',
-  /** 单位代码 */
-  orgCode: 'GREENCLOUD',
-  /** 是否启用源码的值作为key */
-  useValueAsKey: false,
-  /** 是否在构建结束之后将最新的翻译重新打包到主包中，默认不打包 */
-  buildToDist: false,
-  /** 是否启用上传翻译文件到服务器，默认开启 */
-  uploadEnabled: true,
-  /** 翻译器，决定自动翻译使用的api与调用方式，默认使用 Google 翻译器并使用7890(clash)端口代理 */
-  translator: new GoogleTranslator({
-    proxyOption: {
-      port: 7890,
-      host: '127.0.0.1',
-      headers: {
-        'User-Agent': 'Node'
-      }
-    }
-  }),
-  /** 翻译器配置选项，优先级低于translator */
-  translatorOption: undefined,
-  /**
-   * 翻译类型，支持全自动和半自动两种模式
-   * 全自动：所有翻译任务自动完成
-   * 半自动：需要人工标识，类似于 $t('key') 的方式
-   * 默认值为全自动
-   */
-  translateType: TranslateTypeEnum.FULL_AUTO,
-  /**
-   * 是否重写配置文件，默认为true
-   */
-  rewriteConfig: true,
-  /**
-   * 通用翻译key，默认使用namespace，如果commonTranslateKey不为空，则使用commonTranslateKey
-   */
-  commonTranslateKey: '',
-  /**
-   * 实验性属性，表示是否进行深层扫描字符串，默认为 false
-   * 当设置为 true 时，会对代码中的字符串进行更深入的扫描
-   */
-  deepScan: false,
-  /**
-   * 自定义文件拓展名数组
-   */
-  insertFileExtensions: [],
-  /**
-   * 自定义拓展类，插件默认翻译函数挂载在window上，如果希望自定义翻译函数挂载在其他对象上，可以使用该属性
-   * 注意：该属性需要继承BaseExtends类，并且需要实现handleInitFile和handleCodeCall和handleCodeString方法
-   */
-  translateExtends: null,
-  isClear: false,
-  // 是否清除已经不在上下文中的内容（清除项目中不再使用到的源语言键值对）
-
-  /**
-   * 是否保留空格
-   */
-  isClearSpace: true
-};
-
-/**
- * 类型定义：插件配置选项类型
- */
-
-/**
- * 全局插件配置实例，复制自默认配置
- */
-exports.option = {
-  ...DEFAULT_OPTION
-};
-
-/**
- * 类型定义：用户传入的配置选项
- */
-
-/**
- * 通过深度克隆提供的选项信息生成一个用户选项对象，
- * 确保原始配置不被修改。它还根据用户的配置初始化翻译器。
- * @param optionInfo - 包含用户选项和翻译器细节的选项信息。
- * @returns 一个新的、可能已初始化翻译器的用户选项对象。
- */
-function generateUserOption(optionInfo) {
-  // 深拷贝用户传入的配置，防止修改原配置对象
-  const userOption = cloneDeep(optionInfo);
-  userOption.translator = optionInfo?.translator;
-
-  // 如果用户配置了translatorOption则初始化translator，如果都没有则不设置translator
-  userOption.translator ||= userOption.translatorOption ? new Translator(userOption.translatorOption) : undefined;
-  if (!userOption.translator) delete userOption.translator;
-  return userOption;
-}
-
-/**
- * 初始化插件配置选项
- * @param optionInfo 用户提供的配置选项
- */
-function initOption(optionInfo) {
-  // 合并默认配置和用户配置
-  exports.option = {
-    ...DEFAULT_OPTION,
-    ...generateUserOption(optionInfo)
-  };
-
-  // 初始化语言key数组，包含来源语言和目标语言
-  exports.option.langKey = [exports.option.originLang, ...exports.option.targetLangList];
-  // 初始化排除调用函数列表，包含默认排除和调用函数主动排除
-  exports.option.excludedCall = [...exports.option.excludedCall, ...EXCLUDED_CALL, ...[exports.option.translateKey, '$' + exports.option.translateKey]];
-  return exports.option;
-}
-
-/**
- * 校验插件配置选项是否完整有效
- * @returns {boolean} 校验结果，完整返回 true，否则返回 false
- */
-function checkOption() {
-  // 校验翻译调用函数是否配置
-  if (!exports.option.translateKey) {
-    console.error('❌请配置翻译调用函数');
-    return false;
-  }
-
-  // 校验命名空间是否配置
-  if (!exports.option.namespace) {
-    console.error('❌请配置命名空间');
-    return false;
-  }
-
-  // 校验是否配置了打包后生成文件的主文件名称（如果需要打包到主包中）
-  if (exports.option.buildToDist && !exports.option.distKey) {
-    console.log('❌请配置打包后生成文件的主文件名称');
-    return false;
-  }
-
-  // 校验是否配置了打包后生成文件的位置（如果需要打包到主包中）
-  if (exports.option.buildToDist && !exports.option.distPath) {
-    console.log('❌请配置打包后生成文件的位置');
-    return false;
-  }
-
-  // 校验来源语言是否配置
-  if (!exports.option.originLang) {
-    console.error('❌请配置来源语言');
-    return false;
-  }
-
-  // 校验目标翻译语言数组是否配置
-  if (!exports.option.targetLangList || !exports.option.targetLangList.length) {
-    console.error('❌请配置目标翻译语言数组');
-    return false;
-  }
-
-  // 如果所有校验通过，返回 true
-  return true;
-}
-
-var allLanguage = [{
-  code: 'zh-CN',
-  name: '简体中文'
-}, {
-  code: 'zh-TW',
-  name: '繁体中文'
-}, {
-  code: 'zh-UG',
-  name: '维吾尔语'
-}, {
-  code: 'en-US',
-  name: '英文'
-}, {
-  code: 'tr-TR',
-  name: '土耳其语'
-}, {
-  code: 'es-ES',
-  name: '西班牙语'
-}, {
-  code: 'ja-JP',
-  name: '日语'
-}, {
-  code: 'ru-RU',
-  name: '俄语'
-}, {
-  code: 'fr-FR',
-  name: '法语'
-}, {
-  code: 'de-DE',
-  name: '德语'
-}, {
-  code: 'pt-BR',
-  name: '巴西葡萄牙语'
-}, {
-  code: 'pt-PT',
-  name: '葡萄牙语'
-}, {
-  code: 'ko-KR',
-  name: '韩语'
-}, {
-  code: 'vi-VN',
-  name: '越南语'
-}, {
-  code: 'sv-SE',
-  name: '瑞典语'
-}, {
-  code: 'id-ID',
-  name: '印尼语'
-}, {
-  code: 'uk-UA',
-  name: '乌克兰语'
-}, {
-  code: 'it-IT',
-  name: '意大利语'
-}, {
-  code: 'th-TH',
-  name: '泰语'
-}, {
-  code: 'hi-IN',
-  name: '印地语'
-}, {
-  code: 'fa-IR',
-  name: '波斯语'
-}, {
-  code: 'ro-RO',
-  name: '罗马尼亚语'
-}, {
-  code: 'el-GR',
-  name: '希腊语'
-}, {
-  code: 'nl-NL',
-  name: '荷兰语'
-}, {
-  code: 'cs-CZ',
-  name: '捷克语'
-}, {
-  code: 'mn-MN',
-  name: '蒙古语'
-}, {
-  code: 'mn-TR',
-  name: '传统蒙古语'
-}, {
-  code: 'fi-FI',
-  name: '芬兰语'
-}, {
-  code: 'ar-SA',
-  name: '阿拉伯语'
-}, {
-  code: 'ar-EG',
-  name: '阿拉伯语-埃及'
-}, {
-  code: 'da-DK',
-  name: '丹麦语'
-}, {
-  code: 'pl-PL',
-  name: '波兰语'
-}, {
-  code: 'nb-NO',
-  name: '挪威语'
-}, {
-  code: 'si-LK',
-  name: '僧伽罗语'
-}];
-
-/**
- * JSON 格式化配置类型
- */
-
-// 默认的缩进配置
-const indentConfig = {
-  tab: {
-    char: '\t',
-    size: 1
-  },
-  space: {
-    char: ' ',
-    size: 4
+  // 再遍历一次，把不符合separatorRegex 这个正则的拼起来
+  const finalResult = [];
+  let tempStr = '';
+  for (let i = 0; i < result.length; i++) {
+    const item = result[i];
+    if (separatorRegex.test(item)) {
+      if (tempStr) {
+        finalResult.push(tempStr);
+        tempStr = '';
+      }
+      finalResult.push(item);
+    } else {
+      tempStr += item;
+      if (i === result.length - 1 || separatorRegex.test(result[i + 1])) {
+        finalResult.push(tempStr);
+        tempStr = '';
+      }
+    }
   }
-};
-
-// 默认格式化配置
-const configDefault = {
-  type: 'tab'
-};
-
-// 临时存储替换字符串的数组
-let placeholderStorage = [];
-
-// 临时存储处理函数
-const pushPlaceholder = match => `\\${placeholderStorage.push(match)}\\`;
-const popPlaceholder = (_match, index) => placeholderStorage[+index - 1];
-
-// 生成缩进字符
-const generateIndentation = (count, indentType) => {
-  return new Array(count + 1).join(indentType);
-};
+  if (tempStr) {
+    finalResult.push(tempStr);
+  }
+  return finalResult;
+}
 
 /**
- * 格式化 JSON 字符串
- * @param json JSON 字符串
- * @param indentType 缩进类型
- * @returns 格式化的 JSON 字符串
+ * 检查字符串是否需要切割。
+ * @param str - 要检查的字符串。
+ * @returns 如果字符串需要切割，则返回 true，否则返回 false。
  */
-function formatJSON(json, indentType) {
-  placeholderStorage = [];
-  let output = '';
-  let indentLevel = 0;
-
-  // 提取反斜杠和字符串
-  json = json.replace(/\\./g, pushPlaceholder) // 处理反斜杠
-  .replace(/(".*?"|'.*?')/g, pushPlaceholder) // 处理字符串
-  .replace(/\s+/g, ''); // 去除多余空格
-
-  // 根据 JSON 内容添加换行和缩进
-  for (let i = 0; i < json.length; i++) {
-    const char = json.charAt(i);
-    switch (char) {
-      case '{':
-      case '[':
-        output += char + '\n' + generateIndentation(++indentLevel, indentType);
-        break;
-      case '}':
-      case ']':
-        output += '\n' + generateIndentation(--indentLevel, indentType) + char;
-        break;
-      case ',':
-        output += ',\n' + generateIndentation(indentLevel, indentType);
-        break;
-      case ':':
-        output += ': ';
-        break;
-      default:
-        output += char;
-        break;
-    }
-  }
-
-  // 去除数字数组的空格，并还原反斜杠和字符串
-  output = output.replace(/\[[\d,\s]+?\]/g, match => match.replace(/\s/g, '')).replace(/\\(\d+)\\/g, popPlaceholder) // 还原填充数据
-  .replace(/\\(\d+)\\/g, popPlaceholder); // 再次还原填充数据
-
-  return output;
+function checkNeedSplit(str) {
+  // 检查字符串中是否包含需要切割的特殊字符
+  return str.includes('\n') || str.includes('\\') || str.includes('\r') || str.includes('\t') || str.includes('\v') || str.includes('\f') || str.includes('>') || str.includes('<');
 }
 
 /**
- * 格式化 JSON 的主函数
- * @param json 需要格式化的 JSON 对象或字符串
- * @param config 配置选项
- * @returns 格式化后的 JSON 字符串
+ * @description: 将字符串数组转换为babel的模板字符串节点
+ * @param {string[]} strArray - 字符串数组
+ * @return {types.CallExpression} - babel的深度扫描的表达式
  */
-function jsonFormatter(json) {
-  let config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : configDefault;
-  // 确保输入是 JSON 字符串
-  const jsonString = typeof json === 'string' ? json : JSON.stringify(json);
-
-  // 获取缩进配置
-  const indent = indentConfig[config.type];
-  if (!indent) {
-    throw new Error(`Unrecognized indent type: "${config.type}"`);
+function convertToTemplateLiteral(strArray, option) {
+  const quasis = [];
+  const expressions = [];
+  strArray.forEach((str, index) => {
+    if (index === 0) {
+      if (getOriginRegex().test(str)) {
+        quasis.push(types__namespace.templateElement({
+          raw: '',
+          cooked: ''
+        }, false));
+        expressions.push(createI18nTranslator({
+          value: str,
+          isExpression: true,
+          insertOption: option
+        }));
+      } else {
+        quasis.push(types__namespace.templateElement({
+          raw: str,
+          cooked: str
+        }, false));
+      }
+    } else {
+      if (getOriginRegex().test(str)) {
+        expressions.push(createI18nTranslator({
+          value: str,
+          isExpression: true,
+          insertOption: option
+        }));
+      } else {
+        quasis.push(types__namespace.templateElement({
+          raw: str,
+          cooked: str
+        }, false));
+      }
+    }
+  });
+  if (quasis.length === expressions.length) {
+    quasis.push(types__namespace.templateElement({
+      raw: '',
+      cooked: ''
+    }, true));
+  } else if (quasis.length > expressions.length) {
+    quasis[quasis.length - 1].tail = true;
   }
+  const templateLiteral = types__namespace.templateLiteral(quasis, expressions);
+  const deepScanCall = types__namespace.callExpression(types__namespace.identifier('$deepScan'), [templateLiteral]);
+  // 打印转换结果
+  // console.log('deepScanCall', (generate as any).default(deepScanCall).code)
+  return deepScanCall;
+}
 
-  // 生成缩进字符
-  const indentType = generateIndentation(config.size || indent.size, indent.char);
-
-  // 格式化 JSON 字符串
-  return formatJSON(jsonString, indentType);
+// 上传到远程服务器
+// import { getAppCode, saveConfig, convertToUploadJson } from './config.js'
+async function upload(json) {
+  const {
+    appCode,
+    targetLangList
+  } = exports.option;
+  let data = [];
+  _.map(json, (value, key) => {
+    _.map(targetLangList, item => {
+      const parts = item.split('-');
+      const lang = parts[0] + '-' + parts[1].toUpperCase();
+      data.push({
+        page: 'common',
+        key,
+        lang,
+        value: _.get(value, item, key)
+      });
+    });
+  });
+  const res = await axios.post('http://192.168.0.104:8108/i18n-web/kv_translate/batch', {
+    appCode,
+    data
+  }, {
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: '728635D658AE11F18F33000C29A621CA'
+    }
+  });
+  if (res.status === 200 && res.data.result === 0) {
+    console.info('上传翻译服务成功✔');
+  } else {
+    console.error('上传翻译服务失败❌');
+    console.log(`请求数据为:`, JSON.stringify(data));
+    console.log(`返回报错信息为:`, res.data);
+  }
 }
 
+var upload$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    upload: upload
+});
+
 /**
  * @description: 新建国际化配置文件夹
  * @return {*}
@@ -1605,6 +1313,32 @@ var file = /*#__PURE__*/Object.freeze({
 const SEPARATOR = '\n┇┇┇\n';
 const SPLIT_SEPARATOR_REGEX = /\n┇ *┇ *┇\n/;
 let langObj = {};
+function getLangKeyByValue(value) {
+  return Object.entries(langObj).find(_ref => {
+    let [, oldValue] = _ref;
+    return oldValue === value;
+  })?.[0];
+}
+function resolveLangKey(key, value) {
+  return getLangKeyByValue(value) || key;
+}
+function isTemplateValue(value) {
+  return /\$\{[^}]+}/.test(value);
+}
+function getTemplateStaticSegments(value) {
+  return value.split(/\$\{[^}]+}/g).filter(item => item);
+}
+function isTemplateStaticSegment(value) {
+  return Object.values(langObj).some(oldValue => isTemplateValue(oldValue) && getTemplateStaticSegments(oldValue).includes(value));
+}
+function removeTemplateStaticSegments(value) {
+  const segments = new Set(getTemplateStaticSegments(value));
+  Object.keys(langObj).forEach(key => {
+    if (segments.has(langObj[key])) {
+      delete langObj[key];
+    }
+  });
+}
 
 /**
  * @description: 设置翻译对象属性
@@ -1613,6 +1347,15 @@ let langObj = {};
  * @return {*}
  */
 function setLangObj(key, value) {
+  if (isTemplateValue(value)) {
+    removeTemplateStaticSegments(value);
+  } else if (isTemplateStaticSegment(value)) {
+    return;
+  }
+  const existingKey = getLangKeyByValue(value);
+  if (existingKey && existingKey !== key) {
+    return;
+  }
   if (!langObj[key]) {
     langObj[key] = value;
   }
@@ -1632,7 +1375,7 @@ function getLangObj() {
  * @return {*}
  */
 function initLangObj(obj) {
-  if (!Object.keys(langObj)) {
+  if (!Object.keys(langObj).length) {
     langObj = obj;
   }
 }
@@ -1676,7 +1419,6 @@ async function autoTranslate() {
 
   // 无新内容提前退出
   if (Object.keys(transLangObj).length === 0) {
-    console.info('✅ 当前没有需要翻译的新内容');
     return;
   }
 
@@ -1814,378 +1556,684 @@ async function completionTranslateAndWriteConfigFile(langObj, curLangObj, transl
   } catch (error) {
     console.error('❌JSON配置文件写入失败' + error);
   }
-  console.info('新增语言翻译补全成功⭐️⭐️⭐️');
+  console.info('新增语言翻译补全成功⭐️⭐️⭐️');
+}
+
+// 分块翻译流程函数
+async function translateChunks(transLangObj, translateKey) {
+  const {
+    translator
+  } = exports.option;
+  const placeholders = [];
+  const protectedValues = Object.values(transLangObj).map(value => protectInterpolationPlaceholders(value, placeholders));
+  // 获取分块后的文本列表
+  const translationChunks = createTextSplitter(protectedValues, translator.option.maxChunkSize);
+  // 并行执行分块翻译
+  const translatePromises = [];
+  for (let i = 0; i < translationChunks.length; i++) {
+    translatePromises.push(translator.translate(translationChunks[i], exports.option.originLang, translateKey, SEPARATOR));
+  }
+
+  // 等待所有分块完成并合并结果
+  const chunkResults = await Promise.all(translatePromises);
+  return chunkResults.map(item => {
+    item = restoreInterpolationPlaceholders(item, placeholders);
+    // 提取分割逻辑到单独的函数中，提高代码复用性
+    const splitTranslation = (text, separatorRegex) => {
+      return text.split(separatorRegex).map(v => v.trim());
+    };
+
+    // 分割符可能会被翻译，所以这里做了兼容处理
+    if (SPLIT_SEPARATOR_REGEX.test(item)) {
+      return splitTranslation(item, SPLIT_SEPARATOR_REGEX);
+    } else {
+      const lines = item.split('\n');
+      const separator = lines.find(line => line.length === 3);
+      let value = [];
+      if (separator) {
+        value = splitTranslation(item, new RegExp(`\\n${separator}\\n`));
+      }
+      const realList = value.filter(Boolean);
+      if (realList.length > 1) {
+        return realList;
+      }
+      return splitTranslation(item, SPLIT_SEPARATOR_REGEX);
+    }
+  }).flat();
+}
+function protectInterpolationPlaceholders(value, placeholders) {
+  return value.replace(/\$\{[^}]*\}/g, match => {
+    const index = placeholders.push(match) - 1;
+    return `__GC_I18N_PH_${index}__`;
+  });
+}
+function restoreInterpolationPlaceholders(value, placeholders) {
+  return value.replace(/__GC_I18N_PH_(\d+)__/g, (match, index) => {
+    return placeholders[Number(index)] || match;
+  });
+}
+/**
+ * @description: 清理多余的翻译配置JSON文件
+ * @return {void} 无返回值
+ */
+function cleanupUnusedTranslations() {
+  if (!exports.option.isClear) return;
+  console.log('🧹 进入清理流程');
+  // 获取当前的语言对象，如果不存在则使用空对象
+  const langObj = getLangObj() || {};
+
+  // 创建一个Set用于存储当前语言对象的所有key，便于快速查找
+  let langSet = new Set(Object.keys(langObj));
+
+  // 获取基础对象：优先使用传入的insertObj，否则从翻译文件中读取
+  const baseObj = JSON.parse(getLangTranslateJSONFile());
+
+  // 获取基础对象的所有key
+  const baseObjKeys = Object.keys(baseObj);
+  // 遍历所有key，删除在当前语言对象中不存在的配置
+  baseObjKeys.forEach(key => {
+    if (!langSet.has(key)) {
+      baseObj[key] && delete baseObj[key];
+    }
+  });
+  setLangTranslateJSONFile(baseObj);
+}
+
+var translate = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    SEPARATOR: SEPARATOR,
+    SPLIT_SEPARATOR_REGEX: SPLIT_SEPARATOR_REGEX,
+    autoTranslate: autoTranslate,
+    cleanupUnusedTranslations: cleanupUnusedTranslations,
+    completionTranslateAndWriteConfigFile: completionTranslateAndWriteConfigFile,
+    getLangKeyByValue: getLangKeyByValue,
+    getLangObj: getLangObj,
+    initLangObj: initLangObj,
+    get langObj () { return langObj; },
+    languageConfigCompletion: languageConfigCompletion,
+    resolveLangKey: resolveLangKey,
+    setLangObj: setLangObj
+});
+
+/*
+ * @Author: xiaoshanwen
+ * @Date: 2023-10-11 10:01:43
+ * @LastEditTime: 2025-03-28 19:07:17
+ * @FilePath: /i18n_translation_vite/packages/autoI18nPluginCore/src/utils/base.ts
+ */
+function getOriginRegex() {
+  const originLang = FunctionFactoryOption.originLang;
+  return REGEX_MAP[originLang];
+}
+
+/**
+ * @description: 是否包含来源语言字符
+ * @param {string} code
+ * @return {*}
+ */
+function hasOriginSymbols(code) {
+  return getOriginRegex().test(code);
+}
+
+/**
+ * @description: 过滤注释
+ * @param {string} code
+ * @return {*}
+ */
+const removeComments = function (code) {
+  // 使用正则表达式匹配并删除单行注释
+  code = code.replace(/\/\/.*?\n/g, '');
+  // 使用正则表达式匹配并删除多行注释
+  code = code.replace(/\/\*[\s\S]*?\*\//g, '');
+  // 使用正则表达式匹配并删除HTML注释
+  code = code.replace(/<!--[\s\S]*?-->/g, '');
+  return code;
+};
+
+/**
+ * @description: 用于判断提供的值是否符合正则表达式数组中的任一规则，符合则跳过
+ * @param {*} value
+ * @param {*} regexArray
+ * @return {*}
+ */
+function checkAgainstRegexArray(value, regexArray) {
+  for (let i = 0; i < regexArray.length; i++) {
+    const regex = typeof regexArray[i] === 'string' ? new RegExp(regexArray[i]) : regexArray[i];
+    if (regex.test(value)) {
+      return true; // 如果符合任何一个规则，返回 true
+    }
+  }
+  return false; // 如果所有规则都不符合，返回 false
+}
+
+/**
+ * @description: 用于解析抽象语法树中的调用表达式，并提取出调用的名称，如a.b.c() 取 c。
+ * @param {any} node
+ * @return {*}
+ */
+function extractFunctionName(node) {
+  let callName = '';
+  function callObjName(callObj, name) {
+    name += '.' + callObj.property.name;
+    if (types.isMemberExpression(callObj.object)) {
+      // isMemberExpression： 是否是成员表达式
+      return callObjName(callObj.object, name);
+    }
+    name = callObj.object.name + name;
+    return name;
+  }
+  if (types.isCallExpression(node)) {
+    // isCallExpression： 是否是调用表达式
+    if (types.isMemberExpression(node.callee)) {
+      callName = callObjName(node.callee, '');
+    } else {
+      callName = node.callee.name || '';
+    }
+  }
+  return callName;
+}
+
+/**
+ * @description: 提取文件的中文部分
+ * @param {string} fileContent
+ * @return {*}
+ */
+const extractCnStrings = fileContent => {
+  const regex = /[^\x00-\xff]+/g;
+  return extractStrings(fileContent, regex);
+};
+
+/**
+ * @description: 提取文件指定部分内容
+ * @param {string} fileContent
+ * @param {any} regex
+ * @return {*}
+ */
+function extractStrings(fileContent, regex) {
+  const matches = fileContent.match(regex);
+  return matches ? matches.filter((item, index) => matches.indexOf(item) === index) : [];
+}
+
+/**
+ * @description: 生成i8n翻译函数
+ * @param {string} value
+ * @param {boolean} isExpression
+ * @param {string} key
+ * @return {*}
+ */
+function createI18nTranslator(createOption) {
+  const {
+    value,
+    isExpression = false,
+    key,
+    insertOption
+  } = createOption;
+
+  // 从全局配置对象 option 中获取命名空间
+  const nameSpace = exports.option.namespace;
+  const {
+    trimmedValue,
+    valStr
+  } = normalizeTranslateValue(value);
+  // 若 key 存在则使用 key，否则调用 generateId 函数根据 valStr 生成唯一的键
+  const generatedKey = key || resolveLangKey(generateId(valStr), trimmedValue);
+  // 提取公共配置对象，避免重复代码
+  const config = {
+    option: exports.option,
+    hash: generatedKey,
+    value: trimmedValue,
+    uncodeValue: valStr,
+    namespace: nameSpace
+  };
+  if (exports.option.translateExtends) {
+    const {
+      handleCodeCall,
+      handleCodeString
+    } = exports.option.translateExtends;
+    return isExpression ? handleCodeCall(config, insertOption) : handleCodeString(config, insertOption);
+  }
+  if (isExpression) {
+    const valueExp = types.stringLiteral(trimmedValue);
+    valueExp.extra = {
+      raw: `'${valStr}'`,
+      // 防止转码为unicode
+      rawValue: trimmedValue
+    };
+    return exports.option.useValueAsKey ? types.callExpression(types.identifier(exports.option.translateKey), [valueExp]) : types.callExpression(types.identifier(exports.option.translateKey), [types.stringLiteral(generatedKey), valueExp]);
+  } else {
+    return `${exports.option.translateKey}('${generatedKey}','${valStr}')`;
+  }
+}
+function normalizeTranslateValue(value) {
+  const trimmedValue = exports.option.isClearSpace ? value : value.trim();
+  const valStr = trimmedValue.replace(/'/g, '"').replace(/(\n)/g, '\\n');
+  return {
+    trimmedValue,
+    valStr
+  };
 }
 
-// 分块翻译流程函数
-async function translateChunks(transLangObj, translateKey) {
-  const {
-    translator
-  } = exports.option;
-  // 获取分块后的文本列表
-  const translationChunks = createTextSplitter(Object.values(transLangObj), translator.option.maxChunkSize);
-  // 并行执行分块翻译
-  const translatePromises = [];
-  for (let i = 0; i < translationChunks.length; i++) {
-    translatePromises.push(translator.translate(translationChunks[i], exports.option.originLang, translateKey, SEPARATOR));
+/**
+ * @description: 生成唯一id
+ * @param {string} key
+ * @return {*}
+ */
+function generateId(key) {
+  let hash = 0;
+  for (let i = 0; i < key.length; i++) {
+    const charCode = key.charCodeAt(i);
+    hash = (hash << 5) - hash + charCode;
+    hash = hash & hash;
   }
+  const id = Math.abs(hash).toString(36) + key.length.toString(36);
+  return id;
+}
 
-  // 等待所有分块完成并合并结果
-  const chunkResults = await Promise.all(translatePromises);
-  return chunkResults.map(item => {
-    // 提取分割逻辑到单独的函数中，提高代码复用性
-    const splitTranslation = (text, separatorRegex) => {
-      return text.split(separatorRegex).map(v => v.trim());
-    };
+/**
+ * @description: unicode转普通字符串
+ * @param {string} str
+ * @return {*}
+ */
+const unicodeToString = str => {
+  return str.replace(/\\u[\dA-Fa-f]{4}/g, match => {
+    return String.fromCharCode(parseInt(match.replace(/\\u/g, ''), 16));
+  });
+};
 
-    // 分割符可能会被翻译，所以这里做了兼容处理
-    if (SPLIT_SEPARATOR_REGEX.test(item)) {
-      return splitTranslation(item, SPLIT_SEPARATOR_REGEX);
-    } else {
-      const lines = item.split('\n');
-      const separator = lines.find(line => line.length === 3);
-      let value = [];
-      if (separator) {
-        value = splitTranslation(item, new RegExp(`\\n${separator}\\n`));
-      }
-      const realList = value.filter(Boolean);
-      if (realList.length > 1) {
-        return realList;
-      }
-      return splitTranslation(item, SPLIT_SEPARATOR_REGEX);
-    }
-  }).flat();
-}
 /**
- * @description: 清理多余的翻译配置JSON文件
- * @return {void} 无返回值
+ * @description: 有道翻译 标识截取
+ * @param {string} q
+ * @return {*}
  */
-function cleanupUnusedTranslations() {
-  if (!exports.option.isClear) return;
-  console.log('🧹 进入清理流程');
-  // 获取当前的语言对象，如果不存在则使用空对象
-  const langObj = getLangObj() || {};
+function truncate(q) {
+  // 检查输入字符串的长度
+  if (q.length <= 20) {
+    // 如果长度小于等于20，直接返回原字符串
+    return q;
+  } else {
+    // 如果长度大于20，截取前10个字符和后10个字符，并在中间插入长度信息
+    const len = q.length;
+    return q.substring(0, 10) + len + q.substring(len - 10);
+  }
+}
 
-  // 创建一个Set用于存储当前语言对象的所有key，便于快速查找
-  let langSet = new Set(Object.keys(langObj));
+// 导出一个深拷贝函数，用于克隆对象
+function cloneDeep(value) {
+  let cache = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new WeakMap();
+  // 处理基本类型和 null
+  if (typeof value !== 'object' || value === null) {
+    return value;
+  }
 
-  // 获取基础对象：优先使用传入的insertObj，否则从翻译文件中读取
-  const baseObj = JSON.parse(getLangTranslateJSONFile());
+  // 处理循环引用
+  if (cache.has(value)) {
+    return cache.get(value);
+  }
 
-  // 获取基础对象的所有key
-  const baseObjKeys = Object.keys(baseObj);
-  // 遍历所有key，删除在当前语言对象中不存在的配置
-  baseObjKeys.forEach(key => {
-    if (!langSet.has(key)) {
-      baseObj[key] && delete baseObj[key];
-    }
-  });
-  setLangTranslateJSONFile(baseObj);
+  // 处理特殊对象类型
+  if (value instanceof Date) {
+    return new Date(value);
+  }
+  if (value instanceof RegExp) {
+    return new RegExp(value.source, value.flags);
+  }
+
+  // 初始化克隆容器
+  const clone = Array.isArray(value) ? [] : {};
+
+  // 缓存对象防止循环引用
+  cache.set(value, clone);
+
+  // 处理 Symbol 和普通键的枚举
+  const keys = [...Object.keys(value), ...Object.getOwnPropertySymbols(value).filter(sym => value.propertyIsEnumerable(sym))];
+
+  // 递归克隆属性
+  for (const key of keys) {
+    clone[key] = cloneDeep(value[key], cache);
+  }
+  return clone;
 }
 
-var translate = /*#__PURE__*/Object.freeze({
+var base = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    SEPARATOR: SEPARATOR,
-    SPLIT_SEPARATOR_REGEX: SPLIT_SEPARATOR_REGEX,
-    autoTranslate: autoTranslate,
-    cleanupUnusedTranslations: cleanupUnusedTranslations,
-    completionTranslateAndWriteConfigFile: completionTranslateAndWriteConfigFile,
-    getLangObj: getLangObj,
-    initLangObj: initLangObj,
-    get langObj () { return langObj; },
-    languageConfigCompletion: languageConfigCompletion,
-    setLangObj: setLangObj
+    checkAgainstRegexArray: checkAgainstRegexArray,
+    cloneDeep: cloneDeep,
+    createI18nTranslator: createI18nTranslator,
+    extractCnStrings: extractCnStrings,
+    extractFunctionName: extractFunctionName,
+    extractStrings: extractStrings,
+    generateId: generateId,
+    getOriginRegex: getOriginRegex,
+    hasOriginSymbols: hasOriginSymbols,
+    normalizeTranslateValue: normalizeTranslateValue,
+    removeComments: removeComments,
+    truncate: truncate,
+    unicodeToString: unicodeToString
 });
 
-/*
- * @Date: 2025-02-17 17:11:26
- * @LastEditors: xiaoshan
- * @LastEditTime: 2025-02-17 18:00:37
- * @FilePath: /i18n_translation_vite/packages/autoI18nPluginCore/src/utils/chunk.ts
- */
-
+// 代码灵感来自https://github.com/dadidi9900/auto-plugins-json-translate/blob/main/src/services/translationService.ts
 /**
- * 智能文本分块处理器
- * @param values 待分块的原始文本数组
- * @param maxChunkSize 最大分块长度
- * @returns 包含分块文本和重组方法的对象
- *
- * 功能特性：
- * 1. 自动合并小文本为最大可能块
- * 2. 处理超长文本并给出警告
- * 3. 保证块长度不超过限制
- * 4. 保留原始顺序和分隔符语义
+ * 火山引擎翻译器，内置豆包、deepseek等模型
+ * 
+ * 火山引擎大模型介绍：https://www.volcengine.com/docs/82379/1099455
+ * 
+ * api文档：https://www.volcengine.com/docs/82379/1298454
+ * 
+ * 使用方式：
+ * ```ts
+ * vitePluginsAutoI18n({
+    ...
+    translator: new VolcengineTranslator({
+        apiKey: '你申请的apiKey',
+        model: '你要调用的模型，如：`doubao-1-5-pro-32k-250115`，请确保使用前已在控制台开通了对应模型'
+    })
+})
+ * ```
  */
-function createTextSplitter(values, maxChunkSize) {
-  // 分隔符定义（用于合并/拆分时保持语义）
-  const SEP_LENGTH = SEPARATOR.length;
-
-  // 结果存储和缓冲区
-  const result = []; // 最终分块结果
-  let buffer = []; // 当前累积块缓冲区
-  let currentSize = 0; // 当前缓冲区字符数（含分隔符）
-
-  /**
-   * 提交缓冲区内容到结果集
-   * - 将缓冲区内容用分隔符连接
-   * - 重置缓冲区和计数器
-   */
-  const commitBuffer = () => {
-    if (buffer.length > 0) {
-      // 计算实际连接长度用于验证
-      const actualLength = buffer.join(SEPARATOR).length;
-      if (actualLength > maxChunkSize) {
-        console.warn(`缓冲区提交异常：生成块长度 ${actualLength} 超过限制`);
-      }
-      result.push(buffer.join(SEPARATOR));
-      buffer = [];
-      currentSize = 0;
-    }
-  };
-
-  // 主处理循环：遍历所有原始文本项
-  for (const value of values) {
-    // 计算需要新增的空间：文本长度 + 分隔符（非首项）
-    const neededSpace = value.length + (buffer.length > 0 ? SEP_LENGTH : 0);
-
-    // ─── 超长文本处理策略 ───
-    if (value.length > maxChunkSize) {
-      // 优先提交现有缓冲区内容
-      if (buffer.length > 0) commitBuffer();
-
-      /**
-       * 超长文本处理逻辑：
-       * - 长度超过1.5倍限制时发出强警告
-       * - 强制单独成块（即使超过限制）
-       * - 后续需要特殊处理这些异常块
-       */
-      if (value.length > maxChunkSize * 1.5) {
-        console.warn(`超长文本告警：检测到长度 ${value.length} 字符的文本项，可能影响翻译质量`);
-      }
-      // 结果直接新增一个超长文本
-      result.push(value);
-      continue;
-    }
+class VolcengineTranslator extends Translator {
+  constructor(option) {
+    super({
+      name: '火山引擎ai翻译',
+      fetchMethod: async (text, fromKey, toKey, separator) => {
+        let salt = new Date().getTime();
+        const textArr = text.split(separator);
+        const sourceMap = Object.fromEntries(textArr.map(text => [generateId(text), text]));
+        const data = {
+          model: option.model,
+          messages: [{
+            role: 'system',
+            content: `
+                                ###
+                                假如你是一个无情的翻译接口，你将根据一个文本组成的JSON对象，来解决将数组每个成员从源语言A翻译成目标语言B并返回翻译后的JSON对象的任务。需要注意的是，待翻译的文本均来自一个${option.desc ? option.desc + '的' : ''}web平台，遇到歧义时需要做好处理。根据以下规则一步步执行：
+                                1. 明确源语言A和目标语言B。
+                                2. 对JSON对象中数组的每个成员进行从源语言A到目标语言B的翻译。
+                                3. 将翻译后的内容以JSON对象格式返回，确保返回的内容可以被JSON.parse解析。
 
-    // ─── 正常分块逻辑 ───
-    // 空间不足时提交当前缓冲区
-    if (currentSize + neededSpace > maxChunkSize) {
-      commitBuffer();
-    }
+                                参考例子：
+                                示例1：
+                                输入：zh-cn -> en { "awfgx": "你好", "qwfga": "世界" }
+                                输出：{ "awfgx": "Hello", "qwfga": "World" }
 
-    // 更新缓冲区状态（累加长度需包含分隔符）
-    currentSize += neededSpace;
-    buffer.push(value);
-  }
+                                示例2：
+                                输入：de -> fr { "gweaq": "Hallo", "wtrts": "Welt" }
+                                输出：{ "gweaq": "Bonjour", "wtrts": "Monde" }
 
-  // 提交最终未完成的缓冲区内容
-  commitBuffer();
+                                请回答问题：
+                                输入：源语言A -> 目标语言B { "wghhj": "XXX" }
+                                输出：
 
-  // 返回分块结果
-  return result;
+                                要求：
+                                1 以JSON对象格式输出
+                                2 JSON对象中每个成员为翻译后的内容
+                                ###
+                            `
+          }, {
+            role: 'user',
+            content: `${fromKey} -> ${toKey} ${JSON.stringify(sourceMap)}`
+          }],
+          ...(option.insertOption || {})
+        };
+        const response = await axios.post(`https://ark.cn-beijing.volces.com/api/v3/chat/completions?t=${salt}`, data, {
+          headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${option.apiKey}`
+          },
+          proxy: option.proxy
+        });
+        let resultTextArr = Array.from(textArr).fill('');
+        const content = response.data.choices[0].message.content;
+        try {
+          let resultMap;
+          try {
+            resultMap = JSON.parse(content);
+          } catch (error) {
+            throw new Error('大模型返回文本解析失败');
+          }
+          if (typeof resultMap !== 'object' || !resultMap) {
+            throw new Error('大模型返回文本解析后类型不正确');
+          }
+          const isMiss = Object.keys(resultMap).some(key => !(key in sourceMap));
+          if (isMiss) {
+            throw new Error('大模型返回文本内容不完整');
+          }
+          resultTextArr = textArr.map(text => resultMap[generateId(text)]); // 用textArr遍历，保证顺序
+        } catch (error) {
+          const message = error instanceof Error ? error.message : '未知错误';
+          console.warn('⚠', message);
+          console.warn('⚠ 返回的文本内容：', content);
+          console.warn('⚠ 原文本内容：', JSON.stringify(sourceMap));
+        }
+        return resultTextArr.join(separator);
+      },
+      onError: (error, cb) => {
+        cb(error);
+        console.error('请确保在火山引擎控制台开通了对应模型，且有足够的token余额。控制台地址：https://console.volcengine.com/ark/');
+      },
+      maxChunkSize: 1000,
+      // 太长可能会导致返回文本不完整
+      interval: option.interval ?? 1000
+    });
+  }
 }
 
 /*
- * @Date: 2025-03-26 20:28:21
- * @LastEditors: xiaoshan
- * @LastEditTime: 2025-03-31 10:29:49
- * @FilePath: /i18n_translation_vite/packages/autoI18nPluginCore/src/utils/split.ts
+ * @Author: xiaoshanwen
+ * @Date: 2024-04-03 18:12:45
+ * @LastEditTime: 2024-04-03 18:33:53
+ * @FilePath: /i18n_translation_vite/autoI18nPluginCore/src/enums/translate.ts
  */
-// 插件核心文件
-// 字符串切割与转换函数
-// import generate from '@babel/generator'
+let TranslateApiEnum = /*#__PURE__*/function (TranslateApiEnum) {
+  TranslateApiEnum["google"] = "Google";
+  TranslateApiEnum["youdao"] = "Youdao";
+  return TranslateApiEnum;
+}({});
 
-// todo 这个切割函数可以优化，性能可能很差
-/**
- * 根据正则表达式分割字符串，并将符合正则的连续字符拼接起来。
- * @param str - 要分割的字符串。
- * @param separatorRegex - 用于分割字符串的正则表达式。
- * @returns 分割并拼接后的字符串数组。
+/*
+ * @Date: 2025-03-16 14:12:30
+ * @LastEditors: xiaoshan
+ * @LastEditTime: 2025-03-16 14:13:42
+ * @FilePath: /i18n_translation_vite/packages/autoI18nPluginCore/src/enums/option.ts
  */
 /**
- * 这个函数的主要功能是根据给定的正则表达式分割字符串，并对分割结果进行特殊处理。
- * 处理过程分为三个主要步骤：
- *
- * 1. 首先根据分隔符正则和标点符号正则进行初步分割
- * 2. 然后将连续的标点符号和符合分隔符正则的部分重新连接
- * 3. 最后将不符合分隔符正则的相邻部分合并
- *
- * @param str - 需要分割的源字符串
- * @param separatorRegex - 用于分割的正则表达式
- * @returns 处理后的字符串数组
+ * 翻译类型枚举
  */
-function splitByRegex(str, separatorRegex) {
-  if (str.includes('\n')) console.log(str, separatorRegex);
-
-  // 定义标点符号的正则表达式
-  const punctuationRegex = /[，。？！《》,.．：!?""''；'"、0-9\n\r\t\v\f]/;
-  // 创建一个新的正则表达式，用于分割字符串
-  const splitRegex = new RegExp(`(${separatorRegex.source}|${punctuationRegex.source})`, separatorRegex.flags);
-
-  // 使用正则表达式分割字符串，并过滤掉空字符串
-  const splitArr = str.split(splitRegex).filter(Boolean);
-  const result = [];
-  let currentMatch = '';
+let TranslateTypeEnum = /*#__PURE__*/function (TranslateTypeEnum) {
+  TranslateTypeEnum["FULL_AUTO"] = "full-auto";
+  TranslateTypeEnum["SEMI_AUTO"] = "semi-auto";
+  return TranslateTypeEnum;
+}({});
 
-  // 定义连接标点符号的正则表达式
-  const connectPunctuationRegex = /[，。？！《》,.．：!?；'"、0-9]/;
-  // 创建一个新的正则表达式，用于检测是否需要连接
-  const connectRegex = new RegExp(`(${separatorRegex.source}|${connectPunctuationRegex.source})`, separatorRegex.flags);
+/*
+ * @Author: xiaoshanwen
+ * @Date: 2023-10-26 17:34:47
+ * @LastEditTime: 2025-03-31 19:58:37
+ * @FilePath: /i18n_translation_vite/packages/autoI18nPluginCore/src/option.ts
+ */
 
-  // 遍历分割后的数组
-  for (const item of splitArr) {
-    if (connectRegex.test(item)) {
-      // 如果当前项符合连接条件，则将其添加到当前匹配字符串中
-      currentMatch += item;
-    } else {
-      // 如果当前匹配字符串不为空，则将其添加到结果数组中
-      if (currentMatch) {
-        result.push(currentMatch);
-        currentMatch = '';
+const EXCLUDED_CALL = ['$deepScan', 'console.info', 'console.warn', 'console.error', '$i8n', 'console.log', '$t', 'require', '$$i8n', '$$t', '_createCommentVNode'];
+/**
+ * 默认插件配置选项
+ */
+const DEFAULT_OPTION = {
+  appCode: '',
+  /** 是否启用插件，默认启用 */
+  enabled: true,
+  /** 翻译调用函数，默认为 $t */
+  translateKey: '$t',
+  /** 标记不翻译调用函数列表，避免某些调用被错误翻译 */
+  excludedCall: [],
+  /** 标记不用翻译的字符串模式数组，默认是匹配文件扩展名 */
+  excludedPattern: [/\.\w+$/],
+  /** 排查不需要翻译的目录下的文件路径（黑名单）, 默认不处理node_modules */
+  excludedPath: ['node_modules'],
+  /** 指定需要翻译文件的目录路径正则（白名单） */
+  includePath: [/src\//, /src\\/],
+  /** 配置文件生成位置，默认为 './lang' */
+  globalPath: './lang',
+  /** 打包后生成文件的位置，例如 './dist/assets' */
+  distPath: '',
+  /** 打包后生成文件的主文件名称，默认是 'index' */
+  distKey: 'index',
+  /** 来源语言，默认是中文 */
+  originLang: OriginLangKeyEnum.ZH,
+  /** 翻译目标语言列表，默认包含英文 */
+  targetLangList: ['en'],
+  /** 语言key，用于请求谷歌api和生成配置文件下对应语言的内容文件 */
+  langKey: [],
+  /** 命名空间，防止全局命名冲突 */
+  namespace: 'lang',
+  /** 单位代码 */
+  orgCode: 'GREENCLOUD',
+  /** 是否启用源码的值作为key */
+  useValueAsKey: false,
+  /** 是否在构建结束之后将最新的翻译重新打包到主包中，默认不打包 */
+  buildToDist: false,
+  /** 是否启用上传翻译文件到服务器，默认开启 */
+  uploadEnabled: true,
+  /** 翻译器，决定自动翻译使用的api与调用方式，默认使用 Google 翻译器并使用7890(clash)端口代理 */
+  translator: new GoogleTranslator({
+    proxyOption: {
+      port: 7890,
+      host: '127.0.0.1',
+      headers: {
+        'User-Agent': 'Node'
       }
-      // 将当前项添加到结果数组中
-      result.push(item);
     }
-  }
+  }),
+  /** 翻译器配置选项，优先级低于translator */
+  translatorOption: undefined,
+  /**
+   * 翻译类型，支持全自动和半自动两种模式
+   * 全自动：所有翻译任务自动完成
+   * 半自动：需要人工标识，类似于 $t('key') 的方式
+   * 默认值为全自动
+   */
+  translateType: TranslateTypeEnum.FULL_AUTO,
+  /**
+   * 是否重写配置文件，默认为true
+   */
+  rewriteConfig: true,
+  /**
+   * 通用翻译key，默认使用namespace，如果commonTranslateKey不为空，则使用commonTranslateKey
+   */
+  commonTranslateKey: '',
+  /**
+   * 实验性属性，表示是否进行深层扫描字符串，默认为 false
+   * 当设置为 true 时，会对代码中的字符串进行更深入的扫描
+   */
+  deepScan: false,
+  /**
+   * 自定义文件拓展名数组
+   */
+  insertFileExtensions: [],
+  /**
+   * 自定义拓展类，插件默认翻译函数挂载在window上，如果希望自定义翻译函数挂载在其他对象上，可以使用该属性
+   * 注意：该属性需要继承BaseExtends类，并且需要实现handleInitFile和handleCodeCall和handleCodeString方法
+   */
+  translateExtends: null,
+  isClear: false,
+  // 是否清除已经不在上下文中的内容（清除项目中不再使用到的源语言键值对）
+
+  /**
+   * 是否保留空格
+   */
+  isClearSpace: true
+};
+
+/**
+ * 类型定义：插件配置选项类型
+ */
+
+/**
+ * 全局插件配置实例，复制自默认配置
+ */
+exports.option = {
+  ...DEFAULT_OPTION
+};
 
-  // 如果最后一个匹配字符串不为空，则将其添加到结果数组中
-  if (currentMatch) {
-    result.push(currentMatch);
-  }
+/**
+ * 类型定义：用户传入的配置选项
+ */
 
-  // 再遍历一次，把不符合separatorRegex 这个正则的拼起来
-  const finalResult = [];
-  let tempStr = '';
-  for (let i = 0; i < result.length; i++) {
-    const item = result[i];
-    if (separatorRegex.test(item)) {
-      if (tempStr) {
-        finalResult.push(tempStr);
-        tempStr = '';
-      }
-      finalResult.push(item);
-    } else {
-      tempStr += item;
-      if (i === result.length - 1 || separatorRegex.test(result[i + 1])) {
-        finalResult.push(tempStr);
-        tempStr = '';
-      }
-    }
-  }
-  if (tempStr) {
-    finalResult.push(tempStr);
-  }
-  return finalResult;
+/**
+ * 通过深度克隆提供的选项信息生成一个用户选项对象，
+ * 确保原始配置不被修改。它还根据用户的配置初始化翻译器。
+ * @param optionInfo - 包含用户选项和翻译器细节的选项信息。
+ * @returns 一个新的、可能已初始化翻译器的用户选项对象。
+ */
+function generateUserOption(optionInfo) {
+  // 深拷贝用户传入的配置，防止修改原配置对象
+  const userOption = cloneDeep(optionInfo);
+  userOption.translator = optionInfo?.translator;
+
+  // 如果用户配置了translatorOption则初始化translator，如果都没有则不设置translator
+  userOption.translator ||= userOption.translatorOption ? new Translator(userOption.translatorOption) : undefined;
+  if (!userOption.translator) delete userOption.translator;
+  return userOption;
 }
 
 /**
- * 检查字符串是否需要切割。
- * @param str - 要检查的字符串。
- * @returns 如果字符串需要切割，则返回 true，否则返回 false。
+ * 初始化插件配置选项
+ * @param optionInfo 用户提供的配置选项
  */
-function checkNeedSplit(str) {
-  // 检查字符串中是否包含需要切割的特殊字符
-  return str.includes('\n') || str.includes('\\') || str.includes('\r') || str.includes('\t') || str.includes('\v') || str.includes('\f') || str.includes('>') || str.includes('<');
+function initOption(optionInfo) {
+  // 合并默认配置和用户配置
+  exports.option = {
+    ...DEFAULT_OPTION,
+    ...generateUserOption(optionInfo)
+  };
+
+  // 初始化语言key数组，包含来源语言和目标语言
+  exports.option.langKey = [exports.option.originLang, ...exports.option.targetLangList];
+  // 初始化排除调用函数列表，包含默认排除和调用函数主动排除
+  exports.option.excludedCall = [...exports.option.excludedCall, ...EXCLUDED_CALL, ...[exports.option.translateKey, '$' + exports.option.translateKey]];
+  return exports.option;
 }
 
 /**
- * @description: 将字符串数组转换为babel的模板字符串节点
- * @param {string[]} strArray - 字符串数组
- * @return {types.CallExpression} - babel的深度扫描的表达式
+ * 校验插件配置选项是否完整有效
+ * @returns {boolean} 校验结果，完整返回 true，否则返回 false
  */
-function convertToTemplateLiteral(strArray, option) {
-  const quasis = [];
-  const expressions = [];
-  strArray.forEach((str, index) => {
-    if (index === 0) {
-      if (getOriginRegex().test(str)) {
-        quasis.push(types__namespace.templateElement({
-          raw: '',
-          cooked: ''
-        }, false));
-        expressions.push(createI18nTranslator({
-          value: str,
-          isExpression: true,
-          insertOption: option
-        }));
-      } else {
-        quasis.push(types__namespace.templateElement({
-          raw: str,
-          cooked: str
-        }, false));
-      }
-    } else {
-      if (getOriginRegex().test(str)) {
-        expressions.push(createI18nTranslator({
-          value: str,
-          isExpression: true,
-          insertOption: option
-        }));
-      } else {
-        quasis.push(types__namespace.templateElement({
-          raw: str,
-          cooked: str
-        }, false));
-      }
-    }
-  });
-  if (quasis.length === expressions.length) {
-    quasis.push(types__namespace.templateElement({
-      raw: '',
-      cooked: ''
-    }, true));
-  } else if (quasis.length > expressions.length) {
-    quasis[quasis.length - 1].tail = true;
+function checkOption() {
+  // 校验翻译调用函数是否配置
+  if (!exports.option.translateKey) {
+    console.error('❌请配置翻译调用函数');
+    return false;
   }
-  const templateLiteral = types__namespace.templateLiteral(quasis, expressions);
-  const deepScanCall = types__namespace.callExpression(types__namespace.identifier('$deepScan'), [templateLiteral]);
-  // 打印转换结果
-  // console.log('deepScanCall', (generate as any).default(deepScanCall).code)
-  return deepScanCall;
-}
 
-// 上传到远程服务器
-// import { getAppCode, saveConfig, convertToUploadJson } from './config.js'
-async function upload(json) {
-  const {
-    appCode,
-    targetLangList
-  } = exports.option;
-  let data = [];
-  _.map(json, (value, key) => {
-    _.map(targetLangList, item => {
-      const parts = item.split('-');
-      const lang = parts[0] + '-' + parts[1].toUpperCase();
-      data.push({
-        page: 'common',
-        key,
-        lang,
-        value: _.get(value, item, key)
-      });
-    });
-  });
-  const res = await axios.post('http://192.168.0.104:8108/i18n-web/kv_translate/batch', {
-    appCode,
-    data
-  }, {
-    headers: {
-      'Content-Type': 'application/json',
-      Authorization: '728635D658AE11F18F33000C29A621CA'
-    }
-  });
-  if (res.status === 200 && res.data.result === 0) {
-    console.info('上传翻译服务成功✔');
-  } else {
-    console.error('上传翻译服务失败❌');
-    console.log(`请求数据为:`, JSON.stringify(data));
-    console.log(`返回报错信息为:`, res.data);
+  // 校验命名空间是否配置
+  if (!exports.option.namespace) {
+    console.error('❌请配置命名空间');
+    return false;
   }
-}
 
-var upload$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    upload: upload
-});
+  // 校验是否配置了打包后生成文件的主文件名称（如果需要打包到主包中）
+  if (exports.option.buildToDist && !exports.option.distKey) {
+    console.log('❌请配置打包后生成文件的主文件名称');
+    return false;
+  }
+
+  // 校验是否配置了打包后生成文件的位置（如果需要打包到主包中）
+  if (exports.option.buildToDist && !exports.option.distPath) {
+    console.log('❌请配置打包后生成文件的位置');
+    return false;
+  }
+
+  // 校验来源语言是否配置
+  if (!exports.option.originLang) {
+    console.error('❌请配置来源语言');
+    return false;
+  }
+
+  // 校验目标翻译语言数组是否配置
+  if (!exports.option.targetLangList || !exports.option.targetLangList.length) {
+    console.error('❌请配置目标翻译语言数组');
+    return false;
+  }
+
+  // 如果所有校验通过，返回 true
+  return true;
+}
 
 class Vue2Extends {
   constructor() {
@@ -2295,8 +2343,17 @@ function TemplateLiteral (insertOption) {
   };
 }
 function handleTemplateLiteralWithExpressions(node, path) {
-  const placeholders = node.expressions.map(expression => getExpressionPlaceholder(expression));
-  if (placeholders.some(placeholder => !placeholder)) {
+  let hasOptimizedExpression = false;
+  const expressionLabels = node.expressions.map((expression, index) => {
+    const optimizedExpression = optimizeConditionalExpression(expression);
+    if (optimizedExpression) {
+      hasOptimizedExpression = true;
+      node.expressions[index] = optimizedExpression.expression;
+      return optimizedExpression.label;
+    }
+    return getExpressionPlaceholder(expression);
+  });
+  if (expressionLabels.some(placeholder => placeholder === null)) {
     return false;
   }
   const fullValue = node.quasis.reduce((result, quasi, index) => {
@@ -2308,32 +2365,26 @@ function handleTemplateLiteralWithExpressions(node, path) {
         console.log('转换异常');
       }
     }
-    return result + value + (index < node.expressions.length ? `\${${placeholders[index]}}` : '');
+    return result + value + (index < node.expressions.length ? formatExpressionPlaceholder(expressionLabels[index]) : '');
   }, '');
   if (!fullValue || !hasOriginSymbols(fullValue) || !exports.option.excludedPattern.length || checkAgainstRegexArray(fullValue, [...exports.option.excludedPattern])) {
+    if (hasOptimizedExpression) {
+      path.skip();
+      return true;
+    }
     return false;
   }
   const {
     trimmedValue,
     valStr
   } = normalizeTranslateValue(fullValue);
-  const id = generateId(valStr);
-  const translateNode = createTranslateNode(path, id, valStr, placeholders, node.expressions);
+  const id = resolveLangKey(generateId(valStr), trimmedValue);
+  const translateNode = createTranslateNode(path, id, valStr, expressionLabels, node.expressions);
   path.replaceWith(translateNode);
-  path.skip();
   setLangObj(id, trimmedValue);
   return true;
 }
 function getExpressionPlaceholder(expression) {
-  if (types.isIdentifier(expression)) {
-    return expression.name;
-  }
-  if (types.isMemberExpression(expression)) {
-    const objectName = getExpressionPlaceholder(expression.object);
-    const propertyName = expression.computed ? getExpressionPlaceholder(expression.property) : types.isIdentifier(expression.property) ? expression.property.name : '';
-    const value = [objectName, propertyName].filter(Boolean).join('.');
-    return cleanVueRuntimePrefix(value);
-  }
   if (types.isStringLiteral(expression) || types.isNumericLiteral(expression)) {
     return String(expression.value);
   }
@@ -2344,21 +2395,142 @@ function getExpressionPlaceholder(expression) {
     return getExpressionPlaceholder(expression.expression);
   }
   const generateCode = generate__namespace.default?.default || generate__namespace.default || generate__namespace;
-  return cleanVueRuntimePrefix(generateCode(expression).code);
+  return generateCode(expression, {
+    comments: false
+  }).code;
+}
+function optimizeConditionalExpression(expression) {
+  if (!types.isConditionalExpression(expression)) return null;
+  const consequent = translateConditionalStringBranch(expression.consequent);
+  const alternate = translateConditionalStringBranch(expression.alternate);
+  if (!consequent.changed && !alternate.changed) return null;
+  return {
+    label: getConditionalExpressionLabel(expression),
+    expression: types.conditionalExpression(types.cloneNode(expression.test), consequent.expression, alternate.expression)
+  };
+}
+function translateConditionalStringBranch(expression) {
+  if (types.isStringLiteral(expression) && hasOriginSymbols(expression.value)) {
+    return {
+      changed: true,
+      expression: createTrackedTranslateCall(expression.value)
+    };
+  }
+  if (types.isTemplateLiteral(expression)) {
+    const translateCall = createTemplateLiteralTranslateCall(expression);
+    if (translateCall) {
+      return {
+        changed: true,
+        expression: translateCall
+      };
+    }
+  }
+  if (types.isConditionalExpression(expression)) {
+    const optimizedExpression = optimizeConditionalExpression(expression);
+    if (optimizedExpression) {
+      return {
+        changed: true,
+        expression: optimizedExpression.expression
+      };
+    }
+  }
+  return {
+    changed: false,
+    expression: types.cloneNode(expression)
+  };
+}
+function createTrackedTranslateCall(value) {
+  const translateCall = createI18nTranslator({
+    value,
+    isExpression: true
+  });
+  const {
+    trimmedValue,
+    valStr
+  } = normalizeTranslateValue(value);
+  const id = resolveLangKey(generateId(valStr), trimmedValue);
+  if (id && trimmedValue) {
+    setLangObj(id, trimmedValue);
+  }
+  return translateCall;
+}
+function createTemplateLiteralTranslateCall(node) {
+  const expressions = node.expressions.map(expression => {
+    const optimizedExpression = optimizeConditionalExpression(expression);
+    return optimizedExpression ? optimizedExpression.expression : expression;
+  });
+  const expressionLabels = expressions.map(expression => getExpressionPlaceholder(expression));
+  if (expressionLabels.some(placeholder => placeholder === null)) {
+    return null;
+  }
+  const fullValue = node.quasis.reduce((result, quasi, index) => {
+    let value = quasi.value.raw || quasi.value.cooked || '';
+    if (asianLangs.some(lang => exports.option.originLang.includes(lang) || exports.option.originLang === lang)) {
+      try {
+        value = unicodeToString(value);
+      } catch (error) {
+        console.log('转换异常');
+      }
+    }
+    return result + value + (index < expressions.length ? formatExpressionPlaceholder(expressionLabels[index]) : '');
+  }, '');
+  if (!fullValue || !hasOriginSymbols(fullValue) || !exports.option.excludedPattern.length || checkAgainstRegexArray(fullValue, [...exports.option.excludedPattern])) {
+    return null;
+  }
+  const {
+    trimmedValue,
+    valStr
+  } = normalizeTranslateValue(fullValue);
+  const id = resolveLangKey(generateId(valStr), trimmedValue);
+  if (id && trimmedValue) {
+    setLangObj(id, trimmedValue);
+  }
+  return createTranslateCall(id, valStr, expressionLabels, expressions);
+}
+function getConditionalExpressionLabel(expression) {
+  const test = expression.test;
+  if (types.isBinaryExpression(test) || types.isLogicalExpression(test)) {
+    return getExpressionPlaceholder(test.left);
+  }
+  return getExpressionPlaceholder(test);
+}
+function formatExpressionPlaceholder(placeholder) {
+  if (placeholder === null) return '';
+  return placeholder.trim() ? `\${${placeholder}}` : placeholder;
 }
 function createTranslateNode(path, id, valStr) {
   let placeholders = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
   let expressions = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : [];
-  const args = [types.stringLiteral(id), types.stringLiteral(valStr)];
-  if (placeholders.length) {
-    args.push(types.objectExpression(placeholders.map((placeholder, index) => types.objectProperty(types.stringLiteral(placeholder), types.cloneNode(expressions[index])))));
-  }
-  const translateCall = types.callExpression(types.identifier(exports.option.translateKey), args);
+  const translateCall = createTranslateCall(id, valStr, placeholders, expressions);
   if (!isVueTemplateRender(path)) {
     return translateCall;
   }
   return types.sequenceExpression([createVueTemplateLanguageDependency(), translateCall]);
 }
+function createTranslateCall(id, valStr) {
+  let placeholders = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  let expressions = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
+  const args = [types.stringLiteral(id), types.stringLiteral(valStr)];
+  if (placeholders.length) {
+    const placeholderEntries = placeholders.map((placeholder, index) => ({
+      placeholder,
+      expression: expressions[index]
+    })).filter(_ref => {
+      let {
+        placeholder
+      } = _ref;
+      return placeholder && placeholder.trim();
+    });
+    args.push(types.objectExpression(placeholderEntries.map(_ref2 => {
+      let {
+        placeholder,
+        expression
+      } = _ref2;
+      return types.objectProperty(types.stringLiteral(placeholder), types.cloneNode(expression));
+    })));
+  }
+  return types.callExpression(types.identifier(exports.option.translateKey), args);
+}
 function isVueTemplateRender(path) {
   return Boolean(path.scope?.getBinding('_vm'));
 }
@@ -2372,9 +2544,6 @@ function createVueTemplateLanguageDependency() {
   const i18nLocale = types.logicalExpression('&&', types.cloneNode(i18n), types.memberExpression(types.cloneNode(i18n), types.identifier('locale')));
   return types.logicalExpression('||', storeLanguage, i18nLocale);
 }
-function cleanVueRuntimePrefix(value) {
-  return value.replace(/^(?:\$setup|_ctx|_vm|this)\./, '').replace(/([^\w$.])(?:\$setup|_ctx|_vm|this)\./g, '$1');
-}
 
 // 处理模板元素
 function handleTemplateElement(node, insertOption) {
@@ -2397,9 +2566,10 @@ function handleTemplateElement(node, insertOption) {
     // 替换为字符类型翻译节点
     node.value.raw = node.value.cooked = `\${${newNode}}`;
     const {
+      trimmedValue,
       valStr
     } = normalizeTranslateValue(value);
-    let id = generateId(valStr);
+    let id = resolveLangKey(generateId(valStr), trimmedValue);
     if (id && value) {
       setLangObj(id, value);
     }