webpack-gc-i18n-plugin 1.0.3 → 1.1.3

package/dist/customLoader/index.cjs

@@ -1,2 +1,1353 @@
-"use strict";var e=require("gc-i18n-plugin-core"),t=require("@babel/core");function r(e){var t=Object.create(null);return e&&Object.keys(e).forEach((function(r){if("default"!==r){var n=Object.getOwnPropertyDescriptor(e,r);Object.defineProperty(t,r,n.get?n:{enumerable:!0,get:function(){return e[r]}})}})),t.default=e,Object.freeze(t)}var n=r(e),o=r(t);function c(e,t,r,n){return new(r||(r=Promise))((function(o,c){function a(e){try{i(n.next(e))}catch(e){c(e)}}function u(e){try{i(n.throw(e))}catch(e){c(e)}}function i(e){var t;e.done?o(e.value):(t=e.value,t instanceof r?t:new r((function(e){e(t)}))).then(a,u)}i((n=n.apply(e,t||[])).next())}))}function a(e,t){var r,n,o,c={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=u(0),a.throw=u(1),a.return=u(2),"function"==typeof Symbol&&(a[Symbol.iterator]=function(){return this}),a;function u(u){return function(i){return function(u){if(r)throw new TypeError("Generator is already executing.");for(;a&&(a=0,u[0]&&(c=0)),c;)try{if(r=1,n&&(o=2&u[0]?n.return:u[0]?n.throw||((o=n.return)&&o.call(n),0):n.next)&&!(o=o.call(n,u[1])).done)return o;switch(n=0,o&&(u=[2&u[0],o.value]),u[0]){case 0:case 1:o=u;break;case 4:return c.label++,{value:u[1],done:!1};case 5:c.label++,n=u[1],u=[0];continue;case 7:u=c.ops.pop(),c.trys.pop();continue;default:if(!(o=c.trys,(o=o.length>0&&o[o.length-1])||6!==u[0]&&2!==u[0])){c=0;continue}if(3===u[0]&&(!o||u[1]>o[0]&&u[1]<o[3])){c.label=u[1];break}if(6===u[0]&&c.label<o[1]){c.label=o[1],o=u;break}if(o&&c.label<o[2]){c.label=o[2],c.ops.push(u);break}o[2]&&c.ops.pop(),c.trys.pop();continue}u=t.call(e,c)}catch(e){u=[6,e],n=0}finally{r=o=0}if(5&u[0])throw u[1];return{value:u[0]?u[1]:void 0,done:!0}}([u,i])}}}"function"==typeof SuppressedError&&SuppressedError,module.exports=function(e){return c(this,void 0,void 0,(function(){var t,r,c,u,i,l,s,f;return a(this,(function(a){switch(a.label){case 0:return t=n.baseUtils,r=n.option,c=n.filter,u=this,r.includePath.length&&!t.checkAgainstRegexArray(u.resourcePath,r.includePath)||r.excludedPath.length&&t.checkAgainstRegexArray(u.resourcePath,r.excludedPath)?[2,e]:r.translateExtends?[4,null===(f=r.translateExtends)||void 0===f?void 0:f.handleInitFile(e,u.resourcePath)]:[3,2];case 1:return i=a.sent(),[3,3];case 2:i={source:e},a.label=3;case 3:return a.trys.push([3,5,,6]),[4,o.transformAsync(i.source,{configFile:!1,plugins:[c.default(i)]})];case 4:return[2,(null==(l=a.sent())?void 0:l.code)||""];case 5:return s=a.sent(),console.error(s),[3,6];case 6:return[2,e]}}))}))};
+'use strict';
+
+var googleTranslateApi = require('@vitalets/google-translate-api');
+var tunnel = require('tunnel');
+require('axios');
+require('crypto-js');
+var OpenCC = require('opencc-js');
+var types = require('@babel/types');
+require('lodash');
+var babel = require('@babel/core');
+var generate = require('@babel/generator');
+
+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);
+var generate__namespace = /*#__PURE__*/_interopNamespaceDefault(generate);
+
+/******************************************************************************
+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 */
+
+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
+    };
+  }
+}
+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
+    });
+  }
+}
+
+OpenCC__namespace.Converter({
+  from: 'cn',
+  to: 'tw'
+});
+
+/*
+ * @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 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 = option.namespace;
+  const {
+    trimmedValue,
+    valStr
+  } = normalizeTranslateValue(value);
+  // 若 key 存在则使用 key，否则调用 generateId 函数根据 valStr 生成唯一的键
+  const generatedKey = key || generateId(valStr);
+  // 提取公共配置对象，避免重复代码
+  const config = {
+    option: option,
+    hash: generatedKey,
+    value: trimmedValue,
+    uncodeValue: valStr,
+    namespace: nameSpace
+  };
+  if (option.translateExtends) {
+    const {
+      handleCodeCall,
+      handleCodeString
+    } = 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 option.useValueAsKey ? types.callExpression(types.identifier(option.translateKey), [valueExp]) : types.callExpression(types.identifier(option.translateKey), [types.stringLiteral(generatedKey), valueExp]);
+  } else {
+    return `${option.translateKey}('${generatedKey}','${valStr}')`;
+  }
+}
+function normalizeTranslateValue(value) {
+  const trimmedValue = 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
+});
+
+/*
+ * @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 DEFAULT_OPTION = {
+  appCode: '',
+  /** 是否启用插件，默认启用 */
+  enabled: true,
+  /** 翻译调用函数，默认为 $t */
+  translateKey: '$t',
+  /** 标记不翻译调用函数列表，避免某些调用被错误翻译 */
+  excludedCall: [],
+  /** 标记不用翻译的字符串模式数组，默认是匹配文件扩展名 */
+  excludedPattern: [/\.\w+$/],
+  /** 排查不需要翻译的目录下的文件路径（黑名单）, 默认不处理node_modules */
+  excludedPath: ['node_modules'],
+  /** 指定需要翻译文件的目录路径正则（白名单） */
+  includePath: [/src\//, /src\\/],
+  /** 配置文件生成位置，默认为 './lang' */
+  globalPath: './lang',
+  /** 打包后生成文件的位置，例如 './dist/assets' */
+  distPath: '',
+  /** 打包后生成文件的主文件名称，默认是 'index' */
+  distKey: 'index',
+  /** 来源语言，默认是中文 */
+  originLang: OriginLangKeyEnum.ZH,
+  /** 翻译目标语言列表，默认包含英文 */
+  targetLangList: ['en'],
+  /** 语言key，用于请求谷歌api和生成配置文件下对应语言的内容文件 */
+  langKey: [],
+  /** 命名空间，防止全局命名冲突 */
+  namespace: 'lang',
+  /** 单位代码 */
+  orgCode: 'GREENCLOUD',
+  /** 是否启用源码的值作为key */
+  useValueAsKey: false,
+  /** 是否在构建结束之后将最新的翻译重新打包到主包中，默认不打包 */
+  buildToDist: false,
+  /** 是否启用上传翻译文件到服务器，默认开启 */
+  uploadEnabled: true,
+  /** 翻译器，决定自动翻译使用的api与调用方式，默认使用 Google 翻译器并使用7890(clash)端口代理 */
+  translator: new GoogleTranslator({
+    proxyOption: {
+      port: 7890,
+      host: '127.0.0.1',
+      headers: {
+        'User-Agent': 'Node'
+      }
+    }
+  }),
+  /** 翻译器配置选项，优先级低于translator */
+  translatorOption: undefined,
+  /**
+   * 翻译类型，支持全自动和半自动两种模式
+   * 全自动：所有翻译任务自动完成
+   * 半自动：需要人工标识，类似于 $t('key') 的方式
+   * 默认值为全自动
+   */
+  translateType: TranslateTypeEnum.FULL_AUTO,
+  /**
+   * 是否重写配置文件，默认为true
+   */
+  rewriteConfig: true,
+  /**
+   * 通用翻译key，默认使用namespace，如果commonTranslateKey不为空，则使用commonTranslateKey
+   */
+  commonTranslateKey: '',
+  /**
+   * 实验性属性，表示是否进行深层扫描字符串，默认为 false
+   * 当设置为 true 时，会对代码中的字符串进行更深入的扫描
+   */
+  deepScan: false,
+  /**
+   * 自定义文件拓展名数组
+   */
+  insertFileExtensions: [],
+  /**
+   * 自定义拓展类，插件默认翻译函数挂载在window上，如果希望自定义翻译函数挂载在其他对象上，可以使用该属性
+   * 注意：该属性需要继承BaseExtends类，并且需要实现handleInitFile和handleCodeCall和handleCodeString方法
+   */
+  translateExtends: null,
+  isClear: false,
+  // 是否清除已经不在上下文中的内容（清除项目中不再使用到的源语言键值对）
+
+  /**
+   * 是否保留空格
+   */
+  isClearSpace: true
+};
+
+/**
+ * 类型定义：插件配置选项类型
+ */
+
+/**
+ * 全局插件配置实例，复制自默认配置
+ */
+let option = {
+  ...DEFAULT_OPTION
+};
+
+/*
+ * @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
+ */
+
+let langObj = {};
+
+/**
+ * @description: 设置翻译对象属性
+ * @param {string} key
+ * @param {string} value
+ * @return {*}
+ */
+function setLangObj(key, value) {
+  if (!langObj[key]) {
+    langObj[key] = value;
+  }
+}
+
+/*
+ * @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;
+}
+
+/*
+ * @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 (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 && (option.excludedCall.includes(extractFnName) || extractFnName?.split('.')?.pop() && 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 => option.originLang.includes(lang) || option.originLang === lang)) {
+      try {
+        value = unicodeToString(value);
+      } catch (error) {
+        console.log('转换异常');
+      }
+    }
+    return result + value + (index < node.expressions.length ? `\${${placeholders[index]}}` : '');
+  }, '');
+  if (!fullValue || !hasOriginSymbols(fullValue) || !option.excludedPattern.length || checkAgainstRegexArray(fullValue, [...option.excludedPattern])) {
+    return false;
+  }
+  const {
+    trimmedValue,
+    valStr
+  } = normalizeTranslateValue(fullValue);
+  const id = generateId(valStr);
+  const translateNode = createTranslateNode(path, id, valStr, placeholders, node.expressions);
+  path.replaceWith(translateNode);
+  path.skip();
+  setLangObj(id, trimmedValue);
+  return true;
+}
+function getExpressionPlaceholder(expression) {
+  if (types.isIdentifier(expression)) {
+    return expression.name;
+  }
+  if (types.isMemberExpression(expression)) {
+    const objectName = getExpressionPlaceholder(expression.object);
+    const propertyName = expression.computed ? getExpressionPlaceholder(expression.property) : types.isIdentifier(expression.property) ? expression.property.name : '';
+    const value = [objectName, propertyName].filter(Boolean).join('.');
+    return cleanVueRuntimePrefix(value);
+  }
+  if (types.isStringLiteral(expression) || types.isNumericLiteral(expression)) {
+    return String(expression.value);
+  }
+  if (types.isTSAsExpression(expression) || types.isTSTypeAssertion(expression)) {
+    return getExpressionPlaceholder(expression.expression);
+  }
+  if (types.isTSNonNullExpression(expression)) {
+    return getExpressionPlaceholder(expression.expression);
+  }
+  const generateCode = generate__namespace.default?.default || generate__namespace.default || generate__namespace;
+  return cleanVueRuntimePrefix(generateCode(expression).code);
+}
+function createTranslateNode(path, id, valStr) {
+  let placeholders = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
+  let expressions = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : [];
+  const args = [types.stringLiteral(id), types.stringLiteral(valStr)];
+  if (placeholders.length) {
+    args.push(types.objectExpression(placeholders.map((placeholder, index) => types.objectProperty(types.stringLiteral(placeholder), types.cloneNode(expressions[index])))));
+  }
+  const translateCall = types.callExpression(types.identifier(option.translateKey), args);
+  if (!isVueTemplateRender(path)) {
+    return translateCall;
+  }
+  return types.sequenceExpression([createVueTemplateLanguageDependency(), translateCall]);
+}
+function isVueTemplateRender(path) {
+  return Boolean(path.scope?.getBinding('_vm'));
+}
+function createVueTemplateLanguageDependency() {
+  const vm = types.identifier('_vm');
+  const store = types.memberExpression(types.cloneNode(vm), types.identifier('$store'));
+  const storeState = types.memberExpression(types.cloneNode(store), types.identifier('state'));
+  const siteState = types.memberExpression(types.cloneNode(storeState), types.identifier('site'));
+  const storeLanguage = types.logicalExpression('&&', types.logicalExpression('&&', types.logicalExpression('&&', types.cloneNode(store), types.cloneNode(storeState)), types.cloneNode(siteState)), types.memberExpression(types.cloneNode(siteState), types.identifier('language')));
+  const i18n = types.memberExpression(types.cloneNode(vm), types.identifier('$i18n'));
+  const i18nLocale = types.logicalExpression('&&', types.cloneNode(i18n), types.memberExpression(types.cloneNode(i18n), types.identifier('locale')));
+  return types.logicalExpression('||', storeLanguage, i18nLocale);
+}
+function cleanVueRuntimePrefix(value) {
+  return value.replace(/^(?:\$setup|_ctx|_vm|this)\./, '').replace(/([^\w$.])(?:\$setup|_ctx|_vm|this)\./g, '$1');
+}
+
+// 处理模板元素
+function handleTemplateElement(node, insertOption) {
+  let value = node.value.raw || node.value.cooked; // 获取模板字符串的值
+  if (asianLangs.some(lang => option.originLang.includes(lang) || option.originLang === lang)) {
+    try {
+      value = unicodeToString(value || '');
+    } catch (error) {
+      console.log('转换异常');
+    }
+  }
+  // 是否存在来源语言字符，是否在默认字符串中，是否包含过滤字段
+  if (value && hasOriginSymbols(value) && option.excludedPattern.length && !checkAgainstRegexArray(value, [...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 === option.translateKey || callee.property && callee.property.name === option.translateKey // 拓展 半自动模式下的 如 a.b.c() 调用
+    ) {
+      if (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 (option.translateType === TranslateTypeEnum.FULL_AUTO) {
+        // 全自动模式下还是只收集 单独 $t 调用
+        if (callee.name === option.translateKey || callee.property && callee.property.name === 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 (option.translateType === TranslateTypeEnum.SEMI_AUTO) {
+      return;
+    }
+    let {
+      node,
+      parent
+    } = path;
+    let value = node.value;
+
+    // 定义一个包含亚洲语言代码的数组
+    const asianLangs = ['zh-cn', 'ja', 'ko'];
+    if (asianLangs.some(lang => option.originLang.includes(lang) || option.originLang === lang)) {
+      try {
+        value = unicodeToString(value);
+      } catch (error) {
+        console.log('转换异常');
+      }
+    }
+    if (hasOriginSymbols(value) && option.excludedPattern.length && !checkAgainstRegexArray(value, [...option.excludedPattern])) {
+      // 获取真实调用函数
+      const extractFnName = extractFunctionName(parent);
+
+      // 防止导入语句，只处理那些当前节点不是键值对的键的字符串字面量，调用语句判断当前调用语句是否包含需要过滤的调用语句
+      if (isTranslateCall(parent) || types__namespace.isImportDeclaration(parent) || parent.key === node || types__namespace.isCallExpression(parent) && extractFnName && (option.excludedCall.includes(extractFnName) || extractFnName?.split('.')?.pop() && option.excludedCall.includes(extractFnName?.split('.')?.pop() || ''))) return;
+      let replaceNode;
+      if (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);
+    }
+  };
+}
+function isTranslateCall(node) {
+  if (!types__namespace.isCallExpression(node)) return false;
+  const callee = node.callee;
+  if (types__namespace.isIdentifier(callee)) {
+    return callee.name === option.translateKey;
+  }
+  if (types__namespace.isMemberExpression(callee)) {
+    return types__namespace.isIdentifier(callee.property) && callee.property.name === option.translateKey;
+  }
+  return false;
+}
+
+/*
+ * @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 (option.translateType === TranslateTypeEnum.SEMI_AUTO) {
+      return;
+    }
+    let {
+      node
+    } = path;
+    let value = node.value;
+    // 定义一个包含亚洲语言代码的数组
+    const asianLangs = ['zh-cn', 'ja', 'ko'];
+    if (asianLangs.some(lang => option.originLang.includes(lang) || option.originLang === lang)) {
+      try {
+        value = unicodeToString(value);
+      } catch (error) {
+        console.log('转换异常');
+      }
+    }
+    if (hasOriginSymbols(value) && option.excludedPattern.length && !checkAgainstRegexArray(value, [...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
+});
+
+/*
+ * @Date: 2025-01-08 11:51:33
+ * @LastEditors: xiaoshan
+ * @LastEditTime: 2025-02-14 01:02:04
+ * @FilePath: /i18n_translation_vite/packages/webpackPluginsAutoI18n/src/customLoader/index.ts
+ */
+/**
+ * @description: 核心 Loader，用于解析和处理代码，将目标语言提取为国际化的 key-value 映射
+ * @param source {string} - 源代码字符串，需要经过当前 Loader 处理的模块内容
+ * @returns {string} - 返回经过处理后的代码
+ */
+module.exports = function (source) {
+  return __awaiter(this, void 0, void 0, function () {
+    var baseUtils, option$1, filter, global, sourceObj, result, e_1;
+    var _a;
+    return __generator(this, function (_b) {
+      switch (_b.label) {
+        case 0:
+          baseUtils = base, option$1 = option, filter = index$1;
+          global = this;
+          /**
+           * 黑白名单过滤：
+           * - 首先检查是否在 `includePath` 白名单内；如果不在白名单内直接返回原代码。
+           * - 然后检查是否在 `excludedPath` 黑名单内；如果在黑名单内则返回原代码。
+           */
+          if (option$1.includePath.length && !baseUtils.checkAgainstRegexArray(global.resourcePath, option$1.includePath)) {
+            return [2 /*return*/, source]; // 不在白名单目录中的文件，不处理，直接返回原始代码。
+          }
+          if (option$1.excludedPath.length && baseUtils.checkAgainstRegexArray(global.resourcePath, option$1.excludedPath)) {
+            return [2 /*return*/, source]; // 在黑名单目录中的文件，不处理，直接返回原始代码。
+          }
+          if (!option$1.translateExtends) return [3 /*break*/, 2];
+          return [4 /*yield*/, (_a = option$1.translateExtends) === null || _a === void 0 ? void 0 : _a.handleInitFile(source, global.resourcePath)];
+        case 1:
+          sourceObj = _b.sent();
+          return [3 /*break*/, 3];
+        case 2:
+          sourceObj = {
+            source: source
+          };
+          _b.label = 3;
+        case 3:
+          _b.trys.push([3, 5,, 6]);
+          return [4 /*yield*/, babel__namespace.transformAsync(sourceObj.source, {
+            configFile: false,
+            // 不加载本地 Babel 配置文件
+            plugins: [filter.default(sourceObj)] // 使用核心模块提供的 `filter` 插件
+          })
+          // 如果转换成功，返回转换后的代码；否则返回空字符串。
+          ];
+        case 4:
+          result = _b.sent();
+          // 如果转换成功，返回转换后的代码；否则返回空字符串。
+          return [2 /*return*/, (result === null || result === void 0 ? void 0 : result.code) || ''];
+        case 5:
+          e_1 = _b.sent();
+          // 捕捉和打印异常，保证整个构建过程不会中断
+          console.error(e_1);
+          return [3 /*break*/, 6];
+        case 6:
+          // 如果在过滤或转换过程中发生异常，返回原始未改动的代码
+          return [2 /*return*/, source];
+      }
+    });
+  });
+};
 //# sourceMappingURL=index.cjs.map