torchv-translate 1.0.9 → 1.0.10

package/translate.js/translate.js

@@ -2086,13 +2086,8 @@ var translate = {
 		20 浏览器缓存渲染完毕，ajax通过文本翻译接口开始请求，在发起ajax请求前，状态变为20，然后再发起ajax请求
 		至于翻译完毕后进行渲染，这个就不单独记录了，因为如果页面存在不同的语种，不同的语种是按照不同的请求来的，是多个异步同时进行的过程
 	*/
-	state:0,
-
-	/*
-		取消翻译任务的版本号（路由切换时+1），用于忽略未完成的翻译请求
-	*/
-	cancelVersion:0,
-
+	state:0,
+
 
 	/*
 		等待翻译队列  v3.12.6 增加
@@ -2100,72 +2095,45 @@ var translate = {
 		当执行 translate.execute() 时，会先判断状态 translate.state 是否是0空闲的状态，如果空闲，才会执行，如果不是空闲，则不会执行，而是进入到这里进行等待，等待执行完毕后 translate.state 变成0空闲之后，再来执行这里的
 		
 	*/
-	waitingExecute:{
-		use:true, //默认是使用，自有部署场景不担心并发的场景，可以禁用，以提高用户使用体验。
-
-		/*
-			一维数组形态，存放执行的翻译任务
-			二维对象形态，存放执行传入的 docs
-		*/
-		queue:[],
-		//等待队列使用的定时器id集合，便于取消
-		intervalIds:[],
-		/*
-			增加一个翻译任务到翻译队列中
-			docs 同 translate.execute(docs) 的传入参数
-		 */ 
-		add:function(docs){
-			//向数组末尾追加
-			translate.waitingExecute.queue.push(docs);
-			//开启一个定时器进行触发
-			let intervalId = setInterval(function() {
-				if(translate.state == 0){
-					//清除定时器，结束循环
-					clearInterval(intervalId);
-					//移除记录
-					for(var iid = translate.waitingExecute.intervalIds.length - 1; iid >= 0; iid--){
-						if(translate.waitingExecute.intervalIds[iid] === intervalId){
-							translate.waitingExecute.intervalIds.splice(iid, 1);
-							break;
-						}
-					}
-					if(translate.waitingExecute.queue.length < 1){
-						return;
-					}
-					var docs = translate.waitingExecute.get();
-					if(docs != null){
-						translate.execute(docs);
-					}
-					//console.log('stop waitingExecute setInterval');
-				}
-			}, 500);
-			translate.waitingExecute.intervalIds.push(intervalId);
-		},
+	waitingExecute:{
+		use:true, //默认是使用，自有部署场景不担心并发的场景，可以禁用，以提高用户使用体验。
+
+		/*
+			一维数组形态，存放执行的翻译任务
+			二维对象形态，存放执行传入的 docs
+		*/
+		queue:[],
+		/*
+			增加一个翻译任务到翻译队列中
+			docs 同 translate.execute(docs) 的传入参数
+		 */ 
+		add:function(docs){
+			//向数组末尾追加
+			translate.waitingExecute.queue.push(docs);
+			//开启一个定时器进行触发
+			let intervalId = setInterval(function() {
+				if(translate.state == 0){
+					//清除定时器，结束循环
+					clearInterval(intervalId);
+					var docs = translate.waitingExecute.get();
+					translate.execute(docs);
+					//console.log('stop waitingExecute setInterval');
+				}
+			}, 500);
+		},
 		/*
 			从 quque 中取第一个元素，同时将其从queue中删除掉它。
 			如果取的时候 quque已经没有任何元素了，会返回 null， 但是理论上不会出现null
 		 */
-		get:function(){
-			//使用 shift 方法删除数组的第一个元素，并将第一个元素的值返回
-			if(translate.waitingExecute.queue.length > 0){
-				return translate.waitingExecute.queue.shift();
-			}else{
-				translate.log('警告， translate.waitingExecute.get 出现异常，quque已空，但还往外取。');
-				return null;
-			}
-		},
-		/*
-			清空等待队列，并取消定时器
-		*/
-		clear:function(){
-			translate.waitingExecute.queue = [];
-			if(typeof(translate.waitingExecute.intervalIds) != 'undefined' && translate.waitingExecute.intervalIds.length > 0){
-				for(var i = 0; i < translate.waitingExecute.intervalIds.length; i++){
-					clearInterval(translate.waitingExecute.intervalIds[i]);
-				}
-				translate.waitingExecute.intervalIds = [];
-			}
-		},
+		get:function(){
+			//使用 shift 方法删除数组的第一个元素，并将第一个元素的值返回
+			if(translate.waitingExecute.queue.length > 0){
+				return translate.waitingExecute.queue.shift();
+			}else{
+				translate.log('警告， translate.waitingExecute.get 出现异常，quque已空，但还往外取。');
+				return null;
+			}
+		},
 		/*
 			当前 translate.translateRequest[uuid] 的是否已经全部执行完毕
 			这里单纯只是对 translate.translateRequest[uuid] 的进行判断
@@ -2183,38 +2151,28 @@ var translate = {
 			@param result 本次网络请求的结果， 1成功， 0失败。  网络不通，翻译结果返回result非1都是记入0
 			@param info 如果result为0，这里是失败信息
 		*/
-		isAllExecuteFinish:function(uuid, from, to, result, info){
-
-			translate.listener.execute.renderFinishByApiRun(uuid, from, to);
-
-			//通过 uuid、from 取得本次翻译相关的 texts、nodes , 触发 translateNetworkAfter_Trigger 钩子
-			//获取请求日志
-			if(typeof(translate.request) === 'object'
-				&& typeof(translate.request.data) === 'object'
-				&& typeof(translate.request.data[uuid]) === 'object'
-				&& typeof(translate.request.data[uuid].list) === 'object'
-				&& typeof(translate.request.data[uuid].list[from]) === 'object'
-				&& typeof(translate.request.data[uuid].list[from][to]) === 'object'){
-				var requestData = translate.request.data[uuid].list[from][to];
-				translate.lifecycle.execute.translateNetworkAfter_Trigger({
-					uuid: uuid,
-					from: from,
-					to: to,
-					texts: requestData.texts,
-					nodes: requestData.nodes,
-					result: result,
-					info: info
-				});
-			}
-
-			//console.log('uuid:'+uuid+', from:'+from+', to:'+to);
-			if(typeof(translate.translateRequest) !== 'object' || typeof(translate.translateRequest[uuid]) !== 'object'){
-				return;
-			}
-			for(var lang in translate.translateRequest[uuid]){
-				if (!translate.translateRequest[uuid].hasOwnProperty(lang)) {
-		    		continue;
-		    	}
+		isAllExecuteFinish:function(uuid, from, to, result, info){
+
+			translate.listener.execute.renderFinishByApiRun(uuid, from, to);
+
+			//通过 uuid、from 取得本次翻译相关的 texts、nodes , 触发 translateNetworkAfter_Trigger 钩子
+			//获取请求日志
+			var requestData = translate.request.data[uuid].list[from][to];
+			translate.lifecycle.execute.translateNetworkAfter_Trigger({
+				uuid: uuid,
+				from: from,
+				to: to,
+				texts: requestData.texts,
+				nodes: requestData.nodes,
+				result: result,
+				info: info
+			});
+
+			//console.log('uuid:'+uuid+', from:'+from+', to:'+to);
+			for(var lang in translate.translateRequest[uuid]){
+				if (!translate.translateRequest[uuid].hasOwnProperty(lang)) {
+		    		continue;
+		    	}
 				if(translate.translateRequest[uuid][lang].executeFinish == 0){
 					//这个还没执行完，那么直接退出，不在向后执行了
 					//console.log('uuid:'+uuid+'  lang:'+lang+'  executeFinish:0  time:'+translate.translateRequest[uuid][lang][i][addtime]);
@@ -2231,36 +2189,12 @@ var translate = {
 			//都执行完了，那么设置完毕
 			translate.state = 0;
 			translate.executeNumber++;
-		}
-
-	},
-
-	/*
-		路由切换时调用，取消未完成翻译任务并清理等待队列
-	*/
-	routeChange:function(){
-		//版本号递增，旧请求全部失效
-		translate.cancelVersion = translate.cancelVersion + 1;
-		//清空等待队列
-		translate.waitingExecute.clear();
-		//清空翻译请求去重缓存
-		if(typeof(translate.request) === 'object' && typeof(translate.request.pending) === 'object'){
-			translate.request.pending.clear();
-		}
-		//终止当前执行状态
-		translate.state = 0;
-		//中断未完成的翻译请求
-		if(typeof(translate.request) === 'object' && typeof(translate.request.abortTranslateRequests) === 'function'){
-			translate.request.abortTranslateRequests();
-		}
-		//清理本轮翻译请求记录
-		translate.translateRequest = {};
-		translate.request.data = {};
-		translate.nodeQueue = {};
-	},
-	
-	//execute() 方法已经被执行过多少次了， 只有 translate.execute() 完全执行完，也就是界面渲染完毕后，它才会+1
-	executeNumber:0,
+		}
+
+	},
+	
+	//execute() 方法已经被执行过多少次了， 只有 translate.execute() 完全执行完，也就是界面渲染完毕后，它才会+1
+	executeNumber:0,
 	//translate.execute() 方法已经被触发过多少次了， 只要 translate.execute() 被触发，它就会在触发时立即 +1 (translate.execute() 默认是同一时刻只能执行一次，这个触发是在这个同一时刻执行一次的判定之前进行++ 的，如果这个同一时刻执行一次不通过，还有其他在执行，进入排队执行时，这里也会++ ，当从排队的中顺序排到进行执行时，又会执行++ ) 。 当页面打开第一次触发执行translate.execute()，这里便是 1
 	executeTriggerNumber:0, 
 	
@@ -2562,11 +2496,9 @@ var translate = {
 		translate.executeTriggerNumber = translate.executeTriggerNumber + 1;
 		var triggerNumber = translate.executeTriggerNumber; //为了整个 translate.execute 的数据一致性，下面都是使用这个变量
 
-		//每次执行execute，都会生成一个唯一uuid，也可以叫做队列的唯一标识，每一次执行execute都会创建一个独立的翻译执行队列
-		var uuid = translate.util.uuid();
-		translate.time.log('创建uuid:'+uuid);
-		var executeCancelVersion = translate.cancelVersion;
-		var pendingKeysCreated = [];
+		//每次执行execute，都会生成一个唯一uuid，也可以叫做队列的唯一标识，每一次执行execute都会创建一个独立的翻译执行队列
+		var uuid = translate.util.uuid();
+		translate.time.log('创建uuid:'+uuid);
 
 		//如果页面打开第一次使用，先判断缓存中有没有上次使用的语种，从缓存中取出
 		if(translate.to == null || translate.to == ''){
@@ -2982,12 +2914,12 @@ var translate = {
 				//console.log(originalWord);
 
 				//根据hash，判断本地是否有缓存了
-				var cacheHash = originalWord == translateText ? hash:translate.util.hash(translateText); //如果匹配到了自定义术语库，那翻译前的hash是被改变了
-				translate.nodeQueue[uuid]['list'][lang][hash]['cacheHash'] = cacheHash; //缓存的hash。 缓存时，其hash跟翻译的语言是完全对应的，缓存的hash就是翻译的语言转换来的
-				var cache = translate.storage.get('hash_'+translate.to+'_'+cacheHash);
-
-				//缓存是否有拿到具体缓存内容
-				if(cache != null && cache.length > 0){
+				var cacheHash = originalWord == translateText ? hash:translate.util.hash(translateText); //如果匹配到了自定义术语库，那翻译前的hash是被改变了
+				translate.nodeQueue[uuid]['list'][lang][hash]['cacheHash'] = cacheHash; //缓存的hash。 缓存时，其hash跟翻译的语言是完全对应的，缓存的hash就是翻译的语言转换来的
+				var cache = translate.storage.get('hash_'+translate.to+'_'+cacheHash);
+
+				//缓存是否有拿到具体缓存内容
+				if(cache != null && cache.length > 0){
 					for(var node_index = 0; node_index < translate.nodeQueue[uuid]['list'][lang][hash]['nodes'].length; node_index++){
 						//console.log(translate.nodeQueue[uuid]['list'][lang][hash]['nodes'][node_index]);
 
@@ -3070,40 +3002,14 @@ var translate = {
 					}
 
 
-
-					continue;	//跳出，不用在传入下面的翻译接口了
-				}
-
-				//避免虚拟滚动等场景重复请求：如果同一文本正在翻译中，则加入等待队列
-				if(typeof(translate.request) === 'object' && typeof(translate.request.pending) === 'object'){
-					var pendingKey = translate.request.pending.key(lang, translate.to, cacheHash);
-					var pendingItem = translate.request.pending.get(pendingKey);
-					if(pendingItem != null){
-						translate.request.pending.add(pendingKey, {uuid:uuid, lang:lang, hash:hash});
-						//加入loading提示
-						if(typeof(translate.progress) === 'object' && typeof(translate.progress.api) === 'object'){
-							if(translate.progress.api.autoStart && !translate.progress.api.use){
-								translate.progress.api.startUITip();
-							}
-							if(translate.progress.api.use){
-								var pendingNodes = [];
-								for(var pni = 0; pni < translate.nodeQueue[uuid]['list'][lang][hash]['nodes'].length; pni++){
-									pendingNodes.push(translate.nodeQueue[uuid]['list'][lang][hash]['nodes'][pni].node);
-								}
-								translate.progress.api.applyLoadingByNodes(pendingNodes);
-							}
-						}
-						continue;
-					}
-					//记录本次创建的pending，方便异常情况下清理
-					translate.request.pending.add(pendingKey, {uuid:uuid, lang:lang, hash:hash});
-					pendingKeysCreated.push(pendingKey);
-				}
-				
-				/*
-				//取出数组
-				var queueNodes = this.nodeQueue[lang][hash];
-				if(queueNodes.length > 0){
+
+					continue;	//跳出，不用在传入下面的翻译接口了
+				}
+				
+				/*
+				//取出数组
+				var queueNodes = this.nodeQueue[lang][hash];
+				if(queueNodes.length > 0){
 					//因为在这个数组中的值都是一样的，那么只需要取出第一个就行了
 					var valueStr = queueNodes[0].nodeValue;
 					valueStr = this.util.charReplace(valueStr);
@@ -3131,20 +3037,13 @@ var translate = {
 		//console.log(translateTextArray);
 		//return;
 
-		if(typeof(translate.request.api.translate) != 'string' || translate.request.api.translate == null || translate.request.api.translate.length < 1){
-			//用户已经设置了不掉翻译接口进行翻译
-			translate.state = 0;
-
-			//清理本次创建的pending记录
-			if(pendingKeysCreated.length > 0 && typeof(translate.request) === 'object' && typeof(translate.request.pending) === 'object'){
-				for(var pk = 0; pk < pendingKeysCreated.length; pk++){
-					translate.request.pending.take(pendingKeysCreated[pk]);
-				}
-			}
-			
-			//生命周期触发事件
-			translate.lifecycle.execute.renderFinish_Trigger(uuid, translate.to);
-			translate.executeNumber++;
+		if(typeof(translate.request.api.translate) != 'string' || translate.request.api.translate == null || translate.request.api.translate.length < 1){
+			//用户已经设置了不掉翻译接口进行翻译
+			translate.state = 0;
+			
+			//生命周期触发事件
+			translate.lifecycle.execute.renderFinish_Trigger(uuid, translate.to);
+			translate.executeNumber++;
 
 			//钩子
 			translate.lifecycle.execute.finally_Trigger({
@@ -3323,25 +3222,18 @@ var translate = {
 							texts: 当前网络请求有哪些文本进行翻译，值为 [text1, text2, ...]
 
 		*/
-		translate.request.data[uuid] = {
-			time:Date.now(),
-			list:{}
-		};
-
-		//自动启用翻译loading提示
-		if(typeof(translate.progress) === 'object' && typeof(translate.progress.api) === 'object'){
-			if(translate.progress.api.autoStart && !translate.progress.api.use){
-				translate.progress.api.startUITip();
-			}
-		}
-
-
-		//进行掉接口翻译
-		for(var lang_index in fanyiLangs){ //一维数组，取语言
+		translate.request.data[uuid] = {
+			time:Date.now(),
+			list:{}
+		};
+
+
+		//进行掉接口翻译
+		for(var lang_index in fanyiLangs){ //一维数组，取语言
 			if (!fanyiLangs.hasOwnProperty(lang_index)) {
 	    		continue;
 	    	}
-			let lang = fanyiLangs[lang_index];
+			var lang = fanyiLangs[lang_index];
 			if(typeof(lang) != 'string'){
 				continue;
 			}
@@ -3401,280 +3293,151 @@ var translate = {
 			if(typeof(translate.request.data[uuid].list[lang]) === 'undefined'){
 				translate.request.data[uuid].list[lang] = {};
 			}
-			translate.request.data[uuid].list[lang][translate.to] = {
-				texts: translateTextArray[lang],
-				nodes: translateTextNodes,
-			};
-
-			
-			/*** 翻译开始 ***/
-			var url = translate.request.api.translate;
-			//按配置拆分文本数组，避免一次请求过大导致超时
-			var splitTextList = translate.request.splitTranslateTextArray(translateTextArray[lang]);
-			if(typeof(splitTextList) == 'undefined' || splitTextList == null || splitTextList.length < 1){
-				splitTextList = [translateTextArray[lang]];
-			}
-
-			translate.translateRequest[uuid][lang].requestTotal = splitTextList.length;
-			translate.translateRequest[uuid][lang].requestFinish = 0;
-			translate.translateRequest[uuid][lang].requestError = 0;
-			translate.translateRequest[uuid][lang].requestErrorInfo = '';
-			translate.translateRequest[uuid][lang].requestErrorResult = 0;
-
-			var splitHashIndex = 0;
-			var splitRequestFinish = function(result, info, errorResult){
-				if(translate.cancelVersion != executeCancelVersion){
-					return;
-				}
-				if(typeof(translate.translateRequest[uuid]) != 'object' || typeof(translate.translateRequest[uuid][lang]) != 'object'){
-					return;
-				}
-				var requestItem = translate.translateRequest[uuid][lang];
-				requestItem.requestFinish++;
-				if(result === 0){
-					requestItem.requestError = 1;
-					if(typeof(info) === 'string' && info.length > 0){
-						if(typeof(requestItem.requestErrorInfo) !== 'string' || requestItem.requestErrorInfo.length < 1){
-							requestItem.requestErrorInfo = info;
-						}
-					}
-					if(typeof(errorResult) === 'number' && errorResult > 0){
-						if(typeof(requestItem.requestErrorResult) !== 'number' || requestItem.requestErrorResult < errorResult){
-							requestItem.requestErrorResult = errorResult;
-						}
-					}
-				}
-				if(requestItem.requestFinish >= requestItem.requestTotal){
-					if(requestItem.requestError === 1){
-						requestItem.result = requestItem.requestErrorResult > 0 ? requestItem.requestErrorResult : 2;
-					}else{
-						requestItem.result = 1;
-					}
-					requestItem.executeFinish = 1; //1是执行完毕
-					requestItem.stoptime = Math.floor(Date.now() / 1000);
-					var resultFlag = requestItem.requestError === 1 ? 0 : 1;
-					var infoText = requestItem.requestError === 1 ? (requestItem.requestErrorInfo || '') : '';
-					setTimeout(function(){
-						translate.waitingExecute.isAllExecuteFinish(uuid, lang, translate.to, resultFlag, infoText);
-					},5);
-				}
-			};
-
-			for(var splitIndex = 0; splitIndex < splitTextList.length; splitIndex++){
-				let splitTexts = splitTextList[splitIndex];
-				if(typeof(splitTexts) == 'undefined' || splitTexts == null || splitTexts.length < 1){
-					splitRequestFinish(1, '', 0);
-					continue;
-				}
-				let splitHashes = translateHashArray[lang].slice(splitHashIndex, splitHashIndex + splitTexts.length);
-				splitHashIndex = splitHashIndex + splitTexts.length;
-
-				let data = {
-					from:lang,
-					to:translate.to,
-					//lowercase:translate.whole.isEnableAll? '0':'1', //首字母大写
-					//text:JSON.stringify(translateTextArray[lang])
-					text:encodeURIComponent(JSON.stringify(splitTexts))
-				};
-				var xhr = translate.request.post(url, data, function(responseData, requestData){
-					//console.log(data); 
-					//console.log(translateTextArray[data.from]);
-
-					if(translate.cancelVersion != executeCancelVersion){
-						return;
-					}
-
-					//针对 giteeai 增加了账户余额、账户是否激活的拍的判定，所以增加了 401 这个参数，凡是账户异常的，参数值是 401~499 之间。所以只要不是1都是失败
-					if(responseData.result != 1){
-						splitRequestFinish(0, responseData.info, 2);
-
-						translate.log('=======ERROR START=======');
-						translate.log(translateTextArray[requestData.from]);
-						//console.log(encodeURIComponent(JSON.stringify(translateTextArray[data.from])));
-						translate.log('response : '+responseData.info);
-						translate.log('=======ERROR END  =======');
-						//translate.temp_executeFinishNumber++; //记录执行完的次数
-						return;
-					}
-					
-					if(typeof(translate.nodeQueue[uuid]) == 'undefined'){
-						translate.log('提示：你很可能多次引入了 translate.js 所以造成了翻译本身的数据错乱，这只是个提示，它还是会给你正常翻译的，但是你最好不要重复引入太多次 translate.js ，正常情况下只需要引入一次 translate.js 就可以了。太多的话很可能会导致你页面卡顿');
-						splitRequestFinish(0, 'translate.nodeQueue not find', 2);
-						return;
-					}
-
-					//console.log('-----待翻译3：----');
-					//console.log(translate.nodeQueue);
-					
-					//console.log('response:'+uuid);
-					let task = new translate.renderTask();
-					//遍历 translateHashArray
-					var loopLength = responseData.text.length;
-					if(loopLength > splitHashes.length){
-						loopLength = splitHashes.length;
-					}
-					for(var i=0; i<loopLength; i++){
-						//翻译前的语种，如 english
-						var lang = responseData.from;	
-						//翻译后的内容
-						var text = responseData.text[i];	
-						//如果text为null，那么这个可能是一次翻译字数太多，为了保持数组长度，拼上的null
-						if(text == null){
-							continue;
-						}
-
-						// v3.0.3 添加，避免像是 JavaScript 被错误翻译为 “JavaScript的” ，然后出现了多个句子中都出现了Javascript时，会出现翻译后文本重复的问题
-						// 这里就是验证一下，翻译后的文本，是否会完全包含翻以前的文本，如果包含了，那么强制将翻译后的文本赋予翻译前的原始文本（也就是不被翻译）
-						if(text.toLowerCase().indexOf(splitTexts[i].toLowerCase()) > -1){
-							//发现了，那么强制赋予翻以前内容
-							text = splitTexts[i];
-						}
-
-
-					//翻译前的hash对应下标
-					var hash = splitHashes[i];	
-					var cacheHash = translate.nodeQueue[uuid]['list'][lang][hash]['cacheHash'];
-					var pendingItem = null;
-					if(typeof(translate.request) === 'object' && typeof(translate.request.pending) === 'object'){
-						var pendingKey = translate.request.pending.key(lang, responseData.to, cacheHash);
-						pendingItem = translate.request.pending.take(pendingKey);
-					}
-
-
-					
-					//取原始的词，还未经过翻译的，需要进行翻译的词
-					var originalWord = '';
-						try{
-							originalWord = translate.nodeQueue[uuid]['list'][lang][hash]['original'];
-							//console.log('bef:'+translate.nodeQueue[uuid]['list'][lang][hash]['beforeText']);
-						}catch(e){
-							translate.log('uuid:'+uuid+', originalWord:'+originalWord+', lang:'+lang+', hash:'+hash+', text:'+text+', queue:'+translate.nodeQueue[uuid]);
-							translate.log(e);
-							continue;
-						}
-						
-						//for(var index = 0; index < translate.nodeQueue[lang][hash].length; index++){
-					for(var node_index = 0; node_index < translate.nodeQueue[uuid]['list'][lang][hash]['nodes'].length; node_index++){
-						//translate.nodeQueue[lang][hash]['nodes'][node_index].nodeValue = translate.nodeQueue[lang][hash]['nodes'][node_index].nodeValue.replace(new RegExp(originalWord,'g'), text);
-						//加入任务
-						task.add(translate.nodeQueue[uuid]['list'][lang][hash]['nodes'][node_index]['node'], originalWord, translate.nodeQueue[uuid]['list'][lang][hash]['nodes'][node_index]['beforeText']+text+translate.nodeQueue[uuid]['list'][lang][hash]['nodes'][node_index]['afterText'], translate.nodeQueue[uuid]['list'][lang][hash]['nodes'][node_index]['attribute']);
-					}
-					//处理等待同一文本的其他节点
-					if(pendingItem != null && typeof(pendingItem.waits) === 'object'){
-						var waitLoadingNodes = [];
-						for(var wi = 0; wi < pendingItem.waits.length; wi++){
-							var waitItem = pendingItem.waits[wi];
-							if(waitItem.uuid === uuid && waitItem.lang === lang && waitItem.hash === hash){
-								continue;
-							}
-							if(typeof(translate.nodeQueue[waitItem.uuid]) === 'undefined'){
-								continue;
-							}
-							if(typeof(translate.nodeQueue[waitItem.uuid]['list'][waitItem.lang]) === 'undefined'){
-								continue;
-							}
-							if(typeof(translate.nodeQueue[waitItem.uuid]['list'][waitItem.lang][waitItem.hash]) === 'undefined'){
-								continue;
-							}
-							var waitQueue = translate.nodeQueue[waitItem.uuid]['list'][waitItem.lang][waitItem.hash];
-							if(typeof(waitQueue) === 'undefined' || typeof(waitQueue.nodes) === 'undefined'){
-								continue;
-							}
-							var waitOriginal = waitQueue.original;
-							for(var wni = 0; wni < waitQueue.nodes.length; wni++){
-								task.add(waitQueue.nodes[wni]['node'], waitOriginal, waitQueue.nodes[wni]['beforeText']+text+waitQueue.nodes[wni]['afterText'], waitQueue.nodes[wni]['attribute']);
-								waitLoadingNodes.push(waitQueue.nodes[wni]['node']);
-							}
-						}
-						if(waitLoadingNodes.length > 0 && typeof(translate.progress) === 'object' && typeof(translate.progress.api) === 'object' && translate.progress.api.use){
-							translate.progress.api.removeLoadingByNodes(waitLoadingNodes);
-						}
-					}
-						//}
-						/*
-						for(var index = 0; index < translate.nodeQueue[data.from][hash].length; index++){
-							translate.nodeQueue[data.from][hash][index].nodeValue = text;
-						}
-						*/
-						
-						//将翻译结果以 key：hash  value翻译结果的形式缓存
-						translate.storage.set('hash_'+responseData.to+'_'+cacheHash,text);
-						//如果离线翻译启用了全部提取，那么还要存入离线翻译指定存储
-						if(translate.offline.fullExtract.isUse){
-							translate.offline.fullExtract.set(hash, originalWord, responseData.to, text);
-						}
-					}
-					task.execute(); //执行渲染任务
-					//translate.temp_executeFinishNumber++; //记录执行完的次数
-
-					splitRequestFinish(1, '', 0);
-				}, function(xhr){
-					if(translate.cancelVersion != executeCancelVersion){
-						return;
-					}
-					//请求异常，清理pending，允许后续重试
-					if(typeof(translate.request) === 'object' && typeof(translate.request.pending) === 'object'){
-						for(var ph = 0; ph < splitHashes.length; ph++){
-							if(typeof(translate.nodeQueue[uuid]) === 'undefined'){
-								break;
-							}
-							if(typeof(translate.nodeQueue[uuid]['list'][lang]) === 'undefined'){
-								break;
-							}
-							if(typeof(translate.nodeQueue[uuid]['list'][lang][splitHashes[ph]]) === 'undefined'){
-								continue;
-							}
-							var cacheHash = translate.nodeQueue[uuid]['list'][lang][splitHashes[ph]]['cacheHash'];
-							var pendingKey = translate.request.pending.key(lang, translate.to, cacheHash);
-							var pendingItem = translate.request.pending.take(pendingKey);
-							if(pendingItem != null && typeof(pendingItem.waits) === 'object' && typeof(translate.progress) === 'object' && typeof(translate.progress.api) === 'object' && translate.progress.api.use){
-								var waitNodes = [];
-								for(var wi = 0; wi < pendingItem.waits.length; wi++){
-									var waitItem = pendingItem.waits[wi];
-									if(typeof(translate.nodeQueue[waitItem.uuid]) === 'undefined'){
-										continue;
-									}
-									if(typeof(translate.nodeQueue[waitItem.uuid]['list'][waitItem.lang]) === 'undefined'){
-										continue;
-									}
-									if(typeof(translate.nodeQueue[waitItem.uuid]['list'][waitItem.lang][waitItem.hash]) === 'undefined'){
-										continue;
-									}
-									var waitQueue = translate.nodeQueue[waitItem.uuid]['list'][waitItem.lang][waitItem.hash];
-									if(typeof(waitQueue) === 'undefined' || typeof(waitQueue.nodes) === 'undefined'){
-										continue;
-									}
-									for(var wni = 0; wni < waitQueue.nodes.length; wni++){
-										waitNodes.push(waitQueue.nodes[wni]['node']);
-									}
-								}
-								if(waitNodes.length > 0){
-									translate.progress.api.removeLoadingByNodes(waitNodes);
-								}
-							}
-						}
-					}
-					var info = '';
-					if(typeof(xhr.status) != 'undefined'){
-						if(xhr.status < 1){
-							info = 'Network connection failed. url: '+xhr.requestURL;
-						}else{
-							info = 'HTTP response code : '+xhr.status+', url: '+xhr.requestURL;
-						}
-					}else{
-						info = 'Network connection failed. url: '+xhr.requestURL;
-					}
-					splitRequestFinish(0, info, 3);
-				});
-				if(xhr != null && typeof(xhr) == 'object' && typeof(translate.translateRequest[uuid]) == 'object' && typeof(translate.translateRequest[uuid][lang]) == 'object'){
-					if(typeof(translate.translateRequest[uuid][lang].xhrs) == 'undefined'){
-						translate.translateRequest[uuid][lang].xhrs = [];
-					}
-					translate.translateRequest[uuid][lang].xhrs.push(xhr);
-				}
-			}
-			/*** 翻译end ***/
-		}
+			translate.request.data[uuid].list[lang][translate.to] = {
+				texts: translateTextArray[lang],
+				nodes: translateTextNodes,
+			};
+
+			
+			/*** 翻译开始 ***/
+			var url = translate.request.api.translate;
+			var data = {
+				from:lang,
+				to:translate.to,
+				//lowercase:translate.whole.isEnableAll? '0':'1', //首字母大写
+				//text:JSON.stringify(translateTextArray[lang])
+				text:encodeURIComponent(JSON.stringify(translateTextArray[lang]))
+			};
+			translate.request.post(url, data, function(responseData, requestData){
+				//console.log(data); 
+				//console.log(translateTextArray[data.from]);
+
+				//针对 giteeai 增加了账户余额、账户是否激活的拍的判定，所以增加了 401 这个参数，凡是账户异常的，参数值是 401~499 之间。所以只要不是1都是失败
+				if(responseData.result != 1){
+					if(typeof(translate.translateRequest[uuid]) == 'object' && typeof(translate.translateRequest[uuid][requestData.from]) == 'object'){
+						translate.translateRequest[uuid][requestData.from]['result'] = 2;
+						translate.translateRequest[uuid][requestData.from].executeFinish = 1; //1是执行完毕
+						translate.translateRequest[uuid][requestData.from].stoptime = Math.floor(Date.now() / 1000);
+					}else{
+						translate.log('WARINNG!!! translate.translateRequest[uuid][requestData.from] is not object');
+					}
+
+					//为了兼容 v3.14以前的translate.service 版本，做了判断
+					var from = '';
+					if(typeof(requestData.from) != 'undefined' && requestData.from != null){
+						from = requestData.from;
+					}
+					var to = '';
+					if(typeof(requestData.to) != 'undefined' && requestData.to != null){
+						to = requestData.to;
+					}else{
+						to = translate.to;
+					}
+					translate.waitingExecute.isAllExecuteFinish(uuid, from, to, 0, responseData.info);
+					
+
+					translate.log('=======ERROR START=======');
+					translate.log(translateTextArray[requestData.from]);
+					//console.log(encodeURIComponent(JSON.stringify(translateTextArray[data.from])));
+					translate.log('response : '+responseData.info);
+					translate.log('=======ERROR END  =======');
+					//translate.temp_executeFinishNumber++; //记录执行完的次数
+					return;
+				}
+				
+				if(typeof(translate.nodeQueue[uuid]) == 'undefined'){
+					translate.log('提示：你很可能多次引入了 translate.js 所以造成了翻译本身的数据错乱，这只是个提示，它还是会给你正常翻译的，但是你最好不要重复引入太多次 translate.js ，正常情况下只需要引入一次 translate.js 就可以了。太多的话很可能会导致你页面卡顿');
+					return;
+				}
+
+				//console.log('-----待翻译3：----');
+				//console.log(translate.nodeQueue);
+				
+				//console.log('response:'+uuid);
+				let task = new translate.renderTask();
+				//遍历 translateHashArray
+				for(var i=0; i<translateHashArray[responseData.from].length; i++){
+					//翻译前的语种，如 english
+					var lang = responseData.from;	
+					//翻译后的内容
+					var text = responseData.text[i];	
+					//如果text为null，那么这个可能是一次翻译字数太多，为了保持数组长度，拼上的null
+					if(text == null){
+						continue;
+					}
+
+					// v3.0.3 添加，避免像是 JavaScript 被错误翻译为 “JavaScript的” ，然后出现了多个句子中都出现了Javascript时，会出现翻译后文本重复的问题
+					// 这里就是验证一下，翻译后的文本，是否会完全包含翻以前的文本，如果包含了，那么强制将翻译后的文本赋予翻译前的原始文本（也就是不被翻译）
+					if(text.toLowerCase().indexOf(translateTextArray[responseData.from][i].toLowerCase()) > -1){
+						//发现了，那么强制赋予翻以前内容
+						text = translateTextArray[responseData.from][i];
+					}
+
+
+					//翻译前的hash对应下标
+					var hash = translateHashArray[responseData.from][i];	
+					var cacheHash = translate.nodeQueue[uuid]['list'][lang][hash]['cacheHash'];
+
+
+					
+					//取原始的词，还未经过翻译的，需要进行翻译的词
+					var originalWord = '';
+					try{
+						originalWord = translate.nodeQueue[uuid]['list'][lang][hash]['original'];
+						//console.log('bef:'+translate.nodeQueue[uuid]['list'][lang][hash]['beforeText']);
+					}catch(e){
+						translate.log('uuid:'+uuid+', originalWord:'+originalWord+', lang:'+lang+', hash:'+hash+', text:'+text+', queue:'+translate.nodeQueue[uuid]);
+						translate.log(e);
+						continue;
+					}
+					
+					//for(var index = 0; index < translate.nodeQueue[lang][hash].length; index++){
+					for(var node_index = 0; node_index < translate.nodeQueue[uuid]['list'][lang][hash]['nodes'].length; node_index++){
+						//translate.nodeQueue[lang][hash]['nodes'][node_index].nodeValue = translate.nodeQueue[lang][hash]['nodes'][node_index].nodeValue.replace(new RegExp(originalWord,'g'), text);
+						//加入任务
+						task.add(translate.nodeQueue[uuid]['list'][lang][hash]['nodes'][node_index]['node'], originalWord, translate.nodeQueue[uuid]['list'][lang][hash]['nodes'][node_index]['beforeText']+text+translate.nodeQueue[uuid]['list'][lang][hash]['nodes'][node_index]['afterText'], translate.nodeQueue[uuid]['list'][lang][hash]['nodes'][node_index]['attribute']);
+					}
+					//}
+					/*
+					for(var index = 0; index < translate.nodeQueue[data.from][hash].length; index++){
+						translate.nodeQueue[data.from][hash][index].nodeValue = text;
+					}
+					*/
+					
+					//将翻译结果以 key：hash  value翻译结果的形式缓存
+					translate.storage.set('hash_'+responseData.to+'_'+cacheHash,text);
+					//如果离线翻译启用了全部提取，那么还要存入离线翻译指定存储
+					if(translate.offline.fullExtract.isUse){
+						translate.offline.fullExtract.set(hash, originalWord, responseData.to, text);
+					}
+				}
+				task.execute(); //执行渲染任务
+				//translate.temp_executeFinishNumber++; //记录执行完的次数
+
+				translate.translateRequest[uuid][lang].result = 1;
+				translate.translateRequest[uuid][lang].executeFinish = 1; //1是执行完毕
+				translate.translateRequest[uuid][lang].stoptime = Math.floor(Date.now() / 1000);
+				setTimeout(function(){
+					translate.waitingExecute.isAllExecuteFinish(uuid, responseData.from, responseData.to, 1, '');
+				},5);
+			}, function(xhr){
+				translate.translateRequest[uuid][xhr.data.from].executeFinish = 1; //1是执行完毕
+				translate.translateRequest[uuid][xhr.data.from].stoptime = Math.floor(Date.now() / 1000);
+				translate.translateRequest[uuid][xhr.data.from].result = 3;
+				var info = '';
+				if(typeof(xhr.status) != 'undefined'){
+					if(xhr.status < 1){
+						info = 'Network connection failed. url: '+xhr.requestURL;
+					}else{
+						info = 'HTTP response code : '+xhr.status+', url: '+xhr.requestURL;
+					}
+				}else{
+					info = 'Network connection failed. url: '+xhr.requestURL;
+				}
+				translate.waitingExecute.isAllExecuteFinish(uuid, xhr.data.from, translate.to, 0, info);
+			});
+			/*** 翻译end ***/
+		}
 
 		//钩子
 		translate.lifecycle.execute.finally_Trigger({
@@ -8386,7 +8149,7 @@ var translate = {
 		*/
 		data:{},
 		//相关API接口方面
-		api:{
+		api:{
 			/**
 			 * 翻译接口请求的域名主机 host
 			 * 格式注意前面要带上协议如 https:// 域名后要加 /
@@ -8400,130 +8163,9 @@ var translate = {
 			translate:'translate.json', //翻译接口
 			ip:'ip.json', //根据用户当前ip获取其所在地的语种
 			connectTest:'connectTest.json',	//用于 translate.js 多节点翻译自动检测网络连通情况
-			init:'init.json', //获取最新版本号，跟当前版本进行比对，用于提醒版本升级等使用
-
-		},
-		/*
-			translate.json 接口单次请求的文本大小控制
-			size: 按 JSON.stringify(array) 的长度进行拆分
-			maxSize: 拆分后的数组最大元素数量，0则不限制
-		*/
-		translateTextSplit:{
-			size:20000,
-			maxSize:10,
-			//单条文本达到该长度后单独成组，避免与其它文本拼接，0则使用 size/2
-			singleTextMinSize:0
-		},
-		/*
-			翻译请求去重（处理中）
-		*/
-		pending:{
-			map:new Map(),
-			key:function(from, to, cacheHash){
-				return from+'|'+to+'|'+cacheHash;
-			},
-			get:function(key){
-				if(this.map == null){
-					this.map = new Map();
-				}
-				return this.map.get(key) || null;
-			},
-			add:function(key, waitItem){
-				if(this.map == null){
-					this.map = new Map();
-				}
-				var item = this.map.get(key);
-				if(item == null){
-					item = {waits:[]};
-					this.map.set(key, item);
-				}
-				if(waitItem != null){
-					item.waits.push(waitItem);
-				}
-				return item;
-			},
-			take:function(key){
-				if(this.map == null){
-					this.map = new Map();
-					return null;
-				}
-				var item = this.map.get(key) || null;
-				if(item != null){
-					this.map.delete(key);
-				}
-				return item;
-			},
-			clear:function(){
-				this.map = new Map();
-			}
-		},
-		/*
-			将翻译文本数组拆分为多个请求，避免一次请求过大导致超时
-			注意：不会拆分单条文本，避免破坏段落/语义
-		*/
-		splitTranslateTextArray:function(textArray){
-			if(typeof(textArray) == 'undefined' || textArray == null){
-				return [];
-			}
-			if(typeof(textArray.length) == 'undefined'){
-				return [textArray];
-			}
-			var size = translate.request.translateTextSplit.size;
-			var maxSize = translate.request.translateTextSplit.maxSize;
-			var singleMinSize = translate.request.translateTextSplit.singleTextMinSize;
-			if(typeof(size) !== 'number' || size <= 0){
-				return [textArray];
-			}
-			if(typeof(singleMinSize) !== 'number' || singleMinSize <= 0){
-				singleMinSize = Math.floor(size / 2);
-			}
-
-			var list = [];
-			var current = [];
-			var currentSize = 2; // "[]"
-			var pushCurrent = function(){
-				if(current.length > 0){
-					list.push(current);
-					current = [];
-					currentSize = 2;
-				}
-			};
-
-			for(var i = 0; i < textArray.length; i++){
-				var item = textArray[i];
-				if(typeof(item) !== 'string'){
-					item = '' + item;
-				}
-
-				var itemJson = JSON.stringify(item);
-				var itemLen = itemJson.length + 2; // 作为单元素数组的长度
-
-				//大文本单独成组，避免与其他文本拼接
-				if(singleMinSize > 0 && itemLen >= singleMinSize){
-					pushCurrent();
-					list.push([item]);
-					continue;
-				}
-
-				var nextSize = current.length === 0 ? (2 + itemJson.length) : (currentSize + 1 + itemJson.length);
-
-				//超过限制或达到数组最大元素数量，先提交当前组
-				if((maxSize && maxSize > 0 && current.length >= maxSize) || nextSize > size){
-					pushCurrent();
-					current.push(item);
-					currentSize = 2 + itemJson.length;
-				}else{
-					current.push(item);
-					currentSize = nextSize;
-				}
-			}
-
-			pushCurrent();
-			if(list.length < 1){
-				list = [textArray];
-			}
-			return list;
-		},
+			init:'init.json', //获取最新版本号，跟当前版本进行比对，用于提醒版本升级等使用
+
+		},
 		/*
 			v3.18.35.20250920 增加
 		
@@ -8940,12 +8582,12 @@ var translate = {
 		 * 				注意，是响应数据是第一个参数，请求数据是第二个参数。 以向前兼容
 		 * @param abnormalFunc 响应异常所执行的方法，响应码不是200就会执行这个方法 ,传入如 function(xhr){}  另外这里的 xhr 会额外有个参数  xhr.requestURL 返回当前请求失败的url
 		 */
-		post:function(path, data, func, abnormalFunc){
-			var headers = {
-				'content-type':'application/x-www-form-urlencoded',
-			};
-			if(typeof(data) == 'undefined'){
-				return;
+		post:function(path, data, func, abnormalFunc){
+			var headers = {
+				'content-type':'application/x-www-form-urlencoded',
+			};
+			if(typeof(data) == 'undefined'){
+				return;
 			}
 
 			//企业级翻译自动检测
@@ -8956,25 +8598,26 @@ var translate = {
 			// ------- edge start --------
 			var url = translate.request.getUrl(path);
 			//if(url.indexOf('edge') > -1 && path == translate.request.api.translate){
-			if(translate.service.name == 'client.edge'){	
-				if(path == translate.request.api.translate){
-					return translate.service.edge.translate(path, data, func, abnormalFunc);
-				}
-				if(path == translate.request.api.language){
-					var d = {};
-					d.info = 'SUCCESS';
-					d.result = 1;
-					d.list = translate.service.edge.language.json;
-					func(d);
-					return;
-				}
-				
-				//return;
-			}
-			// ------- edge end --------
-
-			return this.send(path, data, data, func, 'post', true, headers, abnormalFunc, true);
-		},
+			if(translate.service.name == 'client.edge'){	
+				if(path == translate.request.api.translate){
+					translate.service.edge.translate(path, data, func, abnormalFunc);
+					return;
+				}
+				if(path == translate.request.api.language){
+					var d = {};
+					d.info = 'SUCCESS';
+					d.result = 1;
+					d.list = translate.service.edge.language.json;
+					func(d);
+					return;
+				}
+				
+				//return;
+			}
+			// ------- edge end --------
+
+			this.send(path, data, data, func, 'post', true, headers, abnormalFunc, true);
+		},
 		/**
 		 * 发送请求
 		 * url 请求的url或者path（path，传入的是translate.request.api.translate 这种的，需要使用 getUrl 来组合真正请求的url ）
@@ -8990,7 +8633,7 @@ var translate = {
 		 * abnormalFunc 响应异常所执行的方法，响应码不是200就会执行这个方法 ,传入如 function(xhr){}  另外这里的 xhr 会额外有个参数  xhr.requestURL 返回当前请求失败的url
 		 * showErrorLog 是否控制台打印出来错误日志，true打印， false 不打印
 		 */
-		send:function(url, data, appendXhrData, func, method, isAsynchronize, headers, abnormalFunc, showErrorLog){
+		send:function(url, data, appendXhrData, func, method, isAsynchronize, headers, abnormalFunc, showErrorLog){
 			//post提交的参数
 			var params = '';
 
@@ -9127,41 +8770,8 @@ var translate = {
 			        }
 			    }
 			}
-			return xhr;
-		},
-		/*
-			中断未完成的翻译请求（translate.json）
-		*/
-		abortTranslateRequests:function(){
-			if(typeof(translate.translateRequest) == 'undefined' || translate.translateRequest == null){
-				return;
-			}
-			for(var uuid in translate.translateRequest){
-				if (!translate.translateRequest.hasOwnProperty(uuid)) {
-		    		continue;
-		    	}
-				var langs = translate.translateRequest[uuid];
-				for(var lang in langs){
-					if (!langs.hasOwnProperty(lang)) {
-			    		continue;
-			    	}
-					var item = langs[lang];
-					if(typeof(item) !== 'object' || item == null){
-						continue;
-					}
-					if(typeof(item.xhrs) === 'object' && item.xhrs.length > 0){
-						for(var xi = 0; xi < item.xhrs.length; xi++){
-							try{
-								if(item.xhrs[xi] && typeof(item.xhrs[xi].abort) === 'function'){
-									item.xhrs[xi].abort();
-								}
-							}catch(e){}
-						}
-						item.xhrs = [];
-					}
-				}
-			}
-		},
+			return xhr;
+		},
 		/*
 
 			手动进行翻译操作。参数说明：
@@ -9205,11 +8815,10 @@ var translate = {
 				console.log(xhr);
 			});
 		*/
-		translateText:function(obj, func, abnormalFunc){
-			var texts = new Array();
-			var from = translate.language.getLocal();
-			var to = translate.language.getCurrent();
-			var executeCancelVersion = translate.cancelVersion;
+		translateText:function(obj, func, abnormalFunc){
+			var texts = new Array();
+			var from = translate.language.getLocal();
+			var to = translate.language.getCurrent();
 
 			if(typeof(obj) == 'string'){
 				//案例一的场景，传入单个字符串
@@ -9287,104 +8896,47 @@ var translate = {
 				return;
 			}
 
-			var url = translate.request.api.translate;
-			//按配置拆分文本数组，避免一次请求过大导致超时
-			var splitTextList = translate.request.splitTranslateTextArray(apiTranslateText);
-			if(typeof(splitTextList) == 'undefined' || splitTextList == null || splitTextList.length < 1){
-				splitTextList = [apiTranslateText];
-			}
-
-			var splitFinishCount = 0;
-			var splitResponseError = false;
-			var splitResponseErrorInfo = '';
-			var splitNetworkError = false;
-			var splitFinish = function(){
-				if(translate.cancelVersion != executeCancelVersion){
-					return;
-				}
-				splitFinishCount++;
-				if(splitFinishCount >= splitTextList.length){
-					if(splitNetworkError){
-						return;
-					}
-					var resultData = {
-						from:from,
-						to: to,
-						text:translateResultArray,
-						result: splitResponseError ? 0 : 1
-					};
-					if(splitResponseError && typeof(splitResponseErrorInfo) === 'string' && splitResponseErrorInfo.length > 0){
-						resultData.info = splitResponseErrorInfo;
-					}
-					func(resultData);
-				}
-			};
-
-			for(var splitIndex = 0; splitIndex < splitTextList.length; splitIndex++){
-				let splitTexts = splitTextList[splitIndex];
-				if(typeof(splitTexts) == 'undefined' || splitTexts == null || splitTexts.length < 1){
-					splitFinish();
-					continue;
-				}
-				let data = {
-					from:from,
-					to: to,
-					text:encodeURIComponent(JSON.stringify(splitTexts))
-				};
-				//console.log(splitTexts);
-				translate.request.post(url, data, function(responseData, requestData){
-					//console.log(responseData); 
-					//console.log(data); 
-					if(translate.cancelVersion != executeCancelVersion){
-						return;
-					}
-					if(responseData.result != 1){
-						splitResponseError = true;
-						if(typeof(responseData.info) === 'string' && responseData.info.length > 0 && splitResponseErrorInfo.length < 1){
-							splitResponseErrorInfo = responseData.info;
-						}
-						translate.log('=======ERROR START=======');
-						translate.log('from : '+requestData.from);
-						translate.log('to : '+requestData.to);
-						translate.log('translate text array : '+texts);
-						translate.log('response error info: '+responseData.info);
-						translate.log('=======ERROR END  =======');
-						//return;
-					}
-
-					if(typeof(responseData.text) == 'undefined' || responseData.text == null){
-						responseData.text = [];
-					}
-					var loopLength = responseData.text.length;
-					if(loopLength > splitTexts.length){
-						loopLength = splitTexts.length;
-					}
-					for(var i = 0; i < loopLength; i++){
-						//将翻译结果以 key：hash  value翻译结果的形式缓存
-						var hash = translate.util.hash(splitTexts[i]);
-						translate.storage.set('hash_'+to+'_'+hash, responseData.text[i]);
-						//如果离线翻译启用了全部提取，那么还要存入离线翻译指定存储
-						if(translate.offline.fullExtract.isUse){
-							translate.offline.fullExtract.set(hash, splitTexts[i], data.to, responseData.text[i]);
-						}
-
-						//进行组合数据到 translateResultArray
-						translateResultArray[apiTranslateArray[hash]] = responseData.text[i];
-					}
-
-					splitFinish();
-				}, (function(xhr){
-					if(translate.cancelVersion != executeCancelVersion){
-						return;
-					}
-					splitNetworkError = true;
-					if(abnormalFunc && typeof(abnormalFunc) == 'function'){
-						abnormalFunc(xhr);
-					}
-					splitFinish();
-				}));
-			}
-		},
+			var url = translate.request.api.translate;
+			var data = {
+				from:from,
+				to: to,
+				text:encodeURIComponent(JSON.stringify(apiTranslateText))
+			};
+			//console.log(apiTranslateText);
+			translate.request.post(url, data, function(responseData, requestData){
+				//console.log(responseData); 
+				//console.log(data); 
+				if(responseData.result != 1){
+					translate.log('=======ERROR START=======');
+					translate.log('from : '+requestData.from);
+					translate.log('to : '+requestData.to);
+					translate.log('translate text array : '+texts);
+					translate.log('response error info: '+responseData.info);
+					translate.log('=======ERROR END  =======');
+					//return;
+				}
+
+				for(var i = 0; i < responseData.text.length; i++){
+					//将翻译结果以 key：hash  value翻译结果的形式缓存
+					var hash = translate.util.hash(apiTranslateText[i]);
+					translate.storage.set('hash_'+to+'_'+hash, responseData.text[i]);
+					//如果离线翻译启用了全部提取，那么还要存入离线翻译指定存储
+					if(translate.offline.fullExtract.isUse){
+						translate.offline.fullExtract.set(hash, apiTranslateText[i], data.to, responseData.text[i]);
+					}
+
+					//进行组合数据到 translateResultArray
+					translateResultArray[apiTranslateArray[hash]] = responseData.text[i];
+				}
+				responseData.text = translateResultArray;			
+
+				func(responseData);
+			}, (function(xhr){
+				if(abnormalFunc && typeof(abnormalFunc) == 'function'){
+					abnormalFunc(xhr);
+				}
+			}));
+		},
 		listener:{
 			//是否已经启动过 translate.request.listener.addListener() 开始监听了，开始了则是true，默认没开始则是false
 			isStart:false,
@@ -9579,33 +9131,19 @@ var translate = {
 			
 		}
 	},
-	//存储，本地缓存
-	storage:{
-		//是否启用 IndexedDB 作为额外持久化缓存（默认启用）
-		useIndexedDB:true,
-		//IndexedDB 的内存级缓存，避免频繁异步回填
-		indexedDBCache:new Map(),
-		//IndexedDB 读取中的 key，避免重复请求
-		indexedDBCachePending:new Map(),
-		//设置是否启用 IndexedDB 缓存
-		setUseIndexedDB:function(use){
-			translate.storage.useIndexedDB = use ? true : false;
-		},
-		/*js translate.storage.IndexedDB start*/
-		//对浏览器的 IndexedDB 操作
-		IndexedDB:{
-			db: null,
-			// 初始化数据库
-			initDB: function () {
-				const self = this;
-				return new Promise((resolve, reject) => {
-					if(typeof(indexedDB) == 'undefined'){
-						reject('IndexedDB not supported');
-						return;
-					}
-					const DB_NAME = 'translate.js';
-					const STORE_NAME = 'kvStore';
-					const DB_VERSION = 1;
+	//存储，本地缓存
+	storage:{
+		/*js translate.storage.IndexedDB start*/
+		//对浏览器的 IndexedDB 操作
+		IndexedDB:{
+			db: null,
+			// 初始化数据库
+			initDB: function () {
+				const self = this;
+				return new Promise((resolve, reject) => {
+					const DB_NAME = 'translate.js';
+					const STORE_NAME = 'kvStore';
+					const DB_VERSION = 1;
 
 					const request = indexedDB.open(DB_NAME, DB_VERSION);
 
@@ -9671,8 +9209,8 @@ var translate = {
 					const users = await translate.storage.IndexedDB.list("*us*r*");
 					其中传入的key可以模糊搜索，其中的 * 标识另个或多个
 			*/
-			list: async function (key = '') {
-				if (!this.db) await this.initDB();
+			list: async function (key = '') {
+				if (!this.db) await this.initDB();
 
 				return new Promise((resolve, reject) => {
 					const tx = this.db.transaction('kvStore', 'readonly');
@@ -9698,68 +9236,18 @@ var translate = {
 
 					request.onerror = () => reject('游标读取失败');
 				});
-			}
-		},
-		/*js translate.storage.IndexedDB end*/
-
-		set:function(key,value){
-			try{
-				localStorage.setItem(key,value);
-			}catch(e){}
-			if(translate.storage.useIndexedDB && typeof(indexedDB) != 'undefined'){
-				try{
-					if(translate.storage.indexedDBCache instanceof Map){
-						translate.storage.indexedDBCache.set(key, value);
-					}
-					translate.storage.IndexedDB.set(key, value);
-				}catch(e){}
-			}
-		},
-		get:function(key){
-			var value = null;
-			try{
-				value = localStorage.getItem(key);
-			}catch(e){
-				value = null;
-			}
-			if(value != null){
-				return value;
-			}
-
-			//尝试从 IndexedDB 读取并回填（异步）
-			if(translate.storage.useIndexedDB && typeof(indexedDB) != 'undefined'){
-				if(translate.storage.indexedDBCache instanceof Map && translate.storage.indexedDBCache.has(key)){
-					return translate.storage.indexedDBCache.get(key);
-				}
-				if(translate.storage.indexedDBCachePending instanceof Map && translate.storage.indexedDBCachePending.has(key)){
-					return value;
-				}
-				if(translate.storage.indexedDBCachePending instanceof Map){
-					translate.storage.indexedDBCachePending.set(key, 1);
-				}
-				translate.storage.IndexedDB.get(key).then(function(v){
-					if(translate.storage.indexedDBCachePending instanceof Map){
-						translate.storage.indexedDBCachePending.delete(key);
-					}
-					if(typeof(v) == 'undefined' || v == null){
-						return;
-					}
-					try{
-						localStorage.setItem(key, v);
-					}catch(e){}
-					if(translate.storage.indexedDBCache instanceof Map){
-						translate.storage.indexedDBCache.set(key, v);
-					}
-				}).catch(function(){
-					if(translate.storage.indexedDBCachePending instanceof Map){
-						translate.storage.indexedDBCachePending.delete(key);
-					}
-				});
-			}
-			return value;
-		}
-
-	},
+			}
+		},
+		/*js translate.storage.IndexedDB end*/
+
+		set:function(key,value){
+			localStorage.setItem(key,value);
+		},
+		get:function(key){
+			return localStorage.getItem(key);
+		}
+
+	},
 	//针对图片进行相关的语种图片替换
 	images:{
 		/* 要替换的图片队列，数组形态，其中某个数组的：
@@ -10208,13 +9696,12 @@ var translate = {
 		/*
 			通过文本翻译API进行的
 		 */
-		api:{
-			isTip:true,//是否显示ui的提示，true显示，false不显示
-			use: false, //默认不使用，translate.progress.api.startUITip(); 可以设置为启用
-			autoStart:true, //是否在触发翻译时自动启用loading
-			setUITip:function(tip){
-				translate.progress.api.isTip = tip;
-			},
+		api:{
+			isTip:true,//是否显示ui的提示，true显示，false不显示
+			use: false, //默认不使用，translate.progress.api.startUITip(); 可以设置为启用
+			setUITip:function(tip){
+				translate.progress.api.isTip = tip;
+			},
 			//移除子元素（无限级别）中的所有 class name 的loading 遮罩
 			//level 层级，数字，比如第一次调用，传入1， 第一次里面产生的第二次调用，这里就是2
 			removeChildClass:function(node, level){
@@ -10253,15 +9740,12 @@ var translate = {
 
 				
 			*/
-			startUITip:function(config){
-				if(translate.progress.api.use){
-					return;
-				}
-				translate.progress.api.use = true;
-
-				if(typeof(config) === 'undefined'){
-					config = {};
-				}
+			startUITip:function(config){
+				translate.progress.api.use = true;
+
+				if(typeof(config) === 'undefined'){
+					config = {};
+				}
 				if(typeof(config.maskLayerMinWidth) !== 'number'){
 					config.maskLayerMinWidth = 10;
 				}
@@ -10288,10 +9772,10 @@ var translate = {
 			        document.head.appendChild(style);
 				}
 		        
-
-				if(translate.progress.api.isTip){
-					//translate.listener.execute.renderStartByApi.push(function(uuid, from, to){
-					translate.lifecycle.execute.translateNetworkBefore.push(function(data){
+
+				if(translate.progress.api.isTip){
+					//translate.listener.execute.renderStartByApi.push(function(uuid, from, to){
+					translate.lifecycle.execute.translateNetworkBefore.push(function(data){
 						var startTime = new Date().getTime();
 
 						//取出当前变动的node，对应的元素
@@ -10349,7 +9833,7 @@ var translate = {
 						//console.log('计算+渲染耗时：'+(new Date().getTime() - startTime));
 					});
 					
-					translate.lifecycle.execute.translateNetworkAfter.push(function(data){
+					translate.lifecycle.execute.translateNetworkAfter.push(function(data){
 						//取出当前变动的node，对应的元素
 						var elements = translate.element.nodeToElement(data.nodes);
 				    	
@@ -10365,48 +9849,12 @@ var translate = {
 				    	}
 						
 						
-					});
-
-				}
-			},
-			//对指定nodes应用loading样式
-			applyLoadingByNodes:function(nodes){
-				if(typeof(nodes) == 'undefined' || nodes == null || nodes.length < 1){
-					return;
-				}
-				var elements = translate.element.nodeToElement(nodes);
-				for(var r = 0; r<elements.length; r++){
-					if(typeof(elements[r].className) !== 'string'){
-						continue;
-					}
-					if(elements[r].className.indexOf('translate_api_in_progress') < 0){
-						elements[r].className = elements[r].className+' translate_api_in_progress';
-					}
-					if(translate.progress.api.isTip && elements[r].className.indexOf('translatejs-text-element-hidden') < 0){
-						elements[r].className = elements[r].className+' translatejs-text-element-hidden';
-					}
-				}
-			},
-			//移除指定nodes的loading样式
-			removeLoadingByNodes:function(nodes){
-				if(typeof(nodes) == 'undefined' || nodes == null || nodes.length < 1){
-					return;
-				}
-				var elements = translate.element.nodeToElement(nodes);
-				for(var r = 0; r<elements.length; r++){
-					if(typeof(elements[r].className) !== 'string'){
-						continue;
-					}
-					if(elements[r].className.indexOf('translate_api_in_progress') > -1){
-						elements[r].className = elements[r].className.replace(/translate_api_in_progress/g, '');
-					}
-					if(elements[r].className.indexOf('translatejs-text-element-hidden') > -1){
-						elements[r].className = elements[r].className.replace(/translatejs-text-element-hidden/g, '');
-					}
-				}
-			}
-		}
-	},
+					});
+
+				}
+			}
+		}
+	},
 	/*js translate.progress end*/
 
 	/*js dispose start*/