vite-gc-i18n-plugin 1.1.4 → 1.1.6

package/dist/index.cjs

@@ -7,10 +7,10 @@ var tunnel = require('tunnel');
 var axios = require('axios');
 var CryptoJS = require('crypto-js');
 var OpenCC = require('opencc-js');
+var fs = require('node:fs');
+var path = require('node:path');
 var types = require('@babel/types');
 var _ = require('lodash');
-var path = require('node:path');
-var fs = require('node:fs');
 var babel = require('@babel/core');
 var generate = require('@babel/generator');
 
@@ -597,1606 +597,1697 @@ 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);
+  // 遍历分割后的数组
+  for (const item of splitArr) {
+    if (connectRegex.test(item)) {
+      // 如果当前项符合连接条件，则将其添加到当前匹配字符串中
+      currentMatch += item;
+    } else {
+      // 如果当前匹配字符串不为空，则将其添加到结果数组中
+      if (currentMatch) {
+        result.push(currentMatch);
+        currentMatch = '';
+      }
+      // 将当前项添加到结果数组中
+      result.push(item);
+    }
   }
-  if (value instanceof RegExp) {
-    return new RegExp(value.source, value.flags);
+
+  // 如果最后一个匹配字符串不为空，则将其添加到结果数组中
+  if (currentMatch) {
+    result.push(currentMatch);
   }
 
-  // 初始化克隆容器
-  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);
+  // 再遍历一次，把不符合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 = '';
+      }
+    }
   }
-  return clone;
+  if (tempStr) {
+    finalResult.push(tempStr);
+  }
+  return finalResult;
 }
 
-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`，请确保使用前已在控制台开通了对应模型'
-    })
-})
- * ```
+ * 检查字符串是否需要切割。
+ * @param str - 要检查的字符串。
+ * @returns 如果字符串需要切割，则返回 true，否则返回 false。
  */
-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" }
+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('<');
+}
 
-                                请回答问题：
-                                输入：源语言A -> 目标语言B { "wghhj": "XXX" }
-                                输出：
+/**
+ * @description: 将字符串数组转换为babel的模板字符串节点
+ * @param {string[]} strArray - 字符串数组
+ * @return {types.CallExpression} - babel的深度扫描的表达式
+ */
+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;
+}
 
-                                要求：
-                                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
+// 上传到远程服务器
+// 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);
   }
 }
 
-/*
- * @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;
-}({});
+var upload$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    upload: upload
+});
 
-/*
- * @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
+ * @description: 新建国际化配置文件夹
+ * @return {*}
  */
-
-const EXCLUDED_CALL = ['$deepScan', 'console.info', 'console.warn', 'console.error', '$i8n', 'console.log', '$t', 'require', '$$i8n', '$$t', '_createCommentVNode'];
+function initLangFile() {
+  if (!fs.existsSync(exports.option.globalPath)) {
+    fs.mkdirSync(exports.option.globalPath); // 创建lang文件夹
+  }
+  initLangTranslateJSONFile();
+  initTranslateBasicFnFile();
+}
 /**
- * 默认插件配置选项
+ * @description: 初始化翻译基础函数文件
+ * @returns {void}
  */
-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'
-      }
+async function initTranslateBasicFnFile() {
+  // 从配置选项中获取必要的配置信息
+  const {
+    targetLangList
+  } = exports.option;
+  // 生成语言映射列表
+  let languages = [];
+  let langList = targetLangList.map(item => {
+    const parts = item.split('-');
+    const lang = parts[0] + '-' + parts[1].toUpperCase();
+    return _.find(allLanguage, {
+      code: lang
+    });
+  });
+  langList
+  // 构建语言映射项
+  .map(item => {
+    languages.push(`{
+                code: "${item.code}",
+                name: "${item.name}"
+            }`);
+  });
+  // 用逗号和换行符连接所有映射项
+  const translateBasicFnText = `
+import gc_i18n from 'gc_i18n'
+export const languages = [${languages.toString()}]
+const gcI18nInstance = new gc_i18n({
+    appCode: 'TEST',
+    env: 'dev', // local 本地部署 dev 多语言测试环境 prod 多语言生产环境
+    orgCode: 'GREENCLOUD',
+    messages: {} // 如果你需要自己引入语言包
+})
+export default {
+    install(app, router) {
+        gcI18nInstance.setRouter(router)
     }
-  }),
-  /** 翻译器配置选项，优先级低于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
-};
+}`;
+  // 构建翻译基础函数文件的路径
+  const indexPath = path.join(exports.option.globalPath, 'index.js');
 
-/**
- * 类型定义：插件配置选项类型
- */
+  // 文件已存在 同时 不重写配置，那么这里就结束
+  if (fs.existsSync(indexPath) && !exports.option.rewriteConfig) return;
 
-/**
- * 全局插件配置实例，复制自默认配置
- */
-exports.option = {
-  ...DEFAULT_OPTION
-};
+  // 新增哈希比对逻辑
 
-/**
- * 类型定义：用户传入的配置选项
- */
+  // 标记是否需要更新文件
+  let needUpdate = true;
+  if (fs.existsSync(indexPath)) {
+    // 检查文件是否已存在
+    // 读取现有文件内容
+    const existingContent = fs.readFileSync(indexPath, 'utf-8');
+    // 生成现有内容的哈希值
+    const existingHash = generateId(existingContent);
+    // 判断是否需要更新文件
+    // needUpdate = currentHash !== existingHash
+    needUpdate = !existingHash;
+  }
 
+  // 如果需要更新文件，则写入新内容
+  if (needUpdate) {
+    fs.writeFileSync(indexPath, translateBasicFnText);
+  }
+}
 /**
- * 通过深度克隆提供的选项信息生成一个用户选项对象，
- * 确保原始配置不被修改。它还根据用户的配置初始化翻译器。
- * @param optionInfo - 包含用户选项和翻译器细节的选项信息。
- * @returns 一个新的、可能已初始化翻译器的用户选项对象。
+ * @description: 生成国际化JSON文件
+ * @return {*}
  */
-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;
+function initLangTranslateJSONFile() {
+  const indexPath = path.join(exports.option.globalPath, 'index.json');
+  if (!fs.existsSync(indexPath)) {
+    // 不存在就创建
+    fs.writeFileSync(indexPath, JSON.stringify({})); // 创建
+  }
 }
 
 /**
- * 初始化插件配置选项
- * @param optionInfo 用户提供的配置选项
+ * @description: 读取国际化JSON文件
+ * @return {*}
  */
-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;
+function getLangTranslateJSONFile() {
+  const filePath = path.join(exports.option.globalPath, 'index.json');
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    return content;
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      console.log('❌读取JSON配置文件异常，文件不存在');
+    } else {
+      console.log('❌读取JSON配置文件异常，无法读取文件');
+    }
+    return JSON.stringify({});
+  }
 }
 
 /**
- * 校验插件配置选项是否完整有效
- * @returns {boolean} 校验结果，完整返回 true，否则返回 false
+ * @description: 基于langKey获取JSON配置文件中对应语言对象
+ * @param {string} key
+ * @return {*}
  */
