vite-gc-i18n-plugin 1.1.0 → 1.1.1

package/dist/index.cjs

@@ -1,2 +1,2699 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("gc-i18n-plugin-core");function t(e){var t=Object.create(null);return e&&Object.keys(e).forEach((function(n){if("default"!==n){var r=Object.getOwnPropertyDescriptor(e,n);Object.defineProperty(t,n,r.get?r:{enumerable:!0,get:function(){return e[n]}})}})),t.default=e,Object.freeze(t)}var n=t(require("@babel/core")),r=function(){return r=Object.assign||function(e){for(var t,n=1,r=arguments.length;n<r;n++)for(var o in t=arguments[n])Object.prototype.hasOwnProperty.call(t,o)&&(e[o]=t[o]);return e},r.apply(this,arguments)};function o(e,t,n,r){return new(n||(n=Promise))((function(o,i){function a(e){try{c(r.next(e))}catch(e){i(e)}}function l(e){try{c(r.throw(e))}catch(e){i(e)}}function c(e){var t;e.done?o(e.value):(t=e.value,t instanceof n?t:new n((function(e){e(t)}))).then(a,l)}c((r=r.apply(e,t||[])).next())}))}function i(e,t){var n,r,o,i={label:0,sent:function(){if(1&o[0])throw o[1];return o[1]},trys:[],ops:[]},a=Object.create(("function"==typeof Iterator?Iterator:Object).prototype);return a.next=l(0),a.throw=l(1),a.return=l(2),"function"==typeof Symbol&&(a[Symbol.iterator]=function(){return this}),a;function l(l){return function(c){return function(l){if(n)throw new TypeError("Generator is already executing.");for(;a&&(a=0,l[0]&&(i=0)),i;)try{if(n=1,r&&(o=2&l[0]?r.return:l[0]?r.throw||((o=r.return)&&o.call(r),0):r.next)&&!(o=o.call(r,l[1])).done)return o;switch(r=0,o&&(l=[2&l[0],o.value]),l[0]){case 0:case 1:o=l;break;case 4:return i.label++,{value:l[1],done:!1};case 5:i.label++,r=l[1],l=[0];continue;case 7:l=i.ops.pop(),i.trys.pop();continue;default:if(!(o=i.trys,(o=o.length>0&&o[o.length-1])||6!==l[0]&&2!==l[0])){i=0;continue}if(3===l[0]&&(!o||l[1]>o[0]&&l[1]<o[3])){i.label=l[1];break}if(6===l[0]&&i.label<o[1]){i.label=o[1],o=l;break}if(o&&i.label<o[2]){i.label=o[2],i.ops.push(l);break}o[2]&&i.ops.pop(),i.trys.pop();continue}l=t.call(e,i)}catch(e){l=[6,e],r=0}finally{n=o=0}if(5&l[0])throw l[1];return{value:l[0]?l[1]:void 0,done:!0}}([l,c])}}}function a(e,t,n){if(n||2===arguments.length)for(var r,o=0,i=t.length;o<i;o++)!r&&o in t||(r||(r=Array.prototype.slice.call(t,0,o)),r[o]=t[o]);return e.concat(r||Array.prototype.slice.call(t))}"function"==typeof SuppressedError&&SuppressedError;var l=[".vue",".ts",".js",".tsx",".jsx"];exports.default=function(t){var c,u="vite-gc-i18n-plugin";if(e.initOption(r({deepScan:!0,globalPath:"./lang",namespace:"lang",translateKey:"$t",distPath:"./dist/assets",distKey:"index",targetLangList:["zh-cn","zh-tw"],originLang:"zh-cn",translator:new e.CNToTWTranslator},t)),!e.checkOption())return{name:u};e.fileUtils.initLangFile();var s=e.fileUtils.getLangObjByJSONFileWithLangKey(e.option.originLang);return e.translateUtils.languageConfigCompletion(s),e.translateUtils.initLangObj(s),{name:u,configResolved:function(e){c=e},transform:function(t,r){return o(this,void 0,void 0,(function(){var o,u;return i(this,(function(i){switch(i.label){case 0:return a(a([],l,!0),e.option.insertFileExtensions||[],!0).some((function(e){return r.endsWith(e)}))?e.option.includePath.length&&!e.baseUtils.checkAgainstRegexArray(r,e.option.includePath)||e.option.excludedPath.length&&e.baseUtils.checkAgainstRegexArray(r,e.option.excludedPath)?[2,t]:(e.FunctionFactoryOption.originLang=e.option.originLang,o=void 0,e.option.translateExtends?[4,null===(u=e.option.translateExtends)||void 0===u?void 0:u.handleInitFile(t,r)]:[3,2]):[3,4];case 1:return o=i.sent(),[3,3];case 2:o={source:t},i.label=3;case 3:return[2,n.transformAsync(o.source,{configFile:!1,plugins:[e.filter.default()]}).then((function(t){return"serve"===(null==c?void 0:c.command)&&e.translateUtils.autoTranslate(),null==t?void 0:t.code})).catch((function(e){console.error(e)}))];case 4:return[2]}}))}))},buildEnd:function(){return o(this,void 0,void 0,(function(){return i(this,(function(t){switch(t.label){case 0:return console.info("构建阶段批量翻译"),[4,e.translateUtils.autoTranslate()];case 1:return t.sent(),[2]}}))}))},closeBundle:function(){return o(this,void 0,void 0,(function(){return i(this,(function(t){switch(t.label){case 0:return c&&"build"===c.command?e.option.uploadEnabled?(console.info("构建阶段:开始上传翻译文件"),[4,e.fileUtils.uploadFile()]):[3,2]:[3,3];case 1:return t.sent(),[3,3];case 2:console.info("构建阶段:上传翻译文件功能已禁用（uploadEnabled: false）"),t.label=3;case 3:return[2]}}))}))}}},Object.keys(e).forEach((function(t){"default"===t||Object.prototype.hasOwnProperty.call(exports,t)||Object.defineProperty(exports,t,{enumerable:!0,get:function(){return e[t]}})}));
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var googleTranslateApi = require('@vitalets/google-translate-api');
+var tunnel = require('tunnel');
+var axios = require('axios');
+var CryptoJS = require('crypto-js');
+var OpenCC = require('opencc-js');
+var types = require('@babel/types');
+var _ = require('lodash');
+var path = require('node:path');
+var fs = require('node:fs');
+var babel = require('@babel/core');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var OpenCC__namespace = /*#__PURE__*/_interopNamespaceDefault(OpenCC);
+var types__namespace = /*#__PURE__*/_interopNamespaceDefault(types);
+var babel__namespace = /*#__PURE__*/_interopNamespaceDefault(babel);
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+var __assign = function () {
+  __assign = Object.assign || function __assign(t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+    }
+    return t;
+  };
+  return __assign.apply(this, arguments);
+};
+function __awaiter(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function (resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+}
+function __generator(thisArg, body) {
+  var _ = {
+      label: 0,
+      sent: function () {
+        if (t[0] & 1) throw t[1];
+        return t[1];
+      },
+      trys: [],
+      ops: []
+    },
+    f,
+    y,
+    t,
+    g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+  return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function () {
+    return this;
+  }), g;
+  function verb(n) {
+    return function (v) {
+      return step([n, v]);
+    };
+  }
+  function step(op) {
+    if (f) throw new TypeError("Generator is already executing.");
+    while (g && (g = 0, op[0] && (_ = 0)), _) try {
+      if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+      if (y = 0, t) op = [op[0] & 2, t.value];
+      switch (op[0]) {
+        case 0:
+        case 1:
+          t = op;
+          break;
+        case 4:
+          _.label++;
+          return {
+            value: op[1],
+            done: false
+          };
+        case 5:
+          _.label++;
+          y = op[1];
+          op = [0];
+          continue;
+        case 7:
+          op = _.ops.pop();
+          _.trys.pop();
+          continue;
+        default:
+          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+            _ = 0;
+            continue;
+          }
+          if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+            _.label = op[1];
+            break;
+          }
+          if (op[0] === 6 && _.label < t[1]) {
+            _.label = t[1];
+            t = op;
+            break;
+          }
+          if (t && _.label < t[2]) {
+            _.label = t[2];
+            _.ops.push(op);
+            break;
+          }
+          if (t[2]) _.ops.pop();
+          _.trys.pop();
+          continue;
+      }
+      op = body.call(thisArg, _);
+    } catch (e) {
+      op = [6, e];
+      y = 0;
+    } finally {
+      f = t = 0;
+    }
+    if (op[0] & 5) throw op[1];
+    return {
+      value: op[0] ? op[1] : void 0,
+      done: true
+    };
+  }
+}
+function __spreadArray(to, from, pack) {
+  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+    if (ar || !(i in from)) {
+      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+      ar[i] = from[i];
+    }
+  }
+  return to.concat(ar || Array.prototype.slice.call(from));
+}
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+  var e = new Error(message);
+  return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+/**
+ * 间隔执行队列
+ */
+class IntervalQueue {
+  /**
+   * @param fn 执行函数
+   * @param delay 执行间隔
+   * @param timeout 超时时间
+   */
+  constructor(fn, delay, timeout) {
+    this.fn = fn;
+    this.delay = delay;
+    this.timeout = timeout;
+  }
+  queue = [];
+  async wait() {
+    let delay = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.delay;
+    await new Promise(resolve => setTimeout(resolve, delay));
+  }
+  isRunning = false;
+  async run() {
+    if (this.isRunning) return;
+    let item;
+    while (item = this.queue.shift()) {
+      const {
+        args,
+        resolve,
+        reject
+      } = item;
+      this.isRunning = true;
+      try {
+        const result = await this.fn(...args);
+        resolve(result);
+      } catch (e) {
+        reject(e);
+      }
+      await this.wait();
+    }
+    this.isRunning = false;
+  }
+
+  /**
+   * 执行一次fn
+   * @param args fn的入参
+   * @returns 返回fn的返回值的Promise
+   */
+  execute() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return new Promise((resolve, reject) => {
+      this.queue.push({
+        args,
+        resolve,
+        reject
+      });
+      this.run();
+      if (this.timeout) {
+        setTimeout(() => {
+          reject(new Error('IntervalQueue timeout'));
+        }, this.timeout);
+      }
+    });
+  }
+}
+
+class Translator {
+  constructor(option) {
+    this.option = this.getResultOption(option);
+  }
+  defaultErrorHandler = error => {
+    const name = this.option.name;
+    console.error(`翻译api${name ? `【${name}】` : ''}请求异常：${this.getErrorMessage(error)}`);
+  };
+  getResultOption(option) {
+    const resultOption = {
+      version: 1,
+      maxChunkSize: 4500,
+      // 目前默认是4500
+      interval: 0,
+      onError: this.defaultErrorHandler,
+      ...option
+    };
+    if (resultOption.interval) {
+      const getIntervalFn = (fn, delay) => {
+        const queue = new IntervalQueue(fn.bind(null), delay);
+        return function () {
+          return queue.execute(...arguments);
+        };
+      };
+      resultOption.fetchMethod = getIntervalFn(resultOption.fetchMethod, resultOption.interval);
+    }
+    return resultOption;
+  }
+  getErrorMessage(error) {
+    if (error instanceof Error) {
+      return error.message;
+    } else {
+      return String(error);
+    }
+  }
+  async translate(text, fromKey, toKey, separator) {
+    let result = '';
+    try {
+      result = await this.option.fetchMethod(text, fromKey, toKey, separator);
+    } catch (error) {
+      this.option.onError(error, this.defaultErrorHandler);
+    }
+    return result;
+  }
+}
+
+/*
+ * @Date: 2025-03-11 17:53:11
+ * @LastEditors: xiaoshan
+ * @LastEditTime: 2025-03-14 14:21:06
+ * @FilePath: /i18n_translation_vite/packages/autoI18nPluginCore/src/translator/google.ts
+ */
+/**
+ * 谷歌翻译器
+ * 
+ * 基于@vitalets/google-translate-api，需要翻墙，不稳定，但是免费
+ * 
+ * 使用方式：
+ * ```ts
+ * vitePluginsAutoI18n({
+    ...
+    translator: translator: new GoogleTranslator({
+        proxyOption: {
+            // 如果你本地的代理在127.0.0.0:8899
+            host: '127.0.0.1',
+            port: 8899,
+            headers: {
+                'User-Agent': 'Node'
+            }
+        }
+    })
+})
+ * ```
+ */
+class GoogleTranslator extends Translator {
+  constructor(option) {
+    super({
+      name: 'Google翻译',
+      fetchMethod: async (text, fromKey, toKey) => {
+        let data = await googleTranslateApi.translate(text, {
+          from: fromKey,
+          to: toKey,
+          ...(option.proxyOption ? {
+            fetchOptions: {
+              agent: tunnel.httpsOverHttp({
+                proxy: option.proxyOption
+              })
+            }
+          } : {}),
+          ...(option.insertOption || {})
+        });
+        return data['text'] || '';
+      },
+      onError: (error, cb) => {
+        cb(error);
+        if (error instanceof Object && 'code' in error && error.code === 'ETIMEDOUT') {
+          console.error('❗ 请求超时，请确保你的网络可以访问google ❗');
+        }
+      },
+      interval: option.interval ?? 1000
+    });
+  }
+}
+
+/**
+ * 有道翻译器
+ * 
+ * api文档：https://ai.youdao.com/DOCSIRMA/html/trans/api/wbfy/index.html
+ * 
+ * 使用方式：
+ * ```ts
+ * vitePluginsAutoI18n({
+    ...
+    translator: new YoudaoTranslator({
+        appId: '你申请的appId',
+        appKey: '你申请的appKey'
+    })
+})
+ * ```
+ */
+class YoudaoTranslator extends Translator {
+  /** 有道的语言类型映射不标准，需要手动控制 */
+  YOUDAO_TRANSLATE_KEY_CONVERT_MAP = {
+    'zh-cn': 'zh-CHS',
+    'zh-tw': 'zh-CHT'
+  };
+  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);
+    }
+  }
+  getTranslateKey(key) {
+    return this.YOUDAO_TRANSLATE_KEY_CONVERT_MAP[key] || key;
+  }
+  constructor(option) {
+    super({
+      name: '有道翻译',
+      fetchMethod: async (text, fromKey, toKey) => {
+        let salt = new Date().getTime();
+        let curTime = Math.round(new Date().getTime() / 1000);
+        let str = option.appId + this.truncate(text) + salt + curTime + option.appKey;
+        let sign = CryptoJS.SHA256(str).toString(CryptoJS.enc.Hex);
+        const data = {
+          q: text,
+          appKey: option.appId,
+          salt,
+          from: this.getTranslateKey(fromKey),
+          to: this.getTranslateKey(toKey),
+          sign,
+          signType: 'v3',
+          curtime: curTime,
+          ...(option.insertOption || {})
+        };
+        const response = await axios.post('https://openapi.youdao.com/api', data, {
+          headers: {
+            'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8'
+          },
+          proxy: option.proxy
+        });
+        // 请求成功，返回响应数据
+        return response.data.translation?.[0] || '';
+      },
+      onError: (error, cb) => {
+        cb(error);
+        console.error('请前往有道翻译官方申请翻译key，默认会有50的额度，并请检查额度是否充足。');
+      },
+      interval: option.interval ?? 1000
+    });
+  }
+}
+
+/*
+ * @Date: 2025-03-16 23:39:13
+ * @LastEditors: xiaoshan
+ * @LastEditTime: 2025-03-17 01:11:37
+ * @FilePath: /i18n_translation_vite/packages/autoI18nPluginCore/src/translator/baidu.ts
+ */
+/**
+ * 百度翻译器
+ * 
+ * api文档：https://api.fanyi.baidu.com/product/113
+ * 
+ * 使用方式：
+ * ```ts
+ * vitePluginsAutoI18n({
+    ...
+    translator: new BaiduTranslator({
+        appId: '你申请的appId',
+        appKey: '你申请的appKey'
+    })
+})
+ * ```
+ */
+class BaiduTranslator extends Translator {
+  /** 百度的语言类型映射不标准，需要手动控制 */
+  BAIDU_TRANSLATE_KEY_CONVERT_MAP = {
+    'zh-cn': 'zh',
+    ja: 'jp',
+    ko: 'kor'
+  };
+  getTranslateKey(key) {
+    return this.BAIDU_TRANSLATE_KEY_CONVERT_MAP[key] || key;
+  }
+  constructor(option) {
+    super({
+      name: '百度翻译',
+      fetchMethod: async (text, fromKey, toKey, separator) => {
+        let salt = new Date().getTime();
+        const data = {
+          q: text,
+          appid: option.appId,
+          from: this.getTranslateKey(fromKey),
+          to: this.getTranslateKey(toKey),
+          salt,
+          sign: CryptoJS.MD5(option.appId + text + salt + option.appKey).toString(),
+          ...(option.insertOption || {})
+        };
+        const response = await axios.post('https://fanyi-api.baidu.com/api/trans/vip/translate', data, {
+          headers: {
+            'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8'
+          },
+          proxy: option.proxy
+        });
+        const translatedTexts = response.data?.trans_result.map(item => item.dst).filter((_item, index) => index % 2 === 0).join(separator);
+
+        // 请求成功，返回响应数据
+        return translatedTexts || '';
+      },
+      onError: (error, cb) => {
+        cb(error);
+        console.error('请前往百度翻译官方申请翻译key，每个月都有免费额度，并请检查额度是否充足。');
+      },
+      interval: option.interval ?? 1000
+    });
+  }
+}
+
+/*
+ * @Date: 2025-03-31 19:05:57
+ * @LastEditors: xiaoshan
+ * @LastEditTime: 2025-03-31 19:52:10
+ * @FilePath: /i18n_translation_vite/packages/autoI18nPluginCore/src/translator/scan.ts
+ */
+
+/**
+ * 空翻译器，不翻译文本，用于配合某些特殊的操作
+ */
+class EmptyTranslator extends Translator {
+  constructor() {
+    let option = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    const resultOption = {
+      name: '空翻译器',
+      fetchMethod: async (text, _from, _to, separator) => {
+        // 相当于把翻译结果统一设置为空串
+        const value = text.split(separator).fill('');
+        return value.join(separator);
+      },
+      ...option
+    };
+    super(resultOption);
+  }
+  // TODO: 后续可以作为基类，提供更多的配置选项
+}
+
+/** @deprecated 别名导出，兼容旧版本 */
+const ScanTranslator = EmptyTranslator;
+
+const cn2tw = OpenCC__namespace.Converter({
+  from: 'cn',
+  to: 'tw'
+});
+class CNToTWTranslator extends Translator {
+  constructor() {
+    super({
+      name: '中翻繁翻译',
+      fetchMethod: async (text, fromKey, toKey) => {
+        let translatedTexts = text;
+        if (fromKey === 'zh-cn' && toKey === 'zh-tw') {
+          translatedTexts = cn2tw(text);
+        }
+
+        // 请求成功，返回响应数据
+        return translatedTexts;
+      },
+      onError: (error, cb) => {
+        cb(error);
+        console.error('翻译失败');
+      }
+    });
+  }
+}
+
+/*
+ * @Author: xiaoshanwen
+ * @Date: 2024-02-29 14:44:18
+ * @LastEditTime: 2024-03-01 11:42:34
+ * @FilePath: /i18n_translation_vite/autoI18nPluginCore/src/utils/option.ts
+ */
+
+class FunctionFactoryOption {
+  static originLang = '';
+}
+
+/*
+ * @Author: xiaoshanwen
+ * @Date: 2024-03-11 18:59:10
+ * @LastEditTime: 2025-03-16 18:15:25
+ * @FilePath: /i18n_translation_vite/packages/autoI18nPluginCore/src/enums/language.ts
+ */
+// 待补充...
+let LanguageEnum = /*#__PURE__*/function (LanguageEnum) {
+  return LanguageEnum;
+}({});
+let OriginLangKeyEnum = /*#__PURE__*/function (OriginLangKeyEnum) {
+  OriginLangKeyEnum["ZH"] = "zh-cn";
+  OriginLangKeyEnum["EN"] = "en";
+  OriginLangKeyEnum["JA"] = "ja";
+  OriginLangKeyEnum["KO"] = "ko";
+  OriginLangKeyEnum["RU"] = "ru";
+  return OriginLangKeyEnum;
+}({});
+
+/*
+ * @Author: xiaoshanwen
+ * @Date: 2024-04-06 15:47:14
+ * @LastEditTime: 2025-03-16 18:18:28
+ * @FilePath: /i18n_translation_vite/packages/autoI18nPluginCore/src/constants/translate.ts
+ */
+const REGEX_MAP = {
+  [OriginLangKeyEnum.ZH]: /[\u4e00-\u9fff]/,
+  [OriginLangKeyEnum.EN]: /[a-zA-Z]/,
+  [OriginLangKeyEnum.JA]: /[\u3040-\u309F\u30A0-\u30FF\u4E00-\u9FFF]/,
+  // 日语假名和汉字
+  [OriginLangKeyEnum.KO]: /[\uAC00-\uD7A3]/,
+  // 韩语字母
+  [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];
+}
+
+/**
+ * @description: 是否包含来源语言字符
+ * @param {string} code
+ * @return {*}
+ */
+function hasOriginSymbols(code) {
+  return getOriginRegex().test(code);
+}
+
+/**
+ * @description: 过滤注释
+ * @param {string} code
+ * @return {*}
+ */
+const removeComments = function (code) {
+  // 使用正则表达式匹配并删除单行注释
+  code = code.replace(/\/\/.*?\n/g, '');
+  // 使用正则表达式匹配并删除多行注释
+  code = code.replace(/\/\*[\s\S]*?\*\//g, '');
+  // 使用正则表达式匹配并删除HTML注释
+  code = code.replace(/<!--[\s\S]*?-->/g, '');
+  return code;
+};
+
+/**
+ * @description: 用于判断提供的值是否符合正则表达式数组中的任一规则，符合则跳过
+ * @param {*} value
+ * @param {*} regexArray
+ * @return {*}
+ */
+function checkAgainstRegexArray(value, regexArray) {
+  for (let i = 0; i < regexArray.length; i++) {
+    const regex = typeof regexArray[i] === 'string' ? new RegExp(regexArray[i]) : regexArray[i];
+    if (regex.test(value)) {
+      return true; // 如果符合任何一个规则，返回 true
+    }
+  }
+  return false; // 如果所有规则都不符合，返回 false
+}
+
+/**
+ * @description: 用于解析抽象语法树中的调用表达式，并提取出调用的名称，如a.b.c() 取 c。
+ * @param {any} node
+ * @return {*}
+ */
+function extractFunctionName(node) {
+  let callName = '';
+  function callObjName(callObj, name) {
+    name += '.' + callObj.property.name;
+    if (types.isMemberExpression(callObj.object)) {
+      // isMemberExpression： 是否是成员表达式
+      return callObjName(callObj.object, name);
+    }
+    name = callObj.object.name + name;
+    return name;
+  }
+  if (types.isCallExpression(node)) {
+    // isCallExpression： 是否是调用表达式
+    if (types.isMemberExpression(node.callee)) {
+      callName = callObjName(node.callee, '');
+    } else {
+      callName = node.callee.name || '';
+    }
+  }
+  return callName;
+}
+
+/**
+ * @description: 提取文件的中文部分
+ * @param {string} fileContent
+ * @return {*}
+ */
+const extractCnStrings = fileContent => {
+  const regex = /[^\x00-\xff]+/g;
+  return extractStrings(fileContent, regex);
+};
+
+/**
+ * @description: 提取文件指定部分内容
+ * @param {string} fileContent
+ * @param {any} regex
+ * @return {*}
+ */
+function extractStrings(fileContent, regex) {
+  const matches = fileContent.match(regex);
+  return matches ? matches.filter((item, index) => matches.indexOf(item) === index) : [];
+}
+
+/**
+ * @description: 生成i8n翻译函数
+ * @param {string} value
+ * @param {boolean} isExpression
+ * @param {string} key
+ * @return {*}
+ */
+function createI18nTranslator(createOption) {
+  const {
+    value,
+    isExpression = false,
+    key,
+    insertOption
+  } = createOption;
+
+  // 从全局配置对象 option 中获取命名空间
+  const nameSpace = exports.option.namespace;
+  const {
+    trimmedValue,
+    valStr
+  } = normalizeTranslateValue(value);
+  // 若 key 存在则使用 key，否则调用 generateId 函数根据 valStr 生成唯一的键
+  const generatedKey = key || generateId(valStr);
+  // 提取公共配置对象，避免重复代码
+  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: 生成唯一id
+ * @param {string} key
+ * @return {*}
+ */
+function generateId(key) {
+  let hash = 0;
+  for (let i = 0; i < key.length; i++) {
+    const charCode = key.charCodeAt(i);
+    hash = (hash << 5) - hash + charCode;
+    hash = hash & hash;
+  }
+  const id = Math.abs(hash).toString(36) + key.length.toString(36);
+  return id;
+}
+
+/**
+ * @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));
+  });
+};
+
+/**
+ * @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);
+  }
+}
+
+// 导出一个深拷贝函数，用于克隆对象
+function cloneDeep(value) {
+  let cache = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new WeakMap();
+  // 处理基本类型和 null
+  if (typeof value !== 'object' || value === null) {
+    return value;
+  }
+
+  // 处理循环引用
+  if (cache.has(value)) {
+    return cache.get(value);
+  }
+
+  // 处理特殊对象类型
+  if (value instanceof Date) {
+    return new Date(value);
+  }
+  if (value instanceof RegExp) {
+    return new RegExp(value.source, value.flags);
+  }
+
+  // 初始化克隆容器
+  const clone = Array.isArray(value) ? [] : {};
+
+  // 缓存对象防止循环引用
+  cache.set(value, clone);
+
+  // 处理 Symbol 和普通键的枚举
+  const keys = [...Object.keys(value), ...Object.getOwnPropertySymbols(value).filter(sym => value.propertyIsEnumerable(sym))];
+
+  // 递归克隆属性
+  for (const key of keys) {
+    clone[key] = cloneDeep(value[key], cache);
+  }
+  return clone;
+}
+
+var base = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    checkAgainstRegexArray: checkAgainstRegexArray,
+    cloneDeep: cloneDeep,
+    createI18nTranslator: createI18nTranslator,
+    extractCnStrings: extractCnStrings,
+    extractFunctionName: extractFunctionName,
+    extractStrings: extractStrings,
+    generateId: generateId,
+    getOriginRegex: getOriginRegex,
+    hasOriginSymbols: hasOriginSymbols,
+    normalizeTranslateValue: normalizeTranslateValue,
+    removeComments: removeComments,
+    truncate: truncate,
+    unicodeToString: unicodeToString
+});
+
+// 代码灵感来自https://github.com/dadidi9900/auto-plugins-json-translate/blob/main/src/services/translationService.ts
+/**
+ * 火山引擎翻译器，内置豆包、deepseek等模型
+ * 
+ * 火山引擎大模型介绍：https://www.volcengine.com/docs/82379/1099455
+ * 
+ * api文档：https://www.volcengine.com/docs/82379/1298454
+ * 
+ * 使用方式：
+ * ```ts
+ * vitePluginsAutoI18n({
+    ...
+    translator: new VolcengineTranslator({
+        apiKey: '你申请的apiKey',
+        model: '你要调用的模型，如：`doubao-1-5-pro-32k-250115`，请确保使用前已在控制台开通了对应模型'
+    })
+})
+ * ```
+ */
+class VolcengineTranslator extends Translator {
+  constructor(option) {
+    super({
+      name: '火山引擎ai翻译',
+      fetchMethod: async (text, fromKey, toKey, separator) => {
+        let salt = new Date().getTime();
+        const textArr = text.split(separator);
+        const sourceMap = Object.fromEntries(textArr.map(text => [generateId(text), text]));
+        const data = {
+          model: option.model,
+          messages: [{
+            role: 'system',
+            content: `
+                                ###
+                                假如你是一个无情的翻译接口，你将根据一个文本组成的JSON对象，来解决将数组每个成员从源语言A翻译成目标语言B并返回翻译后的JSON对象的任务。需要注意的是，待翻译的文本均来自一个${option.desc ? option.desc + '的' : ''}web平台，遇到歧义时需要做好处理。根据以下规则一步步执行：
+                                1. 明确源语言A和目标语言B。
+                                2. 对JSON对象中数组的每个成员进行从源语言A到目标语言B的翻译。
+                                3. 将翻译后的内容以JSON对象格式返回，确保返回的内容可以被JSON.parse解析。
+
+                                参考例子：
+                                示例1：
+                                输入：zh-cn -> en { "awfgx": "你好", "qwfga": "世界" }
+                                输出：{ "awfgx": "Hello", "qwfga": "World" }
+
+                                示例2：
+                                输入：de -> fr { "gweaq": "Hallo", "wtrts": "Welt" }
+                                输出：{ "gweaq": "Bonjour", "wtrts": "Monde" }
+
+                                请回答问题：
+                                输入：源语言A -> 目标语言B { "wghhj": "XXX" }
+                                输出：
+
+                                要求：
+                                1 以JSON对象格式输出
+                                2 JSON对象中每个成员为翻译后的内容
+                                ###
+                            `
+          }, {
+            role: 'user',
+            content: `${fromKey} -> ${toKey} ${JSON.stringify(sourceMap)}`
+          }],
+          ...(option.insertOption || {})
+        };
+        const response = await axios.post(`https://ark.cn-beijing.volces.com/api/v3/chat/completions?t=${salt}`, data, {
+          headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${option.apiKey}`
+          },
+          proxy: option.proxy
+        });
+        let resultTextArr = Array.from(textArr).fill('');
+        const content = response.data.choices[0].message.content;
+        try {
+          let resultMap;
+          try {
+            resultMap = JSON.parse(content);
+          } catch (error) {
+            throw new Error('大模型返回文本解析失败');
+          }
+          if (typeof resultMap !== 'object' || !resultMap) {
+            throw new Error('大模型返回文本解析后类型不正确');
+          }
+          const isMiss = Object.keys(resultMap).some(key => !(key in sourceMap));
+          if (isMiss) {
+            throw new Error('大模型返回文本内容不完整');
+          }
+          resultTextArr = textArr.map(text => resultMap[generateId(text)]); // 用textArr遍历，保证顺序
+        } catch (error) {
+          const message = error instanceof Error ? error.message : '未知错误';
+          console.warn('⚠', message);
+          console.warn('⚠ 返回的文本内容：', content);
+          console.warn('⚠ 原文本内容：', JSON.stringify(sourceMap));
+        }
+        return resultTextArr.join(separator);
+      },
+      onError: (error, cb) => {
+        cb(error);
+        console.error('请确保在火山引擎控制台开通了对应模型，且有足够的token余额。控制台地址：https://console.volcengine.com/ark/');
+      },
+      maxChunkSize: 1000,
+      // 太长可能会导致返回文本不完整
+      interval: option.interval ?? 1000
+    });
+  }
+}
+
+/*
+ * @Author: xiaoshanwen
+ * @Date: 2024-04-03 18:12:45
+ * @LastEditTime: 2024-04-03 18:33:53
+ * @FilePath: /i18n_translation_vite/autoI18nPluginCore/src/enums/translate.ts
+ */
+let TranslateApiEnum = /*#__PURE__*/function (TranslateApiEnum) {
+  TranslateApiEnum["google"] = "Google";
+  TranslateApiEnum["youdao"] = "Youdao";
+  return TranslateApiEnum;
+}({});
+
+/*
+ * @Date: 2025-03-16 14:12:30
+ * @LastEditors: xiaoshan
+ * @LastEditTime: 2025-03-16 14:13:42
+ * @FilePath: /i18n_translation_vite/packages/autoI18nPluginCore/src/enums/option.ts
+ */
+/**
+ * 翻译类型枚举
+ */
+let TranslateTypeEnum = /*#__PURE__*/function (TranslateTypeEnum) {
+  TranslateTypeEnum["FULL_AUTO"] = "full-auto";
+  TranslateTypeEnum["SEMI_AUTO"] = "semi-auto";
+  return TranslateTypeEnum;
+}({});
+
+/*
+ * @Author: xiaoshanwen
+ * @Date: 2023-10-26 17:34:47
+ * @LastEditTime: 2025-03-31 19:58:37
+ * @FilePath: /i18n_translation_vite/packages/autoI18nPluginCore/src/option.ts
+ */
+
+const EXCLUDED_CALL = ['$deepScan', 'console.info', 'console.warn', 'console.error', '$i8n', 'console.log', '$t', 'require', '$$i8n', '$$t', '_createCommentVNode'];
+/**
+ * 默认插件配置选项
+ */
+const DEFAULT_OPTION = {
+  appCode: '',
+  /** 是否启用插件，默认启用 */
+  enabled: true,
+  /** 翻译调用函数，默认为 $t */
+  translateKey: '$t',
+  /** 标记不翻译调用函数列表，避免某些调用被错误翻译 */
+  excludedCall: [],
+  /** 标记不用翻译的字符串模式数组，默认是匹配文件扩展名 */
+  excludedPattern: [/\.\w+$/],
+  /** 排查不需要翻译的目录下的文件路径（黑名单）, 默认不处理node_modules */
+  excludedPath: ['node_modules'],
+  /** 指定需要翻译文件的目录路径正则（白名单） */
+  includePath: [/src\//, /src\\/],
+  /** 配置文件生成位置，默认为 './lang' */
+  globalPath: './lang',
+  /** 打包后生成文件的位置，例如 './dist/assets' */
+  distPath: '',
+  /** 打包后生成文件的主文件名称，默认是 'index' */
+  distKey: 'index',
+  /** 来源语言，默认是中文 */
+  originLang: OriginLangKeyEnum.ZH,
+  /** 翻译目标语言列表，默认包含英文 */
+  targetLangList: ['en'],
+  /** 语言key，用于请求谷歌api和生成配置文件下对应语言的内容文件 */
+  langKey: [],
+  /** 命名空间，防止全局命名冲突 */
+  namespace: 'lang',
+  /** 单位代码 */
+  orgCode: 'GREENCLOUD',
+  /** 是否启用源码的值作为key */
+  useValueAsKey: false,
+  /** 是否在构建结束之后将最新的翻译重新打包到主包中，默认不打包 */
+  buildToDist: false,
+  /** 是否启用上传翻译文件到服务器，默认关闭 */
+  uploadEnabled: false,
+  /** 翻译器，决定自动翻译使用的api与调用方式，默认使用 Google 翻译器并使用7890(clash)端口代理 */
+  translator: new GoogleTranslator({
+    proxyOption: {
+      port: 7890,
+      host: '127.0.0.1',
+      headers: {
+        'User-Agent': 'Node'
+      }
+    }
+  }),
+  /** 翻译器配置选项，优先级低于translator */
+  translatorOption: undefined,
+  /**
+   * 翻译类型，支持全自动和半自动两种模式
+   * 全自动：所有翻译任务自动完成
+   * 半自动：需要人工标识，类似于 $t('key') 的方式
+   * 默认值为全自动
+   */
+  translateType: TranslateTypeEnum.FULL_AUTO,
+  /**
+   * 是否重写配置文件，默认为true
+   */
+  rewriteConfig: true,
+  /**
+   * 通用翻译key，默认使用namespace，如果commonTranslateKey不为空，则使用commonTranslateKey
+   */
+  commonTranslateKey: '',
+  /**
+   * 实验性属性，表示是否进行深层扫描字符串，默认为 false
+   * 当设置为 true 时，会对代码中的字符串进行更深入的扫描
+   */
+  deepScan: false,
+  /**
+   * 自定义文件拓展名数组
+   */
+  insertFileExtensions: [],
+  /**
+   * 自定义拓展类，插件默认翻译函数挂载在window上，如果希望自定义翻译函数挂载在其他对象上，可以使用该属性
+   * 注意：该属性需要继承BaseExtends类，并且需要实现handleInitFile和handleCodeCall和handleCodeString方法
+   */
+  translateExtends: null,
+  isClear: false,
+  // 是否清除已经不在上下文中的内容（清除项目中不再使用到的源语言键值对）
+
+  /**
+   * 是否保留空格
+   */
+  isClearSpace: true
+};
+
+/**
+ * 类型定义：插件配置选项类型
+ */
+
+/**
+ * 全局插件配置实例，复制自默认配置
+ */
+exports.option = {
+  ...DEFAULT_OPTION
+};
+
+/**
+ * 类型定义：用户传入的配置选项
+ */
+
+/**
+ * 通过深度克隆提供的选项信息生成一个用户选项对象，
+ * 确保原始配置不被修改。它还根据用户的配置初始化翻译器。
+ * @param optionInfo - 包含用户选项和翻译器细节的选项信息。
+ * @returns 一个新的、可能已初始化翻译器的用户选项对象。
+ */
+function generateUserOption(optionInfo) {
+  // 深拷贝用户传入的配置，防止修改原配置对象
+  const userOption = cloneDeep(optionInfo);
+  userOption.translator = optionInfo?.translator;
+
+  // 如果用户配置了translatorOption则初始化translator，如果都没有则不设置translator
+  userOption.translator ||= userOption.translatorOption ? new Translator(userOption.translatorOption) : undefined;
+  if (!userOption.translator) delete userOption.translator;
+  return userOption;
+}
+
+/**
+ * 初始化插件配置选项
+ * @param optionInfo 用户提供的配置选项
+ */
+function initOption(optionInfo) {
+  // 合并默认配置和用户配置
+  exports.option = {
+    ...DEFAULT_OPTION,
+    ...generateUserOption(optionInfo)
+  };
+
+  // 初始化语言key数组，包含来源语言和目标语言
+  exports.option.langKey = [exports.option.originLang, ...exports.option.targetLangList];
+  // 初始化排除调用函数列表，包含默认排除和调用函数主动排除
+  exports.option.excludedCall = [...exports.option.excludedCall, ...EXCLUDED_CALL, ...[exports.option.translateKey, '$' + exports.option.translateKey]];
+  return exports.option;
+}
+
+/**
+ * 校验插件配置选项是否完整有效
+ * @returns {boolean} 校验结果，完整返回 true，否则返回 false
+ */
+function checkOption() {
+  // 校验翻译调用函数是否配置
+  if (!exports.option.translateKey) {
+    console.error('❌请配置翻译调用函数');
+    return false;
+  }
+
+  // 校验命名空间是否配置
+  if (!exports.option.namespace) {
+    console.error('❌请配置命名空间');
+    return false;
+  }
+
+  // 校验是否配置了打包后生成文件的主文件名称（如果需要打包到主包中）
+  if (exports.option.buildToDist && !exports.option.distKey) {
+    console.log('❌请配置打包后生成文件的主文件名称');
+    return false;
+  }
+
+  // 校验是否配置了打包后生成文件的位置（如果需要打包到主包中）
+  if (exports.option.buildToDist && !exports.option.distPath) {
+    console.log('❌请配置打包后生成文件的位置');
+    return false;
+  }
+
+  // 校验来源语言是否配置
+  if (!exports.option.originLang) {
+    console.error('❌请配置来源语言');
+    return false;
+  }
+
+  // 校验目标翻译语言数组是否配置
+  if (!exports.option.targetLangList || !exports.option.targetLangList.length) {
+    console.error('❌请配置目标翻译语言数组');
+    return false;
+  }
+
+  // 如果所有校验通过，返回 true
+  return true;
+}
+
+var allLanguage = [{
+  code: 'zh-CN',
+  name: '简体中文'
+}, {
+  code: 'zh-TW',
+  name: '繁体中文'
+}, {
+  code: 'zh-UG',
+  name: '维吾尔语'
+}, {
+  code: 'en-US',
+  name: '英文'
+}, {
+  code: 'tr-TR',
+  name: '土耳其语'
+}, {
+  code: 'es-ES',
+  name: '西班牙语'
+}, {
+  code: 'ja-JP',
+  name: '日语'
+}, {
+  code: 'ru-RU',
+  name: '俄语'
+}, {
+  code: 'fr-FR',
+  name: '法语'
+}, {
+  code: 'de-DE',
+  name: '德语'
+}, {
+  code: 'pt-BR',
+  name: '巴西葡萄牙语'
+}, {
+  code: 'pt-PT',
+  name: '葡萄牙语'
+}, {
+  code: 'ko-KR',
+  name: '韩语'
+}, {
+  code: 'vi-VN',
+  name: '越南语'
+}, {
+  code: 'sv-SE',
+  name: '瑞典语'
+}, {
+  code: 'id-ID',
+  name: '印尼语'
+}, {
+  code: 'uk-UA',
+  name: '乌克兰语'
+}, {
+  code: 'it-IT',
+  name: '意大利语'
+}, {
+  code: 'th-TH',
+  name: '泰语'
+}, {
+  code: 'hi-IN',
+  name: '印地语'
+}, {
+  code: 'fa-IR',
+  name: '波斯语'
+}, {
+  code: 'ro-RO',
+  name: '罗马尼亚语'
+}, {
+  code: 'el-GR',
+  name: '希腊语'
+}, {
+  code: 'nl-NL',
+  name: '荷兰语'
+}, {
+  code: 'cs-CZ',
+  name: '捷克语'
+}, {
+  code: 'mn-MN',
+  name: '蒙古语'
+}, {
+  code: 'mn-TR',
+  name: '传统蒙古语'
+}, {
+  code: 'fi-FI',
+  name: '芬兰语'
+}, {
+  code: 'ar-SA',
+  name: '阿拉伯语'
+}, {
+  code: 'ar-EG',
+  name: '阿拉伯语-埃及'
+}, {
+  code: 'da-DK',
+  name: '丹麦语'
+}, {
+  code: 'pl-PL',
+  name: '波兰语'
+}, {
+  code: 'nb-NO',
+  name: '挪威语'
+}, {
+  code: 'si-LK',
+  name: '僧伽罗语'
+}];
+
+/**
+ * JSON 格式化配置类型
+ */
+
+// 默认的缩进配置
+const indentConfig = {
+  tab: {
+    char: '\t',
+    size: 1
+  },
+  space: {
+    char: ' ',
+    size: 4
+  }
+};
+
+// 默认格式化配置
+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 字符串
+ */
+function formatJSON(json, indentType) {
+  placeholderStorage = [];
+  let output = '';
+  let indentLevel = 0;
+
+  // 提取反斜杠和字符串
+  json = json.replace(/\\./g, pushPlaceholder) // 处理反斜杠
+  .replace(/(".*?"|'.*?')/g, pushPlaceholder) // 处理字符串
+  .replace(/\s+/g, ''); // 去除多余空格
+
+  // 根据 JSON 内容添加换行和缩进
+  for (let i = 0; i < json.length; i++) {
+    const char = json.charAt(i);
+    switch (char) {
+      case '{':
+      case '[':
+        output += char + '\n' + generateIndentation(++indentLevel, indentType);
+        break;
+      case '}':
+      case ']':
+        output += '\n' + generateIndentation(--indentLevel, indentType) + char;
+        break;
+      case ',':
+        output += ',\n' + generateIndentation(indentLevel, indentType);
+        break;
+      case ':':
+        output += ': ';
+        break;
+      default:
+        output += char;
+        break;
+    }
+  }
+
+  // 去除数字数组的空格，并还原反斜杠和字符串
+  output = output.replace(/\[[\d,\s]+?\]/g, match => match.replace(/\s/g, '')).replace(/\\(\d+)\\/g, popPlaceholder) // 还原填充数据
+  .replace(/\\(\d+)\\/g, popPlaceholder); // 再次还原填充数据
+
+  return output;
+}
+
+/**
+ * 格式化 JSON 的主函数
+ * @param json 需要格式化的 JSON 对象或字符串
+ * @param config 配置选项
+ * @returns 格式化后的 JSON 字符串
+ */
+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}"`);
+  }
+
+  // 生成缩进字符
+  const indentType = generateIndentation(config.size || indent.size, indent.char);
+
+  // 格式化 JSON 字符串
+  return formatJSON(jsonString, indentType);
+}
+
+/**
+ * @description: 新建国际化配置文件夹
+ * @return {*}
+ */
+function initLangFile() {
+  if (!fs.existsSync(exports.option.globalPath)) {
+    fs.mkdirSync(exports.option.globalPath); // 创建lang文件夹
+  }
+  initLangTranslateJSONFile();
+  initTranslateBasicFnFile();
+}
+/**
+ * @description: 初始化翻译基础函数文件
+ * @returns {void}
+ */
+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)
+    }
+}`;
+  // 构建翻译基础函数文件的路径
+  const indexPath = path.join(exports.option.globalPath, 'index.js');
+
+  // 文件已存在 同时 不重写配置，那么这里就结束
+  if (fs.existsSync(indexPath) && !exports.option.rewriteConfig) return;
+
+  // 新增哈希比对逻辑
+
+  // 标记是否需要更新文件
+  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);
+  }
+}
+/**
+ * @description: 生成国际化JSON文件
+ * @return {*}
+ */
+function initLangTranslateJSONFile() {
+  const indexPath = path.join(exports.option.globalPath, 'index.json');
+  if (!fs.existsSync(indexPath)) {
+    // 不存在就创建
+    fs.writeFileSync(indexPath, JSON.stringify({})); // 创建
+  }
+}
+
+/**
+ * @description: 读取国际化JSON文件
+ * @return {*}
+ */
+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({});
+  }
+}
+
+/**
+ * @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());
+
+  // 初始化语言映射对象，用于存储不同语言的hash: value映射
+  const langObj = {};
+
+  // 遍历hash，提取hash对应语言key的值，并写入到langObj
+  Object.keys(JSONObj).forEach(langCode => {
+    langObj[langCode] = JSONObj[langCode][key];
+  });
+
+  // 返回当前语言的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配置文件写入异常，文件不存在');
+  }
+}
+
+/**
+ * @description: 构建时把lang配置文件设置到打包后到主文件中
+ * @return {*}
+ */
+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
+  //         }
+
+  //         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)
+  //                     }
+  //                 })
+  //             }
+  //         })
+  //     })
+  // }
+}
+
+var file = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    getLangObjByJSONFileWithLangKey: getLangObjByJSONFileWithLangKey,
+    getLangTranslateJSONFile: getLangTranslateJSONFile,
+    initLangFile: initLangFile,
+    initLangTranslateJSONFile: initLangTranslateJSONFile,
+    initTranslateBasicFnFile: initTranslateBasicFnFile,
+    setLangTranslateJSONFile: setLangTranslateJSONFile,
+    uploadFile: uploadFile
+});
+
+/*
+ * @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
+ */
+
+const SEPARATOR = '\n┇┇┇\n';
+const SPLIT_SEPARATOR_REGEX = /\n┇ *┇ *┇\n/;
+let langObj = {};
+
+/**
+ * @description: 设置翻译对象属性
+ * @param {string} key
+ * @param {string} value
+ * @return {*}
+ */
+function setLangObj(key, value) {
+  if (!langObj[key]) {
+    langObj[key] = value;
+  }
+}
+
+/**
+ * @description: 读取翻译对象
+ * @return {*}
+ */
+function getLangObj() {
+  return langObj;
+}
+
+/**
+ * @description: 初始化翻译对象
+ * @param {langObj} obj
+ * @return {*}
+ */
+function initLangObj(obj) {
+  if (!Object.keys(langObj)) {
+    langObj = obj;
+  }
+}
+
+// todo 类型修复
+/**
+ * 自动生成多语言配置文件的核心方法
+ *
+ * 主要流程：
+ * 1. 加载现有翻译文件
+ * 2. 对比找出新增需要翻译的内容
+ * 3. 分块并行翻译所有目标语言
+ * 4. 合并翻译结果并生成最终配置文件
+ *
+ * 异常处理：
+ * - 翻译结果不完整时中断流程
+ * - 文件读写失败时明确报错
+ */
+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];
+    }
+  });
+
+  // 无新内容提前退出
+  if (Object.keys(transLangObj).length === 0) {
+    console.info('✅ 当前没有需要翻译的新内容');
+    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;
+    }
+    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;
+    }
+
+    // 存储当前语言翻译结果
+    newLangObjMap[currentLang] = translatedValues;
+    console.info(`✅ ${currentLang} 翻译完成`);
+  }
+
+  // ─── 合并翻译结果到配置 ───
+  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];
+    });
+  });
+
+  // ─── 写入文件系统 ───
+  try {
+    setLangTranslateJSONFile(configLangObj);
+    console.info('🎉 多语言配置文件已成功更新');
+  } catch (error) {
+    console.error('❌ 配置文件写入失败，原因:', error);
+    // todo 可添加重试逻辑或回滚机制
+  }
+}
+
+/**
+ * @description: 新增语言类型配置补全
+ * @param {any} obj
+ * @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);
+  });
+}
+
+/**
+ * @description: 补全新增语言翻译写入函数
+ * @param langObj
+ * @param curLangObj
+ * @param translateKey
+ * @return
+ */
+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 {
+    setLangTranslateJSONFile(configLangObj);
+    console.info('JSON配置文件写入成功⭐️⭐️⭐️');
+  } catch (error) {
+    console.error('❌JSON配置文件写入失败' + error);
+  }
+  console.info('新增语言翻译补全成功⭐️⭐️⭐️');
+}
+
+// 分块翻译流程函数
+async function translateChunks(transLangObj, translateKey) {
+  const {
+    translator
+  } = exports.option;
+  // 获取分块后的文本列表
+  const translationChunks = createTextSplitter(Object.values(transLangObj), translator.option.maxChunkSize);
+  // 并行执行分块翻译
+  const translatePromises = [];
+  for (let i = 0; i < translationChunks.length; i++) {
+    translatePromises.push(translator.translate(translationChunks[i], exports.option.originLang, translateKey, SEPARATOR));
+  }
+
+  // 等待所有分块完成并合并结果
+  const chunkResults = await Promise.all(translatePromises);
+  return chunkResults.map(item => {
+    // 提取分割逻辑到单独的函数中，提高代码复用性
+    const splitTranslation = (text, separatorRegex) => {
+      return text.split(separatorRegex).map(v => v.trim());
+    };
+
+    // 分割符可能会被翻译，所以这里做了兼容处理
+    if (SPLIT_SEPARATOR_REGEX.test(item)) {
+      return splitTranslation(item, SPLIT_SEPARATOR_REGEX);
+    } else {
+      const lines = item.split('\n');
+      const separator = lines.find(line => line.length === 3);
+      let value = [];
+      if (separator) {
+        value = splitTranslation(item, new RegExp(`\\n${separator}\\n`));
+      }
+      const realList = value.filter(Boolean);
+      if (realList.length > 1) {
+        return realList;
+      }
+      return splitTranslation(item, SPLIT_SEPARATOR_REGEX);
+    }
+  }).flat();
+}
+/**
+ * @description: 清理多余的翻译配置JSON文件
+ * @return {void} 无返回值
+ */
+function cleanupUnusedTranslations() {
+  if (!exports.option.isClear) return;
+  console.log('🧹 进入清理流程');
+  // 获取当前的语言对象，如果不存在则使用空对象
+  const langObj = getLangObj() || {};
+
+  // 创建一个Set用于存储当前语言对象的所有key，便于快速查找
+  let langSet = new Set(Object.keys(langObj));
+
+  // 获取基础对象：优先使用传入的insertObj，否则从翻译文件中读取
+  const baseObj = JSON.parse(getLangTranslateJSONFile());
+
+  // 获取基础对象的所有key
+  const baseObjKeys = Object.keys(baseObj);
+  // 遍历所有key，删除在当前语言对象中不存在的配置
+  baseObjKeys.forEach(key => {
+    if (!langSet.has(key)) {
+      baseObj[key] && delete baseObj[key];
+    }
+  });
+  setLangTranslateJSONFile(baseObj);
+}
+
+var translate = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    SEPARATOR: SEPARATOR,
+    SPLIT_SEPARATOR_REGEX: SPLIT_SEPARATOR_REGEX,
+    autoTranslate: autoTranslate,
+    cleanupUnusedTranslations: cleanupUnusedTranslations,
+    completionTranslateAndWriteConfigFile: completionTranslateAndWriteConfigFile,
+    getLangObj: getLangObj,
+    initLangObj: initLangObj,
+    get langObj () { return langObj; },
+    languageConfigCompletion: languageConfigCompletion,
+    setLangObj: setLangObj
+});
+
+/*
+ * @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
+ */
+
+/**
+ * 智能文本分块处理器
+ * @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);
+
+    // ─── 超长文本处理策略 ───
+    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);
+  }
+
+  // 提交最终未完成的缓冲区内容
+  commitBuffer();
+
+  // 返回分块结果
+  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'
+
+// todo 这个切割函数可以优化，性能可能很差
+/**
+ * 根据正则表达式分割字符串，并将符合正则的连续字符拼接起来。
+ * @param str - 要分割的字符串。
+ * @param separatorRegex - 用于分割字符串的正则表达式。
+ * @returns 分割并拼接后的字符串数组。
+ */
+/**
+ * 这个函数的主要功能是根据给定的正则表达式分割字符串，并对分割结果进行特殊处理。
+ * 处理过程分为三个主要步骤：
+ *
+ * 1. 首先根据分隔符正则和标点符号正则进行初步分割
+ * 2. 然后将连续的标点符号和符合分隔符正则的部分重新连接
+ * 3. 最后将不符合分隔符正则的相邻部分合并
+ *
+ * @param str - 需要分割的源字符串
+ * @param separatorRegex - 用于分割的正则表达式
+ * @returns 处理后的字符串数组
+ */
+function splitByRegex(str, separatorRegex) {
+  if (str.includes('\n')) console.log(str, separatorRegex);
+
+  // 定义标点符号的正则表达式
+  const punctuationRegex = /[，。？！《》,.．：!?""''；'"、0-9\n\r\t\v\f]/;
+  // 创建一个新的正则表达式，用于分割字符串
+  const splitRegex = new RegExp(`(${separatorRegex.source}|${punctuationRegex.source})`, separatorRegex.flags);
+
+  // 使用正则表达式分割字符串，并过滤掉空字符串
+  const splitArr = str.split(splitRegex).filter(Boolean);
+  const result = [];
+  let currentMatch = '';
+
+  // 定义连接标点符号的正则表达式
+  const connectPunctuationRegex = /[，。？！《》,.．：!?；'"、0-9]/;
+  // 创建一个新的正则表达式，用于检测是否需要连接
+  const connectRegex = new RegExp(`(${separatorRegex.source}|${connectPunctuationRegex.source})`, separatorRegex.flags);
+
+  // 遍历分割后的数组
+  for (const item of splitArr) {
+    if (connectRegex.test(item)) {
+      // 如果当前项符合连接条件，则将其添加到当前匹配字符串中
+      currentMatch += item;
+    } else {
+      // 如果当前匹配字符串不为空，则将其添加到结果数组中
+      if (currentMatch) {
+        result.push(currentMatch);
+        currentMatch = '';
+      }
+      // 将当前项添加到结果数组中
+      result.push(item);
+    }
+  }
+
+  // 如果最后一个匹配字符串不为空，则将其添加到结果数组中
+  if (currentMatch) {
+    result.push(currentMatch);
+  }
+
+  // 再遍历一次，把不符合separatorRegex 这个正则的拼起来
+  const finalResult = [];
+  let tempStr = '';
+  for (let i = 0; i < result.length; i++) {
+    const item = result[i];
+    if (separatorRegex.test(item)) {
+      if (tempStr) {
+        finalResult.push(tempStr);
+        tempStr = '';
+      }
+      finalResult.push(item);
+    } else {
+      tempStr += item;
+      if (i === result.length - 1 || separatorRegex.test(result[i + 1])) {
+        finalResult.push(tempStr);
+        tempStr = '';
+      }
+    }
+  }
+  if (tempStr) {
+    finalResult.push(tempStr);
+  }
+  return finalResult;
+}
+
+/**
+ * 检查字符串是否需要切割。
+ * @param 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('<');
+}
+
+/**
+ * @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;
+}
+
+// 上传到远程服务器
+// 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'
+    }
+  });
+  if (res.status === 200 && res.data.result === 0) {
+    console.info('上传翻译服务成功✔');
+  } else {
+    console.error('上传翻译服务失败❌');
+    console.log(`请求数据为:`, JSON.stringify(data));
+    console.log(`返回报错信息为:`, res.data);
+  }
+}
+
+var upload$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    upload: upload
+});
+
+class Vue2Extends {
+  constructor() {
+    this.handleInitFile = async (source, path) => {
+      let code = source;
+
+      // 检查是否已经引入了 Vue
+      let importVue = false;
+      let hasVue = false;
+      let importDefaultChar = 'Vue';
+      const result = await babel.transformAsync(code, {
+        configFile: false,
+        plugins: [{
+          visitor: {
+            ImportDeclaration(path) {
+              const {
+                node
+              } = path;
+              if (node.source.value === 'vue') {
+                importVue = true;
+                const specifiers = node.specifiers;
+                specifiers.forEach(specifier => {
+                  if (types.isImportDefaultSpecifier(specifier)) {
+                    hasVue = true;
+                    importDefaultChar = specifier.local.name;
+                  }
+                });
+                if (!hasVue) {
+                  hasVue = true;
+                  specifiers.unshift(types.importDefaultSpecifier(types.identifier('Vue')));
+                }
+              }
+            }
+          }
+        }]
+      });
+      if (importVue && result) code = result.code;
+      if (!importVue) code = `import Vue from 'vue'
+                                    ${code}`;
+      return {
+        path,
+        importDefaultChar,
+        source: code
+      };
+    };
+    this.handleCodeCall = (config, _initFileResult) => {
+      const {
+        option,
+        hash,
+        value,
+        uncodeValue,
+        namespace
+      } = config;
+      const valueExp = types.stringLiteral(value);
+      valueExp.extra = {
+        raw: `'${uncodeValue}'`,
+        // 防止转码为unicode
+        rawValue: value
+      };
+      return types.callExpression(types.memberExpression(types.memberExpression(types.identifier(_initFileResult.importDefaultChar), types.identifier('prototype')), types.identifier(option.translateKey)), [types.stringLiteral(hash), valueExp, types.stringLiteral(namespace)]);
+    };
+    this.handleCodeString = (config, _initFileResult) => {
+      const {
+        option,
+        hash,
+        uncodeValue,
+        namespace
+      } = config;
+      return `${_initFileResult.importDefaultChar}.prototype.${option.translateKey}('${hash}','${uncodeValue}','${namespace}')`;
+    };
+  }
+}
+
+/*
+ * @Author: xiaoshanwen
+ * @Date: 2023-11-01 16:35:38
+ * @LastEditTime: 2025-03-31 02:29:02
+ * @FilePath: /i18n_translation_vite/packages/autoI18nPluginCore/src/filter/visitor/TemplateElement.ts
+ */
+
+// 定义一个包含亚洲语言代码的数组
+const asianLangs = ['zh-cn', 'ja', 'ko'];
+function TemplateLiteral (insertOption) {
+  return function (path) {
+    // 如果是半自动翻译，不做处理
+    if (exports.option.translateType === TranslateTypeEnum.SEMI_AUTO) {
+      return;
+    }
+    let {
+      node,
+      parent
+    } = path;
+    if (!node.quasis.length) return;
+    if (types.isTaggedTemplateExpression(parent)) {
+      return;
+    }
+
+    // 获取真实调用函数
+    const extractFnName = extractFunctionName(parent);
+
+    // 调用语句判断当前调用语句是否包含需要过滤的调用语句
+    if (types.isCallExpression(parent) && extractFnName && (exports.option.excludedCall.includes(extractFnName) || extractFnName?.split('.')?.pop() && exports.option.excludedCall.includes(extractFnName?.split('.')?.pop() || ''))) return;
+    if (node.expressions.length && handleTemplateLiteralWithExpressions(node, path)) {
+      return;
+    }
+    node.quasis.forEach(item => handleTemplateElement(item, insertOption));
+  };
+}
+function handleTemplateLiteralWithExpressions(node, path) {
+  const placeholders = node.expressions.map(expression => getExpressionPlaceholder(expression));
+  if (placeholders.some(placeholder => !placeholder)) {
+    return false;
+  }
+  const fullValue = node.quasis.reduce((result, quasi, index) => {
+    let value = quasi.value.raw || quasi.value.cooked || '';
+    if (asianLangs.some(lang => exports.option.originLang.includes(lang) || exports.option.originLang === lang)) {
+      try {
+        value = unicodeToString(value);
+      } catch (error) {
+        console.log('转换异常');
+      }
+    }
+    return result + value + (index < node.expressions.length ? `\${${placeholders[index]}}` : '');
+  }, '');
+  if (!fullValue || !hasOriginSymbols(fullValue) || !exports.option.excludedPattern.length || checkAgainstRegexArray(fullValue, [...exports.option.excludedPattern])) {
+    return false;
+  }
+  const {
+    trimmedValue,
+    valStr
+  } = normalizeTranslateValue(fullValue);
+  const id = generateId(valStr);
+  const translateNode = types.callExpression(types.identifier(exports.option.translateKey), [types.stringLiteral(id), types.stringLiteral(valStr)]);
+  const valuesName = types.identifier('__values');
+  const keyName = types.identifier('__key');
+  const valueMap = types.objectExpression(node.expressions.map((expression, index) => {
+    const placeholder = placeholders[index];
+    return types.objectProperty(types.stringLiteral(placeholder), expression);
+  }));
+  const interpolationNode = types.callExpression(types.arrowFunctionExpression([types.identifier('__value'), valuesName], types.callExpression(types.memberExpression(types.identifier('__value'), types.identifier('replace')), [types.regExpLiteral('\\\\?\\$\\{([^}]+)\\}', 'g'), types.arrowFunctionExpression([types.identifier('__match'), keyName], types.conditionalExpression(types.binaryExpression('in', keyName, valuesName), types.memberExpression(valuesName, keyName, true), types.identifier('__match')))])), [translateNode, valueMap]);
+  path.replaceWith(interpolationNode);
+  setLangObj(id, trimmedValue);
+  return true;
+}
+function getExpressionPlaceholder(expression) {
+  if (types.isIdentifier(expression)) {
+    return expression.name;
+  }
+  if (types.isMemberExpression(expression)) {
+    const objectName = getExpressionPlaceholder(expression.object);
+    const propertyName = expression.computed ? getExpressionPlaceholder(expression.property) : types.isIdentifier(expression.property) ? expression.property.name : '';
+    const value = [objectName, propertyName].filter(Boolean).join('.');
+    return value.replace(/^\$setup\./, '').replace(/^_ctx\./, '');
+  }
+  if (types.isStringLiteral(expression) || types.isNumericLiteral(expression)) {
+    return String(expression.value);
+  }
+  if (types.isTSAsExpression(expression) || types.isTSTypeAssertion(expression)) {
+    return getExpressionPlaceholder(expression.expression);
+  }
+  if (types.isTSNonNullExpression(expression)) {
+    return getExpressionPlaceholder(expression.expression);
+  }
+  return '';
+}
+
+// 处理模板元素
+function handleTemplateElement(node, insertOption) {
+  let value = node.value.raw || node.value.cooked; // 获取模板字符串的值
+  if (asianLangs.some(lang => exports.option.originLang.includes(lang) || exports.option.originLang === lang)) {
+    try {
+      value = unicodeToString(value || '');
+    } catch (error) {
+      console.log('转换异常');
+    }
+  }
+  // 是否存在来源语言字符，是否在默认字符串中，是否包含过滤字段
+  if (value && hasOriginSymbols(value) && exports.option.excludedPattern.length && !checkAgainstRegexArray(value, [...exports.option.excludedPattern])) {
+    // 生成字符类型翻译节点
+    let newNode = createI18nTranslator({
+      insertOption,
+      value
+    });
+
+    // 替换为字符类型翻译节点
+    node.value.raw = node.value.cooked = `\${${newNode}}`;
+    const {
+      valStr
+    } = normalizeTranslateValue(value);
+    let id = generateId(valStr);
+    if (id && value) {
+      setLangObj(id, value);
+    }
+  }
+}
+
+/*
+ * @Author: xiaoshanwen
+ * @Date: 2023-10-12 18:18:51
+ * @LastEditTime: 2025-03-16 15:17:30
+ * @FilePath: /i18n_translation_vite/packages/autoI18nPluginCore/src/filter/visitor/CallExpression.ts
+ */
+
+// 收集翻译对象
+function CallExpressionFn (insertOption) {
+  return function (path) {
+    let {
+      node
+    } = path;
+    // 提取公共部分，减少重复访问 node.callee 属性
+    const callee = node.callee;
+    if (callee.name === exports.option.translateKey || callee.property && callee.property.name === exports.option.translateKey // 拓展 半自动模式下的 如 a.b.c() 调用
+    ) {
+      if (exports.option.translateType === TranslateTypeEnum.SEMI_AUTO) {
+        // 获取当前翻译函数的参数
+        let arg = node.arguments || [];
+        // 如果参数数量不为 1，则直接返回
+        if (arg.length === 1) {
+          const value = arg[0]?.value || '';
+          // 生成真实调用函数
+          const replaceNode = createI18nTranslator({
+            insertOption,
+            value,
+            isExpression: true
+          });
+          path.replaceWith(replaceNode);
+          translateSetLang(replaceNode);
+        }
+      } else if (exports.option.translateType === TranslateTypeEnum.FULL_AUTO) {
+        // 全自动模式下还是只收集 单独 $t 调用
+        if (callee.name === exports.option.translateKey || callee.property && callee.property.name === exports.option.translateKey) translateSetLang(node);
+      }
+    }
+  };
+}
+
+/**
+ * @description: 处理翻译并设置语言对象属性
+ * @param node - 调用表达式节点
+ * @return
+ */
+function translateSetLang(node) {
+  // 获取调用表达式的参数
+  let arg = node.arguments || [];
+  // 提取参数作为值
+  // 检查参数是否为字符串字面量
+  const id = types__namespace.isStringLiteral(arg[0]) ? arg[0].value : '';
+  const value = types__namespace.isStringLiteral(arg[1]) ? arg[1].value : '';
+  // 检查 ID 和值是否存在，并且第二个参数是字符串字面量
+  if (id && value && types__namespace.isStringLiteral(arg[1])) {
+    // 调用翻译工具的 setLangObj 方法设置语言对象属性
+    setLangObj(id, value);
+  }
+}
+
+/*
+ * @Author: xiaoshanwen
+ * @Date: 2023-10-12 18:18:51
+ * @LastEditTime: 2025-03-31 02:28:53
+ * @FilePath: /i18n_translation_vite/packages/autoI18nPluginCore/src/filter/visitor/StringLiteral.ts
+ */
+function StringLiteralFn (insertOption) {
+  return function (path) {
+    if (exports.option.translateType === TranslateTypeEnum.SEMI_AUTO) {
+      return;
+    }
+    let {
+      node,
+      parent
+    } = path;
+    let value = node.value;
+
+    // 定义一个包含亚洲语言代码的数组
+    const asianLangs = ['zh-cn', 'ja', 'ko'];
+    if (asianLangs.some(lang => exports.option.originLang.includes(lang) || exports.option.originLang === lang)) {
+      try {
+        value = unicodeToString(value);
+      } catch (error) {
+        console.log('转换异常');
+      }
+    }
+    if (hasOriginSymbols(value) && exports.option.excludedPattern.length && !checkAgainstRegexArray(value, [...exports.option.excludedPattern])) {
+      // 获取真实调用函数
+      const extractFnName = extractFunctionName(parent);
+
+      // 防止导入语句，只处理那些当前节点不是键值对的键的字符串字面量，调用语句判断当前调用语句是否包含需要过滤的调用语句
+      if (parent?.callee?.property?.name === exports.option.translateKey || types__namespace.isImportDeclaration(parent) || parent.key === node || types__namespace.isCallExpression(parent) && extractFnName && (exports.option.excludedCall.includes(extractFnName) || extractFnName?.split('.')?.pop() && exports.option.excludedCall.includes(extractFnName?.split('.')?.pop() || ''))) return;
+      let replaceNode;
+      if (exports.option.deepScan && checkNeedSplit(value)) {
+        replaceNode = convertToTemplateLiteral(splitByRegex(value, getOriginRegex()), insertOption);
+      } else if (types__namespace.isJSXAttribute(parent)) {
+        let expression = createI18nTranslator({
+          insertOption,
+          value,
+          isExpression: true
+        });
+        replaceNode = types__namespace.jSXExpressionContainer(expression);
+      } else {
+        replaceNode = createI18nTranslator({
+          insertOption,
+          value,
+          isExpression: true
+        });
+      }
+      path.replaceWith(replaceNode);
+    }
+  };
+}
+
+/*
+ * @Author: xiaoshanwen
+ * @Date: 2023-11-01 16:35:38
+ * @LastEditTime: 2025-03-16 18:24:44
+ * @FilePath: /i18n_translation_vite/packages/autoI18nPluginCore/src/filter/visitor/JSXText.ts
+ */
+function JSXTextFn (insertOption) {
+  return function (path) {
+    console.log('jsx text');
+    if (exports.option.translateType === TranslateTypeEnum.SEMI_AUTO) {
+      return;
+    }
+    let {
+      node
+    } = path;
+    let value = node.value;
+    // 定义一个包含亚洲语言代码的数组
+    const asianLangs = ['zh-cn', 'ja', 'ko'];
+    if (asianLangs.some(lang => exports.option.originLang.includes(lang) || exports.option.originLang === lang)) {
+      try {
+        value = unicodeToString(value);
+      } catch (error) {
+        console.log('转换异常');
+      }
+    }
+    if (hasOriginSymbols(value) && exports.option.excludedPattern.length && !checkAgainstRegexArray(value, [...exports.option.excludedPattern])) {
+      // 生成翻译节点
+      let expression = createI18nTranslator({
+        insertOption,
+        value,
+        isExpression: true
+      });
+      // 生成的翻译节点包装在  types.JSXExpressionContainer  中
+      let newNode = types__namespace.jSXExpressionContainer(expression);
+      // 使用  path.replaceWith  方法将原来的节点替换为新的翻译节点
+      path.replaceWith(newNode);
+    }
+  };
+}
+
+/*
+ * @Author: xiaoshanwen
+ * @Date: 2023-10-12 18:00:37
+ * @LastEditTime: 2023-11-02 10:36:02
+ * @FilePath: /i18n_translation_vite/src/plugins/filter/index.ts
+ */
+
+function index (insertOption) {
+  // 分别调用各个访问器函数并传入插入选项
+  const stringLiteralVisitor = StringLiteralFn(insertOption);
+  const jsxTextVisitor = JSXTextFn(insertOption);
+  const templateLiteralVisitor = TemplateLiteral(insertOption);
+  const callExpressionVisitor = CallExpressionFn(insertOption);
+
+  // 返回一个函数，该函数返回包含访问器的对象
+  return function () {
+    return {
+      // 定义 Babel 访问器对象
+      visitor: {
+        StringLiteral: stringLiteralVisitor,
+        JSXText: jsxTextVisitor,
+        TemplateLiteral: templateLiteralVisitor,
+        CallExpression: callExpressionVisitor
+      }
+    };
+  };
+}
+
+var index$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    default: index
+});
+
+var allowedExtensions = ['.vue', '.ts', '.js', '.tsx', '.jsx'];
+function vitePluginsAutoI18n(optionInfo) {
+  var name = 'vite-gc-i18n-plugin';
+  var config;
+  initOption(__assign({
+    deepScan: true,
+    globalPath: './lang',
+    namespace: 'lang',
+    translateKey: '$t',
+    distPath: './dist/assets',
+    distKey: 'index',
+    targetLangList: ['zh-cn', 'zh-tw'],
+    originLang: 'zh-cn',
+    translator: new CNToTWTranslator()
+  }, optionInfo));
+  if (!checkOption()) return {
+    name: name
+  };
+  initLangFile();
+  var originLangObj = getLangObjByJSONFileWithLangKey(exports.option.originLang);
+  languageConfigCompletion(originLangObj);
+  initLangObj(originLangObj);
+  var plugin = {
+    name: name,
+    configResolved: function (resolvedConfig) {
+      // 存储最终解析的配置
+      config = resolvedConfig;
+    },
+    transform: function (code, path) {
+      return __awaiter(this, void 0, void 0, function () {
+        var sourceObj;
+        var _a;
+        return __generator(this, function (_b) {
+          switch (_b.label) {
+            case 0:
+              if (!__spreadArray(__spreadArray([], allowedExtensions, true), exports.option.insertFileExtensions || [], true).some(function (ext) {
+                return path.endsWith(ext);
+              })) return [3 /*break*/, 4];
+              if (exports.option.includePath.length && !checkAgainstRegexArray(path, exports.option.includePath)) return [2 /*return*/, code];
+              if (exports.option.excludedPath.length && checkAgainstRegexArray(path, exports.option.excludedPath)) return [2 /*return*/, code];
+              FunctionFactoryOption.originLang = exports.option.originLang;
+              sourceObj = void 0;
+              if (!exports.option.translateExtends) return [3 /*break*/, 2];
+              return [4 /*yield*/, (_a = exports.option.translateExtends) === null || _a === void 0 ? void 0 : _a.handleInitFile(code, path)];
+            case 1:
+              sourceObj = _b.sent();
+              return [3 /*break*/, 3];
+            case 2:
+              sourceObj = {
+                source: code
+              };
+              _b.label = 3;
+            case 3:
+              return [2 /*return*/, babel__namespace.transformAsync(sourceObj.source, {
+                configFile: false,
+                plugins: [index()]
+              }).then(function (result) {
+                if ((config === null || config === void 0 ? void 0 : config.command) === 'serve') {
+                  autoTranslate(); // 执行前需要确保transformAsync已经完成
+                }
+                return result === null || result === void 0 ? void 0 : result.code;
+              }).catch(function (e) {
+                console.error(e);
+              })];
+            case 4:
+              return [2 /*return*/];
+          }
+        });
+      });
+    },
+    buildEnd: function () {
+      return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+          switch (_a.label) {
+            case 0:
+              console.info('构建阶段批量翻译');
+              return [4 /*yield*/, autoTranslate()];
+            case 1:
+              _a.sent();
+              return [2 /*return*/];
+          }
+        });
+      });
+    },
+    closeBundle: function () {
+      return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+          switch (_a.label) {
+            case 0:
+              if (!(config && config.command === 'build')) return [3 /*break*/, 3];
+              if (!exports.option.uploadEnabled) return [3 /*break*/, 2];
+              console.info('构建阶段:开始上传翻译文件');
+              return [4 /*yield*/, uploadFile()];
+            case 1:
+              _a.sent();
+              return [3 /*break*/, 3];
+            case 2:
+              console.info('构建阶段:上传翻译文件功能已禁用（uploadEnabled: false）');
+              _a.label = 3;
+            case 3:
+              return [2 /*return*/];
+          }
+        });
+      });
+    }
+  };
+  return plugin;
+}
+
+exports.BaiduTranslator = BaiduTranslator;
+exports.CNToTWTranslator = CNToTWTranslator;
+exports.EmptyTranslator = EmptyTranslator;
+exports.FunctionFactoryOption = FunctionFactoryOption;
+exports.GoogleTranslator = GoogleTranslator;
+exports.LanguageEnum = LanguageEnum;
+exports.OriginLangKeyEnum = OriginLangKeyEnum;
+exports.ScanTranslator = ScanTranslator;
+exports.TranslateApiEnum = TranslateApiEnum;
+exports.TranslateTypeEnum = TranslateTypeEnum;
+exports.Translator = Translator;
+exports.VolcengineTranslator = VolcengineTranslator;
+exports.Vue2Extends = Vue2Extends;
+exports.YoudaoTranslator = YoudaoTranslator;
+exports.baseUtils = base;
+exports.checkOption = checkOption;
+exports.default = vitePluginsAutoI18n;
+exports.fileUtils = file;
+exports.filter = index$1;
+exports.initOption = initOption;
+exports.translateUtils = translate;
+exports.uploadUtils = upload$1;
 //# sourceMappingURL=index.cjs.map