i18n-jsautotranslate 3.16.0 → 3.18.0

package/index.js

@@ -14,7 +14,7 @@ var translate = {
 	 * 格式：major.minor.patch.date
 	 */
 	// AUTO_VERSION_START
-	version: '3.16.0.20250618',
+	version: '3.18.0.20250816',
 	// AUTO_VERSION_END
 	/*
 		当前使用的版本，默认使用v2. 可使用 setUseVersion2(); 
@@ -177,21 +177,20 @@ var translate = {
 			}
 
 			//从服务器加载支持的语言库
-			translate.request.post(translate.request.api.language, {}, function(data){
-				if(data.result == 0){
-					console.log('load language list error : '+data.info);
-					return;
-				}
-				
-				translate.selectLanguageTag.customUI(data.list);
-
-				/*
-				try{
-					document.getElementById('translateSelectLanguage').style.width = '94px';
-				}catch(e){ console.log(e);} 
-				*/
-			}, null);
-			
+			if(typeof(translate.request.api.language) == 'string' && translate.request.api.language.length > 0){
+				//从接口加载语种
+				translate.request.post(translate.request.api.language, {}, function(data){
+					if(data.result == 0){
+						console.log('load language list error : '+data.info);
+						return;
+					}
+					//console.log(data.list);
+					translate.selectLanguageTag.customUI(data.list);
+				}, null);
+			}else if(typeof(translate.request.api.language) == 'object'){
+				//无网络环境下，自定义显示语种
+				translate.selectLanguageTag.customUI(translate.request.api.language);
+			}
 			
 		}
 	},