-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;
-  }
+function getLangObjByJSONFileWithLangKey(key) {
+  let insertJSONObj = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
+  // 获取翻译配置对象，优先使用传入的配置，否则从本地文件读取
+  const JSONObj = insertJSONObj || JSON.parse(getLangTranslateJSONFile());
 
-  // 校验来源语言是否配置
-  if (!exports.option.originLang) {
-    console.error('❌请配置来源语言');
-    return false;
-  }
+  // 初始化语言映射对象，用于存储不同语言的hash: value映射
+  const langObj = {};
 
-  // 校验目标翻译语言数组是否配置
-  if (!exports.option.targetLangList || !exports.option.targetLangList.length) {
-    console.error('❌请配置目标翻译语言数组');
-    return false;
-  }
+  // 遍历hash，提取hash对应语言key的值，并写入到langObj
+  Object.keys(JSONObj).forEach(langCode => {
+    langObj[langCode] = JSONObj[langCode][key];
+  });
 
-  // 如果所有校验通过，返回 true
-  return true;
+  // 返回当前语言的hash: value映射对象
+  // 例如: 'zh-cn' > {'hash1': '你好', 'hash2': '世界'}
+  // 'en' > {'hash1': 'hello', 'hash2': 'world'}
+  return langObj;
 }
 
-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 格式化配置类型
+ * @description: 设置国际化JSON文件
+ * @return {*}
  */
-
-// 默认的缩进配置
-const indentConfig = {
-  tab: {
-    char: '\t',
-    size: 1
-  },
-  space: {
-    char: ' ',
-    size: 4
+function setLangTranslateJSONFile(obj) {
+  const filePath = path.join(exports.option.globalPath, 'index.json');
+  const jsonObj = jsonFormatter(obj);
+  if (fs.existsSync(filePath)) {
+    fs.writeFileSync(filePath, jsonObj);
+  } else {
+    console.log('❌JSON配置文件写入异常，文件不存在');
   }
-};
-
-// 默认格式化配置
-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);
-};
+}
 
 /**
- * 格式化 JSON 字符串
- * @param json JSON 字符串
- * @param indentType 缩进类型
- * @returns 格式化的 JSON 字符串
+ * @description: 构建时把lang配置文件设置到打包后到主文件中
+ * @return {*}
  */
-function formatJSON(json, indentType) {
-  placeholderStorage = [];
-  let output = '';
-  let indentLevel = 0;
+function uploadFile() {
+  const JSONObj = JSON.parse(getLangTranslateJSONFile());
+  upload(JSONObj);
+  // if (!option.buildToDist) return
+  // let langObjMap: any = {}
+  // option.langKey.forEach(item => {
+  //     langObjMap[item] = getLangObjByJSONFileWithLangKey(item)
+  // })
+  // if (fs.existsSync(option.distPath)) {
+  //     fs.readdir(option.distPath, (err, files) => {
+  //         if (err) {
+  //             console.error('❌构建文件夹为空，翻译配置无法写入')
+  //             return
+  //         }
 
-  // 提取反斜杠和字符串
-  json = json.replace(/\\./g, pushPlaceholder) // 处理反斜杠
-  .replace(/(".*?"|'.*?')/g, pushPlaceholder) // 处理字符串
-  .replace(/\s+/g, ''); // 去除多余空格
+  //         files.forEach(file => {
+  //             if (file.startsWith(option.distKey) && file.endsWith('.js')) {
+  //                 const filePath = path.join(option.distPath, file)
+  //                 fs.readFile(filePath, 'utf-8', (err, data) => {
+  //                     if (err) {
+  //                         console.log(filePath)
+  //                         console.error('❌构建主文件不存在，翻译配置无法写入')
+  //                         return
+  //                     }
+  //                     let buildLangConfigString = ''
+  //                     Object.keys(langObjMap).forEach(item => {
+  //                         buildLangConfigString =
+  //                             buildLangConfigString +
+  //                             `globalThis['${option.namespace}']['${item}']=${JSON.stringify(langObjMap[item])};`
+  //                     })
+  //                     try {
+  //                         // 翻译配置写入主文件
+  //                         fs.writeFileSync(
+  //                             filePath,
+  //                             `globalThis['${option.namespace}']={};${buildLangConfigString}` +
+  //                                 data
+  //                         )
+  //                         console.info('恭喜：翻译配置写入构建主文件成功🌟🌟🌟')
+  //                     } catch (err) {
+  //                         console.error('翻译配置写入构建主文件失败:', err)
+  //                     }
+  //                 })
+  //             }
+  //         })
+  //     })
+  // }
+}
 
-  // 根据 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;
-    }
-  }
+var file = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    getLangObjByJSONFileWithLangKey: getLangObjByJSONFileWithLangKey,
+    getLangTranslateJSONFile: getLangTranslateJSONFile,
+    initLangFile: initLangFile,
+    initLangTranslateJSONFile: initLangTranslateJSONFile,
+    initTranslateBasicFnFile: initTranslateBasicFnFile,
+    setLangTranslateJSONFile: setLangTranslateJSONFile,
+    uploadFile: uploadFile
+});
 
-  // 去除数字数组的空格，并还原反斜杠和字符串
-  output = output.replace(/\[[\d,\s]+?\]/g, match => match.replace(/\s/g, '')).replace(/\\(\d+)\\/g, popPlaceholder) // 还原填充数据
-  .replace(/\\(\d+)\\/g, popPlaceholder); // 再次还原填充数据
+/*
+ * @Author: xiaoshanwen
+ * @Date: 2023-10-30 18:23:03
+ * @LastEditTime: 2025-03-16 19:12:54
+ * @FilePath: /i18n_translation_vite/packages/autoI18nPluginCore/src/utils/translate.ts
+ */
 
