diff --git a/WebContent/public/js/css-filters-polyfill.js b/WebContent/public/js/css-filters-polyfill.js
index 91b2514..a079c4a 100644
--- a/WebContent/public/js/css-filters-polyfill.js
+++ b/WebContent/public/js/css-filters-polyfill.js
@@ -11,291 +11,362 @@
  *
  */
 ;(function(window){
+	// 定义一个名为polyfilter的对象，用于存储各种方法和属性
 	var polyfilter = {
-		// Detect if we are dealing with IE <= 9
-		// http://james.padolsey.com/javascript/detect-_ie-in-js-using-conditional-comments/
-		_ie:			(function(){
-			var undef,
-			v = 3,
-			div = document.createElement('div'),
-			all = div.getElementsByTagName('i');
-			
-			while(
+		// 检测是否为IE <= 9版本
+		_ie: (function () {
+			// 定义未定义变量和初始值v为3
+			var undef, v = 3,
+				// 创建一个div元素
+				div = document.createElement('div'),
+				// 获取div中的所有i元素
+				all = div.getElementsByTagName('i');
+
+			// 循环判断IE版本
+			while (
 				div.innerHTML = '<!--[if gt IE ' + (++v) + ']><i></i><![endif]-->',
-				all[0]
-			);
-			
+					all[0]
+				) ;
+
+			// 如果v大于4，返回v，否则返回未定义
 			return v > 4 ? v : undef;
 		}()),
-		
-		_svg_cache: 		{},
-		
-		_create_svg_element: function(tagname,attributes){
+
+		// 缓存SVG元素
+		_svg_cache: {},
+
+		// 创建SVG元素的方法
+		_create_svg_element: function (tagname, attributes) {
+			// 定义SVG命名空间
 			var xmlns = 'http://www.w3.org/2000/svg';
-			var elem = document.createElementNS(xmlns,tagname);
-			for(key in attributes){
-				elem.setAttributeNS(null,key,attributes[key]);
+			// 使用命名空间创建SVG元素
+			var elem = document.createElementNS(xmlns, tagname);
+			// 遍历属性并设置到元素上
+			for (key in attributes) {
+				elem.setAttributeNS(null, key, attributes[key]);
 			}
-			
+
+			// 返回创建的SVG元素
 			return elem;
 		},
-		
-		_create_svg:	function(id,filterelements){
+
+		// 创建SVG容器的方法
+		_create_svg: function (id, filterelements) {
+			// 定义SVG命名空间
 			var xmlns = 'http://www.w3.org/2000/svg';
-			var svg = document.createElementNS(xmlns,'svg');
-			svg.setAttributeNS(null,'width','0');
-			svg.setAttributeNS(null,'height','0');
-			svg.setAttributeNS(null,'style','position:absolute');
-			
-			var svg_filter = document.createElementNS(xmlns,'filter');
-			svg_filter.setAttributeNS(null,'id',id);
+			// 使用命名空间创建SVG元素
+			var svg = document.createElementNS(xmlns, 'svg');
+			// 设置SVG元素的宽度和高度为0
+			svg.setAttributeNS(null, 'width', '0');
+			svg.setAttributeNS(null, 'height', '0');
+			// 设置SVG元素的样式为绝对定位
+			svg.setAttributeNS(null, 'style', 'position:absolute');
+
+			// 创建SVG滤镜元素并添加到SVG容器中
+			var svg_filter = document.createElementNS(xmlns, 'filter');
+			svg_filter.setAttributeNS(null, 'id', id);
 			svg.appendChild(svg_filter);
-			
-			for(var i = 0; i < filterelements.length; i++){
+
+			// 将滤镜元素添加到SVG滤镜中
+			for (var i = 0; i < filterelements.length; i++) {
 				svg_filter.appendChild(filterelements[i]);
 			}
-			
+
+			// 返回创建的SVG容器
 			return svg;
 		},
-		
+
+		// 记录待处理的样式表数量
 		_pending_stylesheets: 0,
-	
-		_stylesheets: 		[],
-		
-		_development_mode: (function(){
-			if(location.hostname === 'localhost' || location.hostname.search(/.local$/) !== -1 || location.hostname.search(/\d+\.\d+\.\d+\.\d+/) !== -1){
-				if(window.console) console.log('Detected localhost or IP address. Assuming you are a developer. Caching of stylesheets is disabled.');
+		// 存储样式表内容的数组
+		_stylesheets: [],
+		// 开发模式标志，根据主机名或IP地址判断是否为开发环境
+		_development_mode: (function () {
+			// 检查主机名是否为localhost或IP地址，如果是则启用开发模式
+			if (location.hostname === 'localhost' || location.hostname.search(/.local$/) !== -1 || location.hostname.search(/\d+\.\d+\.\d+\.\d+/) !== -1) {
+				if (window.console) console.log('Detected localhost or IP address. Assuming you are a developer. Caching of stylesheets is disabled.');
 				return true;
 			}
-			if(window.console) console.log('Caching of stylesheets is enabled. You need to refresh twice to see any changes.');
+			// 如果不是开发环境，则启用缓存模式
+			if (window.console) console.log('Caching of stylesheets is enabled. You need to refresh twice to see any changes.');
 			return false;
-		})(),
-		
-		process_stylesheets: function(){
-			var xmlHttp = [];
-			
-			// Check if path to library is correct, do that 2 secs. after this to not disturb initial processing
-			window.setTimeout(function(){
+		}()),
+		// 处理样式表的方法
+		process_stylesheets: function () {
+			// 延迟2秒执行，避免干扰页面加载
+			window.setTimeout(function () {
+				// 检查XMLHttpRequest对象是否存在，如果不存在则使用ActiveXObject
 				if (window.XMLHttpRequest) {
 					var xmlHttpCheck = new XMLHttpRequest();
-				} else if (window.ActiveXObject) {
+				} else {
 					var xmlHttpCheck = new ActiveXObject("Microsoft.XMLHTTP");
 				}
+				// 打开GET请求，检查路径是否正确
 				xmlHttpCheck.open('GET', window.polyfilter_scriptpath + 'htc/sepia.htc', true);
-				xmlHttpCheck.onreadystatechange = function(){
-					if(xmlHttp.readyState == 4 && xmlHttp.status != 200){
-						alert('The configured path \r\rvar polyfilter_scriptpath = "' + window.polyfilter_scriptpath + '"\r\rseems wrong!\r\rConfigure the polyfill\'s correct absolute(!) script path before referencing the css-filters-polyfill.js, like so:\r\rvar polyfilter_scriptpath = "/js/css-filters-polyfill/";\r\rLeaving IE dead in the water is no option. You damn Mac user... ;)');
+				xmlHttpCheck.onreadystatechange = function () {
+					// 如果请求完成且状态码不为200，则输出错误信息
+					if (xmlHttpCheck.readyState == 4 && xmlHttpCheck.status != 200) {
+						('The configured path seems wrong!\r\rvar polyfilter_scriptpath = "' + window.polyfilter_scriptpath + '\r\rConfigure the polyfilter\'s absolute(!) scriptpath before referencing the css-filters-polyfill.js, like so:\r\rvar polyfilter_scriptpath = "/js/css-filters-polyfill/";\r\rLeaving IE dead in the water is no option... ;)');
 					}
 				};
-				try{
+				try {
+					// 发送请求
 					xmlHttpCheck.send(null);
-				} catch(e){}
-			},2000);
-			
-			
+				} catch (e) {
+				}
+			}, 2000);
+
+			// 获取所有样式表和链接标签
 			var stylesheets = document.querySelectorAll ? document.querySelectorAll('style,link[rel="stylesheet"]') : document.getElementsByTagName('*');
-			
-			for(var i = 0; i < stylesheets.length; i++){
-				(function(i){
-					switch(stylesheets[i].nodeName){
+
+			// 遍历所有样式表和链接标签
+			for (var i = 0; i < stylesheets.length; i++) {
+				(function (i) {
+					switch (stylesheets[i].nodeName) {
 						default:
-						break;
-						
+							break;
 						case 'STYLE':
+							// 如果是样式表，将其内容和媒体类型保存到_stylesheets数组中
 							polyfilter._stylesheets.push({
-								media:		stylesheets[i].media || 'all',
-								content: 	stylesheets[i].innerHTML
+								media: stylesheets[i].media || 'all',
+								content: stylesheets[i].innerHTML
 							});
-						break;
-						
+							break;
 						case 'LINK':
-							if(stylesheets[i].rel === 'stylesheet'){
+							// 如果是链接标签且rel属性为stylesheet，则处理外部样式表
+							if (stylesheets[i].rel === 'stylesheet') {
 								var index = polyfilter._stylesheets.length;
-							
+								// 将外部样式表的信息保存到_stylesheets数组中
 								polyfilter._stylesheets.push({
-									media:		stylesheets[i].media || 'all'
+									media: stylesheets[i].media || 'all'
 								});
-								
+								// 增加待处理的样式表数量
 								polyfilter._pending_stylesheets++;
-								
-								// Fetch external stylesheet
+								// 获取外部样式表的href属性
 								var href = stylesheets[i].href;
-								
-								// Use localStorage as cache for stylesheets, if available
-								if(!polyfilter._development_mode && window.localStorage && window.localStorage.getItem('polyfilter_' + href)){
+								// 如果本地存储可用，则使用本地存储作为样式表缓存
+								if (!polyfilter._development_mode && window.localStorage && window.localStorage.getItem('polyfilter_' + href)) {
+									// 减少待处理的样式表数量
 									polyfilter._pending_stylesheets--;
+									// 从本地存储中获取样式表内容并保存到_stylesheets数组中
 									polyfilter._stylesheets[index].content = localStorage.getItem('polyfilter_' + href);
-									if(polyfilter._pending_stylesheets === 0){
+									// 如果所有样式表都已处理完毕，则调用process方法进行处理
+									if (polyfilter._pending_stylesheets === 0) {
 										polyfilter.process();
+
 									}
 								}
-	
-								// Always fetch stylesheets to reflect possible changes
-								try{
-									if(window.XMLHttpRequest) {
-										var xmlHttp = new XMLHttpRequest();
-									} else if(window.ActiveXObject) {
-										var xmlHttp = new ActiveXObject("Microsoft.XMLHTTP");
+
+// Always fetch stylesheets to reflect possible changes
+								try {
+									// 检查浏览器是否支持XMLHttpRequest对象
+									if (window.XMLHttpRequest) {
+										var xmlHttp = new XMLHttpRequest(); // 创建一个新的XMLHttpRequest对象
+									} else if (window.ActiveXObject) {
+										var xmlHttp = new ActiveXObject("Microsoft.XMLHTTP"); // 对于较旧的IE浏览器，使用ActiveXObject
 									}
+									// 初始化一个GET请求，异步方式
 									xmlHttp.open('GET', href, true);
-									xmlHttp.onreadystatechange = function(){
-										if(xmlHttp.readyState === 4){
-											if(xmlHttp.status === 0){
-												if(window.console) console.log('Could not fetch external CSS via HTTP-Request ' + href + '. Probably because of cross origin.');
-												if(!polyfilter._stylesheets[index].content){
-													polyfilter._pending_stylesheets--;
-													polyfilter._stylesheets[index].content = xmlHttp.responseText;
-													if(polyfilter._pending_stylesheets === 0){
-														polyfilter.process();
+									// 定义当readyState属性改变时触发的函数
+									xmlHttp.onreadystatechange = function () {
+										// 检查请求是否完成
+										if (xmlHttp.readyState === 4) {
+											// 检查HTTP状态码是否为0（通常表示跨域问题）
+											if (xmlHttp.status === 0) {
+												if (window.console) console.log('Could not fetch external CSS via HTTP-Request ' + href + '. Probably because of cross origin.'); // 输出错误信息到控制台
+												// 如果当前样式表内容为空
+												if (!polyfilter._stylesheets[index].content) {
+													polyfilter._pending_stylesheets--; // 减少待处理样式表计数
+													polyfilter._stylesheets[index].content = xmlHttp.responseText; // 将响应文本保存到样式表内容中
+													// 如果所有样式表都已加载完毕
+													if (polyfilter._pending_stylesheets === 0) {
+														polyfilter.process(); // 调用处理函数
 													}
 												}
 											} else {
-												if(!polyfilter._stylesheets[index].content){
-													polyfilter._pending_stylesheets--;
-													polyfilter._stylesheets[index].content = xmlHttp.responseText;
-													if(polyfilter._pending_stylesheets === 0){
-														polyfilter.process();
+												// 如果HTTP状态码不为0且当前样式表内容为空
+												if (!polyfilter._stylesheets[index].content) {
+													polyfilter._pending_stylesheets--; // 减少待处理样式表计数
+													polyfilter._stylesheets[index].content = xmlHttp.responseText; // 将响应文本保存到样式表内容中
+													// 如果所有样式表都已加载完毕
+													if (polyfilter._pending_stylesheets === 0) {
+														polyfilter.process(); // 调用处理函数
 													}
 												}
+
 												// Cache stylesheet in localStorage, if available
-												if(!polyfilter._development_mode && window.localStorage){
-													try{
-														window.localStorage.setItem('polyfilter_' + href,polyfilter._stylesheets[index].content)
-													}
-													catch(e){
-														if(window.console) console.log('Local storage quota have been exceeded. Caching of stylesheet ' + href + ' is not possible');
+												// 检查是否不在开发模式且浏览器支持localStorage
+												if (!polyfilter._development_mode && window.localStorage) {
+													try {
+														// 尝试将样式表内容存储到localStorage中，键名为'polyfilter_'加上href
+														window.localStorage.setItem('polyfilter_' + href, polyfilter._stylesheets[index].content
+														);
+													} catch
+														(e) {
+														// 如果存储失败（例如超出配额），在控制台输出错误信息
+														if (window.console) console.log('Local storage quota have been exceeded. Caching of stylesheet ' + href + ' is not possible');
 													}
 												}
 											}
 										}
 									};
-									try{
+									try {// 发送HTTP请求以获取外部CSS文件
 										xmlHttp.send(null);
-									} catch(e){
-										if(window.console) console.log('Could not fetch external CSS via HTTP-Request ' + href + '. Are you maybe testing using the file://-protocol?');
-										if(!polyfilter._stylesheets[index].content){
+									} catch (e) {
+										// 如果控制台可用，则在控制台中记录错误信息
+										if (window.console) console.log('Could not fetch external CSS via HTTP-Request ' + href + '. Are you maybe testing using the file://-protocol?');
+										// 检查当前样式表是否没有内容
+										if (!polyfilter._stylesheets[index].content) {
+											// 减少待处理的样式表计数
 											polyfilter._pending_stylesheets--;
-											if(polyfilter._pending_stylesheets === 0){
+											// 如果所有样式表都已处理完毕，则调用process方法
+											if (polyfilter._pending_stylesheets === 0) {
 												polyfilter.process();
 											}
 										}
 									}
-								} catch(e){}
+								} catch (e) {
+								}
 							}
-						break;
+							break;
 					}
 				})(i);
 			}
-			if(this._pending_stylesheets === 0){
+			if (this._pending_stylesheets === 0) { // 如果所有样式表都已处理完毕，则调用process方法
 				this.process();
 			}
 		},
-	
-		_processDeclarations:	function(rule){
-			var newstyles = '';
-			for(var k in rule.declarations){
-				var declaration = rule.declarations[k];
-			
-				if(declaration.property === 'filter'){
-					
-					if(document.querySelectorAll){
-						var elems = document.querySelectorAll(rule.mSelectorText);
-						for(var k = 0; k < elems.length; k++){
+
+		_processDeclarations: function (rule) {
+			var newstyles = ''; // 初始化新样式字符串
+			for (var k in rule.declarations) {
+				var declaration = rule.declarations[k]; // 获取当前声明
+
+				if (declaration.property === 'filter') {
+					// 如果document支持querySelectorAll方法
+					if (document.querySelectorAll) {
+						var elems = document.querySelectorAll(rule.mSelectorText); // 根据选择器文本获取元素列表
+						for (var k = 0; k < elems.length; k++) {
+							// 为每个元素设置自定义属性polyfilterStore，存储过滤器值
 							elems[k].style.polyfilterStore = declaration.valueText;
 						}
 					}
-					
+
+					// 将声明的值文本赋值给变量gluedvalues
 					var gluedvalues = declaration.valueText;
+
+// 使用正则表达式分割字符串，以匹配右括号后跟一个或多个空白字符的模式
 					var values = gluedvalues.split(/\)\s+/),
+						// 初始化一个对象properties，用于存储不同类型的过滤器和行为
 						properties = {
-							filtersW3C:		[],
-							filtersWebKit: 	[],
-							filtersSVG:		[],
-							filtersIE:		[],
-							behaviorsIE:	[]
+							filtersW3C: [],      // W3C标准的过滤器数组
+							filtersWebKit: [],   // WebKit浏览器的过滤器数组
+							filtersSVG: [],      // SVG格式的过滤器数组
+							filtersIE: [],       // IE浏览器的过滤器数组
+							behaviorsIE: []      // IE浏览器的行为数组
 						};
-					
-					for(idx in values){
+
+					// 遍历分割后的values数组
+					for (idx in values) {
+						// 为每个值添加右括号，因为之前被分割掉了
 						var value = values[idx] + ')';
-						
+
+						// 调用polyfilter.convert函数转换当前值，返回一个包含不同类型过滤器的对象
 						currentproperties = polyfilter.convert(value);
-		
-						for(key in currentproperties){
-							if(typeof properties[key] !== 'undefined'){
+
+						// 遍历currentproperties对象的键
+						for (key in currentproperties) {
+							// 如果properties对象中存在对应的键
+							if (typeof properties[key] !== 'undefined') {
+								// 将currentproperties中的值合并到properties对应的数组中
 								properties[key] = properties[key].concat(currentproperties[key]);
 							}
 						}
 					}
-					
+
+					// 将选择器文本和左大括号添加到newstyles字符串中，开始定义新的CSS规则
 					newstyles += rule.mSelectorText + '{';
-					if(properties['filtersW3C'].length > 0){
-						var filter = 
-						webkitFilter = 
-						mozFilter = 
-						oFilter = 
-						msFilter = 
-						properties['filtersW3C'].join(' ');
-		
-						if(properties['filtersWebKit'] && properties['filtersWebKit'].length > 0){
+
+// 如果W3C标准的过滤器数组不为空
+					if (properties['filtersW3C'].length > 0) {
+						// 将所有W3C标准过滤器连接成一个字符串，并赋值给多个变量
+						var filter =
+							webkitFilter =
+								mozFilter =
+									oFilter =
+										msFilter =
+											properties['filtersW3C'].join(' ');
+
+						// 如果WebKit的过滤器数组存在且不为空，则将其连接成字符串并赋值给webkitFilter变量
+						if (properties['filtersWebKit'] && properties['filtersWebKit'].length > 0) {
 							webkitFilter = properties['filtersWebKit'].join(' ');
 						}
 
-						if(typeof this._ie === 'undefined'){
+						// 如果_ie属性未定义（即不在IE浏览器中）
+						if (typeof this._ie === 'undefined') {
+							// 添加-ms-filter样式到newstyles字符串中
 							newstyles += '-ms-filter:' + msFilter + ';';
 						}
-						
+
+						// 添加-webkit-filter样式到newstyles字符串中
 						newstyles += '-webkit-filter:' + webkitFilter + ';';
+						// 添加-moz-filter样式到newstyles字符串中
 						newstyles += '-moz-filter:' + mozFilter + ';';
+						// 添加-o-filter样式到newstyles字符串中
 						newstyles += '-o-filter:' + oFilter + ';';
 					}
-					if(properties['filtersSVG'].length > 0){
-						if(properties['filtersSVG'][0] != 'none'){
-							var id = gluedvalues.replace(/[^a-z0-9]/g,'');
 
-							if(typeof this._svg_cache[id] === 'undefined'){
-								this._svg_cache[id] = this._create_svg(id,properties['filtersSVG']);
+// 如果SVG过滤器数组不为空
+					if (properties['filtersSVG'].length > 0) {
+						// 如果第一个SVG过滤器不是'none'
+						if (properties['filtersSVG'][0] != 'none') {
+							// 使用正则表达式从gluedvalues中提取字母和数字字符，生成一个ID
+							var id = gluedvalues.replace(/[^a-z0-9]/g, '');
 
-								if(typeof XMLSerializer === 'undefined'){
+							// 如果_svg_cache对象中没有这个ID对应的缓存项
+							if (typeof this._svg_cache[id] === 'undefined') {
+								// 调用_create_svg方法创建一个新的SVG元素，并将其存储在_svg_cache中
+								this._svg_cache[id] = this._create_svg(id, properties['filtersSVG']);
+
+								// 如果XMLSerializer类不存在（可能在某些旧版浏览器中）
+								if (typeof XMLSerializer === 'undefined') {
+									// 直接将SVG元素添加到文档的body中
 									document.body.appendChild(this._svg_cache[id]);
-								}
-								else {
+								} else {
+									// 使用XMLSerializer将SVG元素序列化为字符串
 									var s = new XMLSerializer();
 									var svgString = s.serializeToString(this._svg_cache[id]);
-									if(svgString.search('SourceGraphic') != -1){
+									// 如果序列化后的字符串包含'SourceGraphic'，则将SVG元素添加到文档的body中
+									if (svgString.search('SourceGraphic') != -1) {
 										document.body.appendChild(this._svg_cache[id]);
 									}
 								}
 							}
-		
-							if(typeof XMLSerializer === 'undefined'){
-								newstyles += 'filter: url(#' + id + ')';
-							}
-							else {
-								var s = new XMLSerializer();
-								var svgString = s.serializeToString(this._svg_cache[id]);
-								
-								if(svgString.search('SourceGraphic') != -1){
-									newstyles += 'filter: url(#' + id + ')';
-								}
-								else {
-									newstyles += 'filter: url(\'data:image/svg+xml;utf8,' + svgString + '#' + id + '\')';
+
+							if (typeof XMLSerializer === 'undefined') { // 检查浏览器是否支持XMLSerializer类
+								newstyles += 'filter: url(#' + id + ')'; // 如果不支持，使用旧的IE方式添加滤镜URL
+							} else {
+								var s = new XMLSerializer(); // 创建一个新的XMLSerializer实例
+								var svgString = s.serializeToString(this._svg_cache[id]); // 将SVG元素序列化为字符串
+
+								if (svgString.search('SourceGraphic') != -1) { // 检查序列化后的字符串中是否包含'SourceGraphic'
+									newstyles += 'filter: url(#' + id + ')'; // 如果包含，使用旧的IE方式添加滤镜URL
+								} else {
+									newstyles += 'filter: url(\'data:image/svg+xml;utf8,' + svgString + '#' + id + '\')'; // 如果不包含，使用数据URI的方式添加滤镜
 								}
 							}
-						}
-						else {
-							newstyles += 'filter: none;';
+						} else {
+							newstyles += 'filter: none;'; // 如果所有条件都不满足，设置滤镜为none
 						}
 					}
-					if(typeof this._ie !== 'undefined'){
-						if(properties['filtersIE'].length > 0){
-							var filtersIE = properties['filtersIE'].join(' ');
-							
-							newstyles += 'filter:' + filtersIE + ';';
+					if (typeof this._ie !== 'undefined') { // 检查是否是IE浏览器
+						if (properties['filtersIE'].length > 0) { // 检查是否有IE特定的滤镜
+							var filtersIE = properties['filtersIE'].join(' '); // 将所有IE滤镜连接成一个字符串
+							newstyles += 'filter:' + filtersIE + ';'; // 添加IE滤镜到样式中
 						}
-						if(properties['behaviorsIE'].length > 0){
-							var behaviorsIE = properties['behaviorsIE'].join(' ');
-							
-							newstyles += 'behavior:' + behaviorsIE + ';';
+						if (properties['behaviorsIE'].length > 0) { // 检查是否有IE特定的行为
+							var behaviorsIE = properties['behaviorsIE'].join(' '); // 将所有IE行为连接成一个字符串
+							newstyles += 'behavior:' + behaviorsIE + ';'; // 添加IE行为到样式中
 						}
 					}
 					newstyles += '}\r\n';
@@ -303,484 +374,523 @@
 			}
 			return newstyles;
 		},
-		
+
 		// Absolute path to the .htc-files
-		scriptpath:		
-			window.polyfilter_scriptpath ? window.polyfilter_scriptpath : (function(){
+		scriptpath:
+			window.polyfilter_scriptpath ? window.polyfilter_scriptpath : (function () {
 				alert('Please configure the polyfill\'s absolute(!) script path before referencing the css-filters-polyfill.js, like so:\r\nvar polyfilter_scriptpath = "/js/css-filters-polyfill/";');
 				return './'
 			})(),
-		
+
 		// process stylesheets
-		process:		function(){
+		// 处理样式表的函数
+		process: function () {
+			// 创建一个新的CSSParser实例
 			var parser = new CSSParser();
-	
-			for(var i = 0; i < this._stylesheets.length; i++){
-				var newstyles = '';
+
+			// 遍历所有样式表
+			for (var i = 0; i < this._stylesheets.length; i++) {
+				var newstyles = ''; // 初始化新的样式字符串
+				// 解析当前样式表的内容
 				var sheet = parser.parse(this._stylesheets[i].content, false, true);
-				if(sheet !== null) for(var j in sheet.cssRules){
-					var rule = sheet.cssRules[j];
-					
-					switch(rule.type){
+				if (sheet !== null) for (var j in sheet.cssRules) {
+					var rule = sheet.cssRules[j]; // 获取当前规则
+
+					switch (rule.type) {
 						default:
-						break;
-						
+							break;
+
 						case 1:
-							newstyles += this._processDeclarations(rule);
-						break;
-						
+							newstyles += this._processDeclarations(rule); // 处理普通规则
+							break;
+
 						case 4:
-							newstyles += '@media ' + rule.media.join(',') + '{';
-							for(var k in rule.cssRules){
-								var mediarule = rule.cssRules[k];
-								
-								newstyles += this._processDeclarations(mediarule);
+							newstyles += '@media ' + rule.media.join(',') + '{'; // 处理媒体查询规则
+							for (var k in rule.cssRules) {
+								var mediarule = rule.cssRules[k]; // 获取媒体查询中的规则
+
+								newstyles += this._processDeclarations(mediarule); // 处理媒体查询中的规则
 							}
 							newstyles += '}';
-						break;
+							break;
 					}
 				}
+				// 创建一个新的<style>元素并设置其属性
 				var newstylesheet = document.createElement('style');
-				newstylesheet.setAttribute('media',this._stylesheets[i].media);
-				
-				if(typeof polyfilter._ie === 'undefined'){
-					newstylesheet.innerHTML = newstyles;
-					document.getElementsByTagName('head')[0].appendChild(newstylesheet);
-				}
-				else {
-					document.getElementsByTagName('head')[0].appendChild(newstylesheet);
-					newstylesheet.styleSheet.cssText = newstyles;
+				newstylesheet.setAttribute('media', this._stylesheets[i].media);
+
+				// 根据浏览器类型将新样式添加到<head>中
+				if (typeof polyfilter._ie === 'undefined') {
+					newstylesheet.innerHTML = newstyles; // 非IE浏览器直接设置innerHTML
+					document.getElementsByTagName('head')[0].appendChild(newstylesheet); // 将<style>元素添加到<head>中
+				} else {
+					document.getElementsByTagName('head')[0].appendChild(newstylesheet); // 先添加<style>元素到<head>中
+					newstylesheet.styleSheet.cssText = newstyles; // IE浏览器使用styleSheet.cssText设置样式内容
 				}
 			}
-		},
-		
-		init:				function(){
-			if(Object.defineProperty){
+		},    // 结束process函数的定义
+
+		init: function () { // 定义一个初始化函数
+			if (Object.defineProperty) { // 检查是否支持 Object.defineProperty 方法
+				// 在 CSSStyleDeclaration.prototype 上定义一个新的属性 'polyfilter'
 				Object.defineProperty(CSSStyleDeclaration.prototype, 'polyfilter', {
-					get:	function(){
+					get: function () { // 定义获取器，返回 polyfilterStore 的值
 						return this.polyfilterStore;
 					},
-					set:	function(gluedvalues){
-						values = gluedvalues.split(/\)\s+/);
-						var properties = {
-							filtersW3C:		[],
-							filtersWebKit: 	[],
-							filtersSVG:		[],
-							filtersIE:		[],
-							behaviorsIE:	[]
+					set: function (gluedvalues) { // 定义设置器，处理传入的样式值
+						values = gluedvalues.split(/\)\s+/); // 将传入的样式值按 ')' 分割成数组
+						var properties = { // 初始化一个对象来存储不同类型的滤镜和行为
+							filtersW3C: [],
+							filtersWebKit: [],
+							filtersSVG: [],
+							filtersIE: [],
+							behaviorsIE: []
 						}
-				
-						for(idx in values){
-							var value = values[idx] + ')';
-							
-							currentproperties = polyfilter.convert(value);
-							
-							for(key in currentproperties){
-								if(typeof properties[key] !== 'undefined'){
-									properties[key] = properties[key].concat(currentproperties[key]);
+
+						for (idx in values) { // 遍历分割后的样式值数组
+							var value = values[idx] + ')'; // 为每个值添加右括号
+
+							currentproperties = polyfilter.convert(value); // 调用 polyfilter.convert 方法转换样式值
+
+							for (key in currentproperties) { // 遍历转换后的属性
+								if (typeof properties[key] !== 'undefined') { // 如果属性存在于 properties 对象中
+									properties[key] = properties[key].concat(currentproperties[key]); // 合并属性值
 								}
 							}
 						}
-			
-						if(properties['filtersW3C'].length > 0){
-							if(typeof polyfilter._ie === 'undefined'){
-								this.msFilter = 
-									properties['filtersW3C'].join(' ');
+
+						if (properties['filtersW3C'].length > 0) { // 如果存在 W3C 滤镜
+							if (typeof polyfilter._ie === 'undefined') { // 如果不是 IE 浏览器
+								this.msFilter = properties['filtersW3C'].join(' '); // 设置 msFilter 属性
 							}
-							
-							this.webkitFilter = 
-							this.mozFilter = 
-							this.oFilter = 
-								properties['filtersW3C'].join(' ');
+
+							this.webkitFilter = this.mozFilter = this.oFilter = properties['filtersW3C'].join(' '); // 设置 Webkit、Moz 和 O 滤镜属性
 						}
-						if(properties['filtersWebKit'].length > 0){
-							this.webkitFilter = properties['filtersWebKit'].join(' ');
+						if (properties['filtersWebKit'].length > 0) { // 如果存在 WebKit 滤镜
+							this.webkitFilter = properties['filtersWebKit'].join(' '); // 设置 Webkit 滤镜属性
 						}
-						if(properties['filtersSVG'].length > 0){
-							if(properties['filtersSVG'][0] != 'none'){
-								var id = gluedvalues.replace(/[^a-z0-9]/g,'');
-					
-								if(typeof polyfilter._svg_cache[id] === 'undefined'){
-									polyfilter._svg_cache[id] = polyfilter._create_svg(id,properties['filtersSVG']);
-
-									if(typeof XMLSerializer === 'undefined'){
-										document.body.appendChild(polyfilter._svg_cache[id]);
-									}
-									else {
-										var s = new XMLSerializer();
-										var svgString = s.serializeToString(polyfilter._svg_cache[id]);
-										if(svgString.search('SourceGraphic') != -1){
-											document.body.appendChild(polyfilter._svg_cache[id]);
+						if (properties['filtersSVG'].length > 0) { // 如果存在 SVG 滤镜
+							if (properties['filtersSVG'][0] != 'none') { // 如果第一个滤镜不是 'none'
+								var id = gluedvalues.replace(/[^a-z0-9]/g, ''); // 生成一个唯一的 ID
+
+								if (typeof polyfilter._svg_cache[id] === 'undefined') { // 如果缓存中不存在该 ID
+									polyfilter._svg_cache[id] = polyfilter._create_svg(id, properties['filtersSVG']); // 创建并缓存 SVG 元素
+
+									if (typeof XMLSerializer === 'undefined') { // 如果不支持 XMLSerializer
+										document.body.appendChild(polyfilter._svg_cache[id]); // 直接将 SVG 元素添加到 body
+									} else {
+										var s = new XMLSerializer(); // 创建一个 XMLSerializer 实例
+										var svgString = s.serializeToString(polyfilter._svg_cache[id]); // 序列化 SVG 元素
+										if (svgString.search('SourceGraphic') != -1) { // 如果序列化的字符串包含 'SourceGraphic'
+											document.body.appendChild(polyfilter._svg_cache[id]); // 将 SVG 元素添加到 body
 										}
 									}
-								}
-			
-								if(typeof XMLSerializer === 'undefined'){
-									this.filter = 'url(#' + id + ')';
-								}
-								else {
-									var s = new XMLSerializer();
-									var svgString = s.serializeToString(polyfilter._svg_cache[id]);
-									if(svgString.search('SourceGraphic') != -1){
-										this.filter = 'url(#' + id + ')';
-									}
-									else {
-										this.filter = 'url(\'data:image/svg+xml;utf8,' + svgString + '#' + id + '\')';
+								}// 结束 init 函数的定义
+
+
+								if (typeof XMLSerializer === 'undefined') { // 检查是否支持 XMLSerializer 类
+									this.filter = 'url(#' + id + ')'; // 如果不支持，直接使用 ID 设置滤镜 URL
+								} else {
+									var s = new XMLSerializer(); // 创建一个 XMLSerializer 实例
+									var svgString = s.serializeToString(polyfilter._svg_cache[id]); // 序列化缓存中的 SVG 元素为字符串
+									if (svgString.search('SourceGraphic') != -1) { // 检查序列化的字符串中是否包含 'SourceGraphic'
+										this.filter = 'url(#' + id + ')'; // 如果包含，使用 ID 设置滤镜 URL
+									} else {
+										this.filter = 'url(\'data:image/svg+xml;utf8,' + svgString + '#' + id + '\')'; // 如果不包含，使用数据 URL 设置滤镜
 									}
 								}
-							}
-							else {
-								this.filter = 'none';
+							} else {
+								this.filter = 'none'; // 如果所有条件都不满足，设置滤镜为 'none'
 							}
 						}
-						if(typeof polyfilter._ie !== 'undefined'){
-							if(properties['filtersIE'].length > 0){
-								this.filter = 
-									properties['filtersIE'].join(' ');
-							}
-							else {
-								this.filter = '';
+						if (typeof polyfilter._ie !== 'undefined') { // 检查是否在 IE 浏览器中运行
+							if (properties['filtersIE'].length > 0) { // 如果有 IE 特定的滤镜
+								this.filter = properties['filtersIE'].join(' '); // 将它们连接成一个字符串并设置为滤镜
+							} else {
+								this.filter = ''; // 如果没有 IE 特定滤镜，设置为空字符串
 							}
-							if(properties['behaviorsIE'].length > 0){
-								this.behavior = 
-									properties['behaviorsIE'].join(' ');
-							}
-							else {
-								this.behavior = '';
+							if (properties['behaviorsIE'].length > 0) { // 如果有 IE 特定的行为
+								this.behavior = properties['behaviorsIE'].join(' '); // 将它们连接成一个字符串并设置为行为
+							} else {
+								this.behavior = ''; // 如果没有 IE 特定行为，设置为空字符串
 							}
 						}
-						this.polyfilterStore = gluedvalues;
+						this.polyfilterStore = gluedvalues; // 将处理后的样式值存储到 polyfilterStore 属性中
 					}
-				});
+				}); // 结束函数定义
+
 			}
 		},
-		
-		convert:			function(value){
-			// None
+
+
+		function(value) {
+			// 定义一个函数，接收一个参数 value
 			var fmatch = value.match(/none/i);
-			if(fmatch !== null){
+			// 使用正则表达式匹配 'none'（不区分大小写）
+			if (fmatch !== null) {
+				// 如果匹配成功
 				var properties = this.filters.none();
+				// 调用 filters 对象的 none 方法，并将结果赋值给 properties
 			}
 			// Grayscale
 			var fmatch = value.match(/(grayscale)\(([0-9\.]+)\)/i);
-			if(fmatch !== null){
-				var amount = parseFloat(fmatch[2],10),
+			// 使用正则表达式匹配 'grayscale' 和括号内的数字（不区分大小写）
+			if (fmatch !== null) {
+				// 如果匹配成功
+				var amount = parseFloat(fmatch[2], 10),
+					// 将匹配到的第二个捕获组转换为浮点数
 					properties = this.filters.grayscale(amount);
+				// 调用 filters 对象的 grayscale 方法，并传入转换后的值，将结果赋值给 properties
 			}
 			// Sepia
 			var fmatch = value.match(/(sepia)\(([0-9\.]+)\)/i);
-			if(fmatch !== null){
-				var amount = parseFloat(fmatch[2],10),
+			// 使用正则表达式匹配 'sepia' 和括号内的数字（不区分大小写）
+			if (fmatch !== null) {
+				// 如果匹配成功
+				var amount = parseFloat(fmatch[2], 10),
+					// 将匹配到的第二个捕获组转换为浮点数
 					properties = this.filters.sepia(amount);
+				// 调用 filters 对象的 sepia 方法，并传入转换后的值，将结果赋值给 properties
 			}
 			// Blur
 			var fmatch = value.match(/(blur)\(([0-9]+)[px]*\)/i);
-			if(fmatch !== null){
-				var amount = parseInt(fmatch[2],10),
+			// 使用正则表达式匹配 'blur' 和括号内的数字（不区分大小写），可能包含 'px'
+			if (fmatch !== null) {
+				// 如果匹配成功
+				var amount = parseInt(fmatch[2], 10),
+					// 将匹配到的第二个捕获组转换为整数
 					properties = this.filters.blur(amount);
+				// 调用 filters 对象的 blur 方法，并传入转换后的值，将结果赋值给 properties
 			}
 			// Invert
 			var fmatch = value.match(/(invert)\(([0-9\.]+)\)/i);
-			if(fmatch !== null){
-				var amount = parseFloat(fmatch[2],10),
+			// 使用正则表达式匹配 'invert' 和括号内的数字（不区分大小写）
+			if (fmatch !== null) {
+				// 如果匹配成功
+				var amount = parseFloat(fmatch[2], 10),
+					// 将匹配到的第二个捕获组转换为浮点数
 					properties = this.filters.invert(amount);
+				// 调用 filters 对象的 invert 方法，并传入转换后的值，将结果赋值给 properties
 			}
 			// Brightness
 			var fmatch = value.match(/(brightness)\(([0-9\.]+)%\)/i);
-			if(fmatch !== null){
-				var amount = parseFloat(fmatch[2],10),
+			// 使用正则表达式匹配 'brightness' 和括号内的百分比值（不区分大小写）
+			if (fmatch !== null) {
+				// 如果匹配成功
+				var amount = parseFloat(fmatch[2], 10),
+					// 将匹配到的第二个捕获组转换为浮点数
 					properties = this.filters.brightness(amount);
+				// 调用 filters 对象的 brightness 方法，并传入转换后的值，将结果赋值给 properties
 			}
 			// Drop Shadow
 			var fmatch = value.match(/(drop\-shadow)\(([0-9]+)[px]*\s+([0-9]+)[px]*\s+([0-9]+)[px]*\s+([#0-9]+)\)/i);
-			if(fmatch !== null){
-				var offsetX = parseInt(fmatch[2],10),
-					offsetY = parseInt(fmatch[3],10),
-					radius = parseInt(fmatch[4],10),
+			// 使用正则表达式匹配 'drop-shadow' 和括号内的阴影参数（不区分大小写）
+			if (fmatch !== null) {
+				// 如果匹配成功
+				var offsetX = parseInt(fmatch[2], 10),
+					// 将匹配到的第二个捕获组转换为整数，表示 X 轴偏移量
+					offsetY = parseInt(fmatch[3], 10),
+					// 将匹配到的第三个捕获组转换为整数，表示 Y 轴偏移量
+					radius = parseInt(fmatch[4], 10),
+					// 将匹配到的第四个捕获组转换为整数，表示模糊半径
 					color = fmatch[5],
-					properties = this.filters.dropShadow(offsetX,offsetY,radius,color);
+					// 获取第五个捕获组，表示颜色值
+					properties = this.filters.dropShadow(offsetX, offsetY, radius, color);
+				// 调用 filters 对象的 dropShadow 方法，并传入所有参数，将结果赋值给 properties
 			}
-			
+
 			return properties;
+			// 返回最终生成的 properties 对象
 		},
-		
+
+
 		// EFFECTS SECTION -------------------------------------------------------------------------------------------------------------
-		
-		filters: 		{
+
+		filters: {
 			// None
-			none:			function(){
-				var properties = {};
-				
-				if(typeof polyfilter._ie === 'undefined'){
+			none: function () {
+				var properties = {}; // 初始化一个空对象，用于存储滤镜属性
+
+				if (typeof polyfilter._ie === 'undefined') {
 					// Proposed spec
-					properties['filtersW3C'] = ['none'];
-					
+					properties['filtersW3C'] = ['none']; // 为 W3C 规范的浏览器设置滤镜属性为 'none'
+
 					// Firefox
-					properties['filtersSVG'] = ['none'];
-				}
-				else {
+					properties['filtersSVG'] = ['none']; // 为 Firefox 浏览器设置滤镜属性为 'none'
+				} else {
 					// IE
-					properties['filtersIE'] = ['none'];
+					properties['filtersIE'] = ['none']; // 为 IE 浏览器设置滤镜属性为 'none'
 				}
-				
-				return properties;
+
+				return properties; // 返回包含滤镜属性的对象
 			},
-			
+
 			// Grayscale
-			grayscale:			function(amount){
-				amount = amount || 0;
-				
-				var properties = {};
-				
-				if(typeof polyfilter._ie === 'undefined'){
+			grayscale: function (amount) {
+				amount = amount || 0; // 如果未提供 amount 参数，则默认为 0
+
+				var properties = {}; // 初始化一个空对象，用于存储滤镜属性
+
+				if (typeof polyfilter._ie === 'undefined') {
 					// Proposed spec
-					properties['filtersW3C'] = ['grayscale(' + amount + ')'];
-					
+					properties['filtersW3C'] = ['grayscale(' + amount + ')']; // 为 W3C 规范的浏览器设置灰度滤镜属性
+
 					// Firefox
 					// https://dvcs.w3.org/hg/FXTF/raw-file/tip/filters/index.html
-					var svg_fe1 = polyfilter._create_svg_element('feColorMatrix',{
-						type:	'matrix',
-						values:	(0.2126 + 0.7874 * (1 - amount)) + ' ' 
-							+ (0.7152 - 0.7152 * (1 - amount)) + ' ' 
-							+ (0.0722 - 0.0722 * (1 - amount)) + ' 0 0 ' 
-							+ (0.2126 - 0.2126 * (1 - amount)) + ' ' 
-							+ (0.7152 + 0.2848 * (1 - amount)) + ' ' 
-							+ (0.0722 - 0.0722 * (1 - amount)) + ' 0 0 ' 
-							+ (0.2126 - 0.2126 * (1 - amount)) + ' ' 
-							+ (0.7152 - 0.7152 * (1 - amount)) + ' ' 
+					var svg_fe1 = polyfilter._create_svg_element('feColorMatrix', {
+						type: 'matrix',
+						values: (0.2126 + 0.7874 * (1 - amount)) + ' '
+							+ (0.7152 - 0.7152 * (1 - amount)) + ' '
+							+ (0.0722 - 0.0722 * (1 - amount)) + ' 0 0 '
+							+ (0.2126 - 0.2126 * (1 - amount)) + ' '
+							+ (0.7152 + 0.2848 * (1 - amount)) + ' '
+							+ (0.0722 - 0.0722 * (1 - amount)) + ' 0 0 '
+							+ (0.2126 - 0.2126 * (1 - amount)) + ' '
+							+ (0.7152 - 0.7152 * (1 - amount)) + ' '
 							+ (0.0722 + 0.9278 * (1 - amount)) + ' 0 0 0 0 0 1 0'
 					});
-					properties['filtersSVG'] = [svg_fe1];
-				}
-				else {
+					properties['filtersSVG'] = [svg_fe1]; // 为 Firefox 浏览器设置灰度滤镜属性
+				} else {
 					// IE
-					properties['filtersIE'] = amount >= 0.5 ? ['gray'] : [];
+					properties['filtersIE'] = amount >= 0.5 ? ['gray'] : []; // 根据 amount 值设置 IE 浏览器的灰度滤镜属性
 				}
-				
-				return properties;
+
+				return properties; // 返回包含滤镜属性的对象
 			},
-			
+
 			// Sepia
-			sepia:			function(amount){
-				amount = amount || 0;
-		
-				var properties = {};
-		
-				if(typeof polyfilter._ie === 'undefined'){
-				
+			sepia: function (amount) { // 定义一个名为 sepia 的函数，接受一个参数 amount
+				amount = amount || 0; // 如果未提供 amount 参数，则默认为 0
+
+				var properties = {}; // 初始化一个空对象，用于存储滤镜属性
+
+				if (typeof polyfilter._ie === 'undefined') { // 检查是否在 IE 浏览器中运行
 					// Proposed spec
-					properties['filtersW3C'] = ['sepia(' + amount + ')'];
-					
+					properties['filtersW3C'] = ['sepia(' + amount + ')']; // 为 W3C 规范的浏览器设置滤镜属性为 sepia
+
 					// Firefox
 					// https://dvcs.w3.org/hg/FXTF/raw-file/tip/filters/index.html
-					var svg_fe1 = polyfilter._create_svg_element('feColorMatrix',{
-						type:	'matrix',
-						values:	(0.393 + 0.607 * (1 - amount)) + ' ' 
-							+ (0.769 - 0.769 * (1 - amount)) + ' ' 
-							+ (0.189 - 0.189 * (1 - amount)) + ' 0 0 ' 
-							+ (0.349 - 0.349 * (1 - amount)) + ' ' 
-							+ (0.686 + 0.314 * (1 - amount)) + ' ' 
+					var svg_fe1 = polyfilter._create_svg_element('feColorMatrix', { // 创建一个 feColorMatrix SVG 元素
+						type: 'matrix', // 设置类型为 matrix
+						values: (0.393 + 0.607 * (1 - amount)) + ' '
+							+ (0.769 - 0.769 * (1 - amount)) + ' '
+							+ (0.189 - 0.189 * (1 - amount)) + ' 0 0 '
+							+ (0.349 - 0.349 * (1 - amount)) + ' '
+							+ (0.686 + 0.314 * (1 - amount)) + ' '
 							+ (0.168 - 0.168 * (1 - amount)) + ' 0 0 '
-							+ (0.272 - 0.272 * (1 - amount)) + ' ' 
-							+ (0.534 - 0.534 * (1 - amount)) + ' ' 
-							+ (0.131 + 0.869 * (1 - amount)) + ' 0 0 0 0 0 1 0'
+							+ (0.272 - 0.272 * (1 - amount)) + ' '
+							+ (0.534 - 0.534 * (1 - amount)) + ' '
+							+ (0.131 + 0.869 * (1 - amount)) + ' 0 0 0 0 0 1 0' // 设置颜色矩阵的值
 					});
-					properties['filtersSVG'] = [svg_fe1];
-				}
-				else {
+					properties['filtersSVG'] = [svg_fe1]; // 为 Firefox 浏览器设置滤镜属性为创建的 feColorMatrix 元素
+				} else {
 					// IE
-					properties['filtersIE'] = amount >= 0.5 ? ['gray','progid:DXImageTransform.Microsoft.Light()'] : [];
-					properties['behaviorsIE'] = amount >= 0.5 ? ['url("' + polyfilter.scriptpath + 'htc/sepia.htc")'] : [];
+					properties['filtersIE'] = amount >= 0.5 ? ['gray', 'progid:DXImageTransform.Microsoft.Light()'] : []; // 根据 amount 值设置 IE 浏览器的滤镜属性
+					properties['behaviorsIE'] = amount >= 0.5 ? ['url("' + polyfilter.scriptpath + 'htc/sepia.htc")'] : []; // 根据 amount 值设置 IE 浏览器的行为属性
 				}
-				
-				return properties;
+
+				return properties; // 返回包含滤镜属性的对象
 			},
-			
+
+
 			// Blur
-			blur:			function(amount){
-				amount = Math.round(amount) || 0;
-				
-				var properties = {};
-				
-				if(typeof polyfilter._ie === 'undefined'){
+			blur: function (amount) { // 定义一个名为 blur 的函数，接受一个参数 amount
+				amount = Math.round(amount) || 0; // 将 amount 四舍五入为整数，如果未提供 amount 则默认为 0
+
+				var properties = {}; // 初始化一个空对象，用于存储滤镜属性
+
+				if (typeof polyfilter._ie === 'undefined') { // 检查是否在 IE 浏览器中运行
 					// Proposed spec
-					properties['filtersW3C'] = ['blur(' + amount + 'px)'];
-					
+					properties['filtersW3C'] = ['blur(' + amount + 'px)']; // 为 W3C 规范的浏览器设置滤镜属性为模糊效果
+
 					// Firefox
 					// https://dvcs.w3.org/hg/FXTF/raw-file/tip/filters/index.html
-					var svg_fe1 = polyfilter._create_svg_element('feGaussianBlur',{
-						'in':			'SourceGraphic',
-						stdDeviation: amount
+					var svg_fe1 = polyfilter._create_svg_element('feGaussianBlur', { // 创建一个 feGaussianBlur SVG 元素
+						'in': 'SourceGraphic', // 设置输入源为 SourceGraphic
+						stdDeviation: amount // 设置标准偏差为 amount
 					});
-					properties['filtersSVG'] = [svg_fe1];
-				}
-				else {
+					properties['filtersSVG'] = [svg_fe1]; // 为 Firefox 浏览器设置滤镜属性为创建的 feGaussianBlur 元素
+				} else {
 					// IE
-					properties['filtersIE'] = ['progid:DXImageTransform.Microsoft.Blur(pixelradius=' + amount + ')'];
+					properties['filtersIE'] = ['progid:DXImageTransform.Microsoft.Blur(pixelradius=' + amount + ')']; // 根据 amount 值设置 IE 浏览器的滤镜属性
 				}
-				
-				return properties;
+
+				return properties; // 返回包含滤镜属性的对象
 			},
-			
-			// Invert
-			invert:			function(amount){
-				amount = amount || 0;
-				
-				var properties = {};
-				
-				if(typeof polyfilter._ie === 'undefined'){
+
+// Invert
+			invert: function (amount) { // 定义一个名为 invert 的函数，接受一个参数 amount
+				amount = amount || 0; // 如果未提供 amount 参数，则默认为 0
+
+				var properties = {}; // 初始化一个空对象，用于存储滤镜属性
+
+				if (typeof polyfilter._ie === 'undefined') { // 检查是否在 IE 浏览器中运行
 					// Proposed spec
-					properties['filtersW3C'] = ['invert(' + amount + ')'];
-					
+					properties['filtersW3C'] = ['invert(' + amount + ')']; // 为 W3C 规范的浏览器设置滤镜属性为反转效果
+
 					// Firefox
 					// https://dvcs.w3.org/hg/FXTF/raw-file/tip/filters/index.html
-					var svg_fe1 = polyfilter._create_svg_element('feComponentTransfer',{});
-					var svg_fe1sub = polyfilter._create_svg_element('feFuncR',{
-						type:	'table',
-						tableValues: amount + ' ' + (1 - amount)
+					var svg_fe1 = polyfilter._create_svg_element('feComponentTransfer', {}); // 创建一个 feComponentTransfer SVG 元素
+					var svg_fe1sub = polyfilter._create_svg_element('feFuncR', { // 创建一个 feFuncR 子元素
+						type: 'table', // 设置类型为 table
+						tableValues: amount + ' ' + (1 - amount) // 设置表格值为 amount 和 (1 - amount)
 					});
-					svg_fe1.appendChild(svg_fe1sub);
-					var svg_fe1sub = polyfilter._create_svg_element('feFuncG',{
-						type:	'table',
-						tableValues: amount + ' ' + (1 - amount)
+					svg_fe1.appendChild(svg_fe1sub); // 将 feFuncR 子元素添加到 feComponentTransfer 元素中
+					var svg_fe1sub = polyfilter._create_svg_element('feFuncG', { // 创建一个 feFuncG 子元素
+						type: 'table', // 设置类型为 table
+						tableValues: amount + ' ' + (1 - amount) // 设置表格值为 amount 和 (1 - amount)
 					});
-					svg_fe1.appendChild(svg_fe1sub);
-					var svg_fe1sub = polyfilter._create_svg_element('feFuncB',{
-						type:	'table',
-						tableValues: amount + ' ' + (1 - amount)
+					svg_fe1.appendChild(svg_fe1sub); // 将 feFuncG 子元素添加到 feComponentTransfer 元素中
+					var svg_fe1sub = polyfilter._create_svg_element('feFuncB', { // 创建一个 feFuncB 子元素
+						type: 'table', // 设置类型为 table
+						tableValues: amount + ' ' + (1 - amount) // 设置表格值为 amount 和 (1 - amount)
 					});
-					svg_fe1.appendChild(svg_fe1sub);
-					properties['filtersSVG'] = [svg_fe1];
-				}
-				else {
+					svg_fe1.appendChild(svg_fe1sub); // 将 feFuncB 子元素添加到 feComponentTransfer 元素中
+					properties['filtersSVG'] = [svg_fe1]; // 为 Firefox 浏览器设置滤镜属性为创建的 feComponentTransfer 元素
+				} else {
 					// IE
-					properties['filtersIE'] = amount >= 0.5 ? ['invert'] : [];
+					properties['filtersIE'] = amount >= 0.5 ? ['invert'] : []; // 根据 amount 值设置 IE 浏览器的滤镜属性
 				}
-				
-				return properties;
+
+				return properties; // 返回包含滤镜属性的对象
 			},
-				
+
+
 			// Brightness
-			brightness:			function(amount){
-				amount = amount || 0;
-				
-				var properties = {};
-				
-				if(typeof polyfilter._ie === 'undefined'){
+			brightness: function (amount) { // 定义一个名为 brightness 的函数，接受一个参数 amount
+				amount = amount || 0; // 如果未提供 amount 参数，则默认为 0
+
+				var properties = {}; // 初始化一个空对象，用于存储滤镜属性
+
+				if (typeof polyfilter._ie === 'undefined') { // 检查是否在 IE 浏览器中运行
 					// Proposed spec
-					properties['filtersW3C'] = ['brightness(' + amount + '%)'];
-	
+					properties['filtersW3C'] = ['brightness(' + amount + '%)']; // 为 W3C 规范的浏览器设置滤镜属性为亮度效果
+
 					// WebKit "specialty"
-					properties['filtersWebKit'] = ['brightness(' + (amount - 100) + '%)'];
-					
+					properties['filtersWebKit'] = ['brightness(' + (amount - 100) + '%)']; // 为 WebKit 浏览器设置滤镜属性为亮度效果（特殊处理）
+
 					// Firefox
 					// https://dvcs.w3.org/hg/FXTF/raw-file/tip/filters/index.html
-					var svg_fe1 = polyfilter._create_svg_element('feComponentTransfer',{});
-					var svg_fe1sub = polyfilter._create_svg_element('feFuncR',{
-						type:	'linear',
-						slope: 	amount / 100
+					var svg_fe1 = polyfilter._create_svg_element('feComponentTransfer', {}); // 创建一个 feComponentTransfer SVG 元素
+					var svg_fe1sub = polyfilter._create_svg_element('feFuncR', { // 创建一个 feFuncR 子元素
+						type: 'linear', // 设置类型为线性
+						slope: amount / 100 // 设置斜率为 amount / 100
 					});
-					svg_fe1.appendChild(svg_fe1sub);
-					var svg_fe1sub = polyfilter._create_svg_element('feFuncG',{
-						type:	'linear',
-						slope: 	amount / 100
+					svg_fe1.appendChild(svg_fe1sub); // 将 feFuncR 子元素添加到 feComponentTransfer 元素中
+					var svg_fe1sub = polyfilter._create_svg_element('feFuncG', { // 创建一个 feFuncG 子元素
+						type: 'linear', // 设置类型为线性
+						slope: amount / 100 // 设置斜率为 amount / 100
 					});
-					svg_fe1.appendChild(svg_fe1sub);
-					var svg_fe1sub = polyfilter._create_svg_element('feFuncB',{
-						type:	'linear',
-						slope: 	amount / 100 
+					svg_fe1.appendChild(svg_fe1sub); // 将 feFuncG 子元素添加到 feComponentTransfer 元素中
+					var svg_fe1sub = polyfilter._create_svg_element('feFuncB', { // 创建一个 feFuncB 子元素
+						type: 'linear', // 设置类型为线性
+						slope: amount / 100 // 设置斜率为 amount / 100
 					});
-					svg_fe1.appendChild(svg_fe1sub);
-					properties['filtersSVG'] = [svg_fe1];
-				}
-				else {
+					svg_fe1.appendChild(svg_fe1sub); // 将 feFuncB 子元素添加到 feComponentTransfer 元素中
+					properties['filtersSVG'] = [svg_fe1]; // 为 Firefox 浏览器设置滤镜属性为创建的 feComponentTransfer 元素
+				} else {
 					// IE
-					properties['filtersIE'] = ['progid:DXImageTransform.Microsoft.Light()'];
-					properties['behaviorsIE'] = ['url("' + polyfilter.scriptpath + 'htc/brightness.htc")'];
+					properties['filtersIE'] = ['progid:DXImageTransform.Microsoft.Light()']; // 根据 amount 值设置 IE 浏览器的滤镜属性
+					properties['behaviorsIE'] = ['url("' + polyfilter.scriptpath + 'htc/brightness.htc")']; // 设置 IE 浏览器的行为属性
 				}
-				
-				return properties;
+
+				return properties; // 返回包含滤镜属性的对象
 			},
-				
+
+
 			// Drop Shadow
-			dropShadow:			function(offsetX,offsetY,radius,color){
+			dropShadow: function (offsetX, offsetY, radius, color) {
+				// 将 offsetX 四舍五入为整数，如果未定义则默认为 0
 				offsetX = Math.round(offsetX) || 0;
+				// 将 offsetY 四舍五入为整数，如果未定义则默认为 0
 				offsetY = Math.round(offsetY) || 0;
+				// 将 radius 四舍五入为整数，如果未定义则默认为 0
 				radius = Math.round(radius) || 0;
+				// 如果 color 未定义，则默认为黑色 '#000000'
 				color = color || '#000000';
-				
+
+				// 初始化一个空对象，用于存储滤镜属性
 				var properties = {};
-				
-				if(typeof polyfilter._ie === 'undefined'){
-					// Proposed spec
+
+				// 检查是否在 IE 浏览器中运行
+				if (typeof polyfilter._ie === 'undefined') {
+					// W3C 规范的浏览器设置滤镜属性为 drop-shadow 效果
 					properties['filtersW3C'] = ['drop-shadow(' + offsetX + 'px ' + offsetY + 'px ' + radius + 'px ' + color + ')'];
-					
-					// Firefox
+
+					// Firefox 浏览器设置滤镜属性为 drop-shadow 效果
 					// https://dvcs.w3.org/hg/FXTF/raw-file/tip/filters/index.html
-					var svg_fe1 = polyfilter._create_svg_element('feGaussianBlur',{
-						'in':		'SourceAlpha',
-						stdDeviation: radius
+					// 创建一个 feGaussianBlur SVG 元素，用于模糊效果
+					var svg_fe1 = polyfilter._create_svg_element('feGaussianBlur', {
+						'in': 'SourceAlpha', // 输入源为 alpha 通道
+						stdDeviation: radius // 标准偏差为 radius
 					});
-					var svg_fe2 = polyfilter._create_svg_element('feOffset',{
-						dx:		offsetX + 1,
-						dy:		offsetY + 1,
-						result:	'offsetblur'
+					// 创建一个 feOffset SVG 元素，用于偏移效果
+					var svg_fe2 = polyfilter._create_svg_element('feOffset', {
+						dx: offsetX + 1, // x 轴偏移量
+						dy: offsetY + 1, // y 轴偏移量
+						result: 'offsetblur' // 结果命名为 offsetblur
 					});
-					var svg_fe3 = polyfilter._create_svg_element('feFlood',{
-						'flood-color': color
+					// 创建一个 feFlood SVG 元素，用于填充颜色
+					var svg_fe3 = polyfilter._create_svg_element('feFlood', {
+						'flood-color': color // 填充颜色为 color
 					});
-					var svg_fe4 = polyfilter._create_svg_element('feComposite',{
-						in2:	'offsetblur',
-						operator: 'in'
+					// 创建一个 feComposite SVG 元素，用于合成效果
+					var svg_fe4 = polyfilter._create_svg_element('feComposite', {
+						in2: 'offsetblur', // 第二个输入源为 offsetblur
+						operator: 'in' // 操作符为 in
 					});
-					var svg_fe5 = polyfilter._create_svg_element('feMerge',{});
-					var svg_fe5sub = polyfilter._create_svg_element('feMergeNode',{});
+					// 创建一个 feMerge SVG 元素，用于合并多个滤镜效果
+					var svg_fe5 = polyfilter._create_svg_element('feMerge', {});
+					// 创建第一个 feMergeNode 子元素，并添加到 feMerge 元素中
+					var svg_fe5sub = polyfilter._create_svg_element('feMergeNode', {});
 					svg_fe5.appendChild(svg_fe5sub);
-					var svg_fe5sub = polyfilter._create_svg_element('feMergeNode',{
-						'in':		'SourceGraphic'
+					// 创建第二个 feMergeNode 子元素，并添加到 feMerge 元素中
+					var svg_fe5sub = polyfilter._create_svg_element('feMergeNode', {
+						'in': 'SourceGraphic' // 输入源为 SourceGraphic
 					});
 					svg_fe5.appendChild(svg_fe5sub);
-					properties['filtersSVG'] = [svg_fe1,svg_fe2,svg_fe3,svg_fe4,svg_fe5];
-				}
-				else {
-					// IE
-					properties['filtersIE'] = ['progid:DXImageTransform.Microsoft.Glow(color=' + color + ',strength=0)','progid:DXImageTransform.Microsoft.Shadow(color=' + color + ',strength=0)'];
+					// 将创建的 SVG 元素数组赋值给 filtersSVG 属性
+					properties['filtersSVG'] = [svg_fe1, svg_fe2, svg_fe3, svg_fe4, svg_fe5];
+				} else {
+					// IE 浏览器设置滤镜属性为 Glow 和 Shadow 效果
+					properties['filtersIE'] = ['progid:DXImageTransform.Microsoft.Glow(color=' + color + ',strength=0)', 'progid:DXImageTransform.Microsoft.Shadow(color=' + color + ',strength=0)'];
+					// 设置 IE 浏览器的行为属性
 					properties['behaviorsIE'] = ['url("' + polyfilter.scriptpath + 'htc/drop-shadow.htc")'];
 				}
-				
+
+				// 返回包含滤镜属性的对象
 				return properties;
 			}
 		}
 	}
-
-	// Inialize, either via jQuery...
-	if(window.jQuery){
-		window.jQuery(document).ready(function(e) {
-			polyfilter.process_stylesheets();
+			// Inialize, either via jQuery...
+	if(window.jQuery){ // 检查是否存在全局的 jQuery 对象
+		window.jQuery(document).ready(function(e) { // 如果存在，使用 jQuery 的 ready 方法来确保文档完全加载和解析
+			polyfilter.process_stylesheets(); // 调用 polyfilter 对象的 process_stylesheets 方法处理样式表
 		});
 	}
-	// or via contentLoaded...
-	else if(window.contentLoaded){
-		contentLoaded(window,function(){
-			polyfilter.process_stylesheets();
+// or via contentLoaded...
+	else if(window.contentLoaded){ // 检查是否存在全局的 contentLoaded 函数
+		contentLoaded(window,function(){ // 如果存在，使用 contentLoaded 函数来监听窗口加载事件
+			polyfilter.process_stylesheets(); // 调用 polyfilter 对象的 process_stylesheets 方法处理样式表
 		});
 	}
-	// or on DOM ready / load
-	else {
-		if(window.addEventListener) // W3C standard
+// or on DOM ready / load
+	else { // 如果以上条件都不满足，则使用传统的 DOMContentLoaded 或 onload 事件
+		if(window.addEventListener) // 检查是否支持 W3C 标准的 addEventListener 方法
 		{
-			document.addEventListener('DOMContentLoaded', function(){
-				polyfilter.process_stylesheets();
+			document.addEventListener('DOMContentLoaded', function(){ // 使用 addEventListener 监听 DOMContentLoaded 事件
+				polyfilter.process_stylesheets(); // 调用 polyfilter 对象的 process_stylesheets 方法处理样式表
 			}, false);
-		} 
-		else if(window.attachEvent) // Microsoft
+		}
+		else if(window.attachEvent) // 检查是否支持 Microsoft 的 attachEvent 方法
 		{
-			window.attachEvent('onload', function(){
-				polyfilter.process_stylesheets();
+			window.attachEvent('onload', function(){ // 使用 attachEvent 监听 onload 事件
+				polyfilter.process_stylesheets(); // 调用 polyfilter 对象的 process_stylesheets 方法处理样式表
 			});
 		}
 	}
-	
-	// Install style setters and getters
-	polyfilter.init();
-})(window);
\ No newline at end of file
+
+// Install style setters and getters
+	polyfilter.init(); // 初始化 polyfilter 对象，安装样式设置器和获取器
+})(window); // 立即执行函数表达式 (IIFE)，传入 window 对象作为参数