@@ -368,7 +367,10 @@ var translate = {
 			if(window.self !== window.top){
 				if(typeof(window.parent.translate) == 'object' && typeof(window.parent.translate.version) == 'string'){
 					//iframe页面中存在 translate,那么也控制iframe中的进行翻译
-					window.parent.translate.changeLanguage(languageName);
+					if(window.parent.translate.language.getCurrent() != languageName){
+						//如果父页面当前的语种不是需要翻译的语种，对其进行翻译
+						window.parent.translate.changeLanguage(languageName);
+					}
 				}
 			}
 		}catch(e){
@@ -406,7 +408,9 @@ var translate = {
 
 		//当用户代码设置里启用了 translate.listener.start() 然后用户加载页面后并没有翻译（这时listener是不启动的只是把listener.use标记为true），然后手动点击翻译按钮翻译为其他语种（这是不会刷新页面），翻译后也要跟着启动监听
 		if(translate.listener.use == true && translate.listener.isStart == false){
-			translate.listener.start();
+			if(typeof(translate.listener.start) != 'undefined'){
+				translate.listener.start();
+			}
 		}
 	},
 	
@@ -536,8 +540,26 @@ var translate = {
 		 * 这个其实是借用了 自定义术语 的能力，设置了自定义术语的原字符等于翻译后的字符， 于是这个字符就不会被翻译了
 		 * 这里可以是多个，数组，如 ['你好','世界']
 		 */
-		text:[]
-
+		text:[],
+		/*
+			下面的 textRegex 、 setTextRegexs 正则方式设置忽略不翻译text的能力，有 https://github.com/wangliangyu 提交贡献， 弥补 translate.ignore.text 固定设置的不足
+		*/
+		textRegex:[], 
+		/*
+			使用方式如：
+			translate.ignore.setTextRegexs([/请求/g, /[\u4a01-\u4a05]+/g]);
+		*/
+		setTextRegexs: function(arr) {
+			if (!Array.isArray(arr)) throw new Error('参数必须为数组');
+			for (let i = 0; i < arr.length; i++) {
+				if (!(arr[i] instanceof RegExp)) {
+					throw new Error('第' + i + '项不是RegExp对象');
+				}
+			}
+			//this.textRegex = [...this.textRegex, ...arr];
+			//改为兼容 es5 的方式，提供更多兼容
+			this.textRegex = this.textRegex.concat(arr); 
+		},
 	},
 	//刷新页面，你可以自定义刷新页面的方式，比如在 uniapp 打包生成 apk 时，apk中的刷新页面就不是h5的这个刷新，而是app的刷新方式，就需要自己进行重写这个刷新页面的方法了
 	refreshCurrentPage:function(){
@@ -654,6 +676,10 @@ var translate = {
 			}
 			//console.log(str)
 			for(var originalText in translate.nomenclature.data[translate.language.getLocal()][translate.to]){
+				if (!translate.nomenclature.data[translate.language.getLocal()][translate.to].hasOwnProperty(originalText)) {
+		    		continue;
+		    	}
+
 				var translateText = translate.nomenclature.data[translate.language.getLocal()][translate.to][originalText];
 				if(typeof(translateText) == 'function'){
 					//进行异常的预处理调出
@@ -753,8 +779,15 @@ var translate = {
 
 			var text = '';
 			for(var uuid in translate.nodeQueue){
+				if (!translate.nodeQueue.hasOwnProperty(uuid)) {
+		    		continue;
+		    	}
+
 				var queueValue = translate.nodeQueue[uuid];
 				for(var lang in translate.nodeQueue[uuid].list){
+					if (!translate.nodeQueue[uuid].list.hasOwnProperty(lang)) {
+			    		continue;
+			    	}
 					//console.log('------'+lang)
 					if(typeof(lang) != 'string' || lang.length < 1){
 						continue;
@@ -762,6 +795,9 @@ var translate = {
 					//if(translate.language.getLocal() == lang){
 						//console.log(translate.nodeQueue[uuid].list[lang]);
 						for(var hash in translate.nodeQueue[uuid].list[lang]){
+							if (!translate.nodeQueue[uuid].list[lang].hasOwnProperty(hash)) {
+					    		continue;
+					    	}
 							//console.log(translate.nodeQueue[uuid].list[lang][hash].original);
 							//console.log(translate.nodeQueue[uuid].list[lang][hash].original);
 							text = text + '\n' + translate.nodeQueue[uuid].list[lang][hash].original + '='+translate.storage.get('hash_'+translate.language.getCurrent()+'_'+hash);
@@ -903,6 +939,9 @@ var translate = {
 				
 				var data = await translate.storage.IndexedDB.list('hash_*');
 				for(var i in data){
+					if (!data.hasOwnProperty(i)) {
+			    		continue;
+			    	}
 					var originalText = data[i].value.originalText.replace(/\n/g, "\\n").replace(/\t/g, "\\t");
 					text = text + '\n' + originalText + '='+data[i].value.english.replace(/\n/g, "\\n").replace(/\t/g, "\\t");
 				}
@@ -1183,11 +1222,10 @@ var translate = {
 					}
 					//console.log('translateNodeslength: '+translateNodes.length);
 
-
-					setTimeout(function() {
-						//console.log(translateNodes);
-						translate.execute(translateNodes); //指定要翻译的元素的集合,可传入一个或多个元素。如果不设置，默认翻译整个网页
-					}, 10); //这个要比 task.execute() 中的 settimeout 延迟执行删除 translate.inpr.....nodes 的时间要小，目的是前一个发生变动后，记入 inpr...nodes 然后翻译完成后节点发生变化又触发了listener，此时 inpr....nodes 还有，那么这个变化将不做处理，然后 inp.....nodes 再删除这个标记
+					translate.execute(translateNodes);
+					//setTimeout(function() {
+					//	translate.execute(translateNodes); //指定要翻译的元素的集合,可传入一个或多个元素。如果不设置，默认翻译整个网页
+					//}, 10); //这个要比 task.execute() 中的 settimeout 延迟执行删除 translate.inpr.....nodes 的时间要小，目的是前一个发生变动后，记入 inpr...nodes 然后翻译完成后节点发生变化又触发了listener，此时 inpr....nodes 还有，那么这个变化将不做处理，然后 inp.....nodes 再删除这个标记
 				}
 			};
 			// 创建一个观察器实例并传入回调函数
@@ -1246,7 +1284,7 @@ var translate = {
                 //console.log(translate.nodeQueue[uuid]);
                 for(var i = 0; i < translate.listener.execute.renderFinishByApi.length; i++){
                     try{
-                        translate.listener.execute.renderFinishByApi[i](uuid, from, to);
+                    	translate.listener.execute.renderFinishByApi[i](uuid, from, to);
                     }catch(e){
                         console.log(e);
                     }
@@ -1336,6 +1374,10 @@ var translate = {
 		execute(){
 			//先对tasks任务队列的替换词进行排序，将同一个node的替换词有大到小排列，避免先替换了小的，大的替换时找不到
 			for(var hash in this.taskQueue){
+				if (!this.taskQueue.hasOwnProperty(hash)) {
+		    		continue;
+		    	}
+
 				var tasks = this.taskQueue[hash];
 				if(typeof(tasks) == 'function'){
 					//进行异常的预处理调出
@@ -1358,6 +1400,10 @@ var translate = {
 
 			//对nodeQueue进行翻译
 			for(var hash in this.nodes){
+				if (!this.nodes.hasOwnProperty(hash)) {
+		    		continue;
+		    	}
+		    	
 				var tasks = this.taskQueue[hash]; //取出当前node元素对应的替换任务
 				//var tagName = this.nodes[hash][0].nodeName; //以下节点的tag name
 				//console.log(tasks);
@@ -1438,8 +1484,16 @@ var translate = {
 					/** 执行完成后，保存翻译的历史node **/
 					//将当前翻译完成的node进行缓存记录，以node唯一标识为key，  node、以及node当前翻译之后的内容为值进行缓存。方便下一次执行 translate.execute() 时，若值未变化则不进行翻译
 					for(var hash in renderTask.nodes){
+						if (!renderTask.nodes.hasOwnProperty(hash)) {
+				    		continue;
+				    	}
+
 						//console.log(translate.nodeQueue[uuid].list[lang][hash])
 						for(var nodeindex in renderTask.nodes[hash]){
+							if (!renderTask.nodes[hash].hasOwnProperty(nodeindex)) {
+					    		continue;
+					    	}
+
 							//console.log(translate.nodeQueue[uuid].list[lang][hash].original);
 							//var nodename = translate.element.getNodeName(translate.nodeQueue[uuid].list[lang][hash].nodes[0].node);
 							//console.log("nodename:"+nodename);
@@ -1566,8 +1620,13 @@ var translate = {
 			@param to 翻译为的语种
 		*/
 		isAllExecuteFinish:function(uuid, from, to){
+			translate.listener.execute.renderFinishByApiRun(uuid, from, to);
+
 			//console.log('uuid:'+uuid+', from:'+from+', to:'+to);
 			for(var lang in translate.translateRequest[uuid]){
+				if (!translate.translateRequest[uuid].hasOwnProperty(lang)) {
+		    		continue;
+		    	}
 				//console.log(translate.translateRequest[uuid])
 				for(var i = 0; i<translate.translateRequest[uuid][lang].length; i++){
 					if(translate.translateRequest[uuid][lang][i].executeFinish == 0){
@@ -1581,11 +1640,12 @@ var translate = {
 				}
 			}
 
+			//生命周期触发事件
+			translate.lifecycle.execute.renderFinish_Trigger(uuid, to);
+
 			//都执行完了，那么设置完毕
 			translate.state = 0;
 			translate.executeNumber++;
-
-			translate.listener.execute.renderFinishByApiRun(uuid, from, to);
 		}
 
 	},
@@ -1593,6 +1653,116 @@ var translate = {
 	//execute() 方法已经被执行过多少次了， 只有execute() 完全执行完，也就是界面渲染完毕后，它才会+1
 	executeNumber:0,
 	
+	lifecycle:{
+
+		/*
+			translate.execute() 执行相关
+		*/
+		execute:{
+			/*
+                每当触发执行 translate.execute() 时，会先进行当前是否可以正常进行翻译的判定，比如 当前语种是否就已经是翻译之后的语种了是否没必要翻译了等。（这些初始判定可以理解成它的耗时小于1毫秒，几乎没有耗时）
+                经过初始的判断后，发现允许被翻译，那么在向后执行之前，先触发此。  
+                也就是在进行翻译之前，触发此。 
+				
+                @param uuid：translate.nodeQueue[uuid] 这里的
+				@param to 翻译为的语种
+            */
+            start : [],
+            start_Trigger:function(uuid, to){
+                for(var i = 0; i < translate.lifecycle.execute.start.length; i++){
+                    try{
+                        translate.lifecycle.execute.start[i](uuid, to);
+                    }catch(e){
+                        console.log(e);
+                    }
+                }
+            },
+
+
+			//待整理
+            start_old : [],
+            startRun:function(uuid, from, to){
+                //console.log(translate.nodeQueue[uuid]);
+                for(var i = 0; i < translate.listener.execute.renderStartByApi.length; i++){
+                    try{
+                        translate.listener.execute.renderStartByApi[i](uuid, from, to);
+                    }catch(e){
+                        console.log(e);
+                    }
+                }
+            },
+
+            /*
+                当扫描整个节点完成，进行翻译（1. 命中本地缓存、 2.进行网络翻译请求）之前，触发
+                待整理
+			 */
+            scanNodesFinsh: [],
+
+            
+            /*
+                每当触发执行 translate.execute() 时，当缓存中未发现，需要请求翻译API进行翻译时，在发送API请求前，触发此
+
+                @param uuid：translate.nodeQueue[uuid] 这里的
+                @param from 来源语种，翻译前的语种
+				@param to 翻译为的语种
+				@param texts 要翻译的文本，它是一个数组形态，是要进行通过API翻译接口进行翻译的文本，格式如 ['你好','世界']
+            */
+            translateNetworkBefore:[],
+            translateNetworkBefore_Trigger:function(uuid, from, to, texts){
+            	for(var i = 0; i < translate.lifecycle.execute.translateNetworkBefore.length; i++){
+                    try{
+                        translate.lifecycle.execute.translateNetworkBefore[i](uuid,from, to, texts);
+                    }catch(e){
+                        console.log(e);
+                    }
+                }
+            },
+
+            /*
+				当 translate.execute() 触发网络翻译请求完毕（不管成功还是失败），并将翻译结果渲染到页面完毕后，触发此。
+				@param uuid translate.nodeQueue 的uuid
+				@param from 
+				@param to 当前是执行的翻译为什么语种
+				@param text 网络请求翻译的文本/节点/。。。待定
+            */
+            translateNetworkAfter:[], //已废弃
+            /*
+            
+            translateNetworkAfter_Trigger:function(uuid, to){
+                for(var i = 0; i < translate.lifecycle.execute.translateNetworkAfter.length; i++){
+                    try{
+                        translate.lifecycle.execute.translateNetworkAfter[i](uuid, to);
+                    }catch(e){
+                        console.log(e);
+                    }
+                }
+            },
+            */
+
+            /*
+				translate.execute() 的翻译渲染完毕触发
+				这个完毕是指它当触发 translate.execute() 进行翻译后，无论是全部命中了本地缓存，还是有部分要通过翻译接口发起多个网络请求，当拿到结果（缓存中的翻译结果或多个不同的有xx语种翻译的网络请求全部完成，这个完成是包含所有成功跟失败的响应），并完成将翻译结果渲染到页面中进行显示后，触发此
+				它跟 translateNetworkFinish 的区别是， translateNetworkFinish 仅仅针对有网络请求的才会触发，而 renderFinish 是如果全部命中了浏览器本地缓存，无需发起任何网络翻译请求这种情况时，也会触发。
+            	@param uuid translate.nodeQueue 的uuid
+				@param to 当前是执行的翻译为什么语种
+            */
+            renderFinish:[function(uuid, to){ //这里默认带着一个触发翻译为英文后，自动对英文进行元素视觉处理，追加空格的
+            	if(typeof(translate.visual) != 'undefined'){
+            		translate.visual.adjustTranslationSpacesByNodequeueUuid(uuid);
+            	}
+            }],
+            renderFinish_Trigger:function(uuid, to){
+            	for(var i = 0; i < translate.lifecycle.execute.renderFinish.length; i++){
+                    try{
+                        translate.lifecycle.execute.renderFinish[i](uuid, to);
+                    }catch(e){
+                        console.log(e);
+                    }
+                }
+            }
+		}
+	},
+
 	/*translate.execute() start */
 	/*
 		执行翻译操作。翻译的是 nodeQueue 中的
@@ -1667,11 +1837,11 @@ var translate = {
 			//未指定，判断如果指定了自动获取用户本国语种了，那么进行获取
 			if(translate.autoDiscriminateLocalLanguage){
 				translate.executeByLocalLanguage();
+			}else{
+				//没有指定翻译目标语言、又没自动获取用户本国语种，则不翻译
+				translate.state = 0;
+				return;
 			}
-			
-			//没有指定翻译目标语言、又没自动获取用户本国语种，则不翻译
-			translate.state = 0;
-			return;
 		}
 		
 		//判断本地语种跟要翻译的目标语种是否一样，如果是一样，那就不需要进行任何翻译
@@ -1687,6 +1857,10 @@ var translate = {
 		
 
 		/********** 翻译进行 */
+
+		//生命周期-触发翻译进行之前，用户自定义的钩子
+		translate.lifecycle.execute.start_Trigger(uuid, translate.to);
+
 		
 		//先进行图片的翻译替换，毕竟图片还有加载的过程
 		translate.images.execute();
@@ -1732,6 +1906,27 @@ var translate = {
 			console.log('translate.execute( docs ) 传入的docs.length 过大，超过500，这很不正常，当前 docs.length : '+all.length+' ,如果你感觉真的没问题，请联系作者 http://translate.zvo.cn/43006.html 说明情况，根据你的情况进行分析。 当前只取前500个元素进行翻译');
 		}
 
+		//初始化 translate.element.tagAttribute ，主要针对 v3.17.10 版本的适配调整，对 translate.element.tagAttribute  的设置做了改变，做旧版本的适配
+		try{
+			for(var te_tag in translate.element.tagAttribute){
+				if (!translate.element.tagAttribute.hasOwnProperty(te_tag)) {
+		    		continue;
+		    	}
+		    	if(translate.element.tagAttribute[te_tag] instanceof Array){
+		    		//是 v3.17.10 之前版本的设置方式，要进行对旧版本的适配
+		    		var tArray = translate.element.tagAttribute[te_tag];
+		    		translate.element.tagAttribute[te_tag] = {
+		    			attribute: tArray,
+		    			condition: function(element){
+							return true;
+						}
+		    		}
+		    	}
+			}  
+		}catch(e){
+			console.log(e);
+		}
+
 		//检索目标内的node元素
 		for(var i = 0; i< all.length & i < 500; i++){
 			var node = all[i];
@@ -1742,6 +1937,9 @@ var translate = {
 		if(translate.language.translateLanguagesRange.length > 0){
 			//如果大于0，则是有设置，那么只翻译有设置的语种，不在设置中的语种不会参与翻译
 			for(var lang in translate.nodeQueue[uuid].list){
+				if (!translate.nodeQueue[uuid].list.hasOwnProperty(lang)) {
+		    		continue;
+		    	}
 				if(translate.language.translateLanguagesRange.indexOf(lang) < 0){
 					//删除这个语种
 					delete translate.nodeQueue[uuid].list[lang];
@@ -1759,13 +1957,23 @@ var translate = {
 			console.log('您使用translate.js时可能放的位置不对，不要吧 translate.js 放在网页最顶部，这样当 translate.js 进行执行，也就是 translate.execute() 执行时，因为网页是从上往下加载，它放在网页最顶部，那么它执行时网页后面的内容都还没加载出来，这个是不会获取到网页任何内容的，也就是它是不起任何作用的');
 		}
 		for(var lang in translate.nodeQueue[uuid].list){
+			if (!translate.nodeQueue[uuid].list.hasOwnProperty(lang)) {
+	    		continue;
+	    	}
 			//console.log('lang:'+lang)
 			for(var hash in translate.nodeQueue[uuid].list[lang]){
+				if (!translate.nodeQueue[uuid].list[lang].hasOwnProperty(hash)) {
+		    		continue;
+		    	}
 				//console.log(hash)
 				if(typeof(translate.nodeQueue[uuid].list[lang][hash]) == 'function'){
 					//v2.10增加，避免hash冒出个 Contains 出来导致for中的.length 出错
 					continue;
 				}
+				if(typeof(translate.nodeQueue[uuid].list[lang][hash].nodes) == 'undefined' || typeof(translate.nodeQueue[uuid].list[lang][hash].nodes.length) == 'undefined'){
+					//v3.16.2 增加，针对深圳北理莫斯科学校龙老师提出的这里 .length 遇到了 undefined 的情况
+					continue;
+				}
 				for(var nodeindex = translate.nodeQueue[uuid].list[lang][hash].nodes.length-1; nodeindex > -1; nodeindex--){
 					//console.log(translate.nodeQueue[uuid].list[lang][hash].nodes);
 					var analyse = translate.element.nodeAnalyse.get(translate.nodeQueue[uuid].list[lang][hash].nodes[nodeindex].node);
@@ -1832,6 +2040,9 @@ var translate = {
 		var twoScanNodes = {};
 		var cacheScanNodes = []; //同上面的 twoScanNodes，只不过 twoScanNodes 是按照lang存的，而这个不再有lang区分
 		for(var lang in translate.nodeQueue[uuid]['list']){ //二维数组中，取语言
+			if (!translate.nodeQueue[uuid]['list'].hasOwnProperty(lang)) {
+	    		continue;
+	    	}
 			//console.log('lang:'+lang); //lang为english这种语言标识
 			if(lang == null || typeof(lang) == 'undefined' || lang.length == 0 || lang == 'undefined'){
 				//console.log('lang is null : '+lang);
@@ -1847,6 +2058,9 @@ var translate = {
 			twoScanNodes[lang] = [];
 			//二维数组，取hash、value
 			for(var hash in translate.nodeQueue[uuid]['list'][lang]){
+				if (!translate.nodeQueue[uuid]['list'][lang].hasOwnProperty(hash)) {
+		    		continue;
+		    	}
 				if(typeof(translate.nodeQueue[uuid]['list'][lang][hash]) == 'function'){
 					//跳出，增加容错。  正常情况下应该不会这样
 					continue;
@@ -1994,8 +2208,25 @@ var translate = {
 		//console.log('cacheScanNodes:');
 		//console.log(cacheScanNodes);
 
+
+		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++;
+			return;
+		}
+
+
+
 		/******* 进行第二次扫描、追加入翻译队列。目的是防止缓存打散扫描的待翻译文本 ********/
 		for(var lang in twoScanNodes){
+			if (!twoScanNodes.hasOwnProperty(lang)) {
+	    		continue;
+	    	}
+
 			//记录第一次扫描的数据，以便跟第二次扫描后的进行对比
 			var firstScan = Object.keys(translate.nodeQueue[uuid]['list'][lang]);
 			var firstScan_lang_langth = firstScan.length; //第一次扫描后的数组长度
@@ -2077,6 +2308,10 @@ var translate = {
 		var fanyiLangs = []; 
 		//console.log(translateTextArray)
 		for(var lang in translate.nodeQueue[uuid]['list']){ //二维数组中取语言
+			if (!translate.nodeQueue[uuid]['list'].hasOwnProperty(lang)) {
+	    		continue;
+	    	}
+	    	
 			if(typeof(translateTextArray[lang]) == 'undefined'){
 				continue;
 			}
@@ -2112,6 +2347,10 @@ var translate = {
 		//console.log(translate.nodeQueue[uuid]['list'])
 		if(fanyiLangs.length == 0){
 			//没有需要翻译的，直接退出
+
+			//生命周期触发事件
+			translate.lifecycle.execute.renderFinish_Trigger(uuid, translate.to);
+
 			translate.state = 0;
 			translate.executeNumber++;
 			return;
@@ -2119,6 +2358,9 @@ var translate = {
 		
 		//加入 translate.inProgressNodes -- start
 		for(var lang in translateHashArray){
+			if (!translateHashArray.hasOwnProperty(lang)) {
+	    		continue;
+	    	}
 			if(typeof(translateHashArray[lang]) == 'undefined'){
 				continue;
 			}
@@ -2132,6 +2374,11 @@ var translate = {
 				//console.log('translate.nodeQueue[\''+uuid+'\'][\'list\'][\'chinese_simplified\'][\''+thhash+'\']');
 				//console.log(lang);
 				//console.log(translate.nodeQueue[uuid]['list'][lang][thhash].nodes);
+				if(typeof(translate.nodeQueue[uuid]['list'][lang][thhash].nodes) == 'undefined' || typeof(translate.nodeQueue[uuid]['list'][lang][thhash].nodes.length) == 'undefined'){
+					console.log('translate.nodeQueue[\''+uuid+'\'][\'list\'][\''+lang+'\'][\''+thhash+'\'].nodes.length is null ，理论上不应该存在，进行异常报出，但不影响使用，已容错。');
+					continue;
+				}
+		
 				for(var ipni = 0; ipni < translate.nodeQueue[uuid]['list'][lang][thhash].nodes.length; ipni++){
 					//取得这个翻译的node
 					var ipnode = translate.nodeQueue[uuid]['list'][lang][thhash].nodes[ipni].node;
@@ -2163,14 +2410,21 @@ var translate = {
 		//状态
 		translate.state = 20;
 
-		
 		//进行掉接口翻译
 		for(var lang_index in fanyiLangs){ //一维数组，取语言
+			if (!fanyiLangs.hasOwnProperty(lang_index)) {
+	    		continue;
+	    	}
 			var lang = fanyiLangs[lang_index];
-			//console.log(typeof(translateTextArray[lang]))
+			if(typeof(lang) != 'string'){
+				continue;
+			}
 			
 			if(typeof(translateTextArray[lang]) == 'undefined' || translateTextArray[lang].length < 1){
-				console.log('异常,理论上不应该存在： typeof(translateTextArray[lang]) == \'undefined\' || translateTextArray[lang].length < 1');
+				console.log('异常,理论上不应该存在, lang:'+lang+', translateTextArray:');
+				console.log(translateTextArray);
+				console.log('你无需担心，这个只是个提示，它并不影响你翻译的正常进行，只是个异常提示而已，它会自动容错处理的，不会影响翻译的使用。');
+
 				translate.state = 0;
 				translate.executeNumber++;
 				return;
@@ -2193,7 +2447,8 @@ var translate = {
 
 			//listener
 			translate.listener.execute.renderStartByApiRun(uuid, lang, translate.to); 
-
+			translate.lifecycle.execute.translateNetworkBefore_Trigger(uuid, lang, translate.to, translateTextArray[lang]); 
+			
 			/*** 翻译开始 ***/
 			var url = translate.request.api.translate;
 			var data = {
@@ -2313,10 +2568,10 @@ var translate = {
 					translate.waitingExecute.isAllExecuteFinish(uuid, data.from, data.to);
 				},10);
 			}, function(xhr){
-				translate.translateRequest[uuid][lang].executeFinish = 1; //1是执行完毕
-				translate.translateRequest[uuid][lang].stoptime = Math.floor(Date.now() / 1000);
-				translate.translateRequest[uuid][lang].result = 3;
-				translate.waitingExecute.isAllExecuteFinish(uuid, lang, translate.to);
+				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;
+				translate.waitingExecute.isAllExecuteFinish(uuid, xhr.data.from, translate.to);
 			});
 			/*** 翻译end ***/
 		}
@@ -2371,6 +2626,32 @@ var translate = {
 			有几个要翻译的属性，就写上几个。
 			同样，有几个要额外翻译的tag，就加上几行。  
 			详细文档参考：  http://translate.zvo.cn/231504.html
+
+	
+			//针对宁德时代提出的需求，需要对 标签本身进行一个判定，是否符合条件符合条件才会翻译，不符合条件则不要进行翻译
+			//比如标签带有 disabled 的才会被翻译，所以要增加一个自定义入参的 function ，返回 true、false
+			translate.element.tagAttribute['input']={
+				//要被翻译的tag的属性，这里是要翻译 input 的 value 、 data-value 这两个属性。 
+				//数组格式，可以一个或多个属性
+				attribute:['value','data-value'],  
+				//条件，传入一个function，返回一个布尔值。
+				//只有当返回的布尔值是true时，才会对上面设置的 attribute 进行翻译，否则并不会对当前设定标签的 attribute 进行任何翻译操作。
+				condition:function(element){ 	   
+					//	element 便是当前的元素，
+					//	比如这里是 translate.element.tagAttribute['input']  那这个 element 参数便是扫描到的具体的 input 元素
+					//	可以针对 element 这个当前元素本身来进行判定，来决定是否进行翻译。
+					//	返回值是布尔值 true、false
+					//	    return true; //要对 attribute中设置的 ['value','data-value'] 这两个input 的属性的值进行翻译。 
+					//	                     如果不设置或传入 condition ，比如单纯这样设置： 
+					//	                     translate.element.tagAttribute['input']={ 
+					//	                         attribute:['value','data-value'] 
+					//	                     } 
+					//	                     那么这里默认就是 return true;
+					//	    return false; //不对 attribute中设置的 ['value','data-value'] 这两个input 的属性的值进行任何操作
+					return true;
+				}
+			};
+
 		*/
 		tagAttribute : {},
 
@@ -2431,14 +2712,29 @@ var translate = {
 
 				if(attribute != null && typeof(attribute) == 'string' && attribute.length > 0){
 					//这个node有属性，替换的是node的属性，而不是nodeValue
-					result['text'] = node[attribute];
+
+					var nodeAttributeValue; //这个 attribute 属性的值
+					if(nodename == 'INPUT' && attribute.toLowerCase() == 'value'){
+						//如果是input 的value属性，那么要直接获取，而非通过 attribute ，不然用户自己输入的通过 attribute 是获取不到的 -- catl 赵阳 提出
+						
+						nodeAttributeValue = node.value;
+					}else{
+						nodeAttributeValue = node[attribute];
+					}
+					result['text'] = nodeAttributeValue;
+					
 
 					//替换渲染
 					if(typeof(originalText) != 'undefined' && originalText.length > 0){
-						if(typeof(node[attribute]) != 'undefined'){
+						if(typeof(nodeAttributeValue) != 'undefined'){
 							//这种是主流框架，像是vue、element、react 都是用这种 DOM Property 的方式，更快
-							var resultShowText = translate.util.textReplace(node[attribute], originalText, resultText, translate.to);
-							node[attribute] = resultShowText;  //2025.4.26 变更为此方式
+							var resultShowText = translate.util.textReplace(nodeAttributeValue, originalText, resultText, translate.to);
+							if(nodename == 'INPUT' && attribute.toLowerCase() == 'value'){
+								//input 的value 对于用户输入的必须用 .value 操作
+								node.value = resultShowText;
+							}else{
+								node[attribute] = resultShowText;  //2025.4.26 变更为此方式
+							}
 							if(resultShowText.indexOf(resultText) > -1){
 								result['resultText'] = resultShowText;
 							}else{
@@ -2602,7 +2898,9 @@ var translate = {
 				}else{
 					//替换渲染
 					if(typeof(originalText) != 'undefined' && originalText != null && originalText.length > 0){
+						//console.log(originalText+'|');
 						var resultShowText = translate.util.textReplace(node.nodeValue, originalText, resultText, translate.to);
+						//console.log(resultShowText+'|');
 						node.nodeValue = resultShowText;  //2025.4.26 变更为此方式
 						if(resultShowText.indexOf(resultText) > -1){
 							result['resultText'] = resultShowText;
@@ -2674,34 +2972,47 @@ var translate = {
 				//console.log('find:'+nodeNameLowerCase);
 				//console.log(translate.element.tagAttribute[nodeNameLowerCase]);
 
-				for(var attributeName_index in translate.element.tagAttribute[nodeNameLowerCase]){
+				for(var attributeName_index in translate.element.tagAttribute[nodeNameLowerCase].attribute){
+					if (!translate.element.tagAttribute[nodeNameLowerCase].attribute.hasOwnProperty(attributeName_index)) {
+			    		continue;
+			    	}
+			    	if(typeof(translate.element.tagAttribute[nodeNameLowerCase].condition) !='undefined' && !translate.element.tagAttribute[nodeNameLowerCase].condition(node)){
+			    		continue;
+			    	}
 					
-					var attributeName = translate.element.tagAttribute[nodeNameLowerCase][attributeName_index];
+					var attributeName = translate.element.tagAttribute[nodeNameLowerCase].attribute[attributeName_index];
 					//console.log(attributeName);
 					//console.log(node.getAttribute(attributeName));
 
-					/*
-					 * 默认是 HtmlAtrribute 也就是 HTML特性。取值有两个:
-					 * HTMLAtrribute : HTML特性
-					 * DOMProperty : DOM属性
-					 */
-					var DOMPropOrHTMLAttr = 'HTMLAtrribute'; 
-					var attributeValue = node.getAttribute(attributeName);
-					if(typeof(attributeValue) == 'undefined' || attributeValue == null){
-						//vue、element、react 中的一些动态赋值，比如 element 中的 el-select 选中后赋予显示出来的文本，getAttribute 就取不到，因为是改动的 DOM属性，所以要用这种方式才能取出来
-						attributeValue = node[attributeName];
+
+					if(nodeNameLowerCase == 'input' && attributeName.toLowerCase() == 'value'){
+						//如果是input 的value属性，那么要直接获取，而非通过 attribute ，不然用户自己输入的通过 attribute 是获取不到的 - catl 赵阳 提出
+						attributeValue = node.value;
 						DOMPropOrHTMLAttr = 'DOMProperty';
+					}else{
+						/*
+						 * 默认是 HtmlAtrribute 也就是 HTML特性。取值有两个:
+						 * HTMLAtrribute : HTML特性
+						 * DOMProperty : DOM属性
+						 */
+						var DOMPropOrHTMLAttr = 'HTMLAtrribute'; 
+						var attributeValue = node.getAttribute(attributeName);
+						if(typeof(attributeValue) == 'undefined' || attributeValue == null){
+							//vue、element、react 中的一些动态赋值，比如 element 中的 el-select 选中后赋予显示出来的文本，getAttribute 就取不到，因为是改动的 DOM属性，所以要用这种方式才能取出来
+							attributeValue = node[attributeName];
+							DOMPropOrHTMLAttr = 'DOMProperty';
+						}
+						if(typeof(attributeValue) == 'undefined' || attributeValue == null){
+							//这个tag标签没有这个属性，忽略
+							continue;
+						}
 					}
-					if(typeof(attributeValue) == 'undefined' || attributeValue == null){
-						//这个tag标签没有这个属性，忽略
-						continue;
-					}
+					
 
 					//if(typeof(node.getAttribute(attributeName)) == 'undefined' && typeof(node[attributeName]) == 'undefined'){
 					//	//这个tag标签没有这个 attribute，忽略
 					//	continue
 					//}
-
 					//判断当前元素是否在ignore忽略的tag、id、class name中   v3.15.7 增加					
 					if(!translate.ignore.isIgnore(node)){
 						//加入翻译
@@ -2780,6 +3091,7 @@ var translate = {
 
 			//node分析
 			var nodeAnaly = translate.element.nodeAnalyse.get(node);
+			//console.log(nodeAnaly)
 			if(nodeAnaly['text'].length > 0){
 				//有要翻译的目标内容，加入翻译队列
 				//console.log('addNodeToQueue -- '+nodeAnaly['node']+', text:' + nodeAnaly['text']);
@@ -2912,6 +3224,16 @@ var translate = {
 		textArray.push(text); //先将主 text 赋予 ，后面如果对主text进行加工分割，分割后会将主text给删除掉
 		//console.log(textArray);
 
+		// 处理 ignore.regex
+		for (var ri = 0; ri < translate.ignore.textRegex.length; ri++) {
+			var regex = translate.ignore.textRegex[ri];
+			for (var tai = 0; tai < textArray.length; tai++) {
+				var text = textArray[tai];
+				var ignoreTexts = text.match(regex) || []
+				translate.ignore.text = translate.ignore.text.concat(ignoreTexts)
+			}
+		}
+
 		/**** v3.10.2.20241206 - 增加自定义忽略翻译的文本，忽略翻译的文本不会被翻译 - 当然这样会打乱翻译之后阅读的连贯性 ****/
 		for(var ti = 0; ti<translate.ignore.text.length; ti++){
 			if(translate.ignore.text[ti].trim().length == 0){
@@ -2924,7 +3246,6 @@ var translate = {
 		}
 
 
-
 		/**** v3.10.2.20241206 - 自定义术语能力全面优化 - 当然这样会打乱翻译之后阅读的连贯性 ****/
 		//判断是否进行了翻译，也就是有设置目标语种，并且跟当前语种不一致
 		if(typeof(translate.temp_nomenclature) == 'undefined'){
@@ -2936,6 +3257,9 @@ var translate = {
 		if(typeof(translate.nomenclature.data[translate.language.getLocal()]) != 'undefined' && typeof(translate.nomenclature.data[translate.language.getLocal()][translate.to]) != 'undefined'){
 			var nomenclatureKeyArray;
 			for(var nomenclatureKey in translate.nomenclature.data[translate.language.getLocal()][translate.to]){
+				if (!translate.nomenclature.data[translate.language.getLocal()][translate.to].hasOwnProperty(nomenclatureKey)) {
+		    		continue;
+		    	}
 				//nomenclatureKey 便是自定义术语的原始文本，值是要替换为的文本
 				//console.log(nomenclatureKey);
 				//自定义属于的指定的结果字符串
@@ -3147,6 +3471,9 @@ var translate = {
 			//console.log(langs);
 			
 			for(var lang in langs) {
+				if (!langs.hasOwnProperty(lang)) {
+		    		continue;
+		    	}
 				//创建二维数组， key为语种，如 english
 				/*
 				放到了 translate.addNodeQueueItem 进行判断
@@ -3421,11 +3748,10 @@ var translate = {
 	language:{
 		/*	
 			英语的变种语种，也就是在英语26个字母的基础上加了点别的特殊字母另成的一种语言，而这些语言是没法直接通过识别字符来判断出是哪种语种的
-			v3.4.2 增加
-			当前先只加上:
-			法语、意大利语、德语
+			
+			法语、意大利语、德语、葡萄牙语
 		*/
-		englishVarietys : ['french','italian','deutsch'],
+		englishVarietys : ['french','italian','deutsch', 'portuguese'],
 
 		//当前本地语种，本地语言，默认是简体中文。设置请使用 translate.language.setLocal(...)。不可直接使用，使用需用 getLocal()
 		local:'',
@@ -3487,6 +3813,14 @@ var translate = {
 			清除历史翻译语种的缓存
 		*/
 		clearCacheLanguage:function(){
+			if(typeof(translate.language.setUrlParamControl_use) != 'undefined'){
+				if(translate.language.setUrlParamControl_use){
+					console.log('使用提示：')
+					console.log('translate.language.setUrlParamControl(...) 的作用是 可以通过URL传一个语种，来指定当前页面以什么语种显示。 参考文档： http://translate.zvo.cn/4075.html');
+					console.log('translate.language.clearCacheLanguage() 是清除历史翻译语种缓存，也就是清除之前指定翻译为什么语种。 参考文档：http://translate.zvo.cn/4080.html')
+					console.log('如果你执行了 translate.language.setUrlParamControl(...) 那么是要根据url传参来切换语种的，但是后面又出现了 translate.language.clearCacheLanguage() 它会阻止 translate.language.setUrlParamControl(...) 它的设置，即使有url传递翻译为什么语言，也会因为 translate.language.clearCacheLanguage() 给清除掉，使URL传参的语种不起任何作用。')
+				}
+			}
 			translate.to = '';
 			translate.storage.set('to','');
 		},
@@ -3494,6 +3828,7 @@ var translate = {
 		//设置可以根据当前访问url的某个get参数来控制使用哪种语言显示。
 		//比如当前语种是简体中文，网页url是http://translate.zvo.cn/index.html ,那么可以通过在url后面增加 language 参数指定翻译语种，来使网页内容以英文形态显示 http://translate.zvo.cn/index.html?language=english
 		setUrlParamControl:function(paramName){
+			translate.language.setUrlParamControl_use = true; //标记已执行了 translate.language.setUrlParamControl  ,仅仅只是标记，无其他作用
 			if(typeof(paramName) == 'undefined' || paramName.length < 1){
 				paramName = 'language';
 			}
@@ -3508,25 +3843,85 @@ var translate = {
 			translate.storage.set('to', paramValue);
 			translate.to = paramValue;
 		},
-		//自动识别当前页面是什么语种
-		autoRecognitionLocalLanguage:function(){
-			if(translate.language.local != null && translate.language.local.length > 2){
-				//已设置过了，不需要再设置
-				return;
-			}
+		/* 
+			获取翻译区域的原始文本，翻译前的文本。 这里会把空白符等过滤掉，只返回纯显示的文本
+			也就是获取 translate.setDocument(...) 定义的翻译区域中，翻译前，要参与翻译的文本。 
+			其中像是 translate.ignore.tag 这种忽略翻译的标签，这里也不会获取的，这里只是获取实际要参与翻译的文本。
+		 */
+		getTranslateAreaText:function(){
+			//v3.16.1 优化，获取本地语种，针对开源中国只对 readme 部分进行翻译的场景，将针对设置的 translate.setDocument() 区域的元素的显示文本进行判定语种
+			var translateAreaText = ''; //翻译区域内当前的文本
+			
+			/** 构建虚拟容器，将要翻译的区域放入虚拟容器，以便后续处理 **/
+			var virtualContainer = document.createElement('div'); // 创建虚拟容器，处理、判断也都是针对这个虚拟容器
+			if(translate.documents != null && typeof(translate.documents) != 'undefined' && translate.documents.length > 0){
+				// setDocuments 指定的
+				for(var docs_index = 0; docs_index < translate.documents.length; docs_index++){
+					var doc = translate.documents[docs_index];
+					if(typeof(doc) != 'undefined' && doc != null && typeof(doc.innerText) != 'undefined' && doc.innerText != null && doc.innerText.length > 0){
+						virtualContainer.appendChild(doc.cloneNode(true));
+					}
+				}
+			}else{
+				//未使用 setDocuments指定，那就是整个网页了
+				//return document.all; //翻译所有的  这是 v3.5.0之前的
+				//v3.5.0 之后采用 拿 html的最上层的demo，而不是 document.all 拿到可能几千个dom
+				if(typeof(document.head) != 'undefined'){
+					virtualContainer.appendChild(document.head.cloneNode(true));
+				}
+				if(typeof(document.body) != 'undefined'){
+					virtualContainer.appendChild(document.body.cloneNode(true));
+				}
+			}
+			//console.log(virtualContainer);
+
+
+			/** 对虚拟容器中的元素进行处理，移除忽略的 tag （这里暂时就只是移除忽略的tag， 其他忽略的后续再加） **/
+			// 遍历标签列表
+			//console.log('---- remove element');
+		    for (var i = 0; i < translate.ignore.tag.length; i++) {
+		        var tagName = translate.ignore.tag[i];
+		        var elements = virtualContainer.querySelectorAll(tagName);
+		        // 将 NodeList 转换为数组
+		        var elementArray = Array.prototype.slice.call(elements);
+		        // 遍历并移除每个匹配的元素
+		        for (var j = 0; j < elementArray.length; j++) {
+		            var element = elementArray[j];
+		            if (element.parentNode) {
+		                //console.log(element);
+		                element.parentNode.removeChild(element);
+		            }
+		        }
+		    }
+			//console.log('---- remove element end');
 
-			var bodyText = document.body.outerText;
-			if(bodyText == null || typeof(bodyText) == 'undefined' || bodyText.length < 1){
+
+			/*** 取过滤完后的文本字符 ***/
+			translateAreaText = virtualContainer.innerText;
+			if(translateAreaText == null || typeof(translateAreaText) == 'undefined' || translateAreaText.length < 1){
 				//未取到，默认赋予简体中文
 				translate.language.local = 'chinese_simplified';
 				return;
 			}
+			// 移除所有空白字符（包括空格、制表符、换行符等）
+			translateAreaText = translateAreaText.replace(/\s/g, '');
+
+			//console.log('translateAreaText:\n'+translateAreaText);
+			return translateAreaText;
+		},
+		//自动识别当前页面是什么语种
+		autoRecognitionLocalLanguage:function(){
+			if(translate.language.local != null && translate.language.local.length > 2){
+				//已设置过了，不需要再设置
+				return translate.language.local;
+			}
 
-			bodyText = bodyText.replace(/\n|\t|\r/g,''); //将回车换行等去掉
+			var translateAreaText = translate.language.getTranslateAreaText();
 
 			//默认赋予简体中文
 			translate.language.local = 'chinese_simplified';
-			var recognition = translate.language.recognition(bodyText);
+			var recognition = translate.language.recognition(translateAreaText);
+			//console.log(recognition);
 			translate.language.local = recognition.languageName;
 			return translate.language.local;
 			/* v3.1优化
@@ -3676,6 +4071,109 @@ var translate = {
 			//console.log('get end');
 			return langStrs;
 		},
+		/*	
+			语种识别策略
+
+			str 要识别的字符串 
+			data 对于str字符串识别的结果，格式如：
+				{
+					languageName: 'english',
+			 		languageArray:[
+						english:[
+							list[
+								{beforeText: ' ', afterText: ' ', text: 'hello word'},
+								{beforeText: ' ', afterText: ' ', text: 'who?'},
+							],
+							number:12
+						],
+						japanese:[
+							......
+						]
+			 		]
+			 	}
+			 	有关这里面具体参数的说明，参考 translate.language.recognition 的说明
+			languagesSize key:语言名， value:语言字符数
+			allSize 当前所有发现的语种，加起来的总字符数，也就是 languagesSize 遍历所有的value相加的数
+
+			最后，要 return data;
+		*/
+		recognitionAlgorithm:function(str, data, languagesSize, allSize){
+			
+			/*
+				如果英语跟罗曼语族(法语意大利语等多个语言)一起出现，且当前 data.languageName 认定是英语（也就是英文字符占比最大），那么要判定一下：
+					如果 罗曼语族的字符数/英文的字符数 > 0.008 ， 那么认为当前是罗曼语族的中的某个语种， 在对其判定出具体是罗曼语族中的哪个语种赋予最终结果。
+			*/
+			if(typeof(languagesSize['english']) != 'undefined' && typeof(languagesSize['romance']) != 'undefined' && data.languageName == 'english'){
+				if(languagesSize['romance']/languagesSize['english'] > 0.008){
+					//排定是罗曼语族了，那么判断一下到底是 法语、西班牙语、葡萄牙语、意大利语 中的哪一种呢
+
+					//先判定是否有设置本地语种是罗曼语族中其中的某一个
+					if(typeof(translate.language.local) != 'undefined' && translate.language.local.length > 1){
+						if(translate.language.englishVarietys.indexOf(translate.language.local) > -1){
+							//发现当前设置的是小语种，那么将当前识别的语种识别为 本地设置的这个小语种。
+							data.languageName = translate.language.local;
+						}
+					}
+
+					if(data.languageName == 'english'){
+						//还是英语，那就是没有经过上面本地语种的判定，那进行罗曼语的具体语种识别
+
+						var romanceSentenceLanguage = translate.language.romanceSentenceAnaly(str);
+						if(romanceSentenceLanguage.length == 0){
+							console.log('语种识别异常，应该是 法语、西班牙语、葡萄牙语、意大利语 中的一种才是，除非是除了这四种语种之外的别的 罗曼语族 中的语种，当前已将 '+ str +'识别为英语。 你可以联系我们求助 https://translate.zvo.cn/4030.html');
+						}else{
+							data.languageName = romanceSentenceLanguage;
+						}
+					}
+				}
+			}
+
+			
+			/*
+				日语判定
+				如果发现日语存在，且当前 data.languageName 认定不是日语，那么要判定一下：
+					如果 日语的字符数/所有字符数 的字符数 > 0.08 ， 那么认为当前是日语的
+			*/
+			if( typeof(languagesSize['japanese']) != 'undefined' && data.languageName != 'japanese'){
+				if(languagesSize['japanese']/allSize > 0.08){
+					data.languageName = 'japanese'
+				}
+			}
+
+			/*
+				如果发现英语、简体中文或繁体中文 一起存在，且当前 data.languageName 认定是英语时，那么要判定一下：
+					如果 (简体中文+繁体中文)的字符数/英语 > 0.05 ， 那么认为当前是简体中文（不认为是繁体中文，因为下面还有 简体中文跟繁体中文的判定）
+			*/
+			if( (typeof(languagesSize['chinese_simplified']) != 'undefined' || typeof(languagesSize['chinese_traditional']) != 'undefined' ) && typeof(languagesSize['english']) != 'undefined' && data.languageName == 'english'){
+				var size = 0;
+				if(typeof(languagesSize['chinese_simplified']) != 'undefined'){
+					size = size + languagesSize['chinese_simplified'];
+				}
+				if(typeof(languagesSize['chinese_traditional']) != 'undefined'){
+					size = size + languagesSize['chinese_traditional'];
+				}
+				if(size/languagesSize['english'] > 0.05){
+					data.languageName = 'chinese_simplified'
+				}
+			}
+
+
+			/*
+				如果简体中文跟繁体中文一起出现，且当前 data.languageName 认定是简体中文（也就是简体中文字符占比最大），那么要判定一下繁体中文：
+					如果 繁体中文的字符数/简体中文的字符数 > 0.08 ， 那么认为当前是繁体中文的
+			*/
+			if(typeof(languagesSize['chinese_simplified']) != 'undefined' && typeof(languagesSize['chinese_traditional']) != 'undefined' && data.languageName == 'chinese_simplified'){
+				if(languagesSize['chinese_traditional']/languagesSize['chinese_simplified'] > 0.03){
+					data.languageName = 'chinese_traditional'
+				}
+			}
+			/* if(langkeys.indexOf('chinese_simplified') > -1 && langkeys.indexOf('chinese_traditional') > -1){
+				langsNumber['chinese_simplified'] = 0;
+			} */
+
+
+			return data;
+		},
 
 		/*
 		 * 识别字符串是什么语种。它是 get() 的扩展，以代替get返回更多
@@ -3686,12 +4184,14 @@ var translate = {
 			{
 				languageName: 'english',
 		 		languageArray:[
-					"english":[
-						{beforeText: '', afterText: '', text: 'emoambue hag'},
-						......
+					english:[
+						list[
+							{beforeText: ' ', afterText: ' ', text: 'hello word'},
+							{beforeText: ' ', afterText: ' ', text: 'who?'},
+						],
+						number:12
 					],
-					"japanese":[
-						{beforeText: ' ', afterText: ' ', text: 'ẽ '},
+					japanese:[
 						......
 					]
 		 		]
@@ -3711,7 +4211,12 @@ var translate = {
 			var langsNumber = []; //key  语言名，  value 语言字符数
 			var langsNumberOriginal = []; //同上，只不过这个不会进行清空字符数
 			var allNumber = 0;//总字数
+
+			/** 进行字数统计相关 - start **/
 			for(var key in langs){
+				if (!langs.hasOwnProperty(key)) {
+		    		continue;
+		    	}
 				if(typeof(langs[key]) != 'object'){
 					continue;
 				}
@@ -3723,53 +4228,17 @@ var translate = {
 				langsNumber[key] = langStrLength;
 				langsNumberOriginal[key] = langStrLength;
 			}
+			/** 进行字数统计相关 - end **/
 
-			//过滤 语种的字符数小于总字符数 百分之五的，低于这个数，将忽略
-			var langkeys = [];
-			for(var lang in langsNumber){
-				if(langsNumber[lang]/allNumber > 0.01){
-					langkeys[langkeys.length] = lang+'';
-				}
-			}
 
-			if(langkeys.length > 1 && langkeys.indexOf('english') > -1){
-				//console.log('出现了english, 并且english跟其他语种一起出现那么删除english，因为什么法语德语乱七八糟的都有英语。而且中文跟英文一起，如果认为是英文的话，有时候中文会不被翻译');
-				//这里先判断一下是否有发现了 罗曼语族
-				if(langkeys.indexOf('romance') > -1){
-					//发现了，那么判断一下到底是 法语、西班牙语、葡萄牙语、意大利语 中的哪一种呢
-					var romanceSentenceLanguage = translate.language.romanceSentenceAnaly(str);
-					if(romanceSentenceLanguage.length == 0){
-						console.log('语种识别异常，应该是 法语、西班牙语、葡萄牙语、意大利语 中的一种才是，除非是除了这四种语种之外的别的 罗曼语族 中的语种，当前已将 '+ str +'识别为英语。 你可以联系我们求助 https://translate.zvo.cn/4030.html');
-					}else{
-						//console.log(langsNumber);
-						langsNumber[romanceSentenceLanguage] = langsNumber['romance']+langsNumber['english'];
-						//console.log('set romance to '+romanceSentenceLanguage+' : \t'+str);
-						langsNumber['english'] = 0;
-					}
-				}else{
-					langsNumber['english'] = 0;
-				}
-			}
-
-			//如果简体中文跟繁体中文一起出现，那么会判断当前句子为繁体中文，将简体中文字符数置0
-			if(langkeys.indexOf('chinese_simplified') > -1 && langkeys.indexOf('chinese_traditional') > -1){
-				//langkeys.splice(langkeys.indexOf('chinese_simplified'), 1); 
-				langsNumber['chinese_simplified'] = 0;
-			}
-
-
-			//如果发现日语字符，那么将发现的简体中文、繁体中文字符数量置零
-			if(langkeys.length > 1 && langkeys.indexOf('japanese') > -1){
-				langsNumber['chinese_simplified'] = 0;
-				langsNumber['chinese_traditional'] = 0;
-			}
-
-			
 
 			//从 langsNumber 中找出字数最多的来
 			var maxLang = ''; //字数最多的语种
 			var maxNumber = 0;
 			for(var lang in langsNumber){
+				if (!langsNumber.hasOwnProperty(lang)) {
+		    		continue;
+		    	}
 				if(langsNumber[lang] > maxNumber){
 					maxLang = lang;
 					maxNumber = langsNumber[lang];
@@ -3779,6 +4248,9 @@ var translate = {
 			//重新组合返回值的 languageArray
 			var languageArray = {};
 			for(var lang in langs){
+				if (!langs.hasOwnProperty(lang)) {
+		    		continue;
+		    	}
 				languageArray[lang] = {};
 				languageArray[lang].number = langsNumberOriginal[lang];
 				languageArray[lang].list = langs[lang];
@@ -3788,19 +4260,9 @@ var translate = {
 				languageName: maxLang,
 				languageArray: languageArray
 			};
-
-			//v3.4.2 增加，增加对法语等英文变种的小语种的识别
-			if(result.languageName == 'english'){
-				//如果识别的语种是英语，那便不仅仅是英语，因为法语、德语、意大利语也是在英语里面，还要判断一下是否用户自己设置了具体语种是否是英语延伸的小语种
-
-				var localLang = translate.language.getLocal(); //本地语种
-				if(translate.language.englishVarietys.indexOf(localLang) > -1){
-					//发现当前设置的是小语种，那么将当前识别的语种识别为 本地设置的这个小语种。
-					result.languageName = localLang;
-				}
-			}
-
-			return result;
+			
+			//最后进行一层简单的算法处理
+			return translate.language.recognitionAlgorithm(str, result, langsNumber, allNumber);
 		},
 		/*
 			传入一个char，返回这个char属于什么语种，返回如   如果返回空字符串，那么表示未获取到是什么语种
@@ -4448,6 +4910,10 @@ var translate = {
 			return;
 		}
 
+		if(typeof(translate.request.api.ip) != 'string' || translate.request.api.ip == null || translate.request.api.ip.length < 1){
+			return;
+		}
+
 		//如果用户浏览器没读到默认语言，或者默认语言没有对应到translate.js支持的语种，那么在采用ip识别的方式
 		translate.request.post(translate.request.api.ip, {}, function(data){
 			//console.log(data); 
@@ -4517,7 +4983,7 @@ var translate = {
 
 	                //判断它后面是否还有文本
 	                if(originalIndex+1 < text.length){
-	                    let char = text.charAt(originalIndex+translateOriginal.length);
+	                	let char = text.charAt(originalIndex+translateOriginal.length);
 	                    //console.log(char);
 	                    if(/。/.test(char)){
 	                    	replaceResultText = replaceResultText + '. ';
@@ -4531,8 +4997,12 @@ var translate = {
 	                    }else if([' ', '\n','\t',']','|', '_','-','/'].indexOf(char) !== -1){
 							// 如果后面的字符是 这些字符，那么不用添加空格隔开
 						}else{
-							//补充上一个空格，用于将两个单词隔开
-	                        replaceResultText = replaceResultText + ' ';
+							//补充上一个空格，用于将两个单词隔开。  不过 ，如果当前 replaceResultText 的最后一个字符也是空格，那就不需要再加空格了。 这里就只判断空格就好了，至于其他的换行等基本不会出现这个情况，所以不考虑
+							if(replaceResultText.length > 0 && replaceResultText.charAt(replaceResultText.length-1) == ' '){
+								//replaceResultText 本身有值，且最后一个字符就是空格，就不需要再追加空格进行隔开了
+							}else{
+								replaceResultText = replaceResultText + ' ';
+							}
 	                    }
 	                    
 	                }
@@ -4553,16 +5023,23 @@ var translate = {
 	                    	replaceOriginalText = '：'+replaceOriginalText;	
 	                    }else if([' ', '\n','\t','[', '|', '_','-','/'].indexOf(char) !== -1){
 							// 如果前面的字符是 这些字符，那么不用添加空格隔开
+							//console.log('不需要空格隔开的');
 						}else{
-							//补充上一个空格，用于将两个单词隔开
-	                        //text = text.replace(translateOriginal, ' '+translateResult);
-							replaceResultText = ' '+replaceResultText;
+	                        //补充上一个空格，用于将两个单词隔开。  不过 ，如果当前 replaceResultText 的第一个字符也是空格，那就不需要再加空格了。  这里就只判断空格就好了，至于其他的换行等基本不会出现这个情况，所以不考虑
+							if(replaceResultText.length > 0 && replaceResultText.charAt(0) == ' '){
+								//replaceResultText 本身有值，且最后一个字符就是空格，就不需要再追加空格进行隔开了
+							}else{
+								replaceResultText = ' '+replaceResultText;
+							}
+							//console.log('before add space : '+replaceResultText);
 	                    }
 	                }
 	            }else{
 	            	//如果是其他语种比如英语法语翻译为中文、日文，那么标点符号也要判断的，这个因为目前这个场景还没咋遇到，就不判断了，遇到了在加。
 
 	            }
+	            //console.log(replaceResultText)
+	            //console.log(replaceResultText.length)
 
 	            let replaceResult  = translate.util.replaceFromIndex(text, currentReplaceEndIndex, replaceOriginalText, replaceResultText);
 	            if(replaceResult.replaceEndIndex < 1){
@@ -4658,6 +5135,9 @@ var translate = {
 			}
 
 			for(var item in numbers){
+				if (!numbers.hasOwnProperty(item)) {
+		    		continue;
+		    	}
 			    if(numbers[item]===maxNum){
 			        maxStr.push(item)
 			    }
@@ -5025,6 +5505,7 @@ var translate = {
 			value: translate.js 的语种标识
 		 */
 		browserLanguage:{
+			'zh':'chinese_simplified',
 			'zh-CN':'chinese_simplified',
 			'zh-TW':'chinese_traditional',
 			'zh-HK':'chinese_traditional',
@@ -5198,7 +5679,43 @@ var translate = {
 			}
 
 			return result;
+		},
+
+		/*js translate.util.getElementPosition start*/
+		/*
+			计算一个元素在浏览器中的坐标系，其绝对定位、以及实际显示出来所占用的区域，宽、高
+		*/
+		getElementPosition:function (node) {
+			// 获取元素的边界矩形信息（相对于视口）
+			const rect = node.getBoundingClientRect();
+
+			// 获取当前页面的滚动位置（兼容不同浏览器）
+			const scrollX = window.scrollX || document.documentElement.scrollLeft;
+			const scrollY = window.scrollY || document.documentElement.scrollTop;
+
+			// 计算元素在文档中的起始坐标
+			const startX = rect.left + scrollX;
+			const startY = rect.top + scrollY;
+
+			// 计算元素的宽度和高度
+			const width = rect.right - rect.left;
+			const height = rect.bottom - rect.top;
+
+			// 计算元素在文档中的结束坐标
+			const endX = startX + width;
+			const endY = startY + height;
+
+			// 返回包含所有信息的对象（使用ES5兼容语法）
+		    return {
+		        startX: startX,
+		        startY: startY,
+		        endX: endX,
+		        endY: endY,
+		        width: width,
+		        height: height
+		    };
 		}
+		/*js translate.util.getElementPosition end*/
 	},
 	//机器翻译采用哪种翻译服务
 	service:{  
@@ -5227,6 +5744,9 @@ var translate = {
 			if(typeof(serviceName) == 'string'){
 				translate.service.name = serviceName;
 				if(serviceName != 'translate.service'){
+					//增加元素整体翻译能力
+					translate.whole.enableAll();
+
 					if(serviceName.toLowerCase() == 'giteeai'){
 						//设定翻译接口为GiteeAI的
 						translate.request.api.host=['https://giteeai.zvo.cn/','https://deutsch.enterprise.api.translate.zvo.cn:1000/','https://api.translate.zvo.cn:1000/'];
@@ -5237,9 +5757,6 @@ var translate = {
 						translate.request.api.host=['https://siliconflow.zvo.cn/','https://america.api.translate.zvo.cn:1414/','https://deutsch.enterprise.api.translate.zvo.cn:1414/'];
 						return;
 					}
-
-					//增加元素整体翻译能力
-					translate.whole.enableAll();
 				}
 			}
 		},
@@ -5254,6 +5771,7 @@ var translate = {
 			},
 
 			language:{
+
 				json:[{"id":"ukrainian","name":"Україна","serviceId":"uk"},{"id":"norwegian","name":"Norge","serviceId":"no"},{"id":"welsh","name":"Iaith Weleg","serviceId":"cy"},{"id":"dutch","name":"nederlands","serviceId":"nl"},{"id":"japanese","name":"日本語","serviceId":"ja"},{"id":"filipino","name":"Pilipino","serviceId":"fil"},{"id":"english","name":"English","serviceId":"en"},{"id":"lao","name":"ກະຣຸນາ","serviceId":"lo"},{"id":"telugu","name":"తెలుగుName","serviceId":"te"},{"id":"romanian","name":"Română","serviceId":"ro"},{"id":"nepali","name":"नेपालीName","serviceId":"ne"},{"id":"french","name":"Français","serviceId":"fr"},{"id":"haitian_creole","name":"Kreyòl ayisyen","serviceId":"ht"},{"id":"czech","name":"český","serviceId":"cs"},{"id":"swedish","name":"Svenska","serviceId":"sv"},{"id":"russian","name":"Русский язык","serviceId":"ru"},{"id":"malagasy","name":"Malagasy","serviceId":"mg"},{"id":"burmese","name":"ဗာရမ်","serviceId":"my"},{"id":"pashto","name":"پښتوName","serviceId":"ps"},{"id":"thai","name":"คนไทย","serviceId":"th"},{"id":"armenian","name":"Արմենյան","serviceId":"hy"},{"id":"chinese_simplified","name":"简体中文","serviceId":"zh-CHS"},{"id":"persian","name":"Persian","serviceId":"fa"},{"id":"chinese_traditional","name":"繁體中文","serviceId":"zh-CHT"},{"id":"kurdish","name":"Kurdî","serviceId":"ku"},{"id":"turkish","name":"Türkçe","serviceId":"tr"},{"id":"hindi","name":"हिन्दी","serviceId":"hi"},{"id":"bulgarian","name":"български","serviceId":"bg"},{"id":"malay","name":"Malay","serviceId":"ms"},{"id":"swahili","name":"Kiswahili","serviceId":"sw"},{"id":"oriya","name":"ଓଡିଆ","serviceId":"or"},{"id":"icelandic","name":"ÍslandName","serviceId":"is"},{"id":"irish","name":"Íris","serviceId":"ga"},{"id":"khmer","name":"ភាសា​ខ្មែរName","serviceId":"km"},{"id":"gujarati","name":"ગુજરાતી","serviceId":"gu"},{"id":"slovak","name":"Slovenská","serviceId":"sk"},{"id":"kannada","name":"ಕನ್ನಡ್Name","serviceId":"kn"},{"id":"hebrew","name":"היברית","serviceId":"he"},{"id":"hungarian","name":"magyar","serviceId":"hu"},{"id":"marathi","name":"मराठीName","serviceId":"mr"},{"id":"tamil","name":"தாமில்","serviceId":"ta"},{"id":"estonian","name":"eesti keel","serviceId":"et"},{"id":"malayalam","name":"മലമാലം","serviceId":"ml"},{"id":"inuktitut","name":"ᐃᓄᒃᑎᑐᑦ","serviceId":"iu"},{"id":"arabic","name":"بالعربية","serviceId":"ar"},{"id":"deutsch","name":"Deutsch","serviceId":"de"},{"id":"slovene","name":"slovenščina","serviceId":"sl"},{"id":"bengali","name":"বেঙ্গালী","serviceId":"bn"},{"id":"urdu","name":"اوردو","serviceId":"ur"},{"id":"azerbaijani","name":"azerbaijani","serviceId":"az"},{"id":"portuguese","name":"português","serviceId":"pt"},{"id":"samoan","name":"lifiava","serviceId":"sm"},{"id":"afrikaans","name":"afrikaans","serviceId":"af"},{"id":"tongan","name":"汤加语","serviceId":"to"},{"id":"greek","name":"ελληνικά","serviceId":"el"},{"id":"indonesian","name":"IndonesiaName","serviceId":"id"},{"id":"spanish","name":"Español","serviceId":"es"},{"id":"danish","name":"dansk","serviceId":"da"},{"id":"amharic","name":"amharic","serviceId":"am"},{"id":"punjabi","name":"ਪੰਜਾਬੀName","serviceId":"pa"},{"id":"albanian","name":"albanian","serviceId":"sq"},{"id":"lithuanian","name":"Lietuva","serviceId":"lt"},{"id":"italian","name":"italiano","serviceId":"it"},{"id":"vietnamese","name":"Tiếng Việt","serviceId":"vi"},{"id":"korean","name":"한국어","serviceId":"ko"},{"id":"maltese","name":"Malti","serviceId":"mt"},{"id":"finnish","name":"suomi","serviceId":"fi"},{"id":"catalan","name":"català","serviceId":"ca"},{"id":"croatian","name":"hrvatski","serviceId":"hr"},{"id":"bosnian","name":"bosnian","serviceId":"bs-Latn"},{"id":"polish","name":"Polski","serviceId":"pl"},{"id":"latvian","name":"latviešu","serviceId":"lv"},{"id":"maori","name":"Maori","serviceId":"mi"}],
 				/*
 					获取map形式的语言列表 
@@ -5282,11 +5800,22 @@ var translate = {
 				var textArray = JSON.parse(decodeURIComponent(data.text));
 				let translateTextArray = translate.util.split(textArray, 40000, 900);
 				
-				translate.request.send(translate.service.edge.api.auth, {}, function(auth){
+				translate.request.send(translate.service.edge.api.auth, {},{}, function(auth){
+					var appendXhrData = {
+						"from":data.from+'',
+						"to":data.to,
+						"text":data.text
+					};
 					var from = data.from;
 					if(from != 'auto'){
-						from = translate.service.edge.language.getMap()[data.from];
+						if(from == 'romance'){
+							//这里额外加了一个罗曼语族(romance)会自动认为是法语(fr)
+							from = 'fr';
+						}else{
+							from = translate.service.edge.language.getMap()[data.from];
+						}
 					}
+					
 					var to = translate.service.edge.language.getMap()[data.to];
 					var transUrl = translate.service.edge.api.translate.replace('{from}',from).replace('{to}',to);
 
@@ -5297,7 +5826,7 @@ var translate = {
 							json.push({"Text":translateTextArray[tai][i]});
 						}
 
-						translate.request.send(transUrl, JSON.stringify(json), function(result){
+						translate.request.send(transUrl, JSON.stringify(json), appendXhrData, function(result){
 							var d = {};
 							d.info = 'SUCCESS';
 							d.result = 1;
@@ -5570,6 +6099,10 @@ var translate = {
 					'content-type':'application/x-www-form-urlencoded',
 				};
 
+				if(typeof(translate.request.api.connectTest) != 'string' || translate.request.api.connectTest == null || translate.request.api.connectTest.length < 1){
+					return;
+				}
+				
 
 				translate.request.speedDetectionControl.checkHostQueue = []; //用于实际存储
 				translate.request.speedDetectionControl.checkHostQueueMap = []; //只是map，通过key取值，无其他作用
@@ -5591,6 +6124,7 @@ var translate = {
 						translate.request.send(
 							host+translate.request.api.connectTest,
 							{host:host},
+							{host:host},
 							function(data){
 								var host = data.info;
 								var map = translate.request.speedDetectionControl.checkHostQueueMap[host];
@@ -5623,7 +6157,7 @@ var translate = {
 							headers,
 							function(data){
 								//translate.request.speedDetectionControl.checkResponseSpeed_Storage(host, time);
-								var hostUrl = data.requestURL.replace('connectTest.json','');
+								var hostUrl = data.requestURL.replace(translate.request.api.connectTest,'');
 								translate.request.speedDetectionControl.checkResponseSpeed_Storage(hostUrl, translate.request.speedDetectionControl.disableTime);
 							},
 							false
@@ -5727,12 +6261,13 @@ var translate = {
 			}
 			// ------- edge end --------
 
-			this.send(path, data, func, 'post', true, headers, abnormalFunc, true);
+			this.send(path, data, data, func, 'post', true, headers, abnormalFunc, true);
 		},
 		/**
 		 * 发送请求
 		 * url 请求的url或者path（path，传入的是translate.request.api.translate 这种的，需要使用 getUrl 来组合真正请求的url ）
 		 * data 请求的数据，如 {"author":"管雷鸣",'site':'www.guanleiming.com'} 
+		 * appendXhrData 附加到 xhr.data 中的对象数据，传入比如  {"from":"english","to":"japanese"} ，他会直接赋予 xhr.data
 		 * func 请求完成的回调，传入如 function(data){}
 		 * method 请求方式，可传入 post、get
 		 * isAsynchronize 是否是异步请求， 传入 true 是异步请求，传入false 是同步请求。 如果传入false，则本方法返回xhr
@@ -5740,7 +6275,7 @@ var translate = {
 		 * abnormalFunc 响应异常所执行的方法，响应码不是200就会执行这个方法 ,传入如 function(xhr){}  另外这里的 xhr 会额外有个参数  xhr.requestURL 返回当前请求失败的url
 		 * showErrorLog 是否控制台打印出来错误日志，true打印， false 不打印
 		 */
-		send:function(url, data, func, method, isAsynchronize, headers, abnormalFunc, showErrorLog){
+		send:function(url, data, appendXhrData, func, method, isAsynchronize, headers, abnormalFunc, showErrorLog){
 			//post提交的参数
 			var params = '';
 
@@ -5749,7 +6284,7 @@ var translate = {
 			}
 			
 			if(typeof(data) == 'string'){
-				params = data; //payload 方式
+				params = data; //payload 方式 , edge 的方式
 			}else{
 				//表单提交方式
 				
@@ -5758,6 +6293,9 @@ var translate = {
 				
 				//追加附加参数
 				for(var apindex in translate.request.appendParams){
+					if (!translate.request.appendParams.hasOwnProperty(apindex)) {
+			    		continue;
+			    	}
 					data[apindex] = translate.request.appendParams[apindex];
 				}
 
@@ -5770,6 +6308,9 @@ var translate = {
 				
 				//组合参数
 				for(var index in data){
+					if (!data.hasOwnProperty(index)) {
+			    		continue;
+			    	}
 					if(params.length > 0){
 						params = params + '&';
 					}
@@ -5790,17 +6331,24 @@ var translate = {
 			}catch(e){
 				xhr=new ActiveXObject("Microsoft.XMLHTTP");
 			}
+			xhr.data=appendXhrData;
 			//2.调用open方法（true----异步）
 			xhr.open(method,url,isAsynchronize);
 			//设置headers
 			if(headers != null){
 				for(var index in headers){
+					if (!headers.hasOwnProperty(index)) {
+			    		continue;
+			    	}
 					xhr.setRequestHeader(index,headers[index]);
 				}
 			}
 
 			//追加附加参数
 			for(var ahindex in translate.request.appendHeaders){
+				if (!translate.request.appendHeaders.hasOwnProperty(ahindex)) {
+		    		continue;
+		    	}
 				xhr.setRequestHeader(ahindex,translate.request.appendHeaders[ahindex]);
 			}
 
@@ -5937,41 +6485,83 @@ var translate = {
 					return;
 				}
 			}
-			
-			/*
-			for(var i = texts.length - 1; i >= 0; i--){
-				console.log(texts[i]);
+			//console.log(obj);
+			//返回的翻译结果，下标跟 obj.texts 一一对应的
+			var translateResultArray = new Array();
 
+			// 筛选需要翻译的文本及其原始索引
+  			var apiTranslateText = [];
+			var apiTranslateArray = {};
+			for(var i = 0; i < texts.length; i++){
 				//判断是否在浏览器缓存中出现了
-				var cacheHash = translate.util.hash(texts[i]);
-				var cache = translate.storage.get('hash_'+translate.to+'_'+cacheHash);
+				var hash = translate.util.hash(texts[i]);
+				var cache = translate.storage.get('hash_'+to+'_'+hash);
+				//console.log(hash+'\t'+texts[i]+'\t'+cache);
 				if(cache != null && cache.length > 0){
 					//缓存中发现了这个得结果，那这个就不需要再进行翻译了
-				}
+					translateResultArray[i] = cache;
+				}else{
+					translateResultArray[i] = '';
+					apiTranslateText.push(texts[i]);
+					apiTranslateArray[hash] = i;
+				}
+			}
+			if (apiTranslateText.length == 0) {
+				//没有需要进行通过网络API翻译的任务了，全部命中缓存，那么直接返回
+				var data = {
+					from:from,
+					to: to,
+					text:translateResultArray,
+					result:1
+				};
+				//console.log(data);
+			    func(data);
+			    return;
+			}
+
+
+
+			//还有需要进行通过API接口进行翻译的文本，需要调用翻译接口
+			if(typeof(translate.request.api.translate) != 'string' || translate.request.api.translate == null || translate.request.api.translate.length < 1){
+				//用户已经设置了不掉翻译接口进行翻译
+				return;
 			}
-			*/
-			
 
 			var url = translate.request.api.translate;
 			var data = {
 				from:from,
 				to: to,
-				text:encodeURIComponent(JSON.stringify(texts))
+				text:encodeURIComponent(JSON.stringify(apiTranslateText))
 			};
-			//console.log(data);
-			translate.request.post(url, data, function(data){
+			//console.log(apiTranslateText);
+			translate.request.post(url, data, function(resultData){
+				//console.log(resultData); 
 				//console.log(data); 
-				if(data.result == 0){
+				if(resultData.result == 0){
 					console.log('=======ERROR START=======');
-					console.log('from : '+data.from);
-					console.log('to : '+data.to);
+					console.log('from : '+resultData.from);
+					console.log('to : '+resultData.to);
 					console.log('translate text array : '+texts);
-					console.log('response : '+data.info);
+					console.log('response : '+resultData.info);
 					console.log('=======ERROR END  =======');
 					//return;
 				}
 
-				func(data);
+				for(var i = 0; i < resultData.text.length; i++){
+					//将翻译结果以 key：hash  value翻译结果的形式缓存
+					var hash = translate.util.hash(apiTranslateText[i]);
+					translate.storage.set('hash_'+to+'_'+hash, resultData.text[i]);
+					//如果离线翻译启用了全部提取，那么还要存入离线翻译指定存储
+					if(translate.office.fullExtract.isUse){
+						translate.office.fullExtract.set(hash, apiTranslateText[i], data.to, resultData.text[i]);
+					}
+
+					//进行组合数据到 translateResultArray
+					translateResultArray[apiTranslateArray[hash]] = resultData.text[i];
+				}
+				resultData.text = translateResultArray;			
+
+				func(resultData);
 			}, null);
 		},
 		listener:{
@@ -6030,6 +6620,8 @@ var translate = {
 			trigger:function(url){
 				return true;
 			},
+
+			/*js translate.request.listener.start start*/
 			/*
 				启动根据ajax请求来自动触发执行翻译，避免有时候有的框架存在漏翻译的情况。
 				这个只需要执行一次即可，如果执行多次，只有第一次会生效
@@ -6145,6 +6737,7 @@ var translate = {
 				}
 
 			}
+			/*js translate.request.listener.start end*/
 		}
 	},
 	//存储，本地缓存
@@ -6293,6 +6886,9 @@ var translate = {
 			}
 			*/
 			for(var key in queueArray){
+				if (!queueArray.hasOwnProperty(key)) {
+		    		continue;
+		    	}
 				translate.images.queues[key] = queueArray[key];
 			}
 		},
@@ -6387,50 +6983,81 @@ var translate = {
 	//对翻译结果进行复原。比如当前网页是简体中文的，被翻译为了英文，执行此方法即可复原为网页本身简体中文的状态，而无需在通过刷新页面来实现
 	reset:function(){
 		var currentLanguage = translate.language.getCurrent(); //获取当前翻译至的语种
+
+		var lastUuid = ''; //最后一次的uuid
 		for(var queue in translate.nodeQueue){
-			//console.log(queue);
-			for(var lang in translate.nodeQueue[queue].list){
-				//console.log(lang);
-				
-				for(var hash in translate.nodeQueue[queue].list[lang]){
-					var item = translate.nodeQueue[queue].list[lang][hash];
-					//console.log(item);
-					for(var index in item.nodes){
-						//console.log(item.nodes[index]);
-						//item.nodes[index].node.nodeValue = item.original;
-						var currentShow = translate.storage.get('hash_'+currentLanguage+'_'+hash); //当前显示出来的文字，也就是已经翻译后的文字
-						//console.log('hash_'+lang+'_'+hash+'  --  '+currentShow);
-						if(typeof(currentShow) == 'undefined'){
-							continue;
-						}
-						if(currentShow == null){
-							continue;
-						}
-						if(currentShow.length == 0){
-							continue;
-						}
+			if (!translate.nodeQueue.hasOwnProperty(queue)) {
+	    		continue;
+	    	}
+	    	lastUuid = queue;
+		}
+		//console.log(queue);
+
+		if(lastUuid == ''){
+			console.log('提示，你当前还未执行过翻译，所以你无需执行 translate.reset(); 进行还原。');
+			return;
+		}
+
+		for(var lang in translate.nodeQueue[lastUuid].list){
+			if (!translate.nodeQueue[lastUuid].list.hasOwnProperty(lang)) {
+	    		continue;
+	    	}
+			//console.log(lang);
+			
+			for(var hash in translate.nodeQueue[lastUuid].list[lang]){
+				if (!translate.nodeQueue[lastUuid].list[lang].hasOwnProperty(hash)) {
+		    		continue;
+		    	}
+				var item = translate.nodeQueue[lastUuid].list[lang][hash];
+				//console.log(item);
+				for(var index in item.nodes){
+					if (!item.nodes.hasOwnProperty(index)) {
+			    		continue;
+			    	}
+					//console.log(item.nodes[index]);
+					//item.nodes[index].node.nodeValue = item.original;
+					var currentShow = translate.storage.get('hash_'+currentLanguage+'_'+hash); //当前显示出来的文字，也就是已经翻译后的文字
+					//console.log('hash_'+lang+'_'+hash+'  --  '+currentShow);
+					if(typeof(currentShow) == 'undefined'){
+						continue;
+					}
+					if(currentShow == null){
+						continue;
+					}
+					if(currentShow.length == 0){
+						continue;
+					}
 /*
-						if(item.beforeText.length > 0 || item.afterText.length > 0){
-							console.log('----'+currentShow);
-							console.log(item);
-						}
-						
-						if(item.beforeText.length > 0){
-							currentShow = currentShow.substring(currentShow.lastIndexOf(item.beforeText)+1, currentShow.length);
-						}
-						if(item.afterText.length > 0){
-							currentShow = currentShow.substring(0, currentShow.lastIndexOf(item.afterText));
-						}
-						if(item.beforeText.length > 0 || item.afterText.length > 0){
-							console.log(currentShow);
-						}
+					if(item.beforeText.length > 0 || item.afterText.length > 0){
+						console.log('----'+currentShow);
+						console.log(item);
+					}
+					
+					if(item.beforeText.length > 0){
+						currentShow = currentShow.substring(currentShow.lastIndexOf(item.beforeText)+1, currentShow.length);
+					}
+					if(item.afterText.length > 0){
+						currentShow = currentShow.substring(0, currentShow.lastIndexOf(item.afterText));
+					}
+					if(item.beforeText.length > 0 || item.afterText.length > 0){
+						console.log(currentShow);
+					}
 */						
-						translate.element.nodeAnalyse.analyse(item.nodes[index].node, currentShow, item.original, item.nodes[index].node.attribute);
+					// v3.16.5 针对gitee 的 readme 接入优化
+					if(typeof(item.nodes[index].node) == 'undefined'){
+						continue;
 					}
+					
+					var attribute = typeof(item.nodes[index].node.attribute) == 'undefined' ? null:item.nodes[index].node.attribute;
+					var analyse = translate.element.nodeAnalyse.analyse(item.nodes[index].node, '', '', attribute);
+					translate.element.nodeAnalyse.analyse(item.nodes[index].node, analyse.text, item.original, attribute);
 				}
 			}
 		}
 
+
+
+
 		//清除设置storage中的翻译至的语种
 		translate.storage.set('to', '');
 		translate.to = null;
@@ -6454,6 +7081,13 @@ var translate = {
 			if (curSelection.anchorOffset == curSelection.focusOffset) return;
 			let translateText = window.getSelection().toString();
 
+			//还有需要进行通过API接口进行翻译的文本，需要调用翻译接口
+			if(typeof(translate.request.api.translate) != 'string' || translate.request.api.translate == null || translate.request.api.translate.length < 1){
+				//用户已经设置了不掉翻译接口进行翻译
+				console.log('已设置了不使用 translate 翻译接口，翻译请求被阻止');
+				return;
+			}
+
 			//简单Copy原有代码了
 			var url = translate.request.api.translate
 			var data = {
@@ -6554,10 +7188,15 @@ var translate = {
 			return;
 		}
 		translate.init_execute = '已进行';
+
+		if(typeof(translate.request.api.init) != 'string' || translate.request.api.init == null || translate.request.api.init.length < 1){
+			return;
+		}
 		try{
 			translate.request.send(
 				translate.request.api.init,
 				{},
+				{},
 				function(data){
 					if (data.result == 0){
 						console.log('translate.js init 初始化异常：'+data.info);
@@ -6571,8 +7210,6 @@ var translate = {
 						if(newVersion > currentVersion){
 							console.log('Tip : translate.js find new version : '+data.version);
 						}
-					}else{
-						eval(data.info);
 					}
 				},
 				'post',
@@ -6654,6 +7291,35 @@ var translate = {
 			setUITip:function(tip){
 				translate.progress.api.isTip = tip;
 			},
+			//移除子元素（无限级别）中的所有 class name 的loading 遮罩
+			//level 层级，数字，比如第一次调用，传入1， 第一次里面产生的第二次调用，这里就是2
+			removeChildClass:function(node, level){
+
+				//判断是否有子元素，判断其两级子元素，是否有加了loading遮罩了
+		        var childNodes = node.childNodes;
+				if(childNodes == null || typeof(childNodes) == 'undefined'){
+					
+				}else if(childNodes.length > 0){
+					for(var i = 0; i<childNodes.length; i++){
+						translate.progress.api.removeChildClass(childNodes[i], level+1);
+					}
+				}
+
+				if(level == 1){
+					//第一次调用，是不删除本身的class name
+					return;
+				}
+				if(typeof(node) == 'undefined'){
+					return;
+				}
+				if(typeof(node.className) != 'string'){
+					return;
+				}
+				if(node.className.indexOf('translate_api_in_progress') < -1){
+					return;
+				}
+				node.className = node.className.replace(/translate_api_in_progress/g, '');
+			},
 			startUITip:function(){
 				// 创建一个 style 元素
 		        const style = document.createElement('style');
@@ -6665,49 +7331,67 @@ var translate = {
 
 				if(translate.progress.api.isTip){
 					translate.listener.execute.renderStartByApi.push(function(uuid, from, to){
-					    for(var lang in translate.nodeQueue[uuid].list){
-						    //console.log('lang:'+lang);
-                            //console.log(translate.nodeQueue[uuid].list[lang]);
-                            if(translate.language.getCurrent() == lang){
-                                //忽略这个语种
-                                //console.log('ignore-------');
-                                continue;
-                            }
-
-						    for(var hash in translate.nodeQueue[uuid].list[lang]){
-						    	for(var nodeindex in translate.nodeQueue[uuid].list[lang][hash].nodes){
-						    		var node = translate.nodeQueue[uuid].list[lang][hash].nodes[nodeindex].node;
-						    		//console.log(node);
-						    		var nodeParent = node.parentNode;
-							        if(nodeParent == null){
-							        	continue;
-							        }
-							        /* 这里先不考虑多隐藏的问题，只要符合的都隐藏，宁愿吧一些不需要隐藏的也会跟着一起隐藏
-									if(nodeParent.childNodes.length != 1){
-										//这个文本节点所在的元素里，不止有这一个文本元素，还有别的文本元素
-										continue;
-									}
-									*/
-									if(typeof(nodeParent.className) == 'undefined' || nodeParent.className == null || nodeParent.className == ''){
-										nodeParent.className = ' translate_api_in_progress';
-									}else{
-										//这个元素本身有class了，那就追加
-										if(nodeParent.className.indexOf('translate_api_in_progress') > -1){	
-											continue;
-										}
+						
+					    for(var hash in translate.nodeQueue[uuid].list[from]){
+					    	if (!translate.nodeQueue[uuid].list[from].hasOwnProperty(hash)) {
+					    		continue;
+					    	}
+					    	for(var nodeindex in translate.nodeQueue[uuid].list[from][hash].nodes){
+					    		if (!translate.nodeQueue[uuid].list[from][hash].nodes.hasOwnProperty(nodeindex)) {
+						    		continue;
+						    	}
+					    		var node = translate.nodeQueue[uuid].list[from][hash].nodes[nodeindex].node;
+					    		
+					    		if(typeof(node) == 'undefined' || typeof(node.parentNode) == 'undefined'){
+					    			continue;
+					    		}
+					    		var nodeParent = node.parentNode;
+						        if(nodeParent == null){
+						        	continue;
+						        }
+						        /* 这里先不考虑多隐藏的问题，只要符合的都隐藏，宁愿吧一些不需要隐藏的也会跟着一起隐藏
+								if(nodeParent.childNodes.length != 1){
+									//这个文本节点所在的元素里，不止有这一个文本元素，还有别的文本元素
+									continue;
+								}
+								*/
+
+
+						        //判断其在上一层的父级是否已经加了，如果父级加了，那作为子集就不需要在加了，免得出现两个重合的 loading 遮罩
+						        var nodeParentParent = node.parentNode;
+						        if(nodeParentParent != null && typeof(nodeParentParent.className) != 'undefined' && nodeParentParent.className != null && nodeParent.className.indexOf('translate_api_in_progress') > -1){
+						        	//父有了，那么子就不需要再加了
+						        	continue;
+						        }
+						        //判断是否有子元素，判断其两级子元素，是否有加了loading遮罩了
+								translate.progress.api.removeChildClass(nodeParent, 1);
 
-										nodeParent.className = nodeParent.className+' translate_api_in_progress';
+
+								if(typeof(nodeParent.className) == 'undefined' || nodeParent.className == null || nodeParent.className == ''){
+									nodeParent.className = ' translate_api_in_progress';
+								}else{
+									//这个元素本身有class了，那就追加
+									if(nodeParent.className.indexOf('translate_api_in_progress') > -1){	
+										continue;
 									}
+									nodeParent.className = nodeParent.className+' translate_api_in_progress';
+								}
 
-						    	}
-						    }
-						}
+					    	}
+					    }
+						
 					});
 					translate.listener.execute.renderFinishByApi.push(function(uuid, from, to){
-						//console.log('uuid:'+uuid+', from:'+from+', to:'+to);
-					    
-					    for(var hash in translate.nodeQueue[uuid].list[from]){
+						for(var hash in translate.nodeQueue[uuid].list[from]){
+					    	if (!translate.nodeQueue[uuid].list[from].hasOwnProperty(hash)) {
+					    		continue;
+					    	}
+
 					    	for(var nodeindex in translate.nodeQueue[uuid].list[from][hash].nodes){
+					    		if (!translate.nodeQueue[uuid].list[from][hash].nodes.hasOwnProperty(nodeindex)) {
+						    		continue;
+						    	}
+
 					    		var node = translate.nodeQueue[uuid].list[from][hash].nodes[nodeindex].node;
 					    		var nodeParent = node.parentNode;
 						        if(nodeParent == null){
@@ -6729,6 +7413,7 @@ var translate = {
 									continue;
 								}
 								
+
 								nodeParent.className = parentClassName.replace(/translate_api_in_progress/g, '');
 								//nodeParent.className = parentClassName.replace(/loading/g, '');
 					    	}
@@ -7313,9 +7998,366 @@ var translate = {
 			_requestContext: null
 
 	    }
-	}
+	},
 
 	/*js translate.network end*/
+
+
+	/*js translate.visual start*/
+	/*
+		人眼所看到的纯视觉层的处理
+	*/
+	visual: {
+		/**
+		 * 获取一组节点的视觉矩形信息
+		 * @param {Node[]} nodes - 节点数组，格式如 
+		 * 			[node1,node2,node3]
+		 * @returns {Object[]} - 矩形信息数组，与输入节点一一对应
+		 */
+		getRects:function(nodes){
+		  return nodes.map(node => {
+		    if (!node) return null;
+		    
+		    let rect;
+		    if (node.nodeType === Node.TEXT_NODE) {
+		      const range = document.createRange();
+		      range.selectNodeContents(node);
+		      const rects = range.getClientRects();
+		      //console.log(rect);
+		      rect = rects.length > 0 ? rects[0] : null;
+		    } else if (node.nodeType === Node.ELEMENT_NODE) {
+		      rect = node.getBoundingClientRect();
+		    }
+		    
+		    return rect ? {
+		      node,
+		      left: rect.left,
+		      top: rect.top,
+		      right: rect.right,
+		      bottom: rect.bottom,
+		      width: rect.width,
+		      height: rect.height
+		    } : null;
+		  });
+		},
+		/*
+			对一组坐标进行排序
+			按开始坐标从左到右、从上到下排序
+			@param rects translate.visual.getRects获取到的坐标数据
+		*/
+		coordinateSort:function(rects){
+			// 按从左到右、从上到下排序
+		  const sortedRects = rects
+		    .filter(rect => rect !== null)
+		    .sort((a, b) => {
+		      if (Math.abs(a.top - b.top) < 5) { // 同一行
+		        return a.left - b.left;
+		      }
+		      return a.top - b.top;
+		    });
+		  return sortedRects;
+		},
+		/**
+		 * 查找左右紧邻的矩形对
+		 * @param rects translate.visual.getRects获取到的坐标数据
+		 * @returns {Array<{before: Object, after: Object}>} - 左右紧邻的矩形对数组
+		 */
+		afterAdjacent:function(rects){
+		  var sortedRects = translate.visual.coordinateSort(rects);
+		  
+		  const adjacentPairs = [];
+		  const lineGroups = translate.visual.groupRectsByLine(sortedRects);
+		  
+		  // 检查每行中的所有紧邻元素对
+		  lineGroups.forEach(line => {
+		    for (let i = 0; i < line.length; i++) {
+		      for (let j = i + 1; j < line.length; j++) {
+		        const prev = line[i];
+		        const next = line[j];
+		        
+		        // 如果后续元素与当前元素不紧邻，则后续其他元素也不可能紧邻
+		        if (!translate.visual.areHorizontallyAdjacent(prev, next)) {
+		          break;
+		        }
+		        
+		        adjacentPairs.push({ before: prev, after: next });
+		      }
+		    }
+		  });
+		  
+		  return adjacentPairs;
+		},
+		/**
+		 * 按行分组矩形
+		 * @param rects - 排序后的矩形数组 @param rects translate.visual.coordinateSort 获取到的坐标数据
+		 * @returns {Object[][]} - 按行分组的矩形
+		 */
+		groupRectsByLine:function(rects){
+			const lineGroups = [];
+		  let currentLine = [];
+		  
+		  rects.forEach(rect => {
+		    if (currentLine.length === 0) {
+		      currentLine.push(rect);
+		    } else {
+		      const lastRect = currentLine[currentLine.length - 1];
+		      // 如果在同一行，则添加到当前行
+		      if (Math.abs(rect.top - lastRect.top) < 5) {
+		        currentLine.push(rect);
+		      } else {
+		        // 否则开始新的一行
+		        lineGroups.push(currentLine);
+		        currentLine = [rect];
+		      }
+		    }
+		  });
+		  
+		  // 添加最后一行
+		  if (currentLine.length > 0) {
+		    lineGroups.push(currentLine);
+		  }
+		  
+		  return lineGroups;
+		},
+		/**
+		 * 判断两个矩形是否水平紧邻
+		 * @param {Object} rect1 - 第一个矩形
+		 * @param {Object} rect2 - 第二个矩形
+		 * @returns {boolean} - 是否水平紧邻
+		 */
+		areHorizontallyAdjacent:function(rect1, rect2){
+			// 检查垂直方向是否有重叠（在同一行）
+		  const verticalOverlap = Math.min(rect1.bottom, rect2.bottom) - Math.max(rect1.top, rect2.top);
+		  
+		  // 检查水平间距是否在阈值范围内
+		  const horizontalGap = rect2.left - rect1.right;
+		  
+		  return verticalOverlap > 0 && Math.abs(horizontalGap) < 1; // 允许1px误差
+		},
+		/**
+		 * 找到需要在节点文本末尾添加空格的节点
+		 * @param {Array<{before: Object, after: Object}>} adjacentPairs - 左右紧邻的矩形对数组
+		 * @returns {Node[]} - 需要添加空格的节点数组
+		 */
+		afterAddSpace:function(adjacentPairs){
+
+		  const nodesToAddSpace = [];
+		  
+		  adjacentPairs.forEach(pair => {
+		    const { before, after } = pair;
+		    const beforeNode = before.node;
+		    const afterNode = after.node;
+		    
+		    // 获取计算样式
+		    const beforeStyle = window.getComputedStyle(
+		      beforeNode.nodeType === Node.TEXT_NODE ? beforeNode.parentElement : beforeNode
+		    );
+		    
+		    const afterStyle = window.getComputedStyle(
+		      afterNode.nodeType === Node.TEXT_NODE ? afterNode.parentElement : afterNode
+		    );
+		    
+		    // 检查间距是否由CSS属性引起
+		    const hasRightSpacing = parseFloat(beforeStyle.marginRight) > 0 || 
+		                           parseFloat(beforeStyle.paddingRight) > 0;
+		    
+		    const hasLeftSpacing = parseFloat(afterStyle.marginLeft) > 0 || 
+		                          parseFloat(afterStyle.paddingLeft) > 0;
+		    
+		    // 如果没有明确的间距，且后一个节点的开始非空白符，则需要添加空格
+		    if (!hasRightSpacing && !hasLeftSpacing) {
+		    	//判断 before 节点的最后一个字符是否是空白符
+		    	if(typeof(beforeNode.textContent) == 'string' && typeof(afterNode.textContent) == 'string'){
+		    		if(/\s$/.test(beforeNode.textContent)){
+		    			//before 最后一个字符是空格，则不需要追加空格符了
+		    		}else if(/^\s/.test(afterNode.textContent)){
+		    			//after 节点的开始第一个字符是空白符，那么也不需要追加空格符了
+		    		}else{
+		    			//这里就需要对 beforeNode 追加空格了
+		    			nodesToAddSpace.push(beforeNode);
+		    		}
+		    	}
+		    }
+		  });
+		  
+		  return nodesToAddSpace;
+		},
+		/**
+		 * 主函数：处理翻译后的空格调整
+		 * @param {Node[]} nodes - 节点数组
+		 */
+		adjustTranslationSpaces:function(nodes){
+
+			//先判断当前要显示的语种，是否需要用空格进行间隔单词，如果本身不需要空格间隔，像是中文，那就根本不需要去计算视觉距离
+			if(!translate.language.wordBlankConnector(translate.to)){
+				return;
+			}
+
+			//var startTime = Date.now();
+			// 1. 获取节点视觉矩形
+			const rects = translate.visual.getRects(nodes);
+			//console.log('rects:');
+			//console.log(rects);
+
+			// 2. 查找左右紧邻的矩形对
+			const adjacentPairs = translate.visual.afterAdjacent(rects);
+			//console.log('adjacentPairs:');
+			//console.log(adjacentPairs);
+
+			// 3. 确定需要添加空格的节点
+			const nodesToAddSpace = translate.visual.afterAddSpace(adjacentPairs);
+			//console.log('nodesToAddSpace:');
+			//console.log(nodesToAddSpace);
+
+			// 4. 添加非断行空格
+			nodesToAddSpace.forEach(node => {
+			// 确保只修改文本内容，不影响HTML结构
+			if (node.nodeType === Node.TEXT_NODE) {
+				node.textContent = node.textContent + '\u00A0';
+			} else if (node.nodeType === Node.ELEMENT_NODE) {
+				// 如果是元素节点，修改其最后一个子节点（假设是文本节点）
+				const lastChild = node.lastChild;
+				if (lastChild && lastChild.nodeType === Node.TEXT_NODE) {
+					lastChild.textContent = lastChild.textContent + '\u00A0';
+				}
+			}
+			});
+			//var endTime = Date.now();
+			//console.log('visual recognition time: '+(endTime-startTime)+'ms');
+		},
+		/*
+			通过 translate.nodeQueue[uuid] 中的uuid，来传入这个 translate.nodeQueue[uuid] 中所包含涉及到的所有node (除特殊字符外 ，也就是 translate.nodeQueue[uuid].list 下 特殊字符那一类是不会使用的)
+		*/
+		adjustTranslationSpacesByNodequeueUuid:function(uuid){
+			var nodes = [];
+			for(var from in translate.nodeQueue[uuid].list){
+				if (!translate.nodeQueue[uuid].list.hasOwnProperty(from)) {
+					continue;
+				}
+				if(from.length < 1){
+					continue;
+				}
+				for(var hash in translate.nodeQueue[uuid].list[from]){
+			    	if (!translate.nodeQueue[uuid].list[from].hasOwnProperty(hash)) {
+			    		continue;
+			    	}
+			    	for(var nodeindex in translate.nodeQueue[uuid].list[from][hash].nodes){
+			    		if (!translate.nodeQueue[uuid].list[from][hash].nodes.hasOwnProperty(nodeindex)) {
+				    		continue;
+				    	}
+			    		var node = translate.nodeQueue[uuid].list[from][hash].nodes[nodeindex].node;
+			    		nodes.push(node);
+			    	}
+			    }	
+			}
+			translate.visual.adjustTranslationSpaces(nodes);
+		},
+		/*
+			通过 translate.nodeQueue 中最后一次执行的 uuid，来获取这个 translate.nodeQueue[uuid] 中所包含涉及到的所有node (除特殊字符外 ，也就是 translate.nodeQueue[uuid].list 下 特殊字符那一类是不会使用的)
+		*/
+		adjustTranslationSpacesByLastNodequeueUuid:function(uuid){
+			var uuid = '';
+			for(var uuid_index in translate.nodeQueue){
+				uuid = uuid_index;
+				break;
+			}
+			if(typeof(uuid) == 'string' && uuid.length > 1){
+				translate.visual.adjustTranslationSpacesByNodequeueUuid(uuid);
+			}
+		},
+
+		/**
+		 * 隐藏当前网页的所有文本
+		 *
+		 */
+		hideText:{
+			style:`
+				/* 文本隐藏核心样式 - 仅隐藏文本内容 */
+		        html.translatejs-text-hidden p, html.translatejs-text-hidden div,
+		        html.translatejs-text-hidden h1, html.translatejs-text-hidden h2, html.translatejs-text-hidden h3,
+		        html.translatejs-text-hidden h4, html.translatejs-text-hidden h5, html.translatejs-text-hidden h6,
+		        html.translatejs-text-hidden span, html.translatejs-text-hidden a, html.translatejs-text-hidden b,
+		        html.translatejs-text-hidden strong, html.translatejs-text-hidden i, html.translatejs-text-hidden em,
+		        html.translatejs-text-hidden mark,
+		        html.translatejs-text-hidden blockquote, html.translatejs-text-hidden ul, html.translatejs-text-hidden ol,
+		        html.translatejs-text-hidden li, html.translatejs-text-hidden table, html.translatejs-text-hidden th,
+		        html.translatejs-text-hidden td, html.translatejs-text-hidden label, html.translatejs-text-hidden button,
+		        html.translatejs-text-hidden input, html.translatejs-text-hidden select, html.translatejs-text-hidden textarea {
+		            color: transparent !important;
+		            text-shadow: none !important;
+		        }
+
+		        /* 隐藏占位符文字 */
+		        html.translatejs-text-hidden ::placeholder {
+		            color: transparent !important;
+		        }
+
+		        /* 确保媒体元素不受影响 */
+		        img, video, iframe, canvas, svg,
+		        object, embed, picture, source {
+		            color: initial !important;
+		        }
+
+		        /* 忽略隐藏的元素保持可见 */
+		        .ignore-hidden {
+		            color: inherit !important;
+		        }
+			`,
+
+			/**
+			 * 当点击切换语言按钮后，会刷新当前页面，然后再进行翻译。 
+			 * 这时会出现刷新当前页面后，会先显示原本的文本，然后再翻译为切换为的语种，体验效果有点欠缺。  
+			 * 这个得作用就是增强用户视觉的体验效果，在页面初始化加载时，如果判定需要翻译，那么会隐藏所有网页中的文本 。
+			 * 这个需要在body标签之前执行，需要在head标签中执行此。也就是加载 translate.js 以及触发此都要放到head标签中
+			 */
+			hide:function(){
+				const style = document.createElement('style');
+				style.textContent = translate.visual.hideText.style;
+			    document.head.appendChild(style);
+			    document.documentElement.classList.add('translatejs-text-hidden');
+			},
+			/**
+			 * 撤销隐藏状态，将原本的文本正常显示出来 
+			 * 
+			 */
+			show:function(){
+				document.documentElement.classList.remove('translatejs-text-hidden');
+			}
+		},
+
+		/**
+		 * 网页加载，且要进行翻译时，翻译之前，隐藏当前网页的文本。
+		 * 当点击切换语言按钮后，会刷新当前页面，然后再进行翻译。 
+		 * 这时会出现刷新当前页面后，会先显示原本的文本，然后再翻译为切换为的语种，体验效果有点欠缺。  
+		 * 这个得作用就是增强用户视觉的体验效果，在页面初始化加载时，如果判定需要翻译，那么会隐藏所有网页中的文本 。
+		 * 这个需要在body标签之前执行，需要在head标签中执行此。也就是加载 translate.js 以及触发此都要放到head标签中
+		 */
+		webPageLoadTranslateBeforeHiddenText:function(){
+			if(typeof(document.body) == 'undefined' || document.body == null){
+				//正常，body还没加载
+			}else{
+				console.log('错误警告： translate.visual.webPageLoadTranslateBeforeHiddenText() 要在 head 标签中触发才能达到最好的效果！');
+			}
+			if(translate.language.local == ''){
+				console.log('错误警告：在使用 translate.visual.webPageLoadTranslateBeforeHiddenText() 之前，请先手动设置你的本地语种，参考： http://translate.zvo.cn/4066.html  如果你不设置，则不管你是否有切换语言，网页打开后都会先短暂的不显示文字');
+			}
+
+			if(translate.language.local == '' || translate.language.local != translate.language.getCurrent()){
+				translate.visual.hideText.hide();
+
+				//设置翻译完成后，移除隐藏文本的css 的class name
+				translate.lifecycle.execute.renderFinish.push(function(uuid, to){
+					translate.visual.hideText.show();
+				});
+			}
+		}
+
+		
+
+
+
+	}
+	/*js translate.visual end*/
 	
 }
 /*
@@ -7377,13 +8419,14 @@ var nodeuuid = {
 console.log('------ translate.js ------\nTwo lines of js html automatic translation, page without change, no language configuration file, no API Key, SEO friendly! Open warehouse : https://github.com/xnx3/translate \n两行js实现html全自动翻译。 无需改动页面、无语言配置文件、无API Key、对SEO友好！完全开源，代码仓库：https://gitee.com/mail_osc/translate');
 /*js copyright-notice end*/
 
+
 /*js amd-cmd-commonjs start*/
 /*兼容 AMD、CMD、CommonJS 规范 - start*/
 /**
  * 兼容 AMD、CMD、CommonJS 规范
  * node 环境使用：`npm i i18n-jsautotranslate` 安装包
  */
-(function (root, factory) {
+;(function (root, factory) {
   if (typeof define === 'function' && define.amd) {
     define([], () => factory());
   } else if (typeof module === 'object' && module.exports) {