-  return output;
+const SEPARATOR = '\n┇┇┇\n';
+const SPLIT_SEPARATOR_REGEX = /\n┇ *┇ *┇\n/;
+let langObj = {};
+function normalizeValueForDedupe(value) {
+  return String(value || '').trim();
+}
+function findKeyByValue(valueMap, value) {
+  const exactKey = Object.entries(valueMap).find(_ref => {
+    let [, oldValue] = _ref;
+    return oldValue === value;
+  })?.[0];
+  if (exactKey) return exactKey;
+  const normalizedValue = normalizeValueForDedupe(value);
+  return Object.entries(valueMap).find(_ref2 => {
+    let [, oldValue] = _ref2;
+    return normalizeValueForDedupe(oldValue) === normalizedValue;
+  })?.[0];
+}
+function getExistingOriginLangObj() {
+  try {
+    const filePath = path.join(exports.option.globalPath, 'index.json');
+    if (!fs.existsSync(filePath)) return {};
+    return getLangObjByJSONFileWithLangKey(exports.option.originLang);
+  } catch (error) {
+    return {};
+  }
+}
+function getLangKeyByValue(value) {
+  return findKeyByValue(langObj, value) || findKeyByValue(getExistingOriginLangObj(), value);
+}
+function resolveLangKey(key, value) {
+  return getLangKeyByValue(value) || key;
+}
+function isTemplateValue(value) {
+  return /\$\{[^}]+}/.test(value);
+}
+function hasOriginSymbols$1(value) {
+  const originRegex = REGEX_MAP[exports.option.originLang];
+  return originRegex ? originRegex.test(value) : false;
+}
+function getTemplateSemanticSplitSegments(value) {
+  const segments = value.split(/\$\{[^}]+}/g);
+  const result = new Set();
+  for (let index = 0; index < segments.length - 1; index++) {
+    const beforeValue = segments[index];
+    const afterValue = segments[index + 1];
+    if (!hasOriginSymbols$1(beforeValue) || !hasOriginSymbols$1(afterValue)) continue;
+    [beforeValue, afterValue].forEach(segment => {
+      if (segment.trim().length > 1) {
+        result.add(segment);
+      }
+    });
+  }
+  return [...result];
+}
+function isTemplateStaticSegment(value) {
+  return Object.values(langObj).some(oldValue => isTemplateValue(oldValue) && getTemplateSemanticSplitSegments(oldValue).includes(value));
+}
+function removeTemplateStaticSegments(value) {
+  const segments = new Set(getTemplateSemanticSplitSegments(value));
+  Object.keys(langObj).forEach(key => {
+    if (segments.has(langObj[key])) {
+      delete langObj[key];
+    }
+  });
 }
 
 /**
- * 格式化 JSON 的主函数
- * @param json 需要格式化的 JSON 对象或字符串
- * @param config 配置选项
- * @returns 格式化后的 JSON 字符串
+ * @description: 设置翻译对象属性
+ * @param {string} key
+ * @param {string} value
+ * @return {*}
  */
-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 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;
+  }
+}
+function dedupeLangObjMapByOriginValue(originLangObjMap) {
+  const originMap = originLangObjMap[exports.option.originLang];
+  const valueKeyMap = new Map();
+  Object.keys(originMap).forEach(key => {
+    const value = originMap[key];
+    const normalizedValue = normalizeValueForDedupe(value);
+    const existingKey = valueKeyMap.get(normalizedValue);
+    if (!existingKey) {
+      valueKeyMap.set(normalizedValue, key);
+      return;
+    }
+    exports.option.langKey.forEach(lang => {
+      delete originLangObjMap[lang][key];
+    });
+  });
+}
 
-  // 生成缩进字符
-  const indentType = generateIndentation(config.size || indent.size, indent.char);
-
-  // 格式化 JSON 字符串
-  return formatJSON(jsonString, indentType);
+/**
+ * @description: 读取翻译对象
+ * @return {*}
+ */
+function getLangObj() {
+  return langObj;
 }
 
 /**
- * @description: 新建国际化配置文件夹
+ * @description: 初始化翻译对象
+ * @param {langObj} obj
  * @return {*}
  */
-function initLangFile() {
-  if (!fs.existsSync(exports.option.globalPath)) {
-    fs.mkdirSync(exports.option.globalPath); // 创建lang文件夹
+function initLangObj(obj) {
+  if (!Object.keys(langObj).length) {
+    langObj = obj;
   }
-  initLangTranslateJSONFile();
-  initTranslateBasicFnFile();
 }
+
+// todo 类型修复
 /**
- * @description: 初始化翻译基础函数文件
- * @returns {void}
+ * 自动生成多语言配置文件的核心方法
+ *
+ * 主要流程：
+ * 1. 加载现有翻译文件
+ * 2. 对比找出新增需要翻译的内容
+ * 3. 分块并行翻译所有目标语言
+ * 4. 合并翻译结果并生成最终配置文件
+ *
+ * 异常处理：
+ * - 翻译结果不完整时中断流程
+ * - 文件读写失败时明确报错
  */
-async function initTranslateBasicFnFile() {
-  // 从配置选项中获取必要的配置信息
-  const {
-    targetLangList
-  } = exports.option;
-  // 生成语言映射列表
-  let languages = [];
-  let langList = targetLangList.map(item => {
-    const parts = item.split('-');
-    const lang = parts[0] + '-' + parts[1].toUpperCase();
-    return _.find(allLanguage, {
-      code: lang
-    });
+async function autoTranslate() {
+  const enabled = typeof exports.option.enabled === 'function' ? exports.option.enabled() : exports.option.enabled;
+  if (!enabled) return;
+
+  // 初始化现有翻译文件缓存
+  const originLangObjMap = {};
+
+  // 加载所有语言的现有翻译内容
+  // 获取当前待翻译内容（深拷贝避免污染原始数据）
+  const currentLangObj = JSON.parse(JSON.stringify(getLangObj()));
+  exports.option.langKey.forEach(lang => {
+    const keyMap = getLangObjByJSONFileWithLangKey(lang);
+    originLangObjMap[lang] = keyMap;
   });
-  langList
-  // 构建语言映射项
-  .map(item => {
-    languages.push(`{
-                code: "${item.code}",
-                name: "${item.name}"
-            }`);
+
+  // 筛选需要翻译的新增内容
+  const transLangObj = {};
+  Object.keys(currentLangObj).forEach(key => {
+    if (!originLangObjMap[exports.option.originLang][key]) {
+      transLangObj[key] = currentLangObj[key];
+    }
   });
-  // 用逗号和换行符连接所有映射项
-  const translateBasicFnText = `
-import gc_i18n from 'gc_i18n'
-export const languages = [${languages.toString()}]
-const gcI18nInstance = new gc_i18n({
-    appCode: 'TEST',
-    env: 'dev', // local 本地部署 dev 多语言测试环境 prod 多语言生产环境
-    orgCode: 'GREENCLOUD',
-    messages: {} // 如果你需要自己引入语言包
-})
-export default {
-    install(app, router) {
-        gcI18nInstance.setRouter(router)
+
+  // 无新内容提前退出
+  if (Object.keys(transLangObj).length === 0) {
+    return;
+  }
+
+  // 初始化翻译结果存储结构
+  const newLangObjMap = {};
+
+  // 遍历所有目标语言进行处理
+  for (let langIndex = 0; langIndex < exports.option.langKey.length; langIndex++) {
+    const currentLang = exports.option.langKey[langIndex];
+
+    // 原始语言直接存储原文，读取扫出来的元素翻译内容
+    if (langIndex === 0) {
+      newLangObjMap[exports.option.originLang] = Object.values(transLangObj);
+      continue;
     }
-}`;
-  // 构建翻译基础函数文件的路径
-  const indexPath = path.join(exports.option.globalPath, 'index.js');
+    console.info('开始自动翻译...');
 
-  // 文件已存在 同时 不重写配置，那么这里就结束
-  if (fs.existsSync(indexPath) && !exports.option.rewriteConfig) return;
+    // ─── 分块翻译流程开始 ───
+    const translatedValues = await translateChunks(transLangObj, exports.option.langKey[langIndex]);
+    // ─── 分块翻译流程结束 ───=
 
-  // 新增哈希比对逻辑
+    // ─── 翻译结果校验 ───
+    if (translatedValues.length !== Object.keys(transLangObj).length) {
+      console.error('❌ 使用付费翻译时，请检查翻译API额度是否充足，或是否已申请对应翻译API使用权限');
+      console.error(`❌ 翻译结果不完整
+                预期数量: ${Object.keys(transLangObj).length}
+                实际数量: ${translatedValues.length}
+                样例数据: ${JSON.stringify(translatedValues.slice(0, 3))}`);
+      return;
+    }
 
-  // 标记是否需要更新文件
-  let needUpdate = true;
-  if (fs.existsSync(indexPath)) {
-    // 检查文件是否已存在
-    // 读取现有文件内容
-    const existingContent = fs.readFileSync(indexPath, 'utf-8');
-    // 生成现有内容的哈希值
-    const existingHash = generateId(existingContent);
-    // 判断是否需要更新文件
-    // needUpdate = currentHash !== existingHash
-    needUpdate = !existingHash;
+    // 存储当前语言翻译结果
+    newLangObjMap[currentLang] = translatedValues;
+    console.info(`✅ ${currentLang} 翻译完成`);
   }
 
-  // 如果需要更新文件，则写入新内容
-  if (needUpdate) {
-    fs.writeFileSync(indexPath, translateBasicFnText);
+  // ─── 合并翻译结果到配置 ───
+  Object.keys(transLangObj).forEach((key, index) => {
+    exports.option.langKey.forEach(item => {
+      originLangObjMap[item][key] = newLangObjMap[item][index];
+    });
+  });
+  dedupeLangObjMapByOriginValue(originLangObjMap);
+
+  // ─── 生成最终配置文件结构 ───
+  console.log('📄 构建配置文件数据结构...');
+  const configLangObj = {};
+  Object.keys(originLangObjMap[exports.option.originLang]).forEach(key => {
+    configLangObj[key] = {};
+    exports.option.langKey.forEach(lang => {
+      configLangObj[key][lang] = originLangObjMap[lang][key];
+    });
+  });
+
+  // ─── 写入文件系统 ───
+  try {
+    setLangTranslateJSONFile(configLangObj);
+    console.info('🎉 多语言配置文件已成功更新');
+  } catch (error) {
+    console.error('❌ 配置文件写入失败，原因:', error);
+    // todo 可添加重试逻辑或回滚机制
   }
 }
+
 /**
- * @description: 生成国际化JSON文件
+ * @description: 新增语言类型配置补全
+ * @param {any} obj
  * @return {*}
  */
-function initLangTranslateJSONFile() {
-  const indexPath = path.join(exports.option.globalPath, 'index.json');
-  if (!fs.existsSync(indexPath)) {
-    // 不存在就创建
-    fs.writeFileSync(indexPath, JSON.stringify({})); // 创建
-  }
+function languageConfigCompletion(obj) {
+  if (!Object.keys(obj)) return;
+  const enabled = typeof exports.option.enabled === 'function' ? exports.option.enabled() : exports.option.enabled;
+  if (!enabled) return;
+  let needCompletionList = [];
+  const JSONobj = JSON.parse(getLangTranslateJSONFile());
+  exports.option.targetLangList.forEach(item => {
+    // 获取目标语言 hash：value 对象 和 语言的复合对象，如果当前语言不存在，是langObj的value卡都为空
+    let langObj = getLangObjByJSONFileWithLangKey(item, JSONobj);
+    needCompletionList.push({
+      key: item,
+      curLangObj: langObj
+    });
+  });
+  needCompletionList.forEach(async item => {
+    await completionTranslateAndWriteConfigFile(obj, item.curLangObj, item.key);
+  });
 }
 
 /**
- * @description: 读取国际化JSON文件
- * @return {*}
+ * @description: 补全新增语言翻译写入函数
+ * @param langObj
+ * @param curLangObj
+ * @param translateKey
+ * @return
  */
-function getLangTranslateJSONFile() {
-  const filePath = path.join(exports.option.globalPath, 'index.json');
+async function completionTranslateAndWriteConfigFile(langObj, curLangObj, translateKey) {
+  // 构建需要翻译的语言映射对象
+  // langObj: 源语言的键值对映射，格式为 { hash: sourceText }
+  // curLangObj: 目标语言的键值对映射，格式为 { hash: targetText }，未翻译的值为空
+
+  // 创建待翻译内容对象，仅包含未翻译的条目，key是hash，value是源语言的对应hash的文本
+  const transLangObj = {};
+  Object.keys(langObj).forEach(key => {
+    // 如果目标语言中对应的翻译为空，则将 源语言的对应hash的文本 加入待翻译内容对象 中
+    if (curLangObj[key] === undefined) {
+      transLangObj[key] = langObj[key];
+    }
+  });
+  if (!Object.values(transLangObj).length) return;
+
+  // ─── 分块翻译流程开始 ───
+
+  console.info('进入新增语言补全翻译...');
+
+  // 调用抽离的函数
+  const resultValues = await translateChunks(transLangObj, translateKey);
+  // ─── 分块翻译流程结束 ───
+
+  if (resultValues.length !== Object.values(langObj).length) {
+    console.error('翻译异常，翻译结果缺失❌');
+    return;
+  }
+  let newLangObjMap = resultValues;
+  console.info('翻译成功⭐️⭐️⭐️');
+  Object.keys(transLangObj).forEach((key, index) => {
+    curLangObj[key] = newLangObjMap[index];
+  });
+  console.log('开始写入JSON配置文件...');
+  const configLangObj = JSON.parse(getLangTranslateJSONFile());
+  Object.keys(transLangObj).forEach(key => {
+    configLangObj[key][translateKey] = curLangObj[key];
+  });
   try {
-    const content = fs.readFileSync(filePath, 'utf-8');
-    return content;
+    setLangTranslateJSONFile(configLangObj);
+    console.info('JSON配置文件写入成功⭐️⭐️⭐️');
   } catch (error) {
-    if (error.code === 'ENOENT') {
-      console.log('❌读取JSON配置文件异常，文件不存在');
-    } else {
-      console.log('❌读取JSON配置文件异常，无法读取文件');
-    }
-    return JSON.stringify({});
+    console.error('❌JSON配置文件写入失败' + error);
   }
+  console.info('新增语言翻译补全成功⭐️⭐️⭐️');
 }
 
-/**
- * @description: 基于langKey获取JSON配置文件中对应语言对象
- * @param {string} key
- * @return {*}
- */
-function getLangObjByJSONFileWithLangKey(key) {
-  let insertJSONObj = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
-  // 获取翻译配置对象，优先使用传入的配置，否则从本地文件读取
-  const JSONObj = insertJSONObj || JSON.parse(getLangTranslateJSONFile());
+// 分块翻译流程函数
+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));
+  }
 
-  // 初始化语言映射对象，用于存储不同语言的hash: value映射
-  const langObj = {};
+  // 等待所有分块完成并合并结果
+  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());
+    };
 
-  // 遍历hash，提取hash对应语言key的值，并写入到langObj
-  Object.keys(JSONObj).forEach(langCode => {
-    langObj[langCode] = JSONObj[langCode][key];
+    // 分割符可能会被翻译，所以这里做了兼容处理
+    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}__`;
   });
-
-  // 返回当前语言的hash: value映射对象
-  // 例如: 'zh-cn' > {'hash1': '你好', 'hash2': '世界'}
-  // 'en' > {'hash1': 'hello', 'hash2': 'world'}
-  return langObj;
 }
-
-/**
- * @description: 设置国际化JSON文件
- * @return {*}
- */
-function setLangTranslateJSONFile(obj) {
-  const filePath = path.join(exports.option.globalPath, 'index.json');
-  const jsonObj = jsonFormatter(obj);
-  if (fs.existsSync(filePath)) {
-    fs.writeFileSync(filePath, jsonObj);
-  } else {
-    console.log('❌JSON配置文件写入异常，文件不存在');
-  }
+function restoreInterpolationPlaceholders(value, placeholders) {
+  return value.replace(/__GC_I18N_PH_(\d+)__/g, (match, index) => {
+    return placeholders[Number(index)] || match;
+  });
 }
-
 /**
- * @description: 构建时把lang配置文件设置到打包后到主文件中
- * @return {*}
+ * @description: 清理多余的翻译配置JSON文件
+ * @return {void} 无返回值
  */
-function uploadFile() {
-  const JSONObj = JSON.parse(getLangTranslateJSONFile());
-  upload(JSONObj);
-  // if (!option.buildToDist) return
-  // let langObjMap: any = {}
-  // option.langKey.forEach(item => {
-  //     langObjMap[item] = getLangObjByJSONFileWithLangKey(item)
-  // })
-  // if (fs.existsSync(option.distPath)) {
-  //     fs.readdir(option.distPath, (err, files) => {
-  //         if (err) {
-  //             console.error('❌构建文件夹为空，翻译配置无法写入')
-  //             return
-  //         }
+function cleanupUnusedTranslations() {
+  if (!exports.option.isClear) return;
+  console.log('🧹 进入清理流程');
+  // 获取当前的语言对象，如果不存在则使用空对象
+  const langObj = getLangObj() || {};
 
-  //         files.forEach(file => {
-  //             if (file.startsWith(option.distKey) && file.endsWith('.js')) {
-  //                 const filePath = path.join(option.distPath, file)
-  //                 fs.readFile(filePath, 'utf-8', (err, data) => {
-  //                     if (err) {
-  //                         console.log(filePath)
-  //                         console.error('❌构建主文件不存在，翻译配置无法写入')
-  //                         return
-  //                     }
-  //                     let buildLangConfigString = ''
-  //                     Object.keys(langObjMap).forEach(item => {
-  //                         buildLangConfigString =
-  //                             buildLangConfigString +
-  //                             `globalThis['${option.namespace}']['${item}']=${JSON.stringify(langObjMap[item])};`
-  //                     })
-  //                     try {
-  //                         // 翻译配置写入主文件
-  //                         fs.writeFileSync(
-  //                             filePath,
-  //                             `globalThis['${option.namespace}']={};${buildLangConfigString}` +
-  //                                 data
-  //                         )
-  //                         console.info('恭喜：翻译配置写入构建主文件成功🌟🌟🌟')
-  //                     } catch (err) {
-  //                         console.error('翻译配置写入构建主文件失败:', err)
-  //                     }
-  //                 })
-  //             }
-  //         })
-  //     })
-  // }
+  // 创建一个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 file = /*#__PURE__*/Object.freeze({
+var translate = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    getLangObjByJSONFileWithLangKey: getLangObjByJSONFileWithLangKey,
-    getLangTranslateJSONFile: getLangTranslateJSONFile,
-    initLangFile: initLangFile,
-    initLangTranslateJSONFile: initLangTranslateJSONFile,
-    initTranslateBasicFnFile: initTranslateBasicFnFile,
-    setLangTranslateJSONFile: setLangTranslateJSONFile,
-    uploadFile: uploadFile
+    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-30 18:23:03
- * @LastEditTime: 2025-03-16 19:12:54
- * @FilePath: /i18n_translation_vite/packages/autoI18nPluginCore/src/utils/translate.ts
+ * @Date: 2023-10-11 10:01:43
+ * @LastEditTime: 2025-03-28 19:07:17
+ * @FilePath: /i18n_translation_vite/packages/autoI18nPluginCore/src/utils/base.ts
  */
-
-const SEPARATOR = '\n┇┇┇\n';
-const SPLIT_SEPARATOR_REGEX = /\n┇ *┇ *┇\n/;
-let langObj = {};
+function getOriginRegex() {
+  const originLang = FunctionFactoryOption.originLang;
+  return REGEX_MAP[originLang];
+}
 
 /**
- * @description: 设置翻译对象属性
- * @param {string} key
- * @param {string} value
+ * @description: 是否包含来源语言字符
+ * @param {string} code
  * @return {*}
  */
-function setLangObj(key, value) {
-  if (!langObj[key]) {
-    langObj[key] = value;
-  }
+function hasOriginSymbols(code) {
+  return getOriginRegex().test(code);
 }
 
 /**
- * @description: 读取翻译对象
+ * @description: 过滤注释
+ * @param {string} code
  * @return {*}
  */
-function getLangObj() {
-  return langObj;
-}
+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 {langObj} obj
+ * @description: 用于判断提供的值是否符合正则表达式数组中的任一规则，符合则跳过
+ * @param {*} value
+ * @param {*} regexArray
  * @return {*}
  */
-function initLangObj(obj) {
-  if (!Object.keys(langObj)) {
-    langObj = obj;
+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
 }
 
-// todo 类型修复
 /**
- * 自动生成多语言配置文件的核心方法
- *
- * 主要流程：
- * 1. 加载现有翻译文件
- * 2. 对比找出新增需要翻译的内容
- * 3. 分块并行翻译所有目标语言
- * 4. 合并翻译结果并生成最终配置文件
- *
- * 异常处理：
- * - 翻译结果不完整时中断流程
- * - 文件读写失败时明确报错
+ * @description: 用于解析抽象语法树中的调用表达式，并提取出调用的名称，如a.b.c() 取 c。
+ * @param {any} node
+ * @return {*}
  */
-async function autoTranslate() {
-  const enabled = typeof exports.option.enabled === 'function' ? exports.option.enabled() : exports.option.enabled;
-  if (!enabled) return;
-
-  // 初始化现有翻译文件缓存
-  const originLangObjMap = {};
-
-  // 加载所有语言的现有翻译内容
-  // 获取当前待翻译内容（深拷贝避免污染原始数据）
-  const currentLangObj = JSON.parse(JSON.stringify(getLangObj()));
-  exports.option.langKey.forEach(lang => {
-    const keyMap = getLangObjByJSONFileWithLangKey(lang);
-    originLangObjMap[lang] = keyMap;
-  });
-
-  // 筛选需要翻译的新增内容
-  const transLangObj = {};
-  Object.keys(currentLangObj).forEach(key => {
-    if (!originLangObjMap[exports.option.originLang][key]) {
-      transLangObj[key] = currentLangObj[key];
+function extractFunctionName(node) {
+  let callName = '';
+  function callObjName(callObj, name) {
+    name += '.' + callObj.property.name;
+    if (types.isMemberExpression(callObj.object)) {
+      // isMemberExpression： 是否是成员表达式
+      return callObjName(callObj.object, name);
     }
-  });
-
-  // 无新内容提前退出
-  if (Object.keys(transLangObj).length === 0) {
-    return;
+    name = callObj.object.name + name;
+    return name;
   }
-
-  // 初始化翻译结果存储结构
-  const newLangObjMap = {};
-
-  // 遍历所有目标语言进行处理
-  for (let langIndex = 0; langIndex < exports.option.langKey.length; langIndex++) {
-    const currentLang = exports.option.langKey[langIndex];
-
-    // 原始语言直接存储原文，读取扫出来的元素翻译内容
-    if (langIndex === 0) {
-      newLangObjMap[exports.option.originLang] = Object.values(transLangObj);
-      continue;
-    }
-    console.info('开始自动翻译...');
-
-    // ─── 分块翻译流程开始 ───
-    const translatedValues = await translateChunks(transLangObj, exports.option.langKey[langIndex]);
-    // ─── 分块翻译流程结束 ───=
-
-    // ─── 翻译结果校验 ───
-    if (translatedValues.length !== Object.keys(transLangObj).length) {
-      console.error('❌ 使用付费翻译时，请检查翻译API额度是否充足，或是否已申请对应翻译API使用权限');
-      console.error(`❌ 翻译结果不完整
-                预期数量: ${Object.keys(transLangObj).length}
-                实际数量: ${translatedValues.length}
-                样例数据: ${JSON.stringify(translatedValues.slice(0, 3))}`);
-      return;
+  if (types.isCallExpression(node)) {
+    // isCallExpression： 是否是调用表达式
+    if (types.isMemberExpression(node.callee)) {
+      callName = callObjName(node.callee, '');
+    } else {
+      callName = node.callee.name || '';
     }
-
-    // 存储当前语言翻译结果
-    newLangObjMap[currentLang] = translatedValues;
-    console.info(`✅ ${currentLang} 翻译完成`);
   }
+  return callName;
+}
 
-  // ─── 合并翻译结果到配置 ───
-  Object.keys(transLangObj).forEach((key, index) => {
-    exports.option.langKey.forEach(item => {
-      originLangObjMap[item][key] = newLangObjMap[item][index];
-    });
-  });
-
-  // ─── 生成最终配置文件结构 ───
-  console.log('📄 构建配置文件数据结构...');
-  const configLangObj = {};
-  Object.keys(originLangObjMap[exports.option.originLang]).forEach(key => {
-    configLangObj[key] = {};
-    exports.option.langKey.forEach(lang => {
-      configLangObj[key][lang] = originLangObjMap[lang][key];
-    });
-  });
+/**
+ * @description: 提取文件的中文部分
+ * @param {string} fileContent
+ * @return {*}
+ */
+const extractCnStrings = fileContent => {
+  const regex = /[^\x00-\xff]+/g;
+  return extractStrings(fileContent, regex);
+};
 
-  // ─── 写入文件系统 ───
-  try {
-    setLangTranslateJSONFile(configLangObj);
-    console.info('🎉 多语言配置文件已成功更新');
-  } catch (error) {
-    console.error('❌ 配置文件写入失败，原因:', error);
-    // todo 可添加重试逻辑或回滚机制
-  }
+/**
+ * @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: 新增语言类型配置补全
- * @param {any} obj
+ * @description: 生成i8n翻译函数
+ * @param {string} value
+ * @param {boolean} isExpression
+ * @param {string} key
  * @return {*}
  */
-function languageConfigCompletion(obj) {
-  if (!Object.keys(obj)) return;
-  const enabled = typeof exports.option.enabled === 'function' ? exports.option.enabled() : exports.option.enabled;
-  if (!enabled) return;
-  let needCompletionList = [];
-  const JSONobj = JSON.parse(getLangTranslateJSONFile());
-  exports.option.targetLangList.forEach(item => {
-    // 获取目标语言 hash：value 对象 和 语言的复合对象，如果当前语言不存在，是langObj的value卡都为空
-    let langObj = getLangObjByJSONFileWithLangKey(item, JSONobj);
-    needCompletionList.push({
-      key: item,
-      curLangObj: langObj
-    });
-  });
-  needCompletionList.forEach(async item => {
-    await completionTranslateAndWriteConfigFile(obj, item.curLangObj, item.key);
-  });
+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
+  };
 }
 
 /**
- * @description: 补全新增语言翻译写入函数
- * @param langObj
- * @param curLangObj
- * @param translateKey
- * @return
+ * @description: 生成唯一id
+ * @param {string} key
+ * @return {*}
  */
-async function completionTranslateAndWriteConfigFile(langObj, curLangObj, translateKey) {
-  // 构建需要翻译的语言映射对象
-  // langObj: 源语言的键值对映射，格式为 { hash: sourceText }
-  // curLangObj: 目标语言的键值对映射，格式为 { hash: targetText }，未翻译的值为空
+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;
+}
 
-  // 创建待翻译内容对象，仅包含未翻译的条目，key是hash，value是源语言的对应hash的文本
-  const transLangObj = {};
-  Object.keys(langObj).forEach(key => {
-    // 如果目标语言中对应的翻译为空，则将 源语言的对应hash的文本 加入待翻译内容对象 中
-    if (curLangObj[key] === undefined) {
-      transLangObj[key] = langObj[key];
-    }
+/**
+ * @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 (!Object.values(transLangObj).length) return;
+};
 
-  // ─── 分块翻译流程开始 ───
+/**
+ * @description: 有道翻译 标识截取
+ * @param {string} q
+ * @return {*}
+ */
+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);
+  }
+}
 
-  console.info('进入新增语言补全翻译...');
+// 导出一个深拷贝函数，用于克隆对象
+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 resultValues = await translateChunks(transLangObj, translateKey);
-  // ─── 分块翻译流程结束 ───
+  // 处理循环引用
+  if (cache.has(value)) {
+    return cache.get(value);
+  }
 
-  if (resultValues.length !== Object.values(langObj).length) {
-    console.error('翻译异常，翻译结果缺失❌');
-    return;
+  // 处理特殊对象类型
+  if (value instanceof Date) {
+    return new Date(value);
   }
-  let newLangObjMap = resultValues;
-  console.info('翻译成功⭐️⭐️⭐️');
-  Object.keys(transLangObj).forEach((key, index) => {
-    curLangObj[key] = newLangObjMap[index];
-  });
-  console.log('开始写入JSON配置文件...');
-  const configLangObj = JSON.parse(getLangTranslateJSONFile());
-  Object.keys(transLangObj).forEach(key => {
-    configLangObj[key][translateKey] = curLangObj[key];
-  });
-  try {
-    setLangTranslateJSONFile(configLangObj);
-    console.info('JSON配置文件写入成功⭐️⭐️⭐️');
-  } catch (error) {
-    console.error('❌JSON配置文件写入失败' + error);
+  if (value instanceof RegExp) {
+    return new RegExp(value.source, value.flags);
   }
-  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 clone = Array.isArray(value) ? [] : {};
 
-  // 等待所有分块完成并合并结果
-  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());
-    };
+  // 缓存对象防止循环引用
+  cache.set(value, clone);
 
-    // 分割符可能会被翻译，所以这里做了兼容处理
-    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;
-  });
+  // 处理 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
 /**
- * @description: 清理多余的翻译配置JSON文件
- * @return {void} 无返回值
+ * 火山引擎翻译器，内置豆包、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 cleanupUnusedTranslations() {
-  if (!exports.option.isClear) return;
-  console.log('🧹 进入清理流程');
-  // 获取当前的语言对象，如果不存在则使用空对象
-  const langObj = getLangObj() || {};
+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解析。
 
-  // 创建一个Set用于存储当前语言对象的所有key，便于快速查找
-  let langSet = new Set(Object.keys(langObj));
+                                参考例子：
+                                示例1：
+                                输入：zh-cn -> en { "awfgx": "你好", "qwfga": "世界" }
+                                输出：{ "awfgx": "Hello", "qwfga": "World" }
 
-  // 获取基础对象：优先使用传入的insertObj，否则从翻译文件中读取
-  const baseObj = JSON.parse(getLangTranslateJSONFile());
+                                示例2：
+                                输入：de -> fr { "gweaq": "Hallo", "wtrts": "Welt" }
+                                输出：{ "gweaq": "Bonjour", "wtrts": "Monde" }
 
-  // 获取基础对象的所有key
-  const baseObjKeys = Object.keys(baseObj);
-  // 遍历所有key，删除在当前语言对象中不存在的配置
-  baseObjKeys.forEach(key => {
-    if (!langSet.has(key)) {
-      baseObj[key] && delete baseObj[key];
-    }
-  });
-  setLangTranslateJSONFile(baseObj);
+                                请回答问题：
+                                输入：源语言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
+    });
+  }
 }
 
-var translate = /*#__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
-});
+/*
+ * @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-02-17 17:11:26
+ * @Date: 2025-03-16 14:12:30
  * @LastEditors: xiaoshan
- * @LastEditTime: 2025-02-17 18:00:37
- * @FilePath: /i18n_translation_vite/packages/autoI18nPluginCore/src/utils/chunk.ts
+ * @LastEditTime: 2025-03-16 14:13:42
+ * @FilePath: /i18n_translation_vite/packages/autoI18nPluginCore/src/enums/option.ts
  */
-
 /**
- * 智能文本分块处理器
- * @param values 待分块的原始文本数组
- * @param maxChunkSize 最大分块长度
- * @returns 包含分块文本和重组方法的对象
- *
- * 功能特性：
- * 1. 自动合并小文本为最大可能块
- * 2. 处理超长文本并给出警告
- * 3. 保证块长度不超过限制
- * 4. 保留原始顺序和分隔符语义
+ * 翻译类型枚举
  */
-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);
+let TranslateTypeEnum = /*#__PURE__*/function (TranslateTypeEnum) {
+  TranslateTypeEnum["FULL_AUTO"] = "full-auto";
+  TranslateTypeEnum["SEMI_AUTO"] = "semi-auto";
+  return TranslateTypeEnum;
+}({});
 
-    // ─── 超长文本处理策略 ───
-    if (value.length > maxChunkSize) {
-      // 优先提交现有缓冲区内容
-      if (buffer.length > 0) commitBuffer();
+/*
+ * @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
+ */
 
-      /**
-       * 超长文本处理逻辑：
-       * - 长度超过1.5倍限制时发出强警告
-       * - 强制单独成块（即使超过限制）
-       * - 后续需要特殊处理这些异常块
-       */
-      if (value.length > maxChunkSize * 1.5) {
-        console.warn(`超长文本告警：检测到长度 ${value.length} 字符的文本项，可能影响翻译质量`);
+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(value);
-      continue;
-    }
-
-    // ─── 正常分块逻辑 ───
-    // 空间不足时提交当前缓冲区
-    if (currentSize + neededSpace > maxChunkSize) {
-      commitBuffer();
     }
+  }),
+  /** 翻译器配置选项，优先级低于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,
+  // 是否清除已经不在上下文中的内容（清除项目中不再使用到的源语言键值对）
 
-    // 更新缓冲区状态（累加长度需包含分隔符）
-    currentSize += neededSpace;
-    buffer.push(value);
-  }
-
-  // 提交最终未完成的缓冲区内容
-  commitBuffer();
+  /**
+   * 是否保留空格
+   */
+  isClearSpace: true
+};
 
-  // 返回分块结果
-  return result;
-}
+/**
+ * 类型定义：插件配置选项类型
+ */
 
-/*
- * @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
+/**
+ * 全局插件配置实例，复制自默认配置
  */
-// 插件核心文件
-// 字符串切割与转换函数
-// import generate from '@babel/generator'
+exports.option = {
+  ...DEFAULT_OPTION
+};
 
-// todo 这个切割函数可以优化，性能可能很差
 /**
- * 根据正则表达式分割字符串，并将符合正则的连续字符拼接起来。
- * @param str - 要分割的字符串。
- * @param separatorRegex - 用于分割字符串的正则表达式。
- * @returns 分割并拼接后的字符串数组。
+ * 类型定义：用户传入的配置选项
  */
+
 /**
- * 这个函数的主要功能是根据给定的正则表达式分割字符串，并对分割结果进行特殊处理。
- * 处理过程分为三个主要步骤：
- *
- * 1. 首先根据分隔符正则和标点符号正则进行初步分割
- * 2. 然后将连续的标点符号和符合分隔符正则的部分重新连接
- * 3. 最后将不符合分隔符正则的相邻部分合并
- *
- * @param str - 需要分割的源字符串
- * @param separatorRegex - 用于分割的正则表达式
- * @returns 处理后的字符串数组
+ * 通过深度克隆提供的选项信息生成一个用户选项对象，
+ * 确保原始配置不被修改。它还根据用户的配置初始化翻译器。
+ * @param optionInfo - 包含用户选项和翻译器细节的选项信息。
+ * @returns 一个新的、可能已初始化翻译器的用户选项对象。
  */
-function splitByRegex(str, separatorRegex) {
-  // 定义标点符号的正则表达式
-  const punctuationRegex = /[，。？！《》,.．：!?""''；'"、0-9\n\r\t\v\f]/;
-  // 创建一个新的正则表达式，用于分割字符串
-  const splitRegex = new RegExp(`(${separatorRegex.source}|${punctuationRegex.source})`, separatorRegex.flags);
+function generateUserOption(optionInfo) {
+  // 深拷贝用户传入的配置，防止修改原配置对象
+  const userOption = cloneDeep(optionInfo);
+  userOption.translator = optionInfo?.translator;
 
-  // 使用正则表达式分割字符串，并过滤掉空字符串
-  const splitArr = str.split(splitRegex).filter(Boolean);
-  const result = [];
-  let currentMatch = '';
+  // 如果用户配置了translatorOption则初始化translator，如果都没有则不设置translator
+  userOption.translator ||= userOption.translatorOption ? new Translator(userOption.translatorOption) : undefined;
+  if (!userOption.translator) delete userOption.translator;
+  return userOption;
+}
 
-  // 定义连接标点符号的正则表达式
-  const connectPunctuationRegex = /[，。？！《》,.．：!?；'"、0-9]/;
-  // 创建一个新的正则表达式，用于检测是否需要连接
-  const connectRegex = new RegExp(`(${separatorRegex.source}|${connectPunctuationRegex.source})`, separatorRegex.flags);
+/**
+ * 初始化插件配置选项
+ * @param optionInfo 用户提供的配置选项
+ */
+function initOption(optionInfo) {
+  // 合并默认配置和用户配置
+  exports.option = {
+    ...DEFAULT_OPTION,
+    ...generateUserOption(optionInfo)
+  };
 
-  // 遍历分割后的数组
-  for (const item of splitArr) {
-    if (connectRegex.test(item)) {
-      // 如果当前项符合连接条件，则将其添加到当前匹配字符串中
-      currentMatch += item;
-    } else {
-      // 如果当前匹配字符串不为空，则将其添加到结果数组中
-      if (currentMatch) {
-        result.push(currentMatch);
-        currentMatch = '';
-      }
-      // 将当前项添加到结果数组中
-      result.push(item);
-    }
-  }
+  // 初始化语言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;
+}
 
-  // 如果最后一个匹配字符串不为空，则将其添加到结果数组中
-  if (currentMatch) {
-    result.push(currentMatch);
+/**
+ * 校验插件配置选项是否完整有效
+ * @returns {boolean} 校验结果，完整返回 true，否则返回 false
+ */
+function checkOption() {
+  // 校验翻译调用函数是否配置
+  if (!exports.option.translateKey) {
+    console.error('❌请配置翻译调用函数');
+    return false;
   }
 
-  // 再遍历一次，把不符合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 (!exports.option.namespace) {
+    console.error('❌请配置命名空间');
+    return false;
   }
-  if (tempStr) {
-    finalResult.push(tempStr);
+
+  // 校验是否配置了打包后生成文件的主文件名称（如果需要打包到主包中）
+  if (exports.option.buildToDist && !exports.option.distKey) {
+    console.log('❌请配置打包后生成文件的主文件名称');
+    return false;
   }
-  return finalResult;
-}
 
-/**
- * 检查字符串是否需要切割。
- * @param str - 要检查的字符串。
- * @returns 如果字符串需要切割，则返回 true，否则返回 false。
- */
-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('<');
-}
+  // 校验是否配置了打包后生成文件的位置（如果需要打包到主包中）
+  if (exports.option.buildToDist && !exports.option.distPath) {
+    console.log('❌请配置打包后生成文件的位置');
+    return false;
+  }
 
-/**
- * @description: 将字符串数组转换为babel的模板字符串节点
- * @param {string[]} strArray - 字符串数组
- * @return {types.CallExpression} - babel的深度扫描的表达式
- */
-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;
+  // 校验来源语言是否配置
+  if (!exports.option.originLang) {
+    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.targetLangList || !exports.option.targetLangList.length) {
+    console.error('❌请配置目标翻译语言数组');
+    return false;
   }
-}
 
-var upload$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    upload: upload
-});
+  // 如果所有校验通过，返回 true
+  return true;
+}
 
 class Vue2Extends {
   constructor() {
@@ -2337,16 +2428,37 @@ function handleTemplateLiteralWithExpressions(node, path) {
     }
     return false;
   }
+  if (!hasExpressionInsideOriginContent(node)) {
+    return false;
+  }
   const {
     trimmedValue,
     valStr
   } = normalizeTranslateValue(fullValue);
-  const id = generateId(valStr);
+  const id = resolveLangKey(generateId(valStr), trimmedValue);
   const translateNode = createTranslateNode(path, id, valStr, expressionLabels, node.expressions);
   path.replaceWith(translateNode);
   setLangObj(id, trimmedValue);
   return true;
 }
+function hasExpressionInsideOriginContent(node) {
+  return node.expressions.some((_, index) => {
+    const beforeValue = node.quasis.slice(0, index + 1).map(getTemplateElementValue).join('');
+    const afterValue = node.quasis.slice(index + 1).map(getTemplateElementValue).join('');
+    return hasOriginSymbols(beforeValue) && hasOriginSymbols(afterValue);
+  });
+}
+function getTemplateElementValue(quasi) {
+  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 value;
+}
 function getExpressionPlaceholder(expression) {
   if (types.isStringLiteral(expression) || types.isNumericLiteral(expression)) {
     return String(expression.value);
@@ -2411,7 +2523,7 @@ function createTrackedTranslateCall(value) {
     trimmedValue,
     valStr
   } = normalizeTranslateValue(value);
-  const id = generateId(valStr);
+  const id = resolveLangKey(generateId(valStr), trimmedValue);
   if (id && trimmedValue) {
     setLangObj(id, trimmedValue);
   }
@@ -2440,16 +2552,53 @@ function createTemplateLiteralTranslateCall(node) {
   if (!fullValue || !hasOriginSymbols(fullValue) || !exports.option.excludedPattern.length || checkAgainstRegexArray(fullValue, [...exports.option.excludedPattern])) {
     return null;
   }
+  if (!hasExpressionInsideOriginContent(node)) {
+    return createTemplateLiteralWithTranslatedQuasis(node, expressions);
+  }
   const {
     trimmedValue,
     valStr
   } = normalizeTranslateValue(fullValue);
-  const id = generateId(valStr);
+  const id = resolveLangKey(generateId(valStr), trimmedValue);
   if (id && trimmedValue) {
     setLangObj(id, trimmedValue);
   }
   return createTranslateCall(id, valStr, expressionLabels, expressions);
 }
+function createTemplateLiteralWithTranslatedQuasis(node, expressions) {
+  const quasis = [];
+  const nextExpressions = [];
+  let pendingText = '';
+  let hasTranslatedQuasi = false;
+  node.quasis.forEach((quasi, index) => {
+    const value = getTemplateElementValue(quasi);
+    if (value && hasOriginSymbols(value) && exports.option.excludedPattern.length && !checkAgainstRegexArray(value, [...exports.option.excludedPattern])) {
+      quasis.push(types.templateElement({
+        raw: pendingText,
+        cooked: pendingText
+      }, false));
+      nextExpressions.push(createTrackedTranslateCall(value));
+      pendingText = '';
+      hasTranslatedQuasi = true;
+    } else {
+      pendingText += value;
+    }
+    if (index < expressions.length) {
+      quasis.push(types.templateElement({
+        raw: pendingText,
+        cooked: pendingText
+      }, false));
+      nextExpressions.push(types.cloneNode(expressions[index]));
+      pendingText = '';
+    }
+  });
+  if (!hasTranslatedQuasi) return null;
+  quasis.push(types.templateElement({
+    raw: pendingText,
+    cooked: pendingText
+  }, true));
+  return types.templateLiteral(quasis, nextExpressions);
+}
 function getConditionalExpressionLabel(expression) {
   const test = expression.test;
   if (types.isBinaryExpression(test) || types.isLogicalExpression(test)) {
@@ -2529,9 +2678,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);
     }