From ba98978a8b337d69c7a079b5fb35518b7f7c688b Mon Sep 17 00:00:00 2001
From: STT <3315488997@qq.com>
Date: Mon, 28 Apr 2025 23:03:08 +0800
Subject: [PATCH] 'stt'

---
 stt/axios.js        | 1822 ---------------
 stt/iconPickerFa.js |  478 ----
 stt/index.html      |  229 --
 stt/login.html      |  246 --
 stt/main.html       |  287 ---
 stt/org.js          |  120 -
 stt/step.js         |  135 --
 stt/store.js        |   41 -
 stt/treetable.js    |  301 ---
 stt/wangEditor.js   | 5451 -------------------------------------------
 10 files changed, 9110 deletions(-)
 delete mode 100644 stt/axios.js
 delete mode 100644 stt/iconPickerFa.js
 delete mode 100644 stt/index.html
 delete mode 100644 stt/login.html
 delete mode 100644 stt/main.html
 delete mode 100644 stt/org.js
 delete mode 100644 stt/step.js
 delete mode 100644 stt/store.js
 delete mode 100644 stt/treetable.js
 delete mode 100644 stt/wangEditor.js

diff --git a/stt/axios.js b/stt/axios.js
deleted file mode 100644
index 1b6e305..0000000
--- a/stt/axios.js
+++ /dev/null
@@ -1,1822 +0,0 @@
-
-layui.define(['store'], function(exports){
-    // 定义axios模块，版本v0.21.0，作者Matt Zabriskie
-    (function webpackUniversalModuleDefinition(root, factory) {
-        // 模块定义函数，支持CommonJS, AMD和全局变量
-        if(typeof exports === 'object' && typeof module === 'object')
-            module.exports = factory();
-        // 如果是CommonJS环境
-        else if(typeof define === 'function' && define.amd)
-            define([], factory);
-        // 如果是AMD环境
-        else if(typeof exports === 'object')
-            exports["axios"] = factory();
-        // 如果是作为对象导出
-        else
-            root["axios"] = factory();
-        // 如果是全局变量
-    })(this, function() {
-    return  (function(modules) { // webpackBootstrap
-         	// 模块缓存
-        	var installedModules = {};
-        
-        	// 模块加载函数
-        	function __webpack_require__(moduleId) {
-             		// 如果模块已经在缓存中，直接返回模块的导出内容
-             		if(installedModules[moduleId])
-              			return installedModules[moduleId].exports;
-           
-
-                     // 创建一个新的模块对象，并将其存储在installedModules数组中
-                     var module = installedModules[moduleId] = {
-                         // 初始化模块的exports属性为空对象
-                         exports: {},
-                         // 设置模块的id为传入的moduleId
-                         id: moduleId,
-                         // 初始化模块的loaded属性为false，表示模块尚未加载
-                         loaded: false
-                     };
-                    
-           		// 执行模块函数
-             		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
-            
-            		// 标记模块为已加载
-            		module.loaded = true;
-           
-             		// 返回模块的导出内容
-            		return module.exports;
-          	}
-       
-        
-         	// 暴露模块对象 (__webpack_modules__)
-         	__webpack_require__.m = modules;
-       
-         	// 暴露模块缓存
-        	__webpack_require__.c = installedModules;
-       
-         	// 设置公共路径 (__webpack_public_path__)
-       	__webpack_require__.p = "";
-        
-        	// 加载入口模块并返回导出内容
-         	return __webpack_require__(0);
-         })
-        
-         ([
-            /* 0 */
-                  /***/ (function(module, exports, __webpack_require__) {
- 
-                // 将模块1的导出设置为当前模块的导出
-                module.exports = __webpack_require__(1);
- 
-                /***/ }),
-            /* 1 */
-            /***/ (function(module, exports, __webpack_require__) {
- 
-                'use strict';
- 
-                // 引入工具模块
-                var utils = __webpack_require__(2);
-                // 引入绑定函数
-                var bind = __webpack_require__(3);
-                // 引入Axios类
-                var Axios = __webpack_require__(4);
-                // 引入合并配置函数
-                var mergeConfig = __webpack_require__(22);
-                // 引入默认配置
-                var defaults = __webpack_require__(10);
-                
-                function createInstance(defaultConfig) {
-                    // 创建一个 Axios 实例，使用默认配置
-                    var context = new Axios(defaultConfig);
-                    // 将 Axios 的 request 方法绑定到新创建的 context 实例上
-                    var instance = bind(Axios.prototype.request, context);
-
-                    // 将 Axios 原型上的方法复制到 instance 上，同时绑定 context
-                    utils.extend(instance, Axios.prototype, context);
-
-                    // 将 context 的属性复制到 instance 上
-                    utils.extend(instance, context);
-
-                    // 返回新创建的 instance 实例
-                    return instance;
-                }
- 
-                // 创建默认实例以供导出
-                var axios = createInstance(defaults);
- 
-                // 暴露 Axios 类以允许类继承
-                axios.Axios = Axios;
- 
-                // 工厂方法用于创建新实例
-                axios.create = function create(instanceConfig) {
-                    // 创建一个新的axios实例，通过合并默认配置和实例配置
-                    return createInstance(mergeConfig(axios.defaults, instanceConfig));
-                };
-
-                // 暴露Cancel & CancelToken模块
-                axios.Cancel = __webpack_require__(23);
-                // 引入取消请求的功能模块，并赋值给 axios.Cancel
-                
-                axios.CancelToken = __webpack_require__(24);
-                // 引入取消令牌的功能模块，并赋值给 axios.CancelToken
-                
-                axios.isCancel = __webpack_require__(9);
-                // 引入判断是否为取消请求的函数，并赋值给 axios.isCancel
-                
-                // Expose all/spread
-                axios.all = function all(promises) {
-                    // 返回一个 Promise，该 Promise 在所有传入的 promises 都被解决后才会被解决
-                    return Promise.all(promises);
-                };
-                // 将 __webpack_require__(25) 赋值给 axios.spread 方法
-                axios.spread = __webpack_require__(25);
-    
-                // 导出 axios 对象
-                module.exports = axios;
-    
-                // 允许在 TypeScript 中使用默认导入语法
-                module.exports.default = axios;
-                /***/ }),
-            /* 2 */
-                  (function(module, exports, __webpack_require__) {
-                     
-                      'use strict';
-                     
-                      // 引入绑定函数
-                      var bind = __webpack_require__(3);
-                      // utils 是一个包含与 axios 无关的通用辅助函数的库
-                  
-                      // 获取 Object.prototype.toString 方法的引用
-                      var toString = Object.prototype.toString;
-                  
-
-                      function isArray(val) {
-                          // 使用 Object.prototype.toString 方法判断值的类型是否为 '[object Array]'
-                          return toString.call(val) === '[object Array]';
-                      }
- 
-               
-                function isUndefined(val) {
-                    // 判断传入的值是否为未定义类型
-                    return typeof val === 'undefined';
-                }
-
-                 function isBuffer(val) {
-                     // 检查传入的值是否为 Buffer 类型
-                     // 首先确保 val 不为 null，并且 val 不是 undefined
-                     return val !== null && !isUndefined(val) 
-                         // 确保 val.constructor 不为 null，并且 val.constructor 不是 undefined
-                         && val.constructor !== null && !isUndefined(val.constructor)
-                         // 确保 val.constructor.isBuffer 是一个函数
-                         && typeof val.constructor.isBuffer === 'function' 
-                         // 调用 val.constructor.isBuffer 方法来验证 val 是否为 Buffer 类型
-                         && val.constructor.isBuffer(val);
-                 }
-
-                 
-                // 判断给定的值是否为 ArrayBuffer 对象
-                function isArrayBuffer(val) {
-                    // 使用Object.prototype.toString方法判断传入的值是否为ArrayBuffer类型
-                    return toString.call(val) === '[object ArrayBuffer]';
-                }
-                
-                function isFormData(val) {
-                    // 判断传入的值是否为 FormData 类型
-                    return (typeof FormData !== 'undefined') && (val instanceof FormData);
-                }
-                
-                function isArrayBufferView(val) {
-                    // 判断传入的值是否为 ArrayBufferView 类型
-                    var result;
-                    if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {
-                        // 使用ArrayBuffer.isView方法判断值是否为ArrayBuffer视图对象
-                        result = ArrayBuffer.isView(val);
-                    } else {
-                        // 如果ArrayBuffer.isView方法不可用，则通过检查值的buffer属性是否为ArrayBuffer实例来判断
-                        result = (val) && (val.buffer) && (val.buffer instanceof ArrayBuffer);
-                    }
-                    return result;
-                }
-
-                 function isString(val) {
-                     // 判断传入的值是否为字符串类型
-                     return typeof val === 'string';
-                 }
-                 
-                 function isNumber(val) {
-                     // 检查传入的值是否为数字类型
-                     return typeof val === 'number';
-                 }
-                 
-                 function isObject(val) {
-                     // 检查传入的值是否为对象且不为null
-                     return val !== null && typeof val === 'object';
-                 }
-                 
-                 function isPlainObject(val) {
-                     // 检查 val 是否是一个普通的对象
-                     if (toString.call(val) !== '[object Object]') {
-                         return false;
-                     }
-                 
-                     // 获取 val 的原型对象
-                     var prototype = Object.getPrototypeOf(val);
-                     // 检查原型对象是否为 null 或 Object.prototype
-                     return prototype === null || prototype === Object.prototype;
-                 }
-               
-                function isDate(val) {
-                    // 检查输入的值是否为 Date 对象
-                    return toString.call(val) === '[object Date]';
-                }
-                
-                function isFile(val) {
-                    // 检查传入的值是否为 File 对象
-                    return toString.call(val) === '[object File]';
-                }
-                
-                function isBlob(val) {
-                    // 检查传入的值是否为 Blob 对象
-                    return toString.call(val) === '[object Blob]';
-                }
-                
-                function isFunction(val) {
-                    // 检查给定的值是否为函数
-                    return toString.call(val) === '[object Function]';
-                }
-                
-                function isStream(val) {
-                    // 检查给定的值是否为一个包含 pipe 方法的对象
-                    return isObject(val) && isFunction(val.pipe);
-                }
-                
-                function isURLSearchParams(val) {
-                    // 检查 URLSearchParams 是否在全局作用域中定义，并且 val 是否是 URLSearchParams 的实例
-                    return typeof URLSearchParams !== 'undefined' && val instanceof URLSearchParams;
-                }
-                
-                function trim(str) {
-                    // 移除字符串开头和结尾的空白字符
-                    return str.replace(/^\s*/, '').replace(/\s*$/, '');
-                }
- 
-               
-                function isStandardBrowserEnv() {
-                    // 检查是否在非标准浏览器环境中运行，如 ReactNative, NativeScript, NS
-                    if (typeof navigator !== 'undefined' && (navigator.product === 'ReactNative' ||
-                        navigator.product === 'NativeScript' ||
-                        navigator.product === 'NS')) {
-                        return false; // 如果是非标准环境，返回 false
-                    }
-                    // 确认是否在标准浏览器环境中，通过检查 window 和 document 对象是否存在
-                    return (
-                        typeof window !== 'undefined' &&
-                        typeof document !== 'undefined'
-                    );
-                }
-
-               
-                                function forEach(obj, fn) {
-                                    // 不处理如果提供的值为空
-                                    if (obj === null || typeof obj === 'undefined') {
-                                        return;
-                                    }
-                                
-                                    // 如果不是可迭代的对象，强制转换为数组
-                                    if (typeof obj !== 'object') {
-                                        /*eslint no-param-reassign:0*/
-                                        obj = [obj];
-                                    }
-
-                    if (isArray(obj)) {
-                        // 遍历数组中的每个值
-                        for (var i = 0, l = obj.length; i < l; i++) {
-                            // 调用传入的函数，参数为当前元素、索引和整个数组
-                            fn.call(null, obj[i], i, obj);
-                        }
-                    } else {
-                        // 遍历对象的每个键
-                        for (var key in obj) {
-                            // 确保对象自身包含该属性，而不是从原型链继承的属性
-                            if (Object.prototype.hasOwnProperty.call(obj, key)) {
-                                // 调用传入的函数，参数为当前属性值、键和整个对象
-                                fn.call(null, obj[key], key, obj);
-                            }
-                        }
-                    }
-
-               
-                function merge(/* obj1, obj2, obj3, ... */) {
-                    // 初始化结果对象
-                    var result = {};
-                
-                    // 定义一个函数来处理每个键值对的合并逻辑
-                    function assignValue(val, key) {
-                        if (isPlainObject(result[key]) && isPlainObject(val)) {
-                            // 如果结果对象和当前值都是普通对象，则递归合并
-                            result[key] = merge(result[key], val);
-                        } else if (isPlainObject(val)) {
-                            // 如果当前值是普通对象，则将其深度复制到结果对象中
-                            result[key] = merge({}, val);
-                        } else if (isArray(val)) {
-                            // 如果当前值是数组，则将其浅复制到结果对象中
-                            result[key] = val.slice();
-                        } else {
-                            // 否则直接赋值
-                            result[key] = val;
-                        }
-                    }
-                
-                    // 遍历所有传入的对象，并调用assignValue函数来合并它们的属性
-                    for (var i = 0, l = arguments.length; i < l; i++) {
-                        forEach(arguments[i], assignValue);
-                    }
-                    // 返回合并后的结果对象
-                    return result;
-                }
-
-                
-                function extend(a, b, thisArg) {
-                    // 遍历对象b的每个属性，并将其合并到对象a中
-                    // 如果thisArg存在且属性值是函数，则将该函数绑定到thisArg
-                    forEach(b, function assignValue(val, key) {
-                        // 如果thisArg存在并且当前属性值是函数类型
-                        if (thisArg && typeof val === 'function') {
-                            // 将函数绑定到thisArg并赋值给对象a的对应属性
-                            a[key] = bind(val, thisArg);
-                        } else {
-                            // 否则直接将属性值赋值给对象a的对应属性
-                            a[key] = val;
-                        }
-                    });
-                    // 返回合并后的对象a
-                    return a;
-                }
- 
-               
-                function stripBOM(content) {
-                    // 检查字符串的第一个字符是否为UTF-8 BOM的标记
-                    // 如果是，则移除该标记
-                    if (content.charCodeAt(0) === 0xFEFF) {
-                        content = content.slice(1);
-                    }
-                    // 返回处理后的字符串
-                    return content;
-                }
-
-                module.exports = {
-                    // 判断变量是否为数组
-
-                    isArray: isArray,
-                    // 判断变量是否为ArrayBuffer
-                    isArrayBuffer: isArrayBuffer,
-                    // 判断变量是否为Buffer
-                    isBuffer: isBuffer,
-                    // 判断变量是否为FormData
-                    isFormData: isFormData,
-                    // 判断变量是否为ArrayBufferView
-                    isArrayBufferView: isArrayBufferView,
-                    // 判断变量是否为字符串
-                    isString: isString,
-                    // 判断变量是否为数字
-                    isNumber: isNumber,
-                    // 判断变量是否为对象
-                    isObject: isObject,
-                    // 判断变量是否为普通对象
-                    isPlainObject: isPlainObject,
-                    // 判断变量是否为未定义
-                    isUndefined: isUndefined,
-                    // 判断变量是否为日期对象
-                    isDate: isDate,
-                    // 判断变量是否为文件对象
-                    isFile: isFile,
-                    // 判断变量是否为Blob对象
-                    isBlob: isBlob,
-                    // 判断变量是否为函数
-                    isFunction: isFunction,
-                    // 判断变量是否为流对象
-                    isStream: isStream,
-                    // 判断变量是否为URLSearchParams对象
-                    isURLSearchParams: isURLSearchParams,
-                    // 判断当前环境是否为标准浏览器环境
-                    isStandardBrowserEnv: isStandardBrowserEnv,
-                    // 遍历数组或对象
-                    forEach: forEach,
-                    // 合并多个对象到一个对象
-                    merge: merge,
-                    // 扩展目标对象的属性
-                    extend: extend,
-                    // 去除字符串两端的空白字符
-                    trim: trim,
-                    // 去除字符串开头的BOM字符
-                    stripBOM: stripBOM
-                }
-
-                /***/ }
-                      /* 3 */
-                      /***/ (function(module, exports) {
-
-                          'use strict';
-
-                          // 定义一个名为 bind 的函数，接收两个参数：fn (要绑定的函数) 和 thisArg (要绑定的 this 上下文)
-                          module.exports = function bind(fn, thisArg) {
-                              // 返回一个新的函数 wrap，该函数在调用时会将 fn 的 this 指向 thisArg，并传递所有参数
-                              return function wrap() {
-                                  // 创建一个数组 args，长度与调用 wrap 时传递的参数数量相同
-                                  var args = new Array(arguments.length);
-                                  // 将 wrap 函数接收到的所有参数复制到 args 数组中
-                                  for (var i = 0; i < args.length; i++) {
-                                      args[i] = arguments[i];
-                                  }
-                                  // 使用 apply 方法调用 fn，使其 this 指向 thisArg，并传递 args 数组中的参数
-                                  return fn.apply(thisArg, args);
-                              };
-                          };
-
-
-                          /***/ }),
-            /* 4 */
-                  (function(module, exports, __webpack_require__) {
-                                  // 使用严格模式
-                                  'use strict';
-                    
-                                  var utils = __webpack_require__(2); // 引入工具函数模块
-                                  var buildURL = __webpack_require__(5); // 引入构建URL的模块
-                                  var InterceptorManager = __webpack_require__(6); // 引入拦截器管理模块
-                                  var dispatchRequest = __webpack_require__(7); // 引入发送请求的模块
-                                  var mergeConfig = __webpack_require__(22); // 引入合并配置的模块
-                  
-                                  function Axios(instanceConfig) {
-                                      // 初始化 Axios 实例，默认配置为 instanceConfig
-                                      this.defaults = instanceConfig;
-                                      // 创建拦截器管理对象，包含请求和响应拦截器
-                                      this.interceptors = {
-                                          request: new InterceptorManager(),
-                                          response: new InterceptorManager(),
-
-
-
-
-                Axios:prototype.request = function request(config) {
-
-                    // 允许使用 axios('example/url'[, config]) 类似于 fetch API
-                    if (typeof config === 'string') {
-                        // 如果传入的参数是字符串，则将其视为 URL，并从第二个参数中获取配置对象
-                        config = arguments[1] || {};
-                        // 将第一个参数设置为 URL
-                        config.url = arguments[0];
-                    } else {
-                        // 如果传入的参数不是字符串，则直接使用该对象作为配置
-                        config = config || {};
-                    }
-                    // 合并默认配置和传入的配置
-                    config = mergeConfig(this.defaults, config);
-
-                    // 设置 config.method
-                    // 确保请求方法为小写形式，若config中未定义，则使用默认方法，最后默认为'get'方法
-                    // 根据配置设置请求方法，若未提供则使用默认值 'get'
-                    if (config.method) {
-                        // 将请求方法转换为小写
-                        config.method = config.method.toLowerCase();
-                    } else if (this.defaults.method) {
-                        // 使用默认配置中的请求方法，并将其转换为小写
-                        config.method = this.defaults.method.toLowerCase();
-                    } else {
-                        // 如果没有提供请求方法，则默认使用 'get' 方法
-                        config.method = 'get';
-                    }
-
-                    // 初始化拦截器链，包含请求处理函数和未定义的占位符
-                    var chain = [dispatchRequest, undefined];
-                    // 创建一个已解决的Promise对象，初始值为config
-                    var promise = Promise.resolve(config);
-
-                    // 将请求拦截器添加到链的开头
-                    this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
-                        // 将每个请求拦截器的fulfilled和rejected方法插入到链的开头
-                        chain.unshift(interceptor.fulfilled, interceptor.rejected);
-                    });
-
-                    // 将响应拦截器添加到链的末尾
-                    this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
-                        // 将每个响应拦截器的fulfilled和rejected方法插入到链的末尾
-                        chain.push(interceptor.fulfilled, interceptor.rejected);
-                    });
-
-                    // 依次执行链中的每个拦截器
-                    while (chain.length) {
-                        // 从链中移除并执行第一个拦截器，并将其结果作为新的promise继续链式调用
-                        promise = promise.then(chain.shift(), chain.shift());
-                    }
-                    // 返回最终的promise对象
-                    return promise;
-
-                // 获取请求的 URI
-                Axios.prototype.getUri = function getUri(config) {
-                    // 合并默认配置和传入的配置
-                    config = mergeConfig(this.defaults, config);
-                    // 构建 URL，并移除开头的问号
-                    return buildURL(config.url, config.params, config.paramsSerializer).replace(/^\?/, '');
-                };
-
-                // 为没有请求体的方法提供别名
-                utils.forEach(['delete', 'get', 'head', 'options'], function forEachMethodNoData(method) {
-                    /*eslint func-names:0*/
-                    // 定义Axios原型上的方法，如delete, get, head, options
-                    Axios.prototype[method] = function(url, config) {
-                        // 调用request方法，并合并配置对象
-                        return this.request(mergeConfig(config || {}, {
-                            // 设置HTTP方法
-                            method: method,
-                            // 设置请求的URL
-                            url: url,
-                            // 设置请求的数据，如果config存在则使用其data属性
-                            data: (config || {}).data
-                        }));
-                    };
-                });
-
-                utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
-                    /*eslint func-names:0*/
-                    // 为 Axios 原型添加 post, put, patch 方法，这些方法接受 url, data 和 config 参数并返回请求结果
-                    Axios.prototype[method] = function(url, data, config) {
-                        // 调用 this.request 方法，传入合并后的 config 对象，该对象包含 method, url 和 data 属性
-                        return this.request(mergeConfig(config || {}, {
-                            method: method, // 设置请求方法为当前遍历到的方法（post, put, patch）
-                            url: url, // 设置请求的 URL
-                            data: data // 设置请求的数据
-                        }));
-                    };
-                });
-
-                // 导出 Axios 对象
-                module.exports = Axios;
-
-            /* 5 */
-            (function(module, exports, __webpack_require__) {
-                // 使用严格模式，避免一些常见的错误
-                'use strict';
-
-                // 引入utils模块
-                var utils = __webpack_require__(2);
-
-                /**
-                 * 对输入值进行 URL 编码，并替换特定的百分比编码为对应的字符
-                 * @param {string} val - 需要编码的字符串
-                 * @returns {string} - 编码后的字符串
-                 */
-                function encode(val) {
-                    // 使用encodeURIComponent对字符串进行URL编码
-                    return encodeURIComponent(val).
-                    // 将%3A替换为:
-                    replace(/%3A/gi, ':').
-                    // 将%24替换为$
-                    replace(/%24/g, '$').
-                    // 将%2C替换为,
-                    replace(/%2C/gi, ',').
-                    // 将%20替换为+
-                    replace(/%20/g, '+').
-                    // 将%5B替换为[
-                    replace(/%5B/gi, '[').
-                    // 将%5D替换为]
-                    replace(/%5D/gi, ']');
-                }
-
-
-                module.exports = function buildURL(url, params, paramsSerializer) {
-                    /*eslint no-param-reassign:0*/
-                    // 如果没有参数，直接返回原始URL
-                    if (!params) {
-                        return url;
-                    }
-
-                    var serializedParams;
-                    // 如果提供了参数序列化函数，则使用它
-                    if (paramsSerializer) {
-                        serializedParams = paramsSerializer(params);
-                    // 否则，检查参数是否是URLSearchParams对象
-                    } else if (utils.isURLSearchParams(params)) {
-                        serializedParams = params.toString();
-                    // 如果不是，则手动序列化参数
-                    } else {
-                        var parts = [];
-
-                        // 遍历参数对象，将其序列化为查询字符串
-                        utils.forEach(params, function serialize(val, key) {
-                            // 忽略null或undefined的值
-                            if (val === null || typeof val === 'undefined') {
-                                return;
-                            }
-
-                            // 如果值是数组，则键名后加上'[]'
-                            if (utils.isArray(val)) {
-                                key = key + '[]';
-                            // 否则，将值转换为数组
-                            } else {
-                                val = [val];
-                            }
-                            // 遍历数组中的每个值，进行编码并添加到parts数组中
-                            utils.forEach(val, function parseValue(v) {
-                                // 如果值是日期类型，将其转换为ISO字符串格式
-                                if (utils.isDate(v)) {
-                                    v = v.toISOString();
-                                }
-                                // 如果值是对象类型，将其转换为JSON字符串
-                                else if (utils.isObject(v)) {
-                                    v = JSON.stringify(v);
-                                }
-                                // 将键和值进行URL编码后，以"key=value"的形式添加到parts数组中
-                                parts.push(encode(key) + '=' + encode(v));
-                            });
-                        });
-                        // 将所有部分用'&'连接，形成完整的查询字符串
-                        serializedParams = parts.join('&');
-                    }
-                    if (serializedParams) {
-                        // 检查 URL 中是否包含哈希标记 (#)，如果包含则移除哈希标记后的所有内容
-                        var hashmarkIndex = url.indexOf('#');
-                        if (hashmarkIndex !== -1) {
-                            url = url.slice(0, hashmarkIndex);
-                        }
-
-                        // 将序列化后的参数附加到 URL 上，如果 URL 中已经包含查询参数，则使用 & 连接，否则使用 ? 连接
-                        url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;
-                    }
-
-                    // 返回处理后的 URL
-                    return url;
-                };
-
-                /***/ }),
-            /* 6 */
-            (function(module, exports, __webpack_require__) {
-            
-                'use strict'; // 启用严格模式，以捕获常见的编码错误和不安全的操作
-                // 引入utils模块，用于提供通用的工具函数
-                var utils = __webpack_require__(2);
-
-
-                function InterceptorManager() {
-                    // 初始化一个空数组，用于存储拦截器处理程序
-                    this.handlers = [];
-                }
-
-
-                InterceptorManager.prototype.use = function use(fulfilled, rejected) {
-                    // 将拦截器添加到处理程序堆栈中
-                    this.handlers.push({
-                        fulfilled: fulfilled,
-                        rejected: rejected
-                    });
-                    // 返回拦截器的ID，即堆栈中的索引
-                    return this.handlers.length - 1;
-                };
-
-
-                InterceptorManager.prototype.eject = function eject(id) {
-                    // 如果给定ID的拦截器存在，则将其设置为null以标记为已移除
-                    if (this.handlers[id]) {
-                        this.handlers[id] = null;
-                    }
-                };
-
-                InterceptorManager.prototype.forEach = function forEach(fn) {
-                    // 遍历拦截器管理器中的所有处理器，并对每个非空处理器执行给定的函数 fn
-                    utils.forEach(this.handlers, function forEachHandler(h) {
-                        if (h !== null) {
-                            fn(h);
-                        }
-                    });
-                };
-
-                  module.exports = InterceptorManager;
-                // 导出拦截器管理器类/构造函数，用于管理请求和响应的拦截器
-                /***/ }),
-            /* 7 */
-                  /***/ (function(module, exports, __webpack_require__) {
-
-                'use strict';
-
-                // 引入工具模块
-                var utils = __webpack_require__(2);
-                // 引入数据转换模块
-                var transformData = __webpack_require__(8);
-                // 引入取消请求判断模块
-                var isCancel = __webpack_require__(9);
-                // 引入默认配置模块
-                var defaults = __webpack_require__(10);
-
-                function throwIfCancellationRequested(config) {
-                    // 如果配置中存在取消令牌，则检查是否已请求取消，如果是则抛出异常
-                    if (config.cancelToken) {
-                        config.cancelToken.throwIfRequested();
-                    }
-                }
-
-                module.exports = function dispatchRequest(config) {
-                    // 检查请求是否已被取消，如果取消则抛出异常
-                    throwIfCancellationRequested(config);
-
-                    // 确保请求头存在
-                    config.headers = config.headers || {};
-
-                    // 转换请求数据
-                    config.data = transformData(
-                        config.data,
-                        config.headers,
-                        config.transformRequest
-                    );
-                }
-
-                // 合并通用请求头和特定方法的请求头
-                config.headers = utils.merge(
-                    // 获取通用请求头，如果不存在则使用空对象
-                    config.headers.common || {},
-                    // 获取特定方法的请求头，如果不存在则使用空对象
-                    config.headers[config.method] || {},
-                    // 获取所有请求头
-                    config.headers
-                );
-
-                // 清理请求头中与HTTP方法无关的配置
-                utils.forEach(
-                    ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],
-                    function cleanHeaderConfig(method) {
-                        // 删除配置对象中的指定HTTP方法的头部信息
-                        delete config.headers[method];
-                    }
-                );
-                // 获取配置中的适配器，如果没有则使用默认适配器
-                var adapter = config.adapter || defaults.adapter;
-
-                // 使用配置的适配器或默认适配器发送请求，并处理响应
-                return adapter(config).then(function onAdapterResolution(response) {
-                    // 检查是否取消请求
-                    throwIfCancellationRequested(config);
-
-                    // 转换响应数据
-                    response.data = transformData(
-                        // 调用transformData函数，将响应数据进行转换
-                        response.data,
-                        // 传递响应头信息
-                        response.headers,
-                        // 传递配置中的transformResponse选项
-                        config.transformResponse
-                    );
-                    // 返回响应
-                    return response;
-                }, function onAdapterRejection(reason) {
-                    // 如果错误原因不是取消请求，则进一步处理
-                    if (!isCancel(reason)) {
-                        // 检查是否请求被取消，如果是则抛出异常
-                        throwIfCancellationRequested(config);
-
-                        // 检查是否存在reason对象及其response属性
-                        if (reason && reason.response) {
-                            // 调用transformData函数，将响应数据、响应头和配置中的transformResponse进行转换
-                            reason.response.data = transformData(
-                                reason.response.data, // 原始响应数据
-                                reason.response.headers, // 响应头信息
-                                config.transformResponse // 配置中的transformResponse函数
-                            );
-                        }
-                    }
-
-                    return Promise.reject(reason);
-                });
-            };
-
-
-            /* 8 */
-                  /***/ (function(module, exports, __webpack_require__) {
-
-                'use strict';
-
-                var utils = __webpack_require__(2);
-
-                // 定义一个用于转换数据的函数，接受数据、头部信息和函数数组作为参数
-                module.exports = function transformData(data, headers, fns) {
-                    /*eslint no-param-reassign:0*/
-                    // 遍历传入的函数数组，依次对数据和头部信息进行处理
-                    utils.forEach(fns, function transform(fn) {
-                        data = fn(data, headers);
-                    });
-
-                    // 返回处理后的数据
-                    return data;
-                };
-
-                /***/ }),
-            /* 9 */
-            (function(module, exports) {
-                'use strict';
-
-                // 检查给定的值是否是一个取消操作的标记
-                module.exports = function isCancel(value) {
-                    // 如果值存在且具有 __CANCEL__ 属性，则返回 true；否则返回 false
-                    return !!(value && value.__CANCEL__);
-                };
-
-
-                /***/ }),
-            /* 10 */
-            (function(module, exports, __webpack_require__) {
-
-                'use strict';
-
-                // 引入 utils 模块
-                var utils = __webpack_require__(2);
-                // 引入 normalizeHeaderName 模块
-                var normalizeHeaderName = __webpack_require__(11);
-
-                // 定义默认的内容类型
-                var DEFAULT_CONTENT_TYPE = {
-                    'Content-Type': 'application/x-www-form-urlencoded'
-                };
-
-                function setContentTypeIfUnset(headers, value) {
-                    // 如果 headers 不是未定义且 headers 中没有设置 'Content-Type'，则设置 'Content-Type' 为指定的 value
-                    if (!utils.isUndefined(headers) && utils.isUndefined(headers['Content-Type'])) {
-                        headers['Content-Type'] = value;
-                    }
-                }
-
-                function getDefaultAdapter() {
-                    var adapter;
-                    // 检查是否在浏览器环境中，如果是则使用 XHR 适配器
-                    if (typeof XMLHttpRequest !== 'undefined') {
-                        adapter = __webpack_require__(12);
-                    } else if (typeof process !== 'undefined' && Object.prototype.toString.call(process) === '[object process]') {
-                        // 检查是否在 Node 环境中，如果是则使用 HTTP 适配器
-                        adapter = __webpack_require__(12);
-                    }
-                    return adapter;
-                }
-
-                var defaults = {
-                    // 获取默认的适配器
-                    adapter: getDefaultAdapter(),
-
-                    // transformRequest 是一个数组，包含一个函数，该函数用于在请求发送之前对请求数据进行转换
-                    transformRequest: [function transformRequest(data, headers) {
-                        // 标准化请求头名称为 'Accept'
-                        normalizeHeaderName(headers, 'Accept');
-                        // 标准化请求头名称为 'Content-Type'
-                        normalizeHeaderName(headers, 'Content-Type');
-                        // 如果数据是 FormData、ArrayBuffer、Buffer、Stream、File 或 Blob 类型，直接返回数据
-                        // 检查数据是否为FormData对象
-                        if (utils.isFormData(data) ||
-                            // 检查数据是否为ArrayBuffer对象
-                            utils.isArrayBuffer(data) ||
-                            // 检查数据是否为Buffer对象
-                            utils.isBuffer(data) ||
-                            // 检查数据是否为Stream对象
-                            utils.isStream(data) ||
-                            // 检查数据是否为File对象
-                            utils.isFile(data) ||
-                            // 检查数据是否为Blob对象
-                            utils.isBlob(data)
-                        ) {
-                            // 如果数据是上述任何一种类型，直接返回数据
-                            return data;
-                        }
-                        // 如果数据是 ArrayBufferView 类型，返回其 buffer
-                        if (utils.isArrayBufferView(data)) {
-                            // 如果数据是 ArrayBufferView 类型，返回其底层的 ArrayBuffer
-                            return data.buffer;
-                        }
-                        // 如果数据是 URLSearchParams 类型，设置默认的 'Content-Type' 并返回数据的字符串形式
-                        if (utils.isURLSearchParams(data)) {
-                            setContentTypeIfUnset(headers, 'application/x-www-form-urlencoded;charset=utf-8');
-                            return data.toString();
-                        }
-                        // 如果数据是对象类型，设置默认的 'Content-Type' 并返回数据的 JSON 字符串形式
-                        if (utils.isObject(data)) {
-                            setContentTypeIfUnset(headers, 'application/json;charset=utf-8');
-                            return JSON.stringify(data);
-                        }
-                        // 对于其他类型的数据，直接返回数据
-                        return data;
-                        }],
-                        };
-
-                    transformResponse: [function transformResponse(data) {
-                                            // 如果响应数据是字符串类型，尝试将其解析为 JSON 对象
-                                            /*eslint no-param-reassign:0*/
-                                            if (typeof data === 'string') {
-                                                try {
-                                                    // 尝试将字符串解析为 JSON 对象
-                                                    data = JSON.parse(data);
-                                                } catch (e) {
-                                                    // 如果解析失败，忽略错误并保持原样
-                                                    /* Ignore */
-                                                }
-                                            }
-                                            // 返回处理后的数据
-                                            return data;
-                                        }],
-
-                     // 设置请求的超时时间，单位为毫秒
-                    timeout:0,
-                    // 定义 XSRF Token 的 Cookie 名称
-                    xsrfCookieName: 'XSRF-TOKEN',
-                    // 定义 XSRF Token 的请求头名称
-                    xsrfHeaderName: 'X-XSRF-TOKEN',
-
-                    // 定义响应内容的最大长度，-1 表示无限制
-                    maxContentLength: -1,
-                    // 定义请求体的最大长度，-1 表示无限制
-                    maxBodyLength: -1,
-// 定义一个函数来验证 HTTP 响应状态码是否在成功范围内
-validateStatus: function validateStatus(status) {
-    // 如果状态码大于等于200且小于300，则返回true，表示请求成功
-    return status >= 200 && status < 300;
-}
-
-                // 设置默认的请求头信息，包括通用的 'Accept' 头部
-                defaults.headers = {
-                    common: {
-                        'Accept': 'application/json, text/plain, */*'
-                    }
-                };
-
-                // 为 'delete', 'get', 'head' 方法设置空的头部信息
-                utils.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) {
-                    // 初始化这些方法的头部信息为空对象
-                    defaults.headers[method] = {};
-                });
-
-                // 为 'post', 'put', 'patch' 方法设置默认的内容类型头部信息
-                utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
-                    // 合并默认的内容类型头部信息到这些方法的头部中
-                    defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE);
-                });
-/**
- * 导出defaults模块，使其可以在其他文件中被引用和使用。
- */
-module.exports = defaults;
-
-
-                /***/ }),
-            /* 11 */
-            (function(module, exports, __webpack_require__) {
-
-                'use strict';
-
-                // 引入utils模块
-                var utils = __webpack_require__(2);
-
-                module.exports = function normalizeHeaderName(headers, normalizedName) {
-                    // 遍历headers对象中的每一个键值对
-                    utils.forEach(headers, function processHeader(value, name) {
-                        // 如果当前头部名称与规范化名称不同且不区分大小写相同
-                        if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) {
-                            // 将当前头部的值赋给规范化名称
-                            headers[normalizedName] = value;
-                            // 删除原来的头部名称
-                            delete headers[name];
-                        }
-                    });
-                };
-
-
-               (function(module, exports, __webpack_require__) {
-
-                   'use strict';
-
-                   // 引入工具模块，用于提供各种实用函数
-                   var utils = __webpack_require__(2);
-                   // 引入处理请求结果的模块，用于处理请求完成后的操作
-                   var settle = __webpack_require__(13);
-                   // 引入处理 cookies 的模块，用于操作和管理 cookies
-                   var cookies = __webpack_require__(16);
-                   // 引入构建 URL 的模块，用于生成完整的请求 URL
-                   var buildURL = __webpack_require__(5);
-                   // 引入构建完整请求路径的模块，用于生成包含查询参数和哈希的完整路径
-                   var buildFullPath = __webpack_require__(17);
-                   // 引入解析响应头的模块，用于将响应头字符串解析为对象
-                   var parseHeaders = __webpack_require__(20);
-                   // 引入判断请求是否为同源的模块，用于检查请求是否与当前页面同源
-                   var isURLSameOrigin = __webpack_require__(21);
-                   // 引入创建错误的模块，用于生成错误对象
-                   var createError = __webpack_require__(14);
-
-                // 定义 xhr 适配器函数
-                module.exports = function xhrAdapter(config) {
-                    // 返回一个新的 Promise 实例
-                    return new Promise(function dispatchXhrRequest(resolve, reject) {
-                        // 获取请求数据
-                        var requestData = config.data;
-                        // 获取请求头
-                        var requestHeaders = config.headers;
-
-                        // 如果请求数据是 FormData 类型，删除 Content-Type 请求头，让浏览器自动设置
-                        if (utils.isFormData(requestData)) {
-                            delete requestHeaders['Content-Type'];
-                        }
-
-                        // 创建一个新的 XMLHttpRequest 实例
-                        var request = new XMLHttpRequest();
-                        // 如果配置中包含认证信息，则设置 HTTP basic authentication
-                        if (config.auth) {
-                            var username = config.auth.username || '';
-                            var password = config.auth.password ? unescape(encodeURIComponent(config.auth.password)) : '';
-                            requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password);
-                        }
-
-                        // 构建完整的请求路径
-                        var fullPath = buildFullPath(config.baseURL, config.url);
-                        request.open(config.method.toUpperCase(), buildURL(fullPath, config.params, config.paramsSerializer), true);
-
-                        // 设置请求的超时时间（毫秒）
-                        request.timeout = config.timeout;
-
-                        // 定义请求状态改变时的处理函数
-                        request.onreadystatechange = function handleLoad() {
-                            // 如果请求未完成或不存在，则返回
-                            if (!request || request.readyState !== 4) {
-                                return;
-                            }
-
-                            // 处理请求错误情况，状态为0且非file协议时处理
-                            if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) {
-                                return;
-                            }
-
-                            // 准备响应数据
-                            // 检查 request 对象中是否存在 getAllResponseHeaders 方法，如果存在则解析响应头，否则返回 null
-                            var responseHeaders = 'getAllResponseHeaders' in request ? parseHeaders(request.getAllResponseHeaders()) : null;
-
-                            // 根据配置的 responseType 决定使用 responseText 还是 response 作为响应数据
-                            var responseData = !config.responseType || config.responseType === 'text' ? request.responseText : request.response;
-
-                            // 构建响应对象，包含响应数据、状态码、状态文本、响应头、配置和请求对象
-                            var response = {
-                                // 响应数据
-                                data: responseData,
-                                // HTTP 状态码
-                                status: request.status,
-                                // HTTP 状态文本
-                                statusText: request.statusText,
-                                // 响应头信息
-                                headers: responseHeaders,
-                                // 请求的配置信息
-                                config: config,
-                                // 原始请求对象
-                                request: request
-                            };
-
-                            settle(resolve, reject, response);
-
-                            // 清理请求对象
-                            request = null;
-                        };
-
-                        // 处理浏览器请求取消（非手动取消）
-                        request.onabort = function handleAbort() {
-                            // 检查请求对象是否存在，如果不存在则直接返回
-                            if (!request) {
-                                return;
-                            }
-
-                            // 调用reject函数并传入错误信息，表示请求被中止
-                            reject(createError('Request aborted', config, 'ECONNABORTED', request));
-
-                            // 清理请求对象，将其置为null
-                            request = null;
-                        };
-
-                        // 处理底层网络错误
-                        request.onerror = function handleError() {
-                            // 真实的错误被浏览器隐藏
-                            // onerror 应该只在网络错误时触发
-                            reject(createError('Network Error', config, null, request));
-
-                            // 清理请求对象
-                            request = null;
-                        };
-
-                        // 处理请求超时
-                        request.ontimeout = function handleTimeout() {
-                            // 定义默认的超时错误信息
-                            var timeoutErrorMessage = 'timeout of ' + config.timeout + 'ms exceeded';
-                            // 如果配置中提供了自定义的超时错误信息，则使用该信息
-                            if (config.timeoutErrorMessage) {
-                                timeoutErrorMessage = config.timeoutErrorMessage;
-                            }
-                            // 调用reject函数并传入创建的错误对象，包含超时错误信息、配置和错误代码'ECONNABORTED'
-                            reject(createError(timeoutErrorMessage, config, 'ECONNABORTED', request));
-
-                            // 清理请求对象
-                            request = null;
-                        };
-
-
-                        if (utils.isStandardBrowserEnv()) {
-                            // 检查当前环境是否为标准浏览器环境
-                            // Add xsrf header
-                            var xsrfValue = (config.withCredentials || isURLSameOrigin(fullPath)) && config.xsrfCookieName ?
-                                // 如果配置中允许携带凭证或请求的URL与当前页面同源，并且配置了xsrfCookieName
-                                cookies.read(config.xsrfCookieName) :
-                                // 从cookie中读取xsrfCookieName对应的值
-                                undefined;
-                                // 否则，xsrfValue为undefined
-
-                            if (xsrfValue) {
-                                // 如果xsrfValue存在
-                                requestHeaders[config.xsfHeaderName] = xsrfValue;
-                                // 将xsrfValue添加到请求头中，键名为xsfHeaderName
-                            }
-                        }
-
-                        // 添加请求头到请求中
-                        // 检查 request 对象是否具有 setRequestHeader 方法
-                        if ('setRequestHeader' in request) {
-                            // 遍历 requestHeaders 对象，为每个键值对调用 setRequestHeader 函数
-                            utils.forEach(requestHeaders, function setRequestHeader(val, key) {
-                                // 如果 requestData 未定义且当前键为 'content-type'
-                                if (typeof requestData === 'undefined' && key.toLowerCase() === 'content-type') {
-                                    // 删除 Content-Type 头信息
-                                    delete requestHeaders[key];
-                                } else {
-                                    // 否则将头信息添加到请求中
-                                    request.setRequestHeader(key, val);
-                                }
-                            });
-                        };
-
-
-                        // 检查配置对象中的 withCredentials 属性是否未定义
-                        if (!utils.isUndefined(config.withCredentials)) {
-                            // 如果 withCredentials 属性已定义，则将其值转换为布尔类型并赋值给请求对象的 withCredentials 属性
-                            request.withCredentials = !!config.withCredentials;
-                        }
-
-                        // 根据配置添加 responseType 属性，并处理可能的异常
-                        // 检查配置中是否定义了响应类型
-                        if (config.responseType) {
-                            try {
-                                // 尝试将请求的响应类型设置为配置中的响应类型
-                                request.responseType = config.responseType;
-                            } catch (e) {
-                                // 捕获浏览器不兼容XMLHttpRequest Level 2时抛出的DOMException异常
-                                // 但是，对于'json'类型，可以默认使用'transformResponse'函数进行解析，因此可以忽略此异常
-                                if (config.responseType !== 'json') {
-                                    // 如果响应类型不是'json'，则重新抛出异常
-                                    throw e;
-                                }
-                            }
-                        }
-                        ,
-
-                        // 添加下载进度事件处理
-                        if (typeof config.onDownloadProgress === 'function') {
-                            request.addEventListener('progress', config.onDownloadProgress);
-                        }
-
-                        // 添加上传进度事件处理，如果浏览器支持
-                        if (typeof config.onUploadProgress === 'function' && request.upload) {
-                            request.upload.addEventListener('progress', config.onUploadProgress);
-                        }
-
-                        // 处理取消请求的情况
-                        if (config.cancelToken) {
-                            // 如果存在取消令牌，则监听取消事件，取消请求并拒绝
-                            config.cancelToken.promise.then(function onCanceled(cancel) {
-                                // 检查请求对象是否存在，如果不存在则直接返回
-                                if (!request) {
-                                    return;
-                                }
-
-                                // 终止当前请求
-                                request.abort();
-                                // 拒绝Promise并传递取消原因
-                                reject(cancel);
-                                // 将请求对象置为空，以便后续处理
-                                request = null;
-                            });
-
-                        // 确保 requestData 为 null 如果未提供
-                        if (!requestData) {
-                            // 如果 requestData 为空，则将其设置为 null
-                            requestData = null;
-                        }
-
-                        // 发送请求，将 requestData 作为请求体发送
-                        request.send(requestData);
-
-
-                /***/ }),
-            /* 13 */
-                        (function(module, exports, __webpack_require__) {
-
-                                        'use strict';
-
-                                        // 引入createError模块，用于创建错误对象
-                                        var createError = __webpack_require__(14);
-
-                                                                               module.exports = function settle(resolve, reject, response) {
-                                            // 获取响应配置中的状态验证函数
-                                            var validateStatus = response.config.validateStatus;
-                                            if (!response.status || !validateStatus || validateStatus(response.status)) {
-                                                // 如果响应状态不存在或状态验证函数未定义或验证通过，则解决请求
-                                                resolve(response);
-                                            } else {
-                                                // 如果状态验证失败，则拒绝请求并创建错误信息
-                                                reject(createError(
-                                                    'Request failed with status code ' + response.status, // 错误信息包含状态码
-                                                    response.config, // 请求配置
-                                                    null, // 无特定错误代码
-                                                    response.request, // 请求对象
-                                                    response // 响应对象
-                                                ));
-                                            }
-                };
-
-
-                /***/ }),
-            /* 14 */
-            (function(module, exports, __webpack_require__) {
-
-                'use strict';
-
-                // 引入增强错误处理的模块
-                var enhanceError = __webpack_require__(15);
-
-
-                module.exports = function createError(message, config, code, request, response) {
-                    // 创建一个新的错误对象，并传入错误信息
-                    var error = new Error(message);
-                    // 使用增强错误处理函数对错误对象进行增强，并返回增强后的错误对象
-                    return enhanceError(error, config, code, request, response);
-                };
-                /***/ }),
-            /* 15 */
-            /***/ (function(module, exports) {
-
-                'use strict';
-
-
-                module.exports = function enhanceError(error, config, code, request, response) {
-                    // 将配置对象附加到错误对象上
-                    error.config = config;
-                    // 如果存在错误码，则将其附加到错误对象上
-                    if (code) {
-                        error.code = code;
-                    }
-
-                    // 将请求对象附加到错误对象上
-                    error.request = request;
-                    // 将响应对象附加到错误对象上
-                    error.response = response;
-                    // 标记此错误对象为 Axios 错误
-                    error.isAxiosError = true;
-
-                    // 定义错误对象的 toJSON 方法，用于将错误对象转换为 JSON 格式
-                    error.toJSON = function toJSON() {
-                        return {
-                            // 标准错误属性
-                            message: this.message, // 错误信息
-                            name: this.name, // 错误名称
-                            // Microsoft 特定的错误属性
-                            description: this.description, // 错误描述
-                            number: this.number, // 错误编号
-                            // Mozilla 特定的错误属性
-                            fileName: this.fileName, // 发生错误的文件名
-                            lineNumber: this.lineNumber, // 发生错误的行号
-                            columnNumber: this.columnNumber, // 发生错误的列号
-                            stack: this.stack, // 错误堆栈信息
-                            // Axios 特定的错误属性
-                            config: this.config, // 请求配置
-                            code: this.code // 错误代码
-                        };
-                    };
-                    // 创建并返回一个错误对象
-                    return error;
-                };
-
-                /***/ }),
-            /* 16 */
-            /***/ (function(module, exports, __webpack_require__) {
-
-                'use strict';
-
-                var utils = __webpack_require__(2);
-
-                // 根据环境选择合适的 cookie 操作方法
-                module.exports = (
-                    utils.isStandardBrowserEnv() ?
-
-                        // 标准浏览器环境支持 document.cookie
-                        (function standardBrowserEnv() {
-                            return {
-                                // 写入 cookie 的方法
-                                write: function write(name, value, expires, path, domain, secure) {
-                                    // 创建一个空数组用于存储cookie的各个部分
-                                    var cookie = [];
-                                    // 将name和value添加到cookie数组中，并对value进行编码
-                                    cookie.push(name + '=' + encodeURIComponent(value));
-
-                                    // 如果expires是一个数字，则将其转换为GMT字符串格式并添加到cookie数组中
-                                    if (utils.isNumber(expires)) {
-                                        cookie.push('expires=' + new Date(expires).toGMTString());
-                                    }
-
-                                    // 如果path是一个字符串，则将其添加到cookie数组中
-                                    if (utils.isString(path)) {
-                                        cookie.push('path=' + path);
-                                    }
-
-                                    // 如果domain是一个字符串，则将其添加到cookie数组中
-                                    if (utils.isString(domain)) {
-                                        cookie.push('domain=' + domain);
-                                    }
-
-                                    // 如果secure为true，则向cookie数组中添加'secure'
-                                    if (secure === true) {
-                                        cookie.push('secure');
-                                    }
-
-                                    // 将cookie数组内容拼接为字符串并赋值给document.cookie
-                                    document.cookie = cookie.join('; ');
-                                },
-
-                                read: function read(name) {
-                                    // 使用正则表达式匹配document.cookie中的name对应的cookie值
-                                    var match = document.cookie.match(new RegExp('(^|;\\s*)(' + name + ')=([^;]*)'));
-                                    // 如果找到匹配项，则返回解码后的cookie值；否则返回null
-                                    return (match ? decodeURIComponent(match[3]) : null);
-                                },
-
-                                remove: function remove(name) {
-                                    // 调用write方法，将cookie的过期时间设置为当前时间的前一天，从而删除cookie
-                                    this.write(name, '', Date.now() - 86400000);
-                                }
-                            };
-                        })() :
-                        // 非标准浏览器环境（如web workers、react-native）不支持cookie操作
-                        (function nonStandardBrowserEnv() {
-                            return {
-                                write: function write() {},
-                                read: function read() { return null; },
-                                remove: function remove() {}
-                            };
-                        })()
-                );
-                /***/ }),
-            /* 17 */
-                  /***/ (function(module, exports, __webpack_require__) {
-
-                'use strict';
-
-                // 引入判断URL是否为绝对路径的模块
-                var isAbsoluteURL = __webpack_require__(18);
-                // 引入组合URL的模块
-                var combineURLs = __webpack_require__(19);
-
-                module.exports = function buildFullPath(baseURL, requestedURL) {
-                    // 根据提供的 baseURL 和 requestedURL 构建完整路径
-                    // 如果 baseURL 存在且 requestedURL 不是绝对 URL，则将两者组合
-                    // 否则直接返回 requestedURL
-                    // 如果提供了基础URL并且请求的URL不是绝对URL，则将基础URL与请求的URL组合
-                    if (baseURL && !isAbsoluteURL(requestedURL)) {
-                        return combineURLs(baseURL, requestedURL);
-                    }
-                    // 如果请求的URL是绝对URL，则直接返回请求的URL
-                    return requestedURL;
-                };
-
-
-                // 模块定义的结束部分
-                /***/ }),
-
-            // 模块加载函数的定义开始
-            /***/ (function(module, exports) {
-
-                // 严格模式
-                'use strict';
-
-
-                module.exports = function isAbsoluteURL(url) {
-                    // URL被认为是绝对的，如果它以"<scheme>://"或"//"（协议相对URL）开头。
-                    // RFC 3986定义的方案名称是一系列字符，以字母开头，后跟任意字母、数字、加号、点或连字符的组合。
-                    return /^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(url);
-                };
-
-                /***/ }),
-            /* 19 */
-                  /***/ (function(module, exports) {
-
-                'use strict';
-
-
-                module.exports = function combineURLs(baseURL, relativeURL) {
-                    // 结合基础URL和相对URL，确保URL正确拼接
-                    return relativeURL
-                        ? baseURL.replace(/\/+$/, '') + '/' + relativeURL.replace(/^\/+/, '')
-                        : baseURL;
-                };
-
-                /***/ }),
-            /* 20 */
-                  (function(module, exports, __webpack_require__) {
-
-                      'use strict';
-
-                      // 引入 utils 模块
-                      var utils = __webpack_require__(2);
-
-                  )
-
-                  // 定义一个数组，包含需要忽略重复的请求头字段
-                  var ignoreDuplicateOf = [
-                      'age', 'authorization', 'content-length', 'content-type', 'etag',
-                      'expires', 'from', 'host', 'if-modified-since', 'if-unmodified-since',
-                      'last-modified', 'location', 'max-forwards', 'proxy-authorization',
-                      'referer', 'retry-after', 'user-agent'
-                  ];
-                // 定义一个数组，包含在HTTP请求头中不应被重复设置的字段名称
-
-                module.exports = function parseHeaders(headers) {
-                    // 初始化一个空对象用于存储解析后的头部信息
-                    var parsed = {};
-                    // 声明变量用于存储当前头部信息的键
-                    var key;
-                    // 声明变量用于存储当前头部信息的值
-                    var val;
-                    // 声明变量用于循环计数
-                    var i;
-
-            }
-                    if (!headers) { return parsed; }
-
-                    // 遍历每一行header信息，调用parser函数进行解析
-                    utils.forEach(headers.split('\n'), function parser(line) {
-                        // 解析每一行header信息，存入对象中
-                        i = line.indexOf(':');
-                        key = utils.trim(line.substr(0, i)).toLowerCase();
-                        val = utils.trim(line.substr(i + 1));
-
-                        if (key) {
-                            // 忽略重复的header信息
-                            if (parsed[key] && ignoreDuplicateOf.indexOf(key) >= 0) {
-                                return;
-                            }
-                            // 处理set-cookie header信息的拼接
-                            if (key === 'set-cookie') {
-                                parsed[key] = (parsed[key] ? parsed[key] : []).concat([val]);
-                            } else {
-                                parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;
-                            }
-                        }
-                    });
-                    });
-
-                    // 返回解析后的对象
-                    return parsed;
-                },
-
-                /***/ }
-               ),
-            /* 21 */
-                  /***/ (function(module, exports, __webpack_require__) {
-
-                'use strict';
-
-                // 引入 utils 模块
-                var utils = __webpack_require__(2);
-
-                // 根据环境导出不同的模块
-                module.exports = (
-                    utils.isStandardBrowserEnv() ?
-
-                        // 标准浏览器环境支持测试请求 URL 是否与当前地址同源的 API
-                        (function standardBrowserEnv() {
-                            var msie = /(msie|trident)/i.test(navigator.userAgent);
-                            var urlParsingNode = document.createElement('a');
-                            var originURL;
-
-
-                            function resolveURL(url) {
-                                // 初始化 href 变量为传入的 URL
-                                var href = url;
-
-                                if (msie) {
-                                    // IE 浏览器需要设置 href 属性两次以规范化属性
-                                    urlParsingNode.setAttribute('href', href);
-                                    // 获取规范化后的 href 值
-                                    href = urlParsingNode.href;
-                                }
-                                // 再次设置 href 属性，确保解析正确
-                                urlParsingNode.setAttribute('href', href);
-
-                                // 返回一个解析后的URL对象，包含协议、主机、搜索字符串、哈希、主机名、端口和路径名等信息
-                                return {
-                                    // 完整的 URL 地址
-                                    href: urlParsingNode.href,
-                                    // 协议部分，去掉末尾的冒号
-                                    protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',
-                                    // 主机部分，包括域名和端口号
-                                    host: urlParsingNode.host,
-                                    // 查询字符串部分，去掉开头的问号
-                                    search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, '') : '',
-                                    // 哈希部分，去掉开头的井号
-                                    hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',
-                                    // 主机名部分，不包括端口号
-                                    hostname: urlParsingNode.hostname,
-                                    // 端口号部分
-                                    port: urlParsingNode.port,
-                                    // 路径名部分，如果路径不以斜杠开头，则添加斜杠
-                                    pathname: (urlParsingNode.pathname.charAt(0) === '/') ?
-                                        urlParsingNode.pathname :
-                                        '/' + urlParsingNode.pathname
-                                };
-                            }
-                    // 使用resolveURL函数解析当前窗口的URL，并将结果赋值给originURL变量
-                    originURL = resolveURL(window.location.href);
-
-                    return function isURLSameOrigin(requestURL) {
-                        // 解析请求的URL，如果是字符串则调用resolveURL函数进行解析
-                        var parsed = (utils.isString(requestURL)) ? resolveURL(requestURL) : requestURL;
-                        // 比较解析后的URL与当前页面的协议和主机是否相同
-                        return (parsed.protocol === originURL.protocol &&
-                            parsed.host === originURL.host);
-                    };
-                })()
-
-                // 非标准浏览器环境（如 web workers, react-native）缺乏必要的支持。
-                (function nonStandardBrowserEnv() {
-                    // 返回一个总是返回 true 的函数，表示在非标准浏览器环境中，默认认为 URL 是同源的
-                    return function isURLSameOrigin() {
-                        return true;
-                    };
-                })()
-            /* 22 */
-            /***/ (function(module, exports, __webpack_require__) {
-
-                'use strict';
-
-                // 引入 utils 模块
-                var utils = __webpack_require__(2);
-
-                // 导出一个函数，用于合并两个配置对象
-                module.exports = function mergeConfig(config1, config2) {
-                    // 如果未提供 config2，则将其设置为空对象
-                    config2 = config2 || {};
-                    var config = {};
-
-                    // 定义需要从 config2 获取值的键
-                    var valueFromConfig2Keys = ['url', 'method', 'data'];
-
-                    // 定义需要深度合并属性的键
-                    var mergeDeepPropertiesKeys = ['headers', 'auth', 'proxy', 'params'];
-
-                    // 定义默认优先使用 config2 值的键
-                    var defaultToConfig2Keys = [
-                        'baseURL', 'transformRequest', 'transformResponse', 'paramsSerializer',
-                        'timeout', 'timeoutMessage', 'withCredentials', 'adapter', 'responseType', 'xsrfCookieName',
-                        'xsrfHeaderName', 'onUploadProgress', 'onDownloadProgress', 'decompress',
-                        'maxContentLength', 'maxBodyLength', 'maxRedirects', 'transport', 'httpAgent',
-                        'httpsAgent', 'cancelToken', 'socketPath', 'responseEncoding'
-                    ];
-
-                    // 定义需要直接合并的键
-                    var directMergeKeys = ['validateStatus'];
-
-                    // 定义一个函数，用于根据键获取合并后的值
-                    function getMergedValue(target, source) {
-                    // 合并两个普通对象，如果source是普通对象则合并，如果source是数组则复制，否则直接返回source
-                    // 如果目标和源都是普通对象，则合并它们
-                    if (utils.isPlainObject(target) && utils.isPlainObject(source)) {
-                        return utils.merge(target, source);
-                    // 如果只有源是普通对象，则合并到一个空对象中
-                    } else if (utils.isPlainObject(source)) {
-                        return utils.merge({}, source);
-                    // 如果源是数组，则返回源数组的浅拷贝
-                    } else if (utils.isArray(source)) {
-                        return source.slice();
-                    }
-                    // 否则直接返回源
-                    return source;
-
-                    function mergeDeepProperties(prop) {
-                        // 深度合并config1和config2中的属性，优先使用config2的属性
-                        if (!utils.isUndefined(config2[prop])) {
-                            config[prop] = getMergedValue(config1[prop], config2[prop]);
-                        } else if (!utils.isUndefined(config1[prop])) {
-                            config[prop] = getMergedValue(undefined, config1[prop]);
-                        }
-                    }
-
-                    utils.forEach(valueFromConfig2Keys, function valueFromConfig2(prop) {
-                        // 将config2中的属性复制到config中，如果config2中存在该属性
-                                            if (!utils.isUndefined(config2[prop])) {
-                                                config[prop] = getMergedValue(undefined, config2[prop]);
-                                            }
-                                        });
-
-                    // 深度合并指定的属性
-                    utils.forEach(mergeDeepPropertiesKeys, mergeDeepProperties);
-
-                    // 将默认值设置为 config2 中的属性值
-                    utils.forEach(defaultToConfig2Keys, function defaultToConfig2(propp) {
-                        // 将config2或config1中的属性复制到config中，优先使用config2的属性
-                        if (!utils.isUndefined(config2[prop])) {
-                            config[prop] = getMergedValue(undefined, config2[prop]);
-                        } else if (!utils.isUndefined(config1[prop])) {
-                            config[prop] = getMergedValue(undefined, config1[prop]);
-                        }
-                    });
-
-                    // 遍历 directMergeKeys 数组，将 config1 和 config2 中对应属性的值合并到 config 中
-                    utils.forEach(directMergeKeys, function merge(prop) {
-                        // 合并config1和config2中的属性到config中，如果config2中存在该属性则使用config2和config1合并的结果，否则使用config1的属性
-                                        if (prop in config2) {
-                                            config[prop] = getMergedValue(config1[prop], config2[prop]);
-                                        } else if (prop in config1) {
-                                            config[prop] = getMergedValue(undefined, config1[prop]);
-                                        }
-                                    });
-
-                // 合并axios配置时需要特殊处理的键集合
-                                    var axiosKeys = valueFromConfig2Keys
-                                        .concat(mergeDeepPropertiesKeys)
-                                        .concat(defaultToConfig2Keys)
-                                        .concat(directMergeKeys);
-
-                // 获取所有不在axiosKeys中的键
-                                    var otherKeys = Object
-                                        .keys(config1)
-                                        .concat(Object.keys(config2))
-                                        .filter(function filterAxiosKeys(key) {
-                                            return axiosKeys.indexOf(key) === -1;
-                                        });
-
-                // 对于不在特殊处理集合中的键，进行深度合并
-                                    utils.forEach(otherKeys, mergeDeepProperties);
-
-                // 返回合并后的配置对象
-                                    return config;
-                                };
-            /* 23 */
-                  /***/ (function(module, exports) {
-
-                'use strict';
-
-
-                // 定义一个构造函数 Cancel，用于创建取消操作的对象
-                function Cancel(message) {
-                    // 设置取消操作的消息内容
-                    this.message = message;
-                }
-
-                 Cancel.prototype.toString = function toString() {
-                    // 返回 Cancel 对象的字符串表示形式，如果存在 message 属性，则将其包含在返回的字符串中
-                    return 'Cancel' + (this.message ? ': ' + this.message : '');
-                };
-
-                // 定义 Cancel 类的原型属性 __CANCEL__ 为 true
-                Cancel.prototype.__CANCEL__ = true;
-
-                // 导出 Cancel 类
-                module.exports = Cancel;
-
-                /***/ }),
-            /* 24 */
-                                    /***/ (function(module, exports, __webpack_require__) {
-                  // 定义一个立即执行函数表达式，通常用于模块化管理，避免变量污染全局作用域
-                  // 参数 module, exports, __webpack_require__ 用于模块的加载和导出功能
-                    )
-                'use strict';
-
-                var Cancel = __webpack_require__(23);
-
-                // 取消令牌类，用于处理取消请求的操作
-                function CancelToken(executor) {
-                    // 检查传入的执行器是否为函数类型，如果不是则抛出类型错误
-                    if (typeof executor !== 'function') {
-                        throw new TypeError('executor must be a function.');
-                    }
-
-                    // 定义一个用于解决 Promise 的函数
-                    var resolvePromise;
-                    // 创建一个 Promise 实例，该实例用于表示取消操作的状态
-                    this.promise = new Promise(function promiseExecutor(resolve) {
-                        resolvePromise = resolve;
-                    });
-                }
-
-                    var token = this;
-                    executor(function cancel(message) {
-                        if (token.reason) {
-                            // 取消请求已被提出
-                            return;
-                        }
-                    // 定义取消请求的执行器函数，接收一个消息参数
-                    // 如果token.reason已经存在，说明请求已经被取消，直接返回
-                    // 否则，执行取消逻辑
-                                    });
-                                         token.reason = new Cancel(message);
-                                        resolvePromise(token.reason);
-                                    });
-                                }
-                // 设置取消请求的原因并解析Promise
-
-
-                // 如果请求已取消，则抛出取消原因
-                CancelToken.prototype.throwIfRequested = function throwIfRequested() {
-                    if (this.reason) {
-                        throw this.reason;
-                    }
-                }
-
-
-                CancelToken.source = function source() {
-                    // 创建一个取消令牌和取消函数的源
-                    var cancel;
-                    var token = new CancelToken(function executor(c) {
-                        // 执行器函数，接收一个取消函数并赋值给cancel变量
-                        cancel = c;
-                    });
-                    // 返回一个包含取消令牌和取消函数的对象
-                    return {
-                        token: token,
-                        cancel: cancel
-                    };
-                };
-
-                // 导出CancelToken类或构造函数
-                module.exports = CancelToken;
-
-                /***/ }):
-            /* 25 */
-                  /***/ (function(module, exports) {
-
-                'use strict';
-
-                // 定义一个名为 spread 的函数，该函数接受一个回调函数作为参数
-                module.exports = function spread(callback) {
-                    // 返回一个新的函数，该函数接受一个数组参数
-                    return function wrap(arr) {
-                        // 使用 apply 方法将数组展开作为参数传递给 callback 函数
-                        return callback.apply(null, arr);
-                    };
-                };
-                /***/ )
-            /******/ ]);
-,
-//# sourceMappingURL=axios.map
-
-
-        let axios;
-        axios.interceptors.request.use(function(config){
-    // 如果存储中有有效令牌，则执行以下操作
-    if(store.getToken()){
-        // 将令牌添加到请求头中
-        config.headers.token=store.getToken();
-    }
-    // 返回修改后的配置对象
-    return config;
-},function(error){
-    // 拦截请求错误并返回一个被拒绝的Promise
-    return Promise.reject(error);
-});
-// 该函数在请求发送之前检查存储中是否存在 token，如果存在则将其添加到请求头中，然后返回配置对象。如果请求过程中发生错误，则返回一个被拒绝的 Promise。
-
-axios.interceptors.response.use(function(response){
-    if(response.headers.token){
-        store.setToken(response.headers.token);
-    }
-});
-// 设置响应拦截器，在接收到响应时执行
-// 检查响应头中是否存在'token'字段，如果存在则调用store.setToken方法保存该token
-    // 检查HTTP响应状态是否为200
-    if(response.status==200){
-            // 获取响应数据
-            const res = response.data;
-            // 后端返回的数据为200的时候为正常数据
-            if(res.code==200){
-                // 返回正常的响应数据
-                return res;
-            }else if(res.code==400){//token过时
-              // 如果响应代码为400，表示token已过期，重定向到登录页面
-              window.location.href = 'login.html';
-              return ;
-            }else{
-                // 其他情况返回一个被拒绝的 Promise，拒绝原因设置为响应消息
-                return Promise.reject(res.msg);
-            }
-        }
-                    )else{
-            // 如果响应状态不是成功，则返回一个被拒绝的 Promise，拒绝原因设置为响应的状态文本
-            return Promise.reject(response.statusText);
-        }
-},},function(error){
-    // 拒绝 Promise 并返回错误信息
-    return Promise.reject(error);
-});
-// 设置 axios 的默认基础 URL
-axios.defaults.baseURL="http://localhost:8888/dormitory"
-// 输出 axios
-exports('axios', axios);
-               )},)}
diff --git a/stt/iconPickerFa.js b/stt/iconPickerFa.js
deleted file mode 100644
index 42e944a..0000000
--- a/stt/iconPickerFa.js
+++ /dev/null
@@ -1,478 +0,0 @@
-
-
-layui.define(['laypage', 'form'], function (exports) {
-    "use strict";
-
-    // 定义 IconPicker 构造函数
-    var IconPicker = function () {
-            // 设置版本号为1.1
-            this.v = '1.1';
-        }, _MOD = 'iconPickerFa',
-        // 使用 _this 存储当前的 this 上下文
-        _this = this,
-        // 引入 jQuery
-        $ = layui.jquery,
-        // 引入 laypage 模块
-        laypage = layui.laypage,
-        // 引入 form 模块
-        form = layui.form,
-        // 定义 BODY 选择器
-        BODY = 'body',
-        // 定义提示信息
-        TIPS = '请选择图标';
-})
-
-      
-    IconPicker.prototype.render = function (options) {
-        // 渲染图标选择器的方法
-        var opts = options,
-            // DOM选择器
-            elem = opts.elem,
-            // 数据类型：fontClass/unicode
-            url = opts.url,
-            // 是否分页：true/false
-            page = opts.page == null ? true : opts.page,
-            // 每页显示数量
-            limit = opts.limit == null ? 12 : opts.limit,
-            // 是否开启搜索：true/false
-            search = opts.search == null ? true : opts.search,
-            // 每个图标格子的宽度：'43px'或'20%'
-            cellWidth = opts.cellWidth,
-            // 点击图标后的回调函数
-            click = opts.click,
-            // 渲染成功后的回调函数
-            success = opts.success,
-            // 存储图标数据的json对象
-            data = {},
-            // 唯一标识符，基于当前时间戳生成
-            tmp = new Date().getTime(),
-            // 初始化时input的值
-            ORIGINAL_ELEM_VALUE = $(elem).val(),
-            // 下拉标题的类名
-            TITLE = 'layui-select-title',
-            // 下拉标题的唯一ID
-            TITLE_ID = 'layui-select-title-' + tmp,
-            // 图标选择器主体的唯一ID
-            ICON_BODY = 'layui-iconpicker-' + tmp,
-            // 图标选择器内容区域的唯一ID
-            PICKER_BODY = 'layui-iconpicker-body-' + tmp,
-            // 图标选择器分页区域的唯一ID
-            PAGE_ID = 'layui-iconpicker-page-' + tmp,
-            // 图标列表容器的类名
-            LIST_BOX = 'layui-iconpicker-list-box',
-            // 表单项选中状态的类名
-            selected = 'layui-form-selected',
-            // 表单项未选中状态的类名
-            unselect = 'layui-unselect';
-
-        var a = {
-            // 初始化函数，设置基本数据并绑定事件
-            init: function () {
-                // 从指定URL获取数据
-                data = common.getData(url);
-        
-                // 隐藏元素、创建选择框、创建主体内容、切换选择状态
-                a.hideElem().createSelect().createBody().toggleSelect();
-                // 防止默认事件和监听输入事件
-                a.preventEvent().inputListen();
-                // 加载CSS样式
-                common.loadCss();
-        
-                // 如果成功回调函数存在，则调用成功处理函数
-                if (success) {
-                    success(this.successHandle());
-                }
-        
-                // 返回当前对象以支持链式调用
-                return a;
-            },
-            // 处理成功后的数据返回
-            successHandle: function () {
-                // 创建一个包含选项、数据、ID和元素的对象
-                var d = {
-                    options: opts,
-                    data: data,
-                    id: tmp,
-                    elem: $('#' + ICON_BODY)
-                };
-                // 返回创建的对象
-                return d;
-            },
-            
-            hideElem: function () {
-                // 隐藏指定的元素
-                $(elem).hide();
-                // 返回变量 a
-                return a;
-            },
-            
-                        createSelect: function () {
-                            // 定义一个变量oriIcon，并赋值为包含图标类名的HTML字符串
-                            var oriIcon = '<i class="fa">';
-                                    
-                            // 如果ORIGINAL_ELEM_VALUE为空字符串
-                            if (ORIGINAL_ELEM_VALUE === '') {
-                                // 将ORIGINAL_ELEM_VALUE设置为默认图标类名'fa-adjust'
-                                ORIGINAL_ELEM_VALUE = 'fa-adjust';
-                            }
-            createSelect: 该方法用于创建一个选择元素主要用于图标选择功能
-            
-                            // 创建原始图标的HTML字符串，使用ORIGINAL_ELEM_VALUE作为图标类名
-                            oriIcon = '<i class="fa ' + ORIGINAL_ELEM_VALUE + '">';
-                                                        
-                            // 关闭原始图标的HTML标签
-                            oriIcon += '</i>';
-                                                        
-                            // 创建选择器HTML字符串，包含标题和图标选择区域
-                            var selectHtml = '<div class="layui-iconpicker layui-unselect layui-form-select" id="' + ICON_BODY + '">' +
-                                '<div class="' + TITLE + '" id="' + TITLE_ID + '">' +
-                                '<div class="layui-iconpicker-item">' +
-                                '<span class="layui-iconpicker-icon layui-unselect">' +
-                                // 插入原始图标HTML
-                                oriIcon +
-                                '</span>' +
-                                // 添加一个用于显示边缘效果的图标
-                                '<i class="layui-edge"></i>' +
-                                '</div>' +
-                                '</div>' +
-                                '<div class="layui-anim layui-anim-upbit" style="">' +
-                                // 占位符内容，可能是将来要替换的内容
-                                '123' +
-                                '</div>';
-                                                        
-                            // 在目标元素之后插入生成的选择器HTML
-                            $(elem).after(selectHtml);
-                                                        
-                            // 返回变量a（假设是函数的返回值）
-                            return a;
-           toggleSelect: function  () {
-               // 切换图标的选中状态
-               var item = '#' + TITLE_ID + ' .layui-iconpicker-item,#' + TITLE_ID + ' .layui-iconpicker-item .layui-edge';
-               a.event('click', item, function (e) {
-                   // 获取图标元素
-                   var $icon = $('#' + ICON_BODY);
-                   if ($icon.hasClass(selected)) {
-                       // 如果图标已经被选中，则取消选中状态
-                       $icon.removeClass(selected).addClass(unselect);
-                   } else {
-                       // 隐藏其他picker
-                       $('.layui-form-select').removeClass(selected);
-                       // 显示当前picker并设置为选中状态
-                       $icon.addClass(selected).removeClass(unselect);
-                   }
-                   // 阻止事件冒泡
-                   e.stopPropagation();
-               });
-           }
-                return a;
-            },
-           createBody: function () {
-               // 初始化搜索框的 HTML 内容为空字符串
-               var searchHtml = '';
-           
-               // 如果 search 为真，则创建搜索框的 HTML 结构
-               if (search) {
-                   searchHtml = '<div class="layui-iconpicker-search">' +
-                       '<input class="layui-input">' +
-                       '<i class="layui-icon">&#xe615;</i>' +
-                       '</div>';
-               }
-           }
-
-                // 组合dom
-                // 创建包含图标选择器主体的HTML字符串，并设置其ID为PICKER_BODY
-                var bodyHtml = '<div class="layui-iconpicker-body" id="' + PICKER_BODY + '">' +
-                                // 添加搜索框的HTML内容
-                                searchHtml +
-                                // 添加一个空的列表容器，用于显示图标列表
-                                '<div class="' + LIST_BOX + '"></div> ' +
-                                '</div>';
-                
-                // 在指定的ICON_BODY元素中找到第一个带有layui-anim类的元素，并将其HTML内容替换为bodyHtml
-                $('#' + ICON_BODY).find('.layui-anim').eq(0).html(bodyHtml);
-                
-                // 调用a对象的search方法，创建图标列表，检查图标状态，并进行分页处理
-                a.search().createList().check().page();
-                
-                // 返回对象a
-                return a;
-                    createList: function (text) {
-                        // 创建列表的函数，根据传入的文本过滤图标数据
-                        var d = data, // 获取全局数据
-                            l = d.length, // 获取数据长度
-                            pageHtml = '', // 初始化分页HTML字符串
-                            listHtml = $('<div class="layui-iconpicker-list">'); // 创建一个包含类名'layui-iconpicker-list'的div元素
-                    
-                        // 计算分页数据
-                        var _limit = limit, // 每页显示数量
-                            _pages = l % _limit === 0 ? l / _limit : parseInt(l / _limit + 1), // 计算总页数，如果整除则直接除，否则加1取整
-                            _id = PAGE_ID; // 获取当前页面ID
-
-                // 图标列表
-                var icons = [];
-
-                for (var i = 0; i < l; i++) {
-                    var obj = d[i];
-
-                    // 判断是否模糊查询，如果text存在且obj中不包含text则跳过当前循环
-                    if (text && obj.indexOf(text) === -1) {
-                        continue;
-                    }
-
-                    // 初始化样式字符串为空
-                    var style = '';
-                    // 如果自定义格子宽度不为空
-                    if (cellWidth !== null) {
-                        // 将自定义的格子宽度添加到样式字符串中
-                        style += ' style="width:' + cellWidth + '"';
-                    }
-
-                    // 创建一个包含图标的HTML字符串
-                    var icon = '<div class="layui-iconpicker-icon-item" title="' + obj + '" ' + style + '>';
-                    
-                    // 在div中添加一个i元素，并设置其class为FontAwesome图标类名
-                    icon += '<i class="fa ' + obj + '"></i>';
-                    
-                    // 关闭div标签
-                    icon += '</div>';
-                    
-                    // 将生成的图标HTML字符串添加到icons数组中
-                    icons.push(icon);
-
-                // 查询出图标后再分页
-                                // 获取图标数组的长度
-                                l = icons.length;
-                                
-                                // 计算总页数，如果图标总数不能被每页限制数量整除，则总页数加1
-                                _pages = l % _limit === 0 ? l / _limit : parseInt(l / _limit + 1);
-                                
-                                // 循环遍历每一页
-                                for (var i = 0; i < _pages; i++) {
-                                    // 创建一个新的div元素，用于存放当前页的图标，并设置其class和id
-                                    var lm = $('<div class="layui-iconpicker-icon-limit" id="layui-iconpicker-icon-limit-' + tmp + (i + 1) + '">');
-                                
-                                    // 循环遍历当前页的所有图标
-                                    for (var j = i * _limit; j < (i + 1) * _limit && j < l; j++) {
-                                        // 将当前图标添加到当前页的div中
-                                        lm.append(icons[j]);
-                                    }
-                                
-                                    // 将当前页的div添加到列表的HTML中
-                                    listHtml.append(lm);
-                                }
-                // 根据图标的数量和每页显示的限制，将图标分页并添加到列表中
-
-                // 无数据
-                if (l === 0) {
-                    listHtml.append('<p class="layui-iconpicker-tips">无数据</p>');
-                }
-
-                // 判断是否分页
-                // 检查是否存在分页参数
-                if (page) {
-                    // 为图标选择器主体添加分页样式类
-                    $('#' + PICKER_BODY).addClass('layui-iconpicker-body-page');
-                    
-                    // 生成分页HTML结构
-                    pageHtml = '<div class="layui-iconpicker-page" id="' + PAGE_ID + '">' +
-                        '<div class="layui-iconpicker-page-count">' +
-                        '<span id="' + PAGE_ID + '-current">1</span>/' +
-                        '<span id="' + PAGE_ID + '-pages">' + _pages + '</span>' +
-                        ' (<span id="' + PAGE_ID + '-length">' + l + '</span>)' +
-                        '</div>' +
-                        '<div class="layui-iconpicker-page-operate">' +
-                        '<i class="layui-icon" id="' + PAGE_ID + '-prev" data-index="0" prev>&#xe603;</i> ' +
-                        '<i class="layui-icon" id="' + PAGE_ID + '-next" data-index="2" next>&#xe602;</i> ' +
-                        '</div>' +
-                        '</div>';
-                }
-
-// 清空并更新列表和分页的HTML内容
-$('#' + ICON_BODY).find('.layui-anim').find('.' + LIST_BOX).html('').append(listHtml).append(pageHtml);
-return a;
-},
-
-
-preventEvent: function () {
-    // 定义需要绑定事件的元素选择器
-    var item = '#' + ICON_BODY + ' .layui-anim';
-    // 为元素绑定点击事件，阻止事件冒泡
-    a.event('click', item, function (e) {
-        e.stopPropagation();
-    });
-    return a;
-},
-            // 分页功能
-            page: function () {
-                // 获取分页操作图标的选择器
-                var icon = '#' + PAGE_ID + ' .layui-iconpicker-page-operate .layui-icon';
-            
-                // 解除之前绑定的点击事件
-                $(icon).unbind('click');
-                // 为分页操作图标绑定点击事件
-                a.event('click', icon, function (e) {
-                    // 获取当前点击的元素
-                    var elem = e.currentTarget,
-                        // 获取总页数
-                        total = parseInt($('#' + PAGE_ID + '-pages').html()),
-                        // 判断是否为上一页按钮
-                        isPrev = $(elem).attr('prev') !== undefined,
-                        // 获取按钮上的页码索引
-                        index = parseInt($(elem).attr('data-index')),
-                        // 获取当前显示页码的元素
-                        $cur = $('#' + PAGE_ID + '-current'),
-                        // 获取当前显示的页码
-                        current = parseInt($cur.html());
-
-                    // 分页数据
-                    if (isPrev && current > 1) {
-                        // 如果点击的是上一页且当前页码大于1，则将当前页码减1
-                        current = current - 1;
-                        // 更新上一页图标的data-index属性为新的当前页码
-                        $(icon + '[prev]').attr('data-index', current);
-                    } else if (!isPrev && current < total) {
-                        // 如果点击的是下一页且当前页码小于总页数，则将当前页码加1
-                        current = current + 1;
-                        // 更新下一页图标的data-index属性为新的当前页码
-                        $(icon + '[next]').attr('data-index', current);
-                    }
-                    // 更新当前页码显示
-                    $cur.html(current);
-
-                    // 图标数据
-                    // 隐藏所有图标限制元素
-                    $('#' + ICON_BODY + ' .layui-iconpicker-icon-limit').hide();
-                    // 显示对应页码的图标限制元素
-                    $('#layui-iconpicker-icon-limit-' + tmp + current).show();
-                    // 阻止事件冒泡
-                    e.stopPropagation();
-                });
-                return a;
-            },
-           
-            search: function () {
-                // 为图标搜索输入框绑定输入事件监听器
-                var item = '#' + PICKER_BODY + ' .layui-iconpicker-search .layui-input';
-                a.event('input propertychange', item, function (e) {
-                    // 获取输入框元素及其值
-                    var elem = e.target,
-                        t = $(elem).val();
-                    // 根据输入值创建图标列表
-                    a.createList(t);
-                });
-                // 返回模块对象 a
-                return a;
-            },
-                      
-            // 定义一个名为 check 的函数，用于处理图标选择器的点击事件
-            check: function () {
-                // 选择图标项的 CSS 选择器
-                var item = '#' + PICKER_BODY + ' .layui-iconpicker-icon-item';
-                // 为图标项添加点击事件监听器
-                a.event('click', item, function (e) {
-                    // 获取当前点击的图标元素和图标类名
-                    var el = $(e.currentTarget).find('.fa'),
-                        icon = '';
-
-                    // 分割图标的 class 属性，提取图标类名
-                    var clsArr = el.attr('class').split(/[\s\n]/),
-                        cls = clsArr[1],
-                        icon = cls;
-                    // 更新标题区域显示的图标
-                    $('#' + TITLE_ID).find('.layui-iconpicker-item .fa').html('').attr('class', clsArr.join(' '));
-
-                    // 移除所有图标的选中状态并设置当前图标的选中状态
-                    $('#' + ICON_BODY).removeClass(selected).addClass(unselect);
-                    // 设置输入框的值为当前图标的类名
-                    $(elem).val(icon).attr('value', icon);
-                    // 回调函数，如果存在则执行
-                    if (click) {
-                        click({
-                            icon: icon
-                        });
-                    }
-
-                });
-                // 返回对象 a
-                return a;
-            },
-            // 监听原始input数值改变
-            inputListen: function () {
-                // 获取元素并转换为jQuery对象
-                var el = $(elem);
-                
-                // 为元素绑定'change'事件监听器
-                a.event('change', elem, function () {
-                    // 获取元素的当前值
-                    var value = el.val();
-                })
-                
-                // 返回对象a
-                return a;
-            },
-            // 绑定事件到指定元素
-            event: function (evt, el, fn) {
-                // 使用jQuery在BODY元素上绑定事件处理函数
-                $(BODY).on(evt, el, fn);
-            }
-
-        var common = {
-            // 加载CSS样式函数
-            loadCss: function () {
-                var css = '.layui-iconpicker {max-width: 280px;}.layui-iconpicker .layui-anim{display:none;position:absolute;left:0;top:42px;padding:5px 0;z-index:899;min-width:100%;border:1px solid #d2d2d2;max-height:300px;overflow-y:auto;background-color:#fff;border-radius:2px;box-shadow:0 2px 4px rgba(0,0,0,.12);box-sizing:border-box;}.layui-iconpicker-item{border:1px solid #e6e6e6;width:90px;height:38px;border-radius:4px;cursor:pointer;position:relative;}.layui-iconpicker-icon{border-right:1px solid #e6e6e6;-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;display:block;width:60px;height
-
-            // 获取数据的函数
-            getData: function (url) {
-                // 初始化图标列表数组
-                var iconlist = [];
-                // 发起同步的AJAX请求以获取数据
-                $.ajax({
-                    url: url,
-                    type: 'get',
-                    contentType: "application/x-www-form-urlencoded; charset=UTF-8",
-                    async: false,
-                    // 请求成功时的回调函数
-                    success: function (ret) {
-                        // 正则表达式用于匹配图标名称
-                        var exp = /fa-var-(.*):/ig;
-                        var result;
-                        // 遍历匹配结果并将图标名称添加到列表中
-                        while ((result = exp.exec(ret)) != null) {
-                            iconlist.push('fa-' + result[1]);
-                        }
-                    },
-                    // 请求失败时的回调函数
-                    error: function (xhr, textstatus, thrown) {
-                        layer.msg('fa图标接口有误');
-                    }
-                });
-                // 返回获取到的图标列表
-                return iconlist;
-            }
-        };
-
-        a.init();
-        return new IconPicker();
-    };
-
-   
-    IconPicker.prototype.checkIcon = function (filter, iconName) {
-            // 根据过滤器找到对应的元素，获取其下一个元素中的图标项，并设置当前图标名为c
-            var el = $('*[lay-filter=' + filter + ']'),
-                p = el.next().find('.layui-iconpicker-item .fa'),
-                c = iconName;
-    
-            // 检查图标名是否包含'#xe'，如果包含则直接设置图标内容，否则设置图标类名为c
-            if (c.indexOf('#xe') > 0) {
-                p.html(c);
-            } else {
-                p.html('').attr('class', 'fa ' + c);
-            }
-            // 设置元素的value属性和实际值为当前图标名c
-            el.attr('value', c).val(c);
-        };
-    
-        var iconPicker = new IconPicker();
-        // 导出iconPicker模块
-        exports(_MOD, iconPicker);
-    });
\ No newline at end of file
diff --git a/stt/index.html b/stt/index.html
deleted file mode 100644
index 7baaa85..0000000
--- a/stt/index.html
+++ /dev/null
@@ -1,229 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-    <!-- 设置文档的字符编码为UTF-8 -->
-    <meta charset="utf-8">
-    <!-- 设置网页标题 -->
-    <title>高校宿舍管理系统</title>
-    <!-- 设置网页关键词，便于搜索引擎优化 -->
-    <meta name="keywords" content="高校宿舍管理系统">
-    <!-- 设置网页描述，便于搜索引擎优化 -->
-    <meta name="description" content="高校宿舍管理系统">
-    <!-- 设置渲染引擎为webkit -->
-    <meta name="renderer" content="webkit">
-    <!-- 设置IE浏览器兼容模式 -->
-    <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
-    <!-- 允许所有来源的跨域请求 -->
-    <meta http-equiv="Access-Control-Allow-Origin" content="*">
-    <!-- 设置视口宽度和缩放比例 -->
-    <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
-    <!-- 设置苹果设备的状态栏样式为黑色 -->
-    <meta name="apple-mobile-web-app-status-bar-style" content="black">
-    <!-- 允许将网站添加到主屏幕 -->
-    <meta name="apple-mobile-web-app-capable" content="yes">
-    <!-- 禁用电话识别 -->
-    <meta name="format-detection" content="telephone=no">
-    <!-- 设置网页图标 -->
-    <link rel="icon" href="../images/favicon.ico">
-    <!-- 引入layui框架的CSS文件 -->
-    <link rel="stylesheet" href="../lib/layui-v2.5.5/css/layui.css" media="all">
-    <!-- 引入FontAwesome字体库的CSS文件 -->
-    <link rel="stylesheet" href="../lib/font-awesome-4.7.0/css/font-awesome.min.css" media="all">
-    <!-- 引入自定义的layuimini CSS文件 -->
-    <link rel="stylesheet" href="../css/layuimini.css?v=2.0.1" media="all">
-    <!-- 引入默认主题的CSS文件 -->
-    <link rel="stylesheet" href="../css/themes/default.css" media="all">
-    <!-- 引入公共CSS文件 -->
-    <link rel="stylesheet" href="../css/public.css" media="all">
-    <!--[if lt IE 9]>
-    <script src="https://cdn.staticfile.org/html5shiv/r29/html5.min.js"></script>
-        <!-- 引入 HTML5 shiv，用于使旧版 IE 浏览器支持 HTML5 元素 -->
-        <script src="https://cdn.staticfile.org/respond.js/1.4.2/respond.min.js"></script>
-        <!-- 引入 respond.js，用于使旧版 IE 浏览器支持媒体查询 -->
-        <![endif]-->
-        <!-- 结束条件注释 -->
-        <style id="layuimini-bg-color">
-        </style>
-        <!-- 定义一个空的样式标签，用于动态设置背景颜色 -->
-    </head>
-    <body class="layui-layout-body layuimini-all">
-        <!-- 页面主体部分，使用 layui 布局类 -->
-        <div class="layui-layout layui-layout-admin">
-            <!-- 使用 layui 布局容器 -->
-
-            <div class="layui-header header">
-                <!-- 页头部分 -->
-                <div class="layui-logo layuimini-logo layuimini-back-home"></div>
-                <!-- 网站 logo，点击可返回首页 -->
-
-                <div class="layuimini-header-content">
-                    <!-- 页头内容区域 -->
-                    <a>
-                        <div class="layuimini-tool"><i title="展开" class="fa fa-outdent" data-side-fold="1"></i></div>
-                        <!-- 折叠按钮，点击后展开菜单 -->
-                    </a>
-
-                    <!--电脑端头部菜单-->
-                    <ul class="layui-nav layui-layout-left layuimini-header-menu layuimini-menu-header-pc layuimini-pc-show">
-                        <!-- 电脑端头部菜单列表 -->
-                    </ul>
-
-                    <!--手机端头部菜单-->
-                    <ul class="layui-nav layui-layout-left layuimini-header-menu layuimini-mobile-show">
-                        <!-- 手机端头部菜单列表 -->
-                        <li class="layui-nav-item">
-                            <!-- 单个菜单项 -->
-                            <a href="javascript:;"><i class="fa fa-list-ul"></i> 选择模块</a>
-                            <!-- 菜单项链接和图标 -->
-                            <dl class="layui-nav-child layuimini-menu-header-mobile">
-                                <!-- 子菜单列表 -->
-                            </dl>
-                        </li>
-                    </ul>
-            <ul class="layui-nav layui-layout-right">
-                <!-- 刷新按钮 -->
-                <li class="layui-nav-item" lay-unselect>
-                    <!-- 点击后触发刷新操作 -->
-                    <a href="javascript:;" data-refresh="刷新"><i class="fa fa-refresh"></i></a>
-                </li>
-                <!-- 清理按钮（已注释） -->
-                <!-- <li class="layui-nav-item" lay-unselect>
-                    <a href="javascript:;" data-clear="清理" class="layuimini-clear"><i class="fa fa-trash-o"></i></a>
-                </li> -->
-                <!-- 全屏按钮，仅在移动设备上显示 -->
-                <li class="layui-nav-item mobile layui-hide-xs" lay-unselect>
-                    <!-- 点击后触发全屏操作 -->
-                    <a href="javascript:;" data-check-screen="full"><i class="fa fa-arrows-alt"></i></a>
-                </li>
-                <!-- 设置菜单项 -->
-                <li class="layui-nav-item layuimini-setting">
-                    <!-- 用户名链接 -->
-                    <a href="javascript:;" id="userName"></a>
-                    <!-- 下拉菜单内容 -->
-                    <dl class="layui-nav-child">
-                        <!-- 基本资料子菜单项 -->
-                        <dd>
-                            <a href="javascript:;" layuimini-content-href="user/info.html" data-title="基本资料" data-icon="fa fa-gears">基本资料</a>
-                        </dd>
-                        <!-- 修改密码子菜单项 -->
-                        <dd>
-                            <a href="javascript:;" layuimini-content-href="user/password.html" data-title="修改密码" data-icon="fa fa-gears">修改密码</a>
-                        </dd>
-                        <!-- 分隔线 -->
-                        <dd>
-                            <hr>
-                        </dd>
-                        <!-- 其他子菜单项可以继续添加在这里 -->
-                        <dd>
-    <!-- 退出登录链接 -->
-    <a href="javascript:;" class="login-out">退出登录</a>
-                        </dd>
-                    </dl>
-                </li>
-                <!-- 配色方案选择项 -->
-                <li class="layui-nav-item layuimini-select-bgcolor" lay-unselect>
-                    <!-- 点击后触发背景颜色选择功能 -->
-                    <a href="javascript:;" data-bgcolor="配色方案"><i class="fa fa-ellipsis-v"></i></a>
-                </li>
-            </ul>
-        </div>
-    </div>
-
-    <!-- 无限极左侧菜单容器 -->
-    <div class="layui-side layui-bg-black layuimini-menu-left">
-    </div>
-
-    <!-- 初始化加载层 -->
-    <div class="layuimini-loader">
-        <!-- 加载动画的内部容器 -->
-        <div class="layuimini-loader-inner"></div>
-    </div>
-
-    <!-- 手机端遮罩层 -->
-    <div class="layuimini-make"></div>
-
-    <!-- 移动导航 -->
-    <div class="layuimini-site-mobile"><i class="layui-icon"></i></div>
-    <!-- 页面主体内容 -->
-    <div class="layui-body">
-        <!-- 隐藏的卡片，用于显示面包屑导航 -->
-        <div class="layui-card layuimini-page-header layui-hide">
-            <!-- 面包屑导航 -->
-            <div class="layui-breadcrumb layuimini-page-title">
-                <!-- 主页链接 -->
-                <a lay-href="" href="/">主页</a><span lay-separator="">/</span>
-                <!-- 常规管理链接 -->
-                <a><cite>常规管理</cite></a><span lay-separator="">/</span>
-                <!-- 系统设置链接 -->
-                <a><cite>系统设置</cite></a>
-            </div>
-        </div>
-        <!-- 页面主要内容区域 -->
-        <div class="layuimini-content-page">
-        </div>
-    </div>
-
-</div>
-<script src="../lib/layui-v2.5.5/layui.js" charset="utf-8"></script>
-<!-- 引入 layui 框架 -->
-<script src="../js/lay-config.js?v=2.0.0" charset="utf-8"></script>
-<!-- 引入自定义的 lay-config 配置文件 -->
-<script>
-    // 使用 layui 模块
-    layui.use(['jquery', 'layer', 'miniAdmin','store'], function () {
-        var $ = layui.jquery,
-            // 获取 layui 的 jQuery 模块
-            layer = layui.layer,
-            // 获取 layui 的 layer 模块，用于弹出层和消息提示
-            store = layui.store,
-            // 获取 layui 的 store 模块，用于本地存储
-            miniAdmin = layui.miniAdmin;
-            // 获取 layui 的 miniAdmin 模块，用于后台管理界面
-
-        if(!store.getToken()){
-            // 如果本地存储中没有 token，则跳转到登录页面
-            location.href ='login.html';
-        }
-        if(store.getLoginInfo()){
-            // 如果本地存储中有登录信息，则显示用户名
-            $('#userName').html(store.getLoginInfo());
-        }
-
-        <script>
-            // 定义配置选项对象
-            let options = {
-                iniUrl: "menu/query",    // 功能菜单请求接口地址
-                clearUrl: "", // 缓存清理接口
-                renderPageVersion: true,    // 初始化页面是否加版本号
-                bgColorDefault: false,      // 主题默认配置
-                multiModule: false,          // 是否开启多模块
-                menuChildOpen: false,       // 是否默认展开菜单
-                loadingTime: 0,             // 初始化加载时间
-                pageAnim: true,             // 切换菜单动画
-                logoInfo: {
-                    title: "宿舍管理系统", // 系统标题
-                    image: "../images/logo.png", // 系统Logo图片路径
-                    href: "" // 系统链接
-                },
-                homeInfo: {
-                    title: "首页", // 首页标题
-                    href: "main.html" // 首页链接
-                },
-            };
-            // 调用miniAdmin的render方法，传入配置选项
-            miniAdmin.render(options);
-
-            // 为退出按钮绑定点击事件
-            $('.login-out').on("click", function () {
-                // 弹出确认对话框，询问用户是否确定退出
-                layer.confirm("确定要退出吗？",function () {
-                    // 清除本地存储数据
-                    store.clear();
-                    // 跳转到登录页面
-                    window.location = 'login.html';
-                })
-            });
-        });
-        </script>
-        </body>
-</html>
diff --git a/stt/login.html b/stt/login.html
deleted file mode 100644
index b382588..0000000
--- a/stt/login.html
+++ /dev/null
@@ -1,246 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-    <meta charset="UTF-8">
-    <!-- 设置文档的字符编码为UTF-8 -->
-    <title>后台管理-登陆</title>
-    <!-- 设置网页标题为“后台管理-登陆” -->
-    <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
-    <!-- 设置浏览器兼容模式，优先使用最新版本的IE和Chrome内核 -->
-    <meta http-equiv="Access-Control-Allow-Origin" content="*">
-    <!-- 允许所有来源的跨域请求 -->
-    <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
-    <!-- 设置视口宽度等于设备宽度，初始缩放比例为1，最大缩放比例为1 -->
-    <meta name="apple-mobile-web-app-status-bar-style" content="black">
-    <!-- 设置苹果移动设备上的状态栏样式为黑色 -->
-    <meta name="apple-mobile-web-app-capable" content="yes">
-    <!-- 允许将网页添加到主屏幕，作为应用程序运行 -->
-    <meta name="format-detection" content="telephone=no">
-    <!-- 禁止自动检测电话号码 -->
-    <link rel="stylesheet" href="../lib/layui-v2.5.5/css/layui.css"
-    <!-- 引入Layui框架的CSS文件，用于美化页面 -->
-    <!--[if lt IE 9]>
-    <script src="https://cdn.staticfile.org/html5shiv/r29/html5.min.js"></script>
-    <script src="https://cdn.staticfile.org/respond.js/1.4.2/respond.min.js"></script>
-    <![endif]-->
-    <style>
-            /* 设置主内容区域的样式，使其居中显示 */
-            .main-body {top:50%;left:50%;position:absolute;-webkit-transform:translate(-50%,-50%);-moz-transform:translate(-50%,-50%);-ms-transform:translate(-50%,-50%);-o-transform:translate(-50%,-50%);transform:translate(-50%,-50%);overflow:hidden;}
-
-            /* 设置登录输入框的样式 */
-            .login-main .login-bottom .center .item input {display:inline-block;width:227px;height:22px;padding:0;position:absolute;border:0;outline:0;font-size:14px;letter-spacing:0;}
-
-            /* 设置图标1的背景图片位置 */
-            .login-main .login-bottom .center .item .icon-1 {background:url(../images/icon-login.png) no-repeat 1px 0;}
-
-            /* 设置图标2的背景图片位置 */
-            .login-main .login-bottom .center .item .icon-2 {background:url(../images/icon-login.png) no-repeat -54px 0;}
-
-            /* 设置图标3的背景图片位置 */
-            .login-main .login-bottom .center .item .icon-3 {background:url(../images/icon-login.png) no-repeat -106px 0;}
-
-            /* 设置图标4的背景图片位置和样式 */
-            .login-main .login-bottom .center .item .icon-4 {background:url(../images/icon-login.png) no-repeat 0 -43px;position:absolute;right:-10px;cursor:pointer;}
-
-            /* 设置图标5的背景图片位置 */
-            .login-main .login-bottom .center .item .icon-5 {background:url(../images/icon-login.png) no-repeat -55px -43px;}
-
-            /* 设置图标6的背景图片位置和样式 */
-            .login-main .login-bottom .center .item .icon-6 {background:url(../images/icon-login.png) no-repeat 0 -93px;position:absolute;right:-10px;margin-top:8px;cursor:pointer;}
-
-            /* 设置未选中提示图标的样式 */
-            .login-main .login-bottom .tip .icon-nocheck {display:inline-block;width:10px;height:10px;border-radius:2px;border:solid 1px #9abcda;position:relative;top:2px;margin:1px 8px 1px 1px;cursor:pointer;}
-
-            /* 设置选中提示图标的样式 */
-            .login-main .login-bottom .tip .icon-check {margin:0 7px 0 0;width:14px;height:14px;border:none;background:url(../images/icon-login.png) no-repeat -111px -48px;}
-
-            /* 设置图标的通用样式 */
-            .login-main .login-bottom .center .item .icon {display:inline-block;width:33px;height:22px;}
-
-            /* 设置每个输入项的样式 */
-            .login-main .login-bottom .center .item {width:288px;height:35px;border-bottom:1px solid #dae1e6;margin-bottom:35px;}
-
-            /* 设置登录框的宽度和浮动属性 */
-            .login-main {width:428px;position:relative;float:left;}
-
-            /* 设置顶部区域的高度、背景颜色等样式 */
-            .login-main .login-top {height:117px;background-color:#148be4;border-radius:12px 12px 0 0;font-family:SourceHanSansCN-Regular;font-size:30px;font-weight:400;font-stretch:normal;letter-spacing:0;color:#fff;line-height:117px;text-align:center;overflow:hidden;-webkit-transform:rotate(0);-moz-transform:rotate(0);-ms-transform:rotate(0);-o-transform:rotate(0);transform:rotate(0);}
-
-            /* 设置顶部区域的第一个背景图标样式 */
-            .login-main .login-top .bg1 {display:inline-block;width:74px;height:74px;background:#fff;opacity:.1;border-radius:0 74px 0 0;position:absolute;left:0;top:43px;}
-
-            /* 设置顶部区域的第二个背景图标样式 */
-            .login-main .login-top .bg2 {display:inline-block;width:94px;height:94px;background:#fff;opacity:.1;border-radius:50%;position:absolute;right:-16px;top:-16px;}
-
-            /* 设置底部区域的宽度、背景颜色等样式 */
-            .login-main .login-bottom {width:428px;background:#fff;border-radius:0 0 12px 12px;padding-bottom:53px;}
-
-            /* 设置底部中心区域的样式 */
-            .login-main .login-bottom .center {width:288px;margin:0 auto;padding-top:40px;padding-bottom:15px;position:relative;}
-
-            /* 设置提示信息的样式 */
-            .login-main .login-bottom .tip {clear:both;height:16px;line-height:16px;width:288px;margin:0 auto;}
-
-            /* 设置页面背景图片和字体大小 */
-            body {background:url(../images/login-bg3.jpg) 0% 0% / cover no-repeat;position:static;font-size:12px;}
-
-            /* 设置输入框在Webkit浏览器中的占位符样式 */
-            input::-webkit-input-placeholder {color:#a6aebf;}
-
-            /* 设置输入框在Mozilla Firefox浏览器中的占位符样式 */
-            input::-moz-placeholder {color:#a6aebf;}
-
-            /* 设置输入框在旧版Mozilla Firefox浏览器中的占位符样式 */
-            input:-moz-placeholder {color:#a6aebf;}
-
-            /* 设置输入框在Internet Explorer浏览器中的占位符样式 */
-            input:-ms-input-placeholder {color:#a6aebf;}
-
-            /* 取消Chrome记住密码的背景颜色 */
-            input:-webkit-autofill {-webkit-box-shadow:0 0 0 1000px white inset !important;}
-
-            /* 设置html元素的高度为100% */
-            html {height:100%;}
-        .login-main .login-bottom .tip {clear:both;height:16px;line-height:16px;width:288px;margin:0 auto;}
-        .login-main .login-bottom .tip .login-tip {font-family:MicrosoftYaHei;font-size:12px;font-weight:400;font-stretch:normal;letter-spacing:0;color:#9abcda;cursor:pointer;}
-        .login-main .login-bottom .tip .forget-password {font-stretch:normal;letter-spacing:0;color:#1391ff;text-decoration:none;position:absolute;right:62px;}
-        .login-main .login-bottom .login-btn {width:288px;height:40px;background-color:#1E9FFF;border-radius:16px;margin:24px auto 0;text-align:center;line-height:40px;color:#fff;font-size:14px;letter-spacing:0;cursor:pointer;border:none;}
-        .login-main .login-bottom .center .item .validateImg {position:absolute;right:1px;cursor:pointer;height:36px;border:1px solid #e6e6e6;}
-        .footer {left:0;bottom:0;color:#fff;width:100%;position:absolute;text-align:center;line-height:30px;padding-bottom:10px;text-shadow:#000 0.1em 0.1em 0.1em;font-size:14px;}
-        .padding-5 {padding:5px !important;}
-        .footer a,.footer span {color:#fff;}
-        @media screen and (max-width:428px) {.login-main {width:360px !important;}
-            .login-main .login-top {width:360px !important;}
-            .login-main .login-bottom {width:360px !important;}
-        }
-    </style>
-</head>
-<body>
-<div class="main-body">
-    <!-- 主内容区域 -->
-    <div class="login-main">
-        <!-- 登录界面主体部分 -->
-        <div class="login-top">
-            <!-- 顶部标题和装饰背景 -->
-            <span>高校宿舍管理系统</span>
-            <!-- 背景装饰1 -->
-            <span class="bg1"></span>
-            <!-- 背景装饰2 -->
-            <span class="bg2"></span>
-        </div>
-        <!-- 登录表单 -->
-        <form class="layui-form login-bottom">
-            <!-- 居中对齐 -->
-            <div class="center">
-                <!-- 用户名输入框 -->
-                <div class="item">
-                    <!-- 用户名图标 -->
-                    <span class="icon icon-2"></span>
-                    <!-- 用户名输入框，验证必填，默认值为admin，自动完成关闭，占位符为请输入登录账号，最大长度24 -->
-                    <input type="text" name="userName" lay-verify="required" value="admin" autocomplete="off" placeholder="请输入登录账号" maxlength="24"/>
-                </div>
-                <!-- 密码输入框 -->
-                <div class="item">
-                    <!-- 密码图标 -->
-                    <span class="icon icon-3"></span>
-                    <!-- 密码输入框，验证必填，默认值为123456，自动完成关闭，占位符为请输入密码，最大长度20 -->
-                    <input type="password" name="password" lay-verify="required" value="123456" autocomplete="off" placeholder="请输入密码" maxlength="20">
-                    <!-- 绑定密码图标 -->
-                    <span class="bind-password icon icon-4"></span>
-                </div>
-                <!-- 角色选择下拉框 -->
-                <div class="item">
-                  <!-- 角色选择图标 -->
-                  <span class="icon icon-2" style="float: left"></span>
-                  <div>
-                    <!-- 角色选择下拉框，验证必填 -->
-                    <select name="type" lay-verify="required">
-                      <!-- 提示选择登陆角色 -->
-                      <option value="">请选择登陆角色</option>
-                      <!-- 管理员选项，默认选中 -->
-                      <option value="0" selected>管理员</option>
-                      <!-- 宿管员选项 -->
-                      <option value="1">宿管员</option>
-                      <!-- 学生选项 -->
-                      <option value="2">学生</option>
-                    </select>
-                  </div>
-                </div>
-            </div>
-            <div class="layui-form-item" style="text-align:center; width:100%;height:100%;margin:0px;">
-                <button class="login-btn" lay-submit="" lay-filter="login">立即登录</button>
-            </div>
-        </form>
-    </div>
-</div>
-<div class="footer">
-    ©版权所有 2020 研真教育
-</div>
-<script src="../lib/layui-v2.5.5/layui.js" charset="utf-8"></script>
-<script src="../js/lay-config.js" charset="utf-8"></script>
-
-<script>
-    // 使用layui模块
-    layui.use(['form','jquery','axios','layer','store'], function () {
-        var $ = layui.jquery,
-            form = layui.form,
-            axios = layui.axios,
-            layer = layui.layer,
-            store = layui.store,
-            layer = layui.layer;
-
-        // 如果当前页面不是顶层窗口，则将顶层窗口的地址设置为当前页面地址，跳出iframe框架
-        if (top.location != self.location) top.location = self.location;
-
-        // 绑定点击事件到密码显示按钮
-        $('.bind-password').on('click', function () {
-            // 如果按钮有'icon-5'类，移除该类并设置密码输入框类型为'password'
-            if ($(this).hasClass('icon-5')) {
-                $(this).removeClass('icon-5');
-                $("input[name='password']").attr('type', 'password');
-            } else {
-                // 否则添加'icon-5'类并设置密码输入框类型为'text'
-                $(this).addClass('icon-5');
-                $("input[name='password']").attr('type', 'text');
-            }
-        });
-        // 进行登录操作
-        form.on('submit(login)', function (data) {
-            // 获取表单数据
-            data = data.field;
-            axios({
-                // 设置请求方法为POST
-                method: 'post',
-                // 设置请求URL为/login
-                url: '/login',
-                // 将表单数据作为请求体发送
-                data: data
-            }).then(function(data){
-                // 如果返回的code为200，表示登录成功
-                if(data.code == 200){
-                    // 存储服务器返回的token
-                    store.setToken(data.data.token)
-                    // 如果返回的用户信息存在，则存储用户信息
-                    if(data.data.user){
-                        store.setLoginInfo(data.data.user,0);
-                    }
-                    // 如果返回的学生信息存在，则存储学生信息
-                    if(data.data.student){
-                        store.setLoginInfo(data.data.student,1);
-                    }
-                    // 跳转到首页
-                    location.href='index.html'
-                }else{
-                    // 如果登录失败，显示错误信息
-                    layer.msg(data.msg);
-                }
-            }).catch(function(error){
-                // 捕获并处理请求过程中的错误
-                layer.msg(error);
-            });
-            // 阻止表单默认提交行为
-            return false;
-        });
-</script>
-</body>
-</html>
\ No newline at end of file
diff --git a/stt/main.html b/stt/main.html
deleted file mode 100644
index bbbda38..0000000
--- a/stt/main.html
+++ /dev/null
@@ -1,287 +0,0 @@
-<style>
-    .welcome .layui-card {border:1px solid #f2f2f2;border-radius:5px;}
-        <!-- 设置卡片的边框和圆角 -->
-        .welcome .icon {margin-right:10px;color:#1aa094;}
-        <!-- 设置图标的右边距和颜色 -->
-        .welcome .icon-cray {color:#ffb800 !important;}
-        <!-- 设置特定图标的颜色为黄色 -->
-        .welcome .icon-blue {color:#1e9fff !important;}
-        <!-- 设置特定图标的颜色为蓝色 -->
-        .welcome .icon-tip {color:#ff5722 !important;}
-        <!-- 设置特定图标的颜色为橙色 -->
-        .welcome .layuimini-qiuck-module {text-align:center;margin-top:10px}
-        <!-- 设置快速模块的文本居中和上边距 -->
-        .welcome .layuimini-qiuck-module a i {display:inline-block;width:100%;height:60px;line-height:60px;text-align:center;border-radius:2px;font-size:30px;background-color:#F8F8F8;color:#333;transition:all .3s;-webkit-transition:all .3s;}
-        <!-- 设置快速模块中的链接图标样式，包括尺寸、对齐方式、背景色等 -->
-        .welcome .layuimini-qiuck-module a cite {position:relative;top:2px;display:block;color:#666;text-overflow:ellipsis;overflow:hidden;white-space:nowrap;font-size:14px;}
-        <!-- 设置快速模块中的引用文本样式，包括位置、颜色、溢出处理等 -->
-        .welcome .welcome-module {width:100%;height:210px;}
-        <!-- 设置欢迎模块的宽度和高度 -->
-        .welcome .panel {background-color:#fff;border:1px solid transparent;border-radius:3px;-webkit-box-shadow:0 1px 1px rgba(0,0,0,.05);box-shadow:0 1px 1px rgba(0,0,0,.05)}
-        <!-- 设置面板的背景色、边框和阴影效果 -->
-        .welcome .panel-body {padding:10px}
-        <!-- 设置面板主体的内边距 -->
-        .welcome .panel-title {margin-top:0;margin-bottom:0;font-size:12px;color:inherit}
-        <!-- 设置面板标题的外边距和字体大小 -->
-        .welcome .label {display:inline;padding:.2em .6em .3em;font-size:75%;font-weight:700;line-height:1;color:#fff;text-align:center;white-space:nowrap;vertical-align:baseline;border-radius:.25em;margin-top:.3em;}
-        <!-- 设置标签的显示方式、内边距、字体大小、行高、颜色、对齐方式等 -->
-        .welcome .layui-red {color:red}
-        <!-- 设置红色文字的颜色 -->
-        .welcome .main_btn > p {height:40px;}
-        <!-- 设置主按钮中段落的高度 -->
-        .welcome .layui-bg-number {background-color:#F8F8F8;}
-        <!-- 设置数字背景的颜色 -->
-        .welcome .layuimini-notice:hover {background:#f6f6f6;}
-        <!-- 设置通知悬停时的背景颜色 -->
-        .welcome .layuimini-notice {padding:7px 16px;clear:both;font-size:12px !important;cursor:pointer;position:relative;transition:background 0.2s ease-in-out;}
-        <!-- 设置通知的内边距、清除浮动、字体大小、光标类型、位置和过渡效果 -->
-        .welcome .layuimini-notice-title,.layuimini-notice-label {padding-right:70px !important;text-overflow:ellipsis !important;overflow:hidden !important;white-space:nowrap !important;}
-        <!-- 设置通知标题和标签的右内边距、文本溢出处理、隐藏溢出内容和不换行 -->
-        .welcome .layuimini-notice-title {line-height:28px;font-size:14px;}
-        <!-- 设置通知标题的行高和字体大小 -->
-        .welcome .layuimini-notice-extra {position:absolute;top:50%;margin-top:-8px;right:16px;display:inline-block;height:16px;color:#999;}
-        <!-- 设置通知额外信息的绝对定位、顶部偏移、右边距、显示方式、高度和颜色 -->
-    </style>
-<!-- 主容器，包含页面动画效果 -->
-<div class="layuimini-container layuimini-page-anim">
-    <!-- 主要内容区域，class为welcome -->
-    <div class="layuimini-main welcome">
-        <!-- 行布局，列间距为15px -->
-        <div class="layui-row layui-col-space15">
-            <!-- 占据8个栅格的列 -->
-            <div class="layui-col-md8">
-                <!-- 嵌套行布局 -->
-                <div class="layui-row">
-                    <!-- 卡片组件，高度400px -->
-                    <div class="layui-card" style="height: 400px;">
-                        <!-- 卡片头部，包含警告图标和标题 -->
-                        <div class="layui-card-header"><i class="fa fa-warning icon"></i>数据统计</div>
-                        <!-- 卡片主体部分 -->
-                        <div class="layui-card-body">
-                            <!-- 欢迎模块，高度350px，内容溢出时自动滚动 -->
-                            <div class="welcome-module" style="height: 350px;overflow: auto;">
-                                <!-- 表格组件，使用line风格 -->
-                                <table class="layui-table" lay-skin="line">
-                                    <tr>
-                                        <!-- 表头：楼宇 -->
-                                        <th>楼宇</th>
-                                        <!-- 表头：宿舍数量 -->
-                                        <th>宿舍数量</th>
-                                        <!-- 表头：入住人数 -->
-                                        <th>入住人数</th>
-                                        <!-- 表头：闲置数量 -->
-                                        <th>闲置数量</th>
-                                        <!-- 表头：使用率 -->
-                                        <th>使用率</th>
-                                    </tr>
-                                    <!-- 表格主体部分，id为building-data -->
-                                    <tbody id="building-data"></tbody>
-                                    </table>
-                                    </div>
-                                    </div>
-                                    </div>
-                                    <div class="layui-card">
-                                        <!-- 报表统计卡片头部，包含图标和标题 -->
-                                        <div class="layui-card-header"><i class="fa fa-line-chart icon"></i>报表统计</div>
-                                        <div class="layui-card-body">
-                                            <!-- 报表统计的ECharts容器，最小高度为365px -->
-                                            <div id="echarts-records" style="min-height:365px"></div>
-                                        </div>
-                                    </div>
-                                    </div>
-                                    </div>
-                                    <div class="layui-col-md4">
-                                        <div class="layui-card" style="height: 400px;">
-                                            <!-- 系统公告卡片头部，包含图标和标题 -->
-                                            <div class="layui-card-header"><i class="fa fa-bullhorn icon icon-tip"></i>系统公告</div>
-                                            <!-- 系统公告内容展示区域，id为notice-data -->
-                                            <div class="layui-card-body layui-text" id="notice-data"></div>
-                                        </div>
-                                        <div class="layui-card">
-                                            <!-- 版本信息卡片头部，包含图标和标题 -->
-                                            <div class="layui-card-header"><i class="fa fa-fire icon"></i>版本信息</div>
-                                            <div class="layui-card-body layui-text">
-                                                <!-- 版本信息的表格结构 -->
-                                                <table class="layui-table">
-                                                    <colgroup>
-                                <col width="100">
-                                <col>
-                            </colgroup>
-                            <tbody>
-                            <tr>
-                                <td>项目名称</td>
-                                <td>
-                                    高校宿舍管理系统
-                                </td>
-                            </tr>
-                            <tr>
-                                <td>当前版本</td>
-                                <td>v1.0.0</td>
-                            </tr>
-                            <tr>
-                                <td>后端技术</td>
-                                <td>SpringBoot</td>
-                            </tr>
-                            <tr>
-                              <td>前端技术</td>
-                              <td>Layui框架</td>
-                            </tr>
-
-                            </tbody>
-                        </table>
-                    </div>
-                </div>
-            </div>
-        </div>
-    </div>
-</div>
-<script>
-    layui.use(['layer','echarts'], function () {
-        // 引入layui的jquery、layer和echarts模块
-        var $ = layui.jquery,
-            layer = layui.layer,
-            echarts = layui.echarts;
-
-        // 判断登录类型是否为1，如果是则清空欢迎信息并显示特定文本
-        if(store.getLoginType() == 1){
-            $('.welcome').empty(); // 清空欢迎信息
-            $('.welcome').append("欢迎高校学生宿舍管理系统"); // 添加特定文本到欢迎信息中
-            return; // 结束函数执行
-        }
-
-        /**
-         * 加载建筑信息的函数
-         * 通过axios发送GET请求获取建筑数据，并将数据渲染到页面上
-         */
-        function loadBuilding(){
-            // 发送GET请求获取建筑数据，限制返回的数据条数为1000
-            axios.get('main/building',{limit:1000}).then(function (response) {
-                // 遍历响应数据中的每一项
-                response.data.forEach(item=>{
-                    // 创建包含建筑信息的HTML字符串
-                    let html = `<tr>
-                                    <td>${item.name}</td> <!-- 建筑名称 -->
-                                    <td>${item.all}</td> <!-- 总床位数 -->
-                                    <td>${item.used}</td> <!-- 已使用床位数 -->
-                                    <td>${item.unused}</td> <!-- 未使用床位数 -->
-                                    <td>${item.percent}%</td> <!-- 使用率百分比 -->
-                                </tr>`
-
-                $('#building-data').append(html);
-              })
-          });
-        }
-        loadBuilding();
-        function loadNotice() {
-          axios.get('main/notice').then(function (response) {
-            response.data.forEach(item=>{
-              let html = `<div class="layuimini-notice">
-                            <div class="layuimini-notice-title">${item.title}</div>
-                            <div class="layuimini-notice-extra">${item.createTime}</div>
-                            <div class="layuimini-notice-content layui-hide">${item.content}</div>
-                         </div>`
-              $('#notice-data').append(html);
-            })
-          });
-        }
-      loadNotice();
-
-
-
-        $('body').on('click', '.layuimini-notice', function () {
-            // 获取公告标题文本
-            let title = $(this).children('.layuimini-notice-title').text(),
-                // 获取公告时间文本
-                noticeTime = $(this).children('.layuimini-notice-extra').text(),
-                // 获取公告内容HTML
-                content = $(this).children('.layuimini-notice-content').html();
-
-            // 构建公告弹窗的HTML内容
-            let html = '<div style="padding:15px 20px; text-align:justify; line-height: 22px;border-bottom:1px solid #e2e2e2;background-color: #eeeeee;color: #222222;">\n' +
-                '<div style="text-align: center;margin-bottom: 20px;font-weight: bold;border-bottom:1px solid #718fb5;padding-bottom: 5px"><h4 class="text-danger">' + title + '</h4></div>\n' +
-                '<div style="font-size: 14px">' + content + '</div>\n' +
-                '</div>\n';
-
-            // 使用layer插件打开公告弹窗
-            parent.layer.open({
-                // 弹窗类型为页面层
-                type: 1,
-                // 设置弹窗标题，包含系统公告和公告时间
-                title: '系统公告' + '<span style="float: right;right: 1px;font-size: 12px;color: #b1b3b9;margin-top: 1px">' + noticeTime + '</span>',
-                // 设置弹窗宽度
-                area: '400px;',
-                // 设置遮罩透明度
-                shade: 0.8,
-                // 设置弹窗ID
-                id: 'layuimini-notice',
-                // 设置弹窗按钮
-                btn: ['取消'],
-                // 设置按钮对齐方式为居中
-                btnAlign: 'c',
-                // 设置拖拽类型
-                moveType: 1,
-                // 设置弹窗内容为构建的HTML
-                content: html
-            });
-        });
-        });
-
-
-
-        function loadReport(){
-            // 使用axios发送GET请求，获取建筑数据，限制返回1000条记录
-            axios.get('main/building',{limit:1000}).then(function (response) {
-                // 从响应数据中提取每个建筑的used属性值
-                let used = response.data.map(item=>item.used);
-                // 从响应数据中提取每个建筑的name属性值
-                let name = response.data.map(item=>item.name);
-                // 调用loadEchars函数，将提取到的名称和数值传递给它
-                loadEchars(name,used);
-            });
-        }
-
-        // 调用loadReport函数，加载报告数据
-        loadReport();
-
-        function loadEchars(name,values){
-            // 初始化echarts实例，绑定到页面中的'echarts-records'元素，并使用'walden'主题
-            let echartsRecords = echarts.init(document.getElementById('echarts-records'), 'walden');
-            // 配置echarts图表的选项
-            let option = {
-                xAxis: {
-                    // x轴类型为类目轴
-                    type: 'category',
-                    // x轴的数据为建筑名称
-                    data: name
-                },
-                tooltip: {}, // 提示框组件，默认配置
-                yAxis: {
-                    // y轴类型为数值轴
-                    type: 'value'
-                },
-                series: [{
-                    // 系列数据为传入的数值数组
-                    data: values,
-                    // 系列类型为柱状图
-                    type: 'bar',
-                    // 显示背景
-                    showBackground: true,
-                    backgroundStyle: {
-                        // 设置背景颜色为半透明灰色
-                        color: 'rgba(220, 220, 220, 0.8)'
-              }
-            }]
-          };
-  // 设置 ECharts 图表的配置项和数据
-  echartsRecords.setOption(option);
-
-  // 定义窗口大小变化时的事件处理函数，使 ECharts 图表自适应窗口大小
-  window.onresize = function () {
-    // 调用 ECharts 实例的 resize 方法，调整图表大小以适应新的窗口尺寸
-    echartsRecords.resize();
-  }
-      }
-
-
-    });
-</script>
diff --git a/stt/org.js b/stt/org.js
deleted file mode 100644
index a6f49f7..0000000
--- a/stt/org.js
+++ /dev/null
@@ -1,120 +0,0 @@
-layui.define(['ztree', 'jquery','axios'], function (exports) {
-    "use strict";
-    // 定义模块名称为 'selectOrg'
-    let MOD_NAME = 'selectOrg',
-        // 引入 layui 的 jQuery 模块
-        $ = layui.jquery,
-        // 引入 layui 的 axios 模块
-        axios = layui.axios,
-        // 引入 layui 的 ztree 模块
-        ztree = layui.ztree;
-    // 定义 selectOrg 类
-    let selectOrg = function () {
-        // 初始化版本号为 '1.1.0'
-        this.v = '1.1.0';
-    };
-   
-    selectOrg.prototype.render = function (opt) {
-        // 获取目标元素
-        let elem = $(opt.elem);
-        // 获取渲染完成后的回调函数，默认为空函数
-        let tableDone = opt.done || function(){};
-        // 设置表格高度，默认为315px
-        opt.height = opt.height || 315;
-        // 设置表格最小宽度，默认为300px
-        opt.width = opt.width || 300;
-        // 为元素绑定点击事件，防止事件冒泡
-        elem.off('click').on('click', function(e) {
-            // 阻止事件冒泡
-            e.stopPropagation();
-            // 如果页面上已经存在treeSelect元素，则返回false
-            if($('div.treeSelect').length >= 1){
-                return false;
-            }
-            // 计算treeSelect的top和left位置
-            let t = elem.offset().top + elem.outerHeight()+"px";
-            let l = elem.offset().left +"px";
-            // 构建treeSelect的HTML结构
-            let treeBox = '<div class="treeSelect layui-anim layui-anim-upbit" style="left:'+l+';top:'+t+';border: 1px solid #d2d2d2;background-color: #fff;box-shadow: 0 2px 4px rgba(0,0,0,.12);padding:10px 10px 0 10px;position: absolute;z-index:66666666;margin: 5px 0;border-radius: 2px;min-width:'+opt.width+'px;max-height: 300px;overflow: auto;">';
-            // 如果opt.checked为真，则添加确定按钮
-            if(opt.checked){
-                treeBox += '<div><button type="button" style="float: right" class="layui-btn layui-btn-normal layui-btn-sm tree-sure">确定</button></div>';
-            }
-            // 添加ztree容器
-            treeBox += '<div class="ztree" id="ztree_xx">';
-            treeBox += '</div>';
-            // 将treeBox转换为jQuery对象
-            treeBox = $(treeBox);
-            // 将treeBox添加到body元素中
-            $('body').append(treeBox);
-
-            
-
-        let setting = {
-            // 定义树结构的基本数据格式
-            data: {
-                simpleData: {
-                    enable: true // 启用简单数据模式
-                }
-            },
-            // 定义点击事件的回调函数
-            callback:{
-                onClick:function (event, treeId, treeNode) {
-                    // 如果未选中任何节点
-                    if(!opt.checked){
-                        $('.treeSelect').remove(); // 移除树选择元素
-                        opt.done([treeNode]); // 执行完成回调函数并传递当前点击的节点
-                    }
-                }
-            },
-            // 定义树节点的选中状态
-            check:{
-                enable: opt.checked // 根据外部传入的 opt.checked 决定是否启用节点选中功能
-            }
-        };
-
-        // 使用 axios 获取组织树数据，并初始化 ztree
-        axios.get('org/tree').then(function (response) {
-            // 初始化 ztree，传入目标元素、配置和数据
-            ztree.init($("#ztree_xx"), setting, response.data);
-        
-            // 获取 ztree 对象
-            let treeObj = ztree.getZTreeObj("ztree_xx");
-            if(opt.checked){
-                // 如果 opt.checked 为真，初始化 checked 节点
-                opt.selected.forEach(v=>{
-                    // 根据 id 获取节点
-                    let checkNodes = treeObj.getNodesByParam("id", v, null);
-                    // 设置节点为选中状态
-                    treeObj.checkNode(checkNodes[0], true);
-                });
-                // 确定按钮点击事件，获取选中的节点并处理
-                $('.tree-sure').click(function () {
-                    // 获取所有选中的节点
-                    let arr = treeObj.getCheckedNodes(true);
-                    // 调用 done 方法处理选中的节点
-                    opt.done(arr);
-                    // 更新 opt.selected 为选中节点的 id 数组
-                    opt.selected = arr.map(item=>item.id);
-                    // 移除树框
-                    treeBox.remove();
-                });
-            }
-        
-        }).catch(function (error) {
-            // 捕获并打印错误信息
-            console.log(error);
-        });
-        // 监听文档的 mouseup 事件，用于移除树选择框
-        $(document).mouseup(function(e){
-            // 获取用户设置的容器元素和树选择框元素
-            let userSet_con = $(''+opt.elem+',.treeSelect');
-            // 如果点击的目标不是用户设置的容器或其子元素，则移除树选择框
-            if(!userSet_con.is(e.target) && userSet_con.has(e.target).length === 0){
-                treeBox.remove();
-            }
-        });
-        
-        }); // elem end
-        // 导出模块，创建新的 selectOrg 实例
-        exports(MOD_NAME, new selectOrg());
\ No newline at end of file
diff --git a/stt/step.js b/stt/step.js
deleted file mode 100644
index 7e36b04..0000000
--- a/stt/step.js
+++ /dev/null
@@ -1,135 +0,0 @@
-layui.define(['layer', 'carousel'], function (exports) {
-    // 引入 jQuery 模块
-    var $ = layui.jquery;
-    // 引入 layer 模块
-    var layer = layui.layer;
-    // 引入 carousel 模块
-    var carousel = layui.carousel;
-
-    // 添加步骤条dom节点
-    var renderDom = function (elem, stepItems, postion) {
-        // 初始化步骤条的 HTML 字符串
-        var stepDiv = '<div class="lay-step">';
-        // 遍历步骤项数组，生成每个步骤项的 HTML
-        for (var i = 0; i < stepItems.length; i++) {
-            // 为每个步骤项添加一个包含类名 "step-item" 的 div 标签
-            stepDiv += '<div class="step-item">';
-            // 线
-            // 检查当前索引是否小于步骤项数组的最后一个索引
-            if (i < (stepItems.length - 1)) {
-                // 如果当前索引小于目标位置
-                if (i < postion) {
-                    // 添加已完成的步骤项尾部HTML代码
-                    stepDiv += '<div class="step-item-tail"><i class="step-item-tail-done"></i></div>';
-                } else {
-                    // 添加未完成的步骤项尾部HTML代码
-                    stepDiv += '<div class="step-item-tail"><i class=""></i></div>';
-                }
-            }
-
-            // 数字
-            // 获取当前步骤的编号
-            var number = stepItems[i].number;
-            
-            // 如果当前步骤没有编号，则使用默认编号（步骤索引加1）
-            if (!number) {
-                number = i + 1;
-            }
-            
-            // 根据当前步骤的位置生成相应的HTML代码
-            if (i == postion) {
-                // 如果当前步骤是活动步骤，添加活动状态的样式
-                stepDiv += '<div class="step-item-head step-item-head-active"><i class="layui-icon">' + number + '</i></div>';
-            } else if (i < postion) {
-                // 如果当前步骤在活动步骤之前，添加已完成状态的样式
-                stepDiv += '<div class="step-item-head"><i class="layui-icon layui-icon-ok"></i></div>';
-            } else {
-                // 如果当前步骤在活动步骤之后，添加未完成状态的样式
-                stepDiv += '<div class="step-item-head "><i class="layui-icon">' + number + '</i></div>';
-            }
-
-        // 获取当前步骤的标题和描述
-        var title = stepItems[i].title;
-        var desc = stepItems[i].desc;
-        
-        // 如果标题或描述存在，则创建包含标题和描述的HTML结构
-        if (title || desc) {
-            stepDiv += '<div class="step-item-main">';
-            
-            // 如果标题存在，添加标题的HTML结构
-            if (title) {
-                stepDiv += '<div class="step-item-main-title">' + title + '</div>';
-            }
-            
-            // 如果描述存在，添加描述的HTML结构
-            if (desc) {
-                stepDiv += '<div class="step-item-main-desc">' + desc + '</div>';
-            }
-            
-            stepDiv += '</div>';
-        }
-        
-        // 关闭当前步骤的div标签
-        stepDiv += '</div>';
-    }
-    
-    // 关闭所有步骤的容器div标签
-    stepDiv += '</div>';
-
-    // 将生成的HTML插入到指定的元素中
-    $(elem).prepend(stepDiv);
-
-    // 计算每一个条目的宽度，使其平均分布
-    var bfb = 100 / stepItems.length;
-    $('.step-item').css('width', bfb + '%');
-};
-
-    var step = {
-            // 渲染步骤条
-            render: function (param) {
-                param.indicator = 'none';  // 不显示指示器
-                param.arrow = 'always';  // 始终显示箭头
-                param.autoplay = false;  // 关闭自动播放
-                if (!param.stepWidth) {
-                    param.stepWidth = '400px';  // 如果未设置步骤条宽度，则默认为400px
-                }
-    
-                // 渲染轮播图
-                carousel.render(param);
-    
-                // 渲染步骤条
-                var stepItems = param.stepItems;
-                renderDom(param.elem, stepItems, 0);  // 初始渲染步骤条DOM元素
-                $('.lay-step').css('width', param.stepWidth);  // 设置步骤条的宽度
-    
-                //监听轮播切换事件
-                carousel.on('change(' + param.filter + ')', function (obj) {
-                    $(param.elem).find('.lay-step').remove();  // 移除旧的步骤条DOM元素
-                    renderDom(param.elem, stepItems, obj.index);  // 根据当前索引重新渲染步骤条DOM元素
-                    $('.lay-step').css('width', param.stepWidth);  // 设置步骤条的宽度
-                });
-
-    // 隐藏左右箭头按钮
-            $(param.elem).find('.layui-carousel-arrow').css('display', 'none');
-
-            // 去掉轮播图的背景颜色
-            $(param.elem).css('background-color', 'transparent');
-        },
-        // 下一步
-        next: function (elem) {
-            // 触发点击事件，使轮播图切换到下一张
-            $(elem).find('.layui-carousel-arrow[lay-type=add]').trigger('click');
-        },
-        // 上一步
-        pre: function (elem) {
-            // 触发点击事件，使轮播图切换到上一张
-            $(elem).find('.layui-carousel-arrow[lay-type=sub]').trigger('click');
-        }
-    };
-
-    // 加载外部CSS文件
-    layui.link(layui.cache.base + 'step-lay/step.css');
-
-    // 导出模块
-    exports('step', step);
-});
diff --git a/stt/store.js b/stt/store.js
deleted file mode 100644
index 182f5b0..0000000
--- a/stt/store.js
+++ /dev/null
@@ -1,41 +0,0 @@
-layui.define([], function (exports) {
-    // 定义一个存储模块，用于处理本地存储操作
-    exports("store", store = {
-        // 设置 token 到本地存储
-        setToken: function (token) {
-            // 将传入的 token 值保存到 localStorage 中，键名为 "token"
-            localStorage.setItem("token", token)
-        },
-        // 从本地存储获取 token
-        getToken: function () {
-            // 从本地存储中获取名为 "token" 的项并返回其值
-            return localStorage.getItem("token");
-        },
-        // 清除本地存储中的 token
-        clear: function () {
-            return localStorage.removeItem("token");
-        },
-        // 设置登录信息到本地存储
-        setLoginInfo: function (obj, type) {
-            // 如果传入的用户对象存在
-            if (obj) {
-                // 将用户名存储到本地存储中
-                localStorage.setItem("userName", obj.name);
-                // 将用户类型存储到本地存储中
-                localStorage.setItem("type", type);
-            }
-        }
-            }
-        },
-        // 从本地存储获取用户名
-        getLoginInfo: function () {
-            // 从localStorage中获取键为"userName"的值并返回
-            return localStorage.getItem("userName");
-        }
-        },
-        // 从本地存储获取登录类型
-        getLoginType: function () {
-          return localStorage.getItem("type");
-        }
-    });
-});
\ No newline at end of file
diff --git a/stt/treetable.js b/stt/treetable.js
deleted file mode 100644
index 5fad3f9..0000000
--- a/stt/treetable.js
+++ /dev/null
@@ -1,301 +0,0 @@
-layui.define(['layer', 'table'], function (exports) {
-    // 引入jQuery库
-    var $ = layui.jquery;
-    // 引入layer模块
-    var layer = layui.layer;
-    // 引入table模块
-    var table = layui.table;
-
-    var treetable = {
-       
-        render: function (param) {
-            // 检查参数是否合法
-            if (!treetable.checkParam(param)) {
-                // 如果参数不合法，直接返回
-                return;
-            }
-            // 获取数据
-            if (param.data) {
-                // 如果参数中包含数据，则直接初始化树表
-                treetable.init(param, param.data);
-            } else {
-                // 如果参数中不包含数据，则通过AJAX请求获取数据并初始化树表
-                $.getJSON(param.url, param.where, function (res) {
-                    treetable.init(param, res.data);
-                });
-            }
-            },
-            };
-            });
-            
-            // 渲染表格
-            init: function (param, data) {
-                // 存储处理后的数据
-                var mData = [];
-                // 保存回调函数
-                var doneCallback = param.done;
-                // 获取传入的节点数据
-                var tNodes = data;
-                // 补上id和pid字段
-                for (var i = 0; i < tNodes.length; i++) {
-                    var tt = tNodes[i];
-                // 检查tt对象是否有id属性，如果没有则进行以下操作
-                if (!tt.id) {
-                    // 如果param对象中没有treeIdName属性，提示错误信息并返回
-                    if (!param.treeIdName) {
-                        layer.msg('参数treeIdName不能为空', {icon: 5});
-                        return;
-                    }
-                    // 将tt对象的id属性设置为tt对象中对应treeIdName属性的值
-                    tt.id = tt[param.treeIdName];
-                }
-                
-                // 检查tt对象是否有pid属性，如果没有则进行以下操作
-                if (!tt.pid) {
-                    // 如果param对象中没有treePidName属性，提示错误信息并返回
-                    if (!param.treePidName) {
-                        layer.msg('参数treePidName不能为空', {icon: 5});
-                        return;
-                    }
-                    // 将tt对象的pid属性设置为tt对象中对应treePidName属性的值
-                    tt.pid = tt[param.treePidName];
-                }
-
-            
-           
-            var sort = function (s_pid, data) {
-                // 遍历数据数组中的每一个元素
-                for (var i = 0; i < data.length; i++) {
-                    // 如果当前元素的父节点ID等于传入的父节点ID
-                    if (data[i].pid == s_pid) {
-                        // 获取mData数组的长度
-                        var len = mData.length;
-                        // 如果mData数组不为空且最后一个元素的ID等于传入的父节点ID
-                        if (len > 0 && mData[len - 1].id == s_pid) {
-                            // 将最后一个元素的isParent属性设置为true
-                            mData[len - 1].isParent = true;
-                        }
-                        // 将当前元素添加到mData数组中
-                        mData.push(data[i]);
-                        // 递归调用sort函数，处理当前元素的子节点
-                        sort(data[i].id, data);
-                    }
-                }
-            };
-            sort(param.treeSpid, tNodes);
-                        // 对树形节点进行排序
-            
-                        param.url = undefined;
-                        // 将参数中的URL设置为undefined
-            
-                        param.data = mData;
-                        // 将处理后的数据赋值给参数的data属性
-            
-                        param.page = {
-                            count: param.data.length,
-                            limit: param.data.length
-                        };
-                        // 设置分页信息，count和limit都为数据的长度
-            
-                        param.cols[0][param.treeColIndex].templet = function (d) {
-                            // 定义树表列的模板函数
-            
-                            var mId = d.id;
-                            // 获取当前节点的ID
-            
-                            var mPid = d.pid;
-                            // 获取当前节点的父节点ID
-            
-                            var isDir = d.isParent;
-                            // 判断当前节点是否为目录（是否有子节点）
-            
-                            var emptyNum = treetable.getEmptyNum(mPid, mData);
-                            // 计算当前节点前面的空位数量
-            
-                            var iconHtml = '';
-                            // 初始化图标HTML字符串
-            
-                            for (var i = 0; i < emptyNum; i++) {
-                                iconHtml += '<span class="treeTable-empty"></span>';
-                                // 根据空位数量生成相应数量的空位图标
-                            }
-                if (isDir) {
-                    // 如果是目录，添加两个图标：一个三角形和一个图层图标
-                    iconHtml += '<i class="layui-icon layui-icon-triangle-d"></i> <i class="layui-icon layui-icon-layer"></i>';
-                } else {
-                    // 如果是文件，添加一个文件图标
-                    iconHtml += '<i class="layui-icon layui-icon-file"></i>';
-                }
-                // 添加两个空格作为间隔
-                iconHtml += '&nbsp;&nbsp;';
-                // 根据是否是目录设置类型为'dir'或'file'
-                var ttype = isDir ? 'dir' : 'file';
-                // 创建包含图标和名称的HTML字符串
-                var vg = '<span class="treeTable-icon open" lay-tid="' + mId + '" lay-tpid="' + mPid + '" lay-ttype="' + ttype + '">';
-                // 返回完整的HTML字符串
-                return vg + iconHtml + d[param.cols[0][param.treeColIndex].field] + '</span>'
-
-            param.done = function (res, curr, count) {
-                // 在目标元素后插入一个带有'class'为'treeTable'的元素
-                $(param.elem).next().addClass('treeTable');
-                
-                // 隐藏'treeTable'中的分页控件
-                $('.treeTable .layui-table-page').css('display', 'none');
-                
-                // 设置'treeTable'元素的'treeLinkage'属性
-                $(param.elem).next().attr('treeLinkage', param.treeLinkage);
-                
-                // 如果设置了默认关闭树形结构，则折叠所有节点
-                if (param.treeDefaultClose) {
-                    treetable.foldAll(param.elem);
-                }
-                
-                // 如果存在回调函数，则执行回调函数
-                if (doneCallback) {
-                    doneCallback(res, curr, count);
-                }
-            };
-
-        // 渲染表格
-            table.render(param);
-        },
-        // 计算缩进的数量
-        getEmptyNum: function (pid, data) {
-            // 初始化缩进数量为0
-            var num = 0;
-            // 如果pid不存在，直接返回缩进数量0
-            if (!pid) {
-                return num;
-            }
-            // 临时变量tPid用于存储当前节点的父节点ID
-            var tPid;
-            // 遍历数据数组
-            for (var i = 0; i < data.length; i++) {
-                if (pid == data[i].id) {
-                    // 如果当前节点的父ID与目标ID匹配，则计数器加1
-                    num += 1;
-                    // 更新tPid为当前节点的父ID
-                    tPid = data[i].pid;
-                    // 跳出循环
-                    break;
-                }
-                return num + treetable.getEmptyNum(tPid, data);
-                // 返回当前节点及其子节点的数量总和
-                },
-                // 展开/折叠行
-                toggleRows: function ($dom, linkage) {
-                    // 获取当前行的lay-ttype属性值
-                    var type = $dom.attr('lay-ttype');
-                    // 如果类型是'file'，直接返回
-                    if ('file' == type) {
-                        return;
-                    }
-                    // 获取当前行的lay-tid属性值
-                    var mId = $dom.attr('lay-tid');
-                    // 判断当前行是否处于打开状态
-                    var isOpen = $dom.hasClass('open');
-            if (isOpen) {
-                // 如果当前状态是打开的，移除 'open' 类
-                $dom.removeClass('open');
-            } else {
-                // 如果当前状态是关闭的，添加 'open' 类
-                $dom.addClass('open');
-            }
-            
-            // 遍历当前元素最近的父级 <tbody> 中的所有 <tr> 元素
-            $dom.closest('tbody').find('tr').each(function () {
-                // 获取当前行中的树表图标元素
-                var $ti = $(this).find('.treeTable-icon');
-                // 获取图标元素的父节点 ID
-                var pid = $ti.attr('lay-tpid');
-                // 获取图标元素的类型（目录或文件）
-                var ttype = $ti.attr('lay-ttype');
-                // 判断图标元素是否处于打开状态
-                var tOpen = $ti.hasClass('open');
-            
-                // 如果当前行的父节点 ID 与目标 ID 相同
-                if (mId == pid) {
-                    if (isOpen) {
-                        // 如果当前状态是打开的，隐藏当前行
-                        $(this).hide();
-                        // 如果当前行的类型是目录且其打开状态与当前状态一致，触发点击事件
-                        if ('dir' == ttype && tOpen == isOpen) {
-                            $ti.trigger('click');
-                        }
-                    } else {
-                        // 如果当前状态是关闭的，显示当前行
-                        $(this).show();
-                        // 如果需要联动且当前行的类型是目录且其打开状态与当前状态一致，触发点击事件
-                        if (linkage && 'dir' == ttype && tOpen == isOpen) {
-                            $ti.trigger('click');
-                        }
-                    }
-                }
-            });
-        // 检查参数
-        checkParam: function (param) {
-            if (!param.treeSpid && param.treeSpid != 0) {
-                // 如果参数treeSpid为空且不等于0，则弹出提示信息并返回false
-                layer.msg('参数treeSpid不能为空', {icon: 5});
-                return false;
-            }
-            
-            if (!param.treeColIndex && param.treeColIndex != 0) {
-                // 如果参数treeColIndex为空且不等于0，则弹出提示信息并返回false
-                layer.msg('参数treeColIndex不能为空', {icon: 5});
-                return false;
-            }
-            // 参数验证通过，返回true
-            return true;
-            },
-            // 展开所有
-            expandAll: function (dom) {
-                // 查找指定DOM元素的下一个兄弟元素中的树表，遍历其每一行
-                $(dom).next('.treeTable').find('.layui-table-body tbody tr').each(function () {
-                    // 获取当前行的树图标元素
-                    var $ti = $(this).find('.treeTable-icon');
-                    // 获取树图标的类型属性
-                    var ttype = $ti.attr('lay-ttype');
-                    // 判断树图标是否处于打开状态
-                    var tOpen = $ti.hasClass('open');
-                    // 如果类型是目录且未打开，则触发点击事件以展开目录
-                    if ('dir' == ttype && !tOpen) {
-                        $ti.trigger('click');
-                    }
-                });
-            },
-    // 折叠所有树节点
-    foldAll: function (dom) {
-        // 遍历指定DOM元素下的所有树表行
-        $(dom).next('.treeTable').find('.layui-table-body tbody tr').each(function () {
-            // 获取当前行的图标元素
-            var $ti = $(this).find('.treeTable-icon');
-            // 获取图标元素的类型属性
-            var ttype = $ti.attr('lay-ttype');
-            // 判断图标是否处于打开状态
-            var tOpen = $ti.hasClass('open');
-            // 如果图标类型为目录且处于打开状态，则触发点击事件以折叠该节点
-            if ('dir' == ttype && tOpen) {
-                $ti.trigger('click');
-            }
-        });
-    }
-};
-
-// 加载树表样式文件
-layui.link(layui.cache.base + 'treetable-lay/treetable.css');
-
-// 给图标列绑定点击事件
-$('body').on('click', '.treeTable .treeTable-icon', function () {
-    // 获取当前树表的联动属性值
-    var treeLinkage = $(this).parents('.treeTable').attr('treeLinkage');
-    // 根据联动属性值决定是否联动展开或折叠行
-    if ('true' == treeLinkage) {
-        treetable.toggleRows($(this), true);
-    } else {
-        treetable.toggleRows($(this), false);
-    }
-});
-    // 导出 treetable 模块，使其可以在其他文件中被引用和使用
-    exports('treetable', treetable);
-});
\ No newline at end of file
diff --git a/stt/wangEditor.js b/stt/wangEditor.js
deleted file mode 100644
index 5cc8d10..0000000
--- a/stt/wangEditor.js
+++ /dev/null
@@ -1,5451 +0,0 @@
-(function (global, factory) {
-    // 检查是否在Node.js环境中，如果是则使用CommonJS模块规范导出
-    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
-    // 检查是否在AMD环境中，如果是则使用AMD模块定义
-    typeof define === 'function' && define.amd ? define(factory) :
-    // 否则将wangEditor挂载到全局对象上
-    (global.wangEditor = factory());
-}(this, (function () { 'use strict';
-
-
-var polyfill = function () {
-
-    // Object.assign的polyfill实现
-    if (typeof Object.assign != 'function') {
-        Object.assign = function (target, varArgs) {
-            // 如果目标对象为null或undefined，抛出TypeError异常
-            if (target == null) {
-                // 如果目标对象为null或undefined，抛出类型错误异常
-                throw new TypeError('Cannot convert undefined or null to object');
-            }
-            
-            // 将目标对象转换为一个普通对象
-            var to = Object(target);
-            
-            // 遍历所有传入的源对象
-            for (var index = 1; index < arguments.length; index++) {
-                var nextSource = arguments[index];
-            
-                // 如果当前源对象不为null或undefined
-                if (nextSource != null) {
-                    // 遍历当前源对象的所有属性
-                    for (var nextKey in nextSource) {
-                        // 确保只复制源对象自身的属性，而不是继承的属性
-                        if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {
-                            // 将当前属性赋值给目标对象
-                            to[nextKey] = nextSource[nextKey];
-                        }
-                    }
-                }
-            }
-            // 返回合并后的目标对象
-            return to;
-            };
-
-   
-    // 检查浏览器是否支持 matches 方法，如果不支持则进行扩展
-    if (!Element.prototype.matches) {
-        // 将 matches 方法定义为 matchesSelector、mozMatchesSelector、msMatchesSelector、oMatchesSelector 或 webkitMatchesSelector 中的一种
-        Element.prototype.matches = Element.prototype.matchesSelector || Element.prototype.mozMatchesSelector || Element.prototype.msMatchesSelector || Element.prototype.oMatchesSelector || Element.prototype.webkitMatchesSelector || function (s) {
-            // 使用 querySelectorAll 获取所有匹配选择器的元素
-            var matches = (this.document || this.ownerDocument).querySelectorAll(s),
-                i = matches.length;
-            // 遍历匹配的元素列表，查找当前元素是否存在于其中
-            while (--i >= 0 && matches.item(i) !== this) {}
-            // 如果找到当前元素，返回 true；否则返回 false
-            return i > -1;
-        };
-    }
-
-// 根据 html 代码片段创建 dom 对象
-
-function createElemByHTML(html) {
-    // 声明一个变量div，用于存储创建的div元素
-    var div = void 0;
-    // 创建一个新的div元素并赋值给div变量
-    div = document.createElement('div');
-    // 将传入的HTML字符串设置为div元素的innerHTML
-    div.innerHTML = html;
-    // 返回div元素的子元素集合
-    return div.children;
-}
-
-
-
-function isDOMList(selector) {
-    // 如果选择器为空，返回false
-    if (!selector) {
-        return false;
-    }
-    // 如果选择器是HTMLCollection或NodeList的实例，返回true
-    if (selector instanceof HTMLCollection || selector instanceof NodeList) {
-        return true;
-    }
-    // 默认情况下，返回false
-    return false;
-}
-
-
-
-function querySelectorAll(selector) {
-    // 使用document.querySelectorAll方法根据选择器查找元素
-    var result = document.querySelectorAll(selector);
-    
-    // 判断result是否为DOMList类型
-    if (isDOMList(result)) {
-        // 如果是DOMList类型，直接返回结果
-        return result;
-    } else {
-        // 如果不是DOMList类型，将结果包装成数组后返回
-        return [result];
-    }
-}
-
-// 记录所有的事件绑定
-var eventList = [];
-
-// 创建构造函数
-
-function DomElement(selector) {
-    // 如果未传入选择器，则直接返回
-    if (!selector) {
-        return;
-    }
-
-    // 如果传入的是DomElement实例，则直接返回该实例
-    if (selector instanceof DomElement) {
-        return selector;
-    }
-
-    // 将选择器赋值给当前实例的selector属性
-    this.selector = selector;
-    // 获取选择器的节点类型
-    var nodeType = selector.nodeType;
-
-    // 定义一个空数组用于存储选择结果
-    var selectorResult = [];
-    // 如果选择器是文档节点（nodeType为9），则将其放入数组中
-    if (nodeType === 9) {
-        selectorResult = [selector];
-    // 如果选择器是元素节点（nodeType为1），则将其放入数组中
-    } else if (nodeType === 1) {
-        selectorResult = [selector];
-    // 如果选择器是DOM列表或数组，则直接赋值给selectorResult
-    } else if (isDOMList(selector) || selector instanceof Array) {
-        selectorResult = selector;
-    // 如果选择器是字符串类型
-    } else if (typeof selector === 'string') {
-        // 去除选择器中的换行符并去除首尾空格
-        selector = selector.replace('/\n/mg', '').trim();
-        // 如果选择器以'<'开头，表示HTML字符串，创建对应的DOM元素
-        if (selector.indexOf('<') === 0) {
-            selectorResult = createElemByHTML(selector);
-        // 否则，使用querySelectorAll方法查找匹配的元素
-        } else {
-            selectorResult = querySelectorAll(selector);
-        }
-    }
-
-    // 获取选择器结果的长度
-    var length = selectorResult.length;
-    
-    // 如果长度为0，则直接返回当前对象
-    if (!length) {
-       
-        return this;
-    }
-    
-    // 声明变量i并初始化为undefined
-    var i = void 0;
-    
-    // 循环遍历从0到length的每一个索引
-    for (i = 0; i < length; i++) {
-        // 将selectorResult数组中对应索引的值赋给当前对象的相应位置
-        this[i] = selectorResult[i];
-    }
-    
-    // 设置当前对象的长度属性为传入的length值
-    this.length = length;
-
-
-omElement.prototype = {
-    constructor: DomElement,
-
-   
-    forEach: function forEach(fn) {
-        // 声明变量i用于循环计数
-        var i = void 0;
-        // 遍历当前对象的每一个元素
-        for (i = 0; i < this.length; i++) {
-            // 获取当前元素
-            var elem = this[i];
-            // 调用传入的函数，并将当前元素和索引作为参数传递
-            var result = fn.call(elem, elem, i);
-            // 如果传入的函数返回false，则中断循环
-            if (result === false) {
-                break;
-            }
-        }
-        // 返回当前对象以支持链式调用
-        return this;
-    },
-
-   
-   
-    clone: function clone(deep) {
-        // 创建一个空数组用于存储克隆的节点
-        var cloneList = [];
-        // 遍历当前对象的每个元素
-        this.forEach(function (elem) {
-            // 将克隆的节点（根据deep参数决定是否深度克隆）添加到cloneList中
-            cloneList.push(elem.cloneNode(!!deep));
-        });
-        // 返回包含克隆节点的新对象
-        return $(cloneList);
-    },
-
-   
-    get: function get(index) {
-        // 获取当前对象的长度
-        var length = this.length;
-        // 如果索引大于等于长度，则取模以循环索引
-        if (index >= length) {
-            index = index % length;
-        }
-        // 返回指定索引处的元素，并包装成jQuery对象
-        return $(this[index]);
-    },
-    
-    first: function first() {
-        // 调用get方法获取第一个元素
-        return this.get(0);
-    },
-    
-    last: function last() {
-        // 获取当前对象的长度
-        var length = this.length;
-        // 调用get方法获取最后一个元素
-        return this.get(length - 1);
-    },
-    
-    on: function on(type, selector, fn) {
-        // 如果fn未定义，则将selector赋值给fn，并将selector置为空
-        if (!fn) {
-            fn = selector;
-            selector = null;
-        }
-
-        
-    // 初始化一个空数组，用于存储事件类型
-    var types = [];
-    // 将传入的事件类型字符串按空格分割成数组
-    types = type.split(/\s+/);
-
-    // 遍历当前对象的每一个元素
-    return this.forEach(function (elem) {
-        // 遍历每一个事件类型
-        types.forEach(function (type) {
-            // 如果事件类型为空，则跳过本次循环
-            if (!type) {
-                return;
-            }
-
-            // 将事件信息（元素、事件类型、处理函数）推入事件列表
-            eventList.push({
-                elem: elem,
-                type: type,
-                fn: fn
-            });
-
-            // 如果没有选择器，直接在元素上添加事件监听器
-            if (!selector) {
-                elem.addEventListener(type, fn);
-                return;
-            }
-
-                
-                elem.addEventListener(type, function (e) {
-                    // 获取事件的目标元素
-                    var target = e.target;
-                    // 如果目标元素匹配选择器
-                    if (target.matches(selector)) {
-                        // 调用传入的函数，并将目标元素和事件对象作为参数传递
-                        fn.call(target, e);
-                    }
-                });
-
-    off: function off(type, fn) {
-        // 遍历当前对象中的每一个元素，移除指定类型的事件监听器
-        return this.forEach(function (elem) {
-            elem.removeEventListener(type, fn);
-        });
-    },
-    
-    attr: function attr(key, val) {
-        if (val == null) {
-            // 如果val为null或undefined，则获取第一个元素的指定属性值
-            return this[0].getAttribute(key);
-        } else {
-            // 如果val不为null或undefined，则设置每个元素的指定属性值
-            return this.forEach(function (elem) {
-                elem.setAttribute(key, val);
-            });
-        }
-    },
-
-    
-    addClass: function addClass(className) {
-        // 如果 className 为空，直接返回当前对象
-        if (!className) {
-            return this;
-        }
-        // 遍历当前对象中的每个元素
-        return this.forEach(function (elem) {
-            var arr = void 0;
-            // 如果元素已经有 className
-            if (elem.className) {
-                // 解析当前 className 转换为数组
-                arr = elem.className.split(/\s/);
-                // 过滤掉空白的 class 名称
-                arr = arr.filter(function (item) {
-                    return !!item.trim();
-                });
-                // 如果数组中不包含新的 className，则添加它
-                if (arr.indexOf(className) < 0) {
-                    arr.push(className);
-                }
-                // 将数组重新拼接成字符串并赋值给元素的 className
-                elem.className = arr.join(' ');
-            } else {
-                // 如果元素没有 className，直接赋值新的 className
-                elem.className = className;
-            }
-        });
-    },
-
-    // 删除 class
-    removeClass: function removeClass(className) {
-        // 如果 className 为空，直接返回当前对象
-        if (!className) {
-            return this;
-        }
-        // 遍历每一个元素
-        return this.forEach(function (elem) {
-            var arr = void 0;
-            // 如果元素有 className 属性
-            if (elem.className) {
-                // 解析当前 className 转换为数组
-                arr = elem.className.split(/\s/);
-                // 过滤掉要删除的 className
-                arr = arr.filter(function (item) {
-                    item = item.trim();
-                    // 删除 class
-                    if (!item || item === className) {
-                        return false;
-                    }
-                    return true;
-                });
-                // 修改 elem.class
-                elem.className = arr.join(' ');
-            }
-        });
-    },
-
-   
-    css: function css(key, val) {
-        // 将传入的键值对转换为CSS样式字符串
-        var currentStyle = key + ':' + val + ';';
-        
-        // 遍历当前对象中的每一个元素
-        return this.forEach(function (elem) {
-            // 获取元素的style属性，并去除首尾空格
-            var style = (elem.getAttribute('style') || '').trim();
-            var styleArr = void 0,
-                resultArr = [];
-            
-            // 如果style属性不为空
-            if (style) {
-                // 将style属性按分号分割成数组
-                styleArr = style.split(';');
-                
-                // 遍历style数组中的每一个项
-                styleArr.forEach(function (item) {
-                    // 将每一项按冒号分割成键值对数组，并去除首尾空格
-                    var arr = item.split(':').map(function (i) {
-                        return i.trim();
-                    });
-                    
-                    // 如果键值对数组长度为2，则将其重新组合成字符串并加入结果数组
-                    if (arr.length === 2) {
-                        resultArr.push(arr[0] + ':' + arr[1]);
-                    }
-                });
-              // 遍历resultArr数组，对每个元素进行处理
-              resultArr = resultArr.map(function (item) {
-                  // 如果当前元素的开头部分与key相同，则替换为currentStyle
-                  if (item.indexOf(key) === 0) {
-                      return currentStyle;
-                  } else {
-                      // 否则保持原样
-                      return item;
-                  }
-              });
-              
-              // 如果resultArr中不包含currentStyle，则将其添加到resultArr末尾
-              if (resultArr.indexOf(currentStyle) < 0) {
-                  resultArr.push(currentStyle);
-              }
-              
-              // 将处理后的样式数组转换为字符串并设置为元素的style属性
-              elem.setAttribute('style', resultArr.join('; '));
-              } else {
-                  // 如果不需要合并样式，直接设置元素的style属性为currentStyle
-                  elem.setAttribute('style', currentStyle);
-              }
-
-   
-    show: function show() {
-        // 将元素的CSS display属性设置为'block'，使其显示
-        return this.css('display', 'block');
-    },
-    
-    hide: function hide() {
-        // 将元素的CSS display属性设置为'none'，使其隐藏
-        return this.css('display', 'none');
-    },
-    
-    children: function children() {
-        // 获取当前元素的第一个子元素
-        var elem = this[0];
-        if (!elem) {
-            // 如果当前元素不存在，返回null
-            return null;
-        }
-    
-        // 返回当前元素的所有子元素，使用$函数包装成jQuery对象
-        return $(elem.children);
-    },
-
-   childNodes: function childNodes() {
-       // 获取当前对象的第一个元素
-       var elem = this[0];
-       // 如果元素不存在，返回null
-       if (!elem) {
-           return null;
-       }
-   
-       // 返回该元素的所有子节点
-       return $(elem.childNodes);
-   },
-   
-   append: function append($children) {
-       // 遍历当前对象中的每个元素
-       return this.forEach(function (elem) {
-           // 遍历要添加的子节点
-           $children.forEach(function (child) {
-               // 将子节点添加到当前元素中
-               elem.appendChild(child);
-           });
-       });
-   },
-
-    remove: function remove() {
-        // 遍历当前对象中的每一个元素
-        return this.forEach(function (elem) {
-            // 如果元素有remove方法，则调用该方法移除元素
-            if (elem.remove) {
-                elem.remove();
-            } else {
-                // 否则获取元素的父节点并从父节点中移除该元素
-                var parent = elem.parentElement;
-                parent && parent.removeChild(elem);
-            }
-        });
-    },
-
-    isContain: function isContain($child) {
-        // 获取当前对象的第一个元素
-        var elem = this[0];
-        // 获取传入子元素的第一个元素
-        var child = $child[0];
-        // 判断当前元素是否包含传入的子元素
-        return elem.contains(child);
-    },
-
-    getSizeData: function getSizeData() {
-        // 获取当前对象的第一个元素
-        var elem = this[0];
-        // 返回元素的边界矩形数据，包括 bottom, height, left, right, top, width 等属性
-        return elem.getBoundingClientRect(); // 可得到 bottom height left right top width 的数据
-    },
-
-    getNodeName: function getNodeName() {
-        // 获取当前对象的第一个元素
-        var elem = this[0];
-        // 返回元素的节点名称
-        return elem.nodeName;
-    },
-
-
-    find: function find(selector) {
-        // 获取当前对象的第一个元素
-        var elem = this[0];
-        // 使用querySelectorAll查找子元素，并返回包装后的结果
-        return $(elem.querySelectorAll(selector));
-    },
-    
-    text: function text(val) {
-        if (!val) {
-            // 如果未传入参数，则获取第一个元素的文本内容
-            var elem = this[0];
-            // 移除HTML标签，只保留纯文本
-            return elem.innerHTML.replace(/<.*?>/g, function () {
-                return '';
-            });
-        } else {
-            // 如果传入了参数，则设置每个元素的文本内容
-            return this.forEach(function (elem) {
-                elem.innerHTML = val;
-            });
-        }
-    },
-
-
-    html: function html(value) {
-        // 获取当前对象的第一个元素
-        var elem = this[0];
-        
-        // 如果传入的值为null或undefined，则返回元素的innerHTML内容
-        if (value == null) {
-            return elem.innerHTML;
-        } else {
-            // 否则，将传入的值设置为元素的innerHTML内容
-            elem.innerHTML = value;
-            // 返回当前对象以支持链式调用
-            return this;
-        }
-    },
-
-    val: function val() {
-        // 获取当前对象的第一个元素
-        var elem = this[0];
-        // 返回该元素的值，并去除前后空格
-        return elem.value.trim();
-    },
-    
-    focus: function focus() {
-        // 遍历当前对象的每一个元素
-        return this.forEach(function (elem) {
-            // 将焦点设置到当前元素上
-            elem.focus();
-        });
-    },
-
-    parent: function parent() {
-        // 获取当前对象的第一个元素
-        var elem = this[0];
-        // 返回该元素的父元素，并包装成jQuery对象
-        return $(elem.parentElement);
-    },
-    
-   
-    parentUntil: function parentUntil(selector, _currentElem) {
-        // 使用querySelectorAll查找所有匹配选择器的元素
-        var results = document.querySelectorAll(selector);
-        // 获取匹配元素的数量
-        var length = results.length;
-        // 如果没有匹配的元素
-        if (!length) {
-            // 返回null
-            return null;
-        }
-
-        var elem = _currentElem || this[0]; // 获取当前元素，如果未定义则使用this的第一个元素
-        if (elem.nodeName === 'BODY') { // 如果当前元素的节点名称是'BODY'
-            return null; // 返回null
-        }
-        
-        var parent = elem.parentElement; // 获取当前元素的父元素
-        var i = void 0; // 声明变量i并初始化为undefined
-        for (i = 0; i < length; i++) { // 遍历长度为length的数组
-            if (parent === results[i]) { // 如果父元素等于results数组中的某个元素
-                // 找到，并返回
-                return $(parent); // 返回父元素的jQuery对象
-            }
-        }
-
-    // 继续查找父元素，直到找到匹配选择器的父元素
-    return this.parentUntil(selector, parent);
-},
-
-// 判断两个 elem 是否相等
-equal: function equal($elem) {
-    // 如果传入的 $elem 是一个节点类型为1的元素（即元素节点）
-    if ($elem.nodeType === 1) {
-        // 比较当前对象的第一个元素和传入的 $elem 是否相同
-        return this[0] === $elem;
-    } else {
-        // 否则，比较当前对象的第一个元素和传入的 $elem 的第一个元素是否相同
-        return this[0] === $elem[0];
-    }
-},
-
-    // 将该元素插入到某个元素前面
-    insertBefore: function insertBefore(selector) {
-        // 获取参考节点的jQuery对象
-        var $referenceNode = $(selector);
-        // 获取参考节点的DOM对象
-        var referenceNode = $referenceNode[0];
-        // 如果参考节点不存在，直接返回当前对象
-        if (!referenceNode) {
-            return this;
-        }
-        // 遍历当前对象中的每个元素
-        return this.forEach(function (elem) {
-            // 获取参考节点的父节点
-            var parent = referenceNode.parentNode;
-            // 将当前元素插入到参考节点之前
-            parent.insertBefore(elem, referenceNode);
-        });
-    },
-
-    // 将该元素插入到某个元素后面
-    insertAfter: function insertAfter(selector) {
-        // 获取参考节点的jQuery对象
-        var $referenceNode = $(selector);
-        // 获取参考节点的DOM对象
-        var referenceNode = $referenceNode[0];
-        // 如果参考节点不存在，直接返回当前对象
-        if (!referenceNode) {
-            return this;
-        }
-        // 遍历当前对象中的每个元素
-        return this.forEach(function (elem) {
-            // 获取参考节点的父节点
-            var parent = referenceNode.parentNode;
-            // 如果参考节点是父节点的最后一个子节点
-            if (parent.lastChild === referenceNode) {
-                // 将当前元素追加到父节点的末尾
-                parent.appendChild(elem);
-            } else {
-                // 否则，将当前元素插入到参考节点的下一个兄弟节点之前
-                parent.insertBefore(elem, referenceNode.nextSibling);
-            }
-        });
-    }
-
-
-function $(selector) {
-    // 创建一个新的DomElement对象并返回
-    return new DomElement(selector);
-}
-
-
-$.offAll = function () {
-    // 遍历事件列表
-    eventList.forEach(function (item) {
-        // 获取元素、事件类型和处理函数
-        var elem = item.elem;
-        var type = item.type;
-        var fn = item.fn;
-        // 解绑事件监听器
-        elem.removeEventListener(type, fn);
-    });
-};
-
-
-
-
-var config = {
-
-    // 默认菜单配置，包含各种编辑功能按钮
-    menus: ['head', 'bold', 'fontSize', 'fontName', 'italic', 'underline', 'strikeThrough', 'foreColor', 'backColor', 'link', 'list', 'justify', 'quote', 'emoticon', 'image', 'table', 'video', 'code', 'undo', 'redo'],
-
-    // 字体名称列表
-    fontNames: ['宋体', '微软雅黑', 'Arial', 'Tahoma', 'Verdana'],
-
-    // 颜色代码数组，用于设置文本和背景颜色
-    colors: ['#000000', '#eeece0', '#1c487f', '#4d80bf', '#c24f4a', '#8baa4a', '#7b5ba1', '#46acc8', '#f9963b', '#ffffff'],
-
-    // 表情配置
-    emotions: [{
-        // tab 的标题
-        title: '默认',
-        // type -> 'emoji' / 'image'，表示表情的类型是图片
-        type: 'image',
-        // content -> 数组，包含表情的具体信息
-        content: [{
-            // alt 属性为表情的描述文字
-            alt: '[坏笑]',
-            // src 属性为表情图片的 URL
-            src: 'http://img.t.sinajs.cn/t4/appstyle/expression/ext/normal/50/pcmoren_huaixiao_org.png'
-        }, {
-            alt: '[舔屏]',
-            src: 'http://img.t.sinajs.cn/t4/appstyle/expression/ext/normal/40/pcmoren_tian_org.png'
-        }, {
-            alt: '[污]',
-            src: 'http://img.t.sinajs.cn/t4/appstyle/expression/ext/normal/3c/pcmoren_wu_org.png'
-        }]
-    }, {
-    // tab 的标题
-    title: '新浪',
-    // type -> 'emoji' / 'image'
-    type: 'image',
-    // content -> 数组，包含多个表情图片对象
-    content: [{
-        // 表情图片的 URL 地址
-        src: 'http://img.t.sinajs.cn/t35/style/images/common/face/ext/normal/7a/shenshou_thumb.gif',
-        // 表情图片的替代文本
-        alt: '[草泥马]'
-    }, {
-        // 表情图片的 URL 地址
-        src: 'http://img.t.sinajs.cn/t35/style/images/common/face/ext/normal/60/horse2_thumb.gif',
-        // 表情图片的替代文本
-        alt: '[神马]'
-    }, {
-        // 表情图片的 URL 地址
-        src: 'http://img.t.sinajs.cn/t35/style/images/common/face/ext/normal/bc/fuyun_thumb.gif',
-        // 表情图片的替代文本
-        alt: '[浮云]'
-    }]
-}, {
-    // tab 的标题
-    title: 'emoji',
-    // type -> 'emoji' / 'image'
-    type: 'emoji',
-    // content -> 数组，包含多个 emoji 字符
-    content: '😀 😃 😄 😁 😆 😅 😂 😊 😇 🙂 🙃 😉 😓 😪 😴 🙄 🤔 😬 🤐'.split(/\s/)
-}],
-    title: 'emoji',
-    // type -> 'emoji' / 'image'
-    type: 'emoji',
-    // content -> 数组，包含多个 emoji 字符
-    content: '😀 😃 😄 😁 😆 😅 😂 😊 😇 🙂 🙃 😉 😓 😪 😴 🙄 🤔 😬 🤐'.split(/\s/)
-}],
-
-    // 编辑区域的 z-index
-    zIndex: 10000,
-
-    // 是否开启 debug 模式（debug 模式下错误会 throw error 形式抛出）
-    debug: false,
-
-    // 插入链接时候的格式校验
-    linkCheck: function linkCheck(text, link) {
-        // text 是插入的文字
-        // link 是插入的链接
-        return true; // 返回 true 即表示成功
-        // return '校验失败' // 返回字符串即表示失败的提示信息
-    },
-
-    // 插入网络图片的校验
-    linkImgCheck: function linkImgCheck(src) {
-        // src 即图片的地址
-        return true; // 返回 true 即表示成功
-        // return '校验失败'  // 返回字符串即表示失败的提示信息
-    },
-
-    // 粘贴过滤样式，默认开启
-    pasteFilterStyle: true,
-
-    // 粘贴内容时，忽略图片。默认关闭
-    pasteIgnoreImg: false,
-
-   
-    pasteTextHandle: function pasteTextHandle(content) {
-        // content 即粘贴过来的内容（html 或 纯文本），可进行自定义处理然后返回
-        return content;
-    },
-    
-    showLinkImg: true,
-
-    // 插入网络图片的回调
-    linkImgCallback: function linkImgCallback(url) {
-        // console.log(url)  // url 即插入图片的地址
-    },
-
-    // 默认上传图片 max size: 5M
-    uploadImgMaxSize: 5 * 1024 * 1024,
-
-    // 配置一次最多上传几个图片
-    // uploadImgMaxLength: 5,
-
-    // 上传图片，是否显示 base64 格式
-    uploadImgShowBase64: false,
-
-    // 上传图片，server 地址（如果有值，则 base64 格式的配置则失效）
-    // uploadImgServer: '/upload',
-
-    // 自定义配置 filename
-    uploadFileName: '',
-
-    // 上传图片的自定义参数
-    uploadImgParams: {
-        // token: 'abcdef12345'
-    },
-
-    // 上传图片的自定义header
-    uploadImgHeaders: {
-        // 'Accept': 'text/x-json'
-    },
-
-    // 配置 XHR withCredentials
-    withCredentials: false,
-
-    // 自定义上传图片超时时间 ms
-    uploadImgTimeout: 10000,
-
-    // 上传图片 hook 
-    uploadImgHooks: {
-       
-        before: function before(xhr, editor, files) {
-          
-        },
-        success: function success(xhr, editor, result) {
-            // 图片上传并返回结果，图片插入成功之后触发
-        },
-        fail: function fail(xhr, editor, result) {
-            // 图片上传并返回结果，但图片插入错误时触发
-        },
-        error: function error(xhr, editor) {
-            // 图片上传出错时触发
-        },
-        timeout: function timeout(xhr, editor) {
-            // 图片上传超时时触发
-        }
-    },
-
-    // 是否上传七牛云，默认为 false
-    qiniu: false
-
-};
-
-
-var UA = {
-    // 获取用户代理字符串
-    _ua: navigator.userAgent,
-
-    // 判断是否为 Webkit 内核的浏览器
-    isWebkit: function isWebkit() {
-        // 定义匹配 Webkit 的正则表达式
-        var reg = /webkit/i;
-        // 测试用户代理字符串是否包含 'webkit'
-        return reg.test(this._ua);
-    },
-
-    // 判断是否为 IE 浏览器
-    isIE: function isIE() {
-        // 检查 window 对象中是否存在 ActiveXObject 属性
-        return 'ActiveXObject' in window;
-    }
-};
-
-
-
-function objForEach(obj, fn) {
-    // 定义变量key用于存储当前遍历的属性名
-    var key = void 0,
-        // 定义变量result用于存储函数fn的返回值
-        result = void 0;
-    // 使用for...in循环遍历对象的所有可枚举属性
-    for (key in obj) {
-        // 检查属性是否是对象自身的属性（而不是继承自原型链）
-        if (obj.hasOwnProperty(key)) {
-            // 调用传入的函数fn，并将当前属性名和属性值作为参数传递
-            result = fn.call(obj, key, obj[key]);
-            // 如果函数fn返回false，则中断循环
-            if (result === false) {
-                break;
-            }
-        }
-    }
-}
-
-
-
-function arrForEach(fakeArr, fn) {
-    // 声明变量i用于循环计数，item用于存储当前元素，result用于存储函数返回值
-    var i = void 0,
-        item = void 0,
-        result = void 0;
-    // 获取伪数组的长度，如果长度为undefined则默认为0
-    var length = fakeArr.length || 0;
-    // 使用for循环遍历伪数组
-    for (i = 0; i < length; i++) {
-        // 获取当前元素
-        item = fakeArr[i];
-        // 调用传入的函数，并将当前元素、索引和数组本身作为参数传递
-        result = fn.call(fakeArr, item, i);
-        // 如果函数返回false，则中断循环
-        if (result === false) {
-            break;
-        }
-    }
-}
-
-
-
-function getRandom(prefix) {
-    // 使用Math.random()生成一个0到1之间的随机数，并将其转换为字符串
-    // 然后通过slice(2)去掉字符串的前两位（即"0."），只保留小数部分
-    return prefix + Math.random().toString().slice(2);
-}
-
-
-/function replaceHtmlSymbol(html) {
-    // 如果输入的HTML字符串为null，则返回空字符串
-    if (html == null) {
-        return '';
-    }
-    // 使用正则表达式替换HTML字符串中的<、>、"和换行符为对应的HTML实体
-    return html.replace(/</gm, '&lt;') // 替换所有的<为&lt;
-               .replace(/>/gm, '&gt;') // 替换所有的>为&gt;
-               .replace(/"/gm, '&quot;') // 替换所有的"为&quot;
-               .replace(/(\r\n|\r|\n)/g, '<br/>'); // 替换所有的换行符为<br/>
-}
-
-
-
-
-
-
-function isFunction(fn) {
-    // 使用typeof运算符检查参数的类型是否为'function'
-    return typeof fn === 'function';
-}
-
-
-function Bold(editor) {
-    // 将传入的编辑器实例赋值给当前对象的editor属性
-    this.editor = editor;
-    // 创建一个包含加粗图标的div元素，并赋值给当前对象的$elem属性
-    this.$elem = $('<div class="w-e-menu">\n            <i class="w-e-icon-bold"></i>\n        </div>');
-    // 设置按钮类型为点击事件
-    this.type = 'click';
-}
-
-    // 当前是否 active 状态
-    this._active = false;
-}
-
-// 原型
-Bold.prototype = {
-    constructor: Bold,
-
-    // 点击事件处理函数
-    onClick: function onClick(e) {
-        // 获取编辑器实例
-        var editor = this.editor;
-        // 检查当前选区是否为空
-        var isSeleEmpty = editor.selection.isSelectionEmpty();
-
-        if (isSeleEmpty) {
-            // 如果选区为空，创建一个空的选区并选中一个“空白”
-            editor.selection.createEmptyRange();
-        }
-
-        // 执行加粗命令
-        editor.cmd.do('bold');
-
-        if (isSeleEmpty) {
-            // 如果之前选区为空，将选区折叠起来并恢复之前的选区状态
-            editor.selection.collapseRange();
-            editor.selection.restoreSelection();
-        }
-    },
-
-    // 试图改变 active 状态
-    tryChangeActive: function tryChangeActive(e) {
-        // 获取编辑器实例
-        var editor = this.editor;
-        // 获取当前元素的jQuery对象
-        var $elem = this.$elem;
-        // 检查编辑器中的'bold'命令是否处于激活状态
-        if (editor.cmd.queryCommandState('bold')) {
-            // 如果'bold'命令激活，设置_active为true
-            this._active = true;
-            // 给元素添加'w-e-active'类，表示激活状态
-            $elem.addClass('w-e-active');
-        } else {
-            // 如果'bold'命令未激活，设置_active为false
-            this._active = false;
-            // 从元素中移除'w-e-active'类，表示非激活状态
-            $elem.removeClass('w-e-active');
-        }
-    }
-
-
-
-
-var replaceLang = function (editor, str) {
-    // 获取编辑器配置中的语言参数数组，如果没有则默认为空数组
-    var langArgs = editor.config.langArgs || [];
-    // 初始化结果字符串为输入字符串
-    var result = str;
-
-    // 遍历语言参数数组
-    langArgs.forEach(function (item) {
-        // 获取当前语言参数的正则表达式
-        var reg = item.reg;
-        // 获取当前语言参数的值
-        var val = item.val;
-
-        // 如果结果字符串匹配当前正则表达式
-        if (reg.test(result)) {
-            // 使用当前值替换匹配的部分
-            result = result.replace(reg, function () {
-                return val;
-            });
-        }
-    });
-
-    // 返回处理后的结果字符串
-    return result;
-};
-
-
-var _emptyFn = function _emptyFn() {}; // 定义一个空函数，用于默认的点击事件处理
-
-
-function DropList(menu, opt) {
-    var _this = this; // 保存当前上下文
-
-    var editor = menu.editor; // 获取编辑器实例
-    this.menu = menu; // 保存菜单对象
-    this.opt = opt; // 保存配置选项
-
-    // 创建容器元素
-    var $container = $('<div class="w-e-droplist"></div>');
-
-    var $title = opt.$title; // 获取标题元素
-    var titleHtml = void 0; // 初始化标题 HTML
-    if ($title) {
-        // 替换多语言
-        titleHtml = $title.html(); // 获取标题 HTML
-        titleHtml = replaceLang(editor, titleHtml); // 替换多语言文本
-        $title.html(titleHtml); // 设置替换后的标题 HTML
-
-        $title.addClass('w-e-dp-title'); // 添加标题样式类
-        $container.append($title); // 将标题添加到容器中
-    }
-
-    var list = opt.list || []; // 获取列表项数组，默认为空数组
-    var type = opt.type || 'list'; // 获取类型，默认为 'list'
-    var onClick = opt.onClick || _emptyFn; // 获取点击事件处理函数，默认为空函数
-
-    // 创建列表元素并绑定事件
-    var $list = $('<ul class="' + (type === 'list' ? 'w-e-list' : 'w-e-block') + '"></ul>'); // 根据类型选择样式类
-    $container.append($list); // 将列表添加到容器中
-    list.forEach(function (item) {
-        var $elem = item.$elem; // 获取每个列表项的元素
-
-
-        // 获取元素的HTML内容
-        var elemHtml = $elem.html();
-        // 替换语言标记
-        elemHtml = replaceLang(editor, elemHtml);
-        // 将替换后的内容重新设置到元素中
-        $elem.html(elemHtml);
-        
-        // 获取item的值
-        var value = item.value;
-        // 创建一个新的<li>元素，并添加类名"w-e-item"
-        var $li = $('<li class="w-e-item"></li>');
-        if ($elem) {
-            // 如果$elem存在，则将其添加到<li>元素中
-            $li.append($elem);
-            // 将<li>元素添加到列表中
-            $list.append($li);
-            // 为<li>元素绑定点击事件
-            $li.on('click', function (e) {
-                // 调用点击处理函数
-                onClick(value);
-        
-                // 隐藏操作
-                _this.hideTimeoutId = setTimeout(function () {
-                    // 调用隐藏方法
-                    _this.hide();
-                }, 0);
-            });
-        }
-
-    // 绑定隐藏事件
-    $container.on('mouseleave', function (e) {
-        // 设置一个定时器，在鼠标离开容器时延迟执行隐藏操作
-        _this.hideTimeoutId = setTimeout(function () {
-            // 调用隐藏方法
-            _this.hide();
-        }, 0);
-    });
-
-    // 记录属性
-    this.$container = $container;
-
-    // 基本属性
-    // 标记是否已经渲染
-    this._rendered = false;
-    // 标记是否显示
-    this._show = false;
-}
-
-
-DropList.prototype = {
-    constructor: DropList,
-
-    show: function show() {
-        // 如果存在隐藏超时ID，则清除该超时
-        if (this.hideTimeoutId) {
-            clearTimeout(this.hideTimeoutId);
-        }
-
-        var menu = this.menu; // 获取当前菜单对象
-        var $menuELem = menu.$elem; // 获取菜单的DOM元素
-        var $container = this.$container; // 获取容器的DOM元素
-
-        // 如果菜单已经显示，则直接返回
-        if (this._show) {
-            return;
-        }
-
-        // 如果菜单已经渲染过，则直接显示容器
-        if (this._rendered) {
-            $container.show();
-        } else {
-            // 获取菜单的高度，如果未定义则默认为0
-            var menuHeight = $menuELem.getSizeData().height || 0;
-            // 获取宽度，如果未定义则默认为100
-            var width = this.opt.width || 100;
-            // 设置容器的上边距和宽度
-            $container.css('margin-top', menuHeight + 'px').css('width', width + 'px');
-
-            // 将容器添加到菜单的DOM元素中
-            $menuELem.append($container);
-            // 标记菜单已渲染
-            this._rendered = true;
-        }
-    }
-};
-        // 修改属性
-        this._show = true;
-    },
-
-    // 隐藏（移除DOM）
-    hide: function hide() {
-        // 如果存在显示定时器ID，则清除之前的定时显示
-        if (this.showTimeoutId) {
-            clearTimeout(this.showTimeoutId);
-        }
-    
-        var $container = this.$container;
-        // 如果当前状态为不显示，则直接返回
-        if (!this._show) {
-            return;
-        }
-        // 隐藏容器并修改显示状态属性
-        $container.hide();
-        this._show = false;
-    }
-
-
-
-function Head(editor) {
-    // 保存当前上下文的引用
-    var _this = this;
-
-    // 将传入的编辑器实例赋值给当前对象的editor属性
-    this.editor = editor;
-    // 创建一个包含头部菜单图标的div元素，并赋值给当前对象的$elem属性
-    this.$elem = $('<div class="w-e-menu"><i class="w-e-icon-header"></i></div>');
-    // 设置当前对象的类型为下拉列表
-    this.type = 'droplist';
-
-    // 当前是否 active 状态
-    this._active = false;
-
-    // 初始化 droplist
-    this.droplist = new DropList(this, {
-        width: 100,
-        $title: $('<p>设置标题</p>'),
-        type: 'list', // droplist 以列表形式展示
-        list: [{ $elem: $('<h1>H1</h1>'), value: '<h1>' }, { $elem: $('<h2>H2</h2>'), value: '<h2>' }, { $elem: $('<h3>H3</h3>'), value: '<h3>' }, { $elem: $('<h4>H4</h4>'), value: '<h4>' }, { $elem: $('<h5>H5</h5>'), value: '<h5>' }, { $elem: $('<p>正文</p>'), value: '<p>' }],
-        onClick: function onClick(value) {
-            // 注意 this 是指向当前的 Head 对象
-            _this._command(value);
-        }
-    });
-}
-
-
-Head.prototype = {
-    constructor: Head,
-
-    
-    _command: function _command(value) {
-        // 获取编辑器实例
-        var editor = this.editor;
-
-        // 获取当前选中的容器元素
-        var $selectionElem = editor.selection.getSelectionContainerElem();
-        
-        // 如果选中的元素是文本元素，则不进行任何操作
-        if (editor.$textElem.equal($selectionElem)) {
-            return;
-        }
-
-        // 执行格式化命令，将选中的内容格式化为指定的块类型
-        editor.cmd.do('formatBlock', value);
-    },
-
-    // 试图改变 active 状态
-    tryChangeActive: function tryChangeActive(e) {
-        // 获取编辑器实例
-        var editor = this.editor;
-        // 获取当前元素
-        var $elem = this.$elem;
-        // 定义正则表达式，用于匹配以 'h' 开头的字符串（忽略大小写）
-        var reg = /^h/i;
-        // 查询当前命令的值，判断是否为标题格式
-        var cmdValue = editor.cmd.queryCommandValue('formatBlock');
-        // 如果命令值匹配正则表达式，表示当前是标题格式
-        if (reg.test(cmdValue)) {
-            // 设置活动状态为 true
-            this._active = true;
-            // 为当前元素添加 'w-e-active' 类，表示激活状态
-            $elem.addClass('w-e-active');
-        } else {
-            // 设置活动状态为 false
-            this._active = false;
-            // 移除当前元素的 'w-e-active' 类，表示非激活状态
-            $elem.removeClass('w-e-active');
-        }
-    }
-
-
-function FontSize(editor) {
-    var _this = this; // 保存当前对象的引用，以便在嵌套函数中使用
-
-    this.editor = editor; // 将传入的编辑器对象赋值给当前实例的 editor 属性
-    this.$elem = $('<div class="w-e-menu"><i class="w-e-icon-text-heigh"></i></div>'); // 创建菜单元素并添加到当前实例的 $elem 属性中
-    this.type = 'droplist'; // 设置菜单类型为下拉列表
-
-    // 当前是否 active 状态
-    this._active = false; // 初始化 active 状态为 false
-
-    // 初始化 droplist
-    this.droplist = new DropList(this, {
-        width: 160, // 设置下拉列表的宽度
-        $title: $('<p>字号</p>'), // 设置下拉列表的标题
-        type: 'list', // 设置下拉列表的类型为列表形式展示
-        list: [
-            { $elem: $('<span style="font-size: x-small;">x-small</span>'), value: '1' }, // 定义第一个选项：字体大小为 x-small
-            { $elem: $('<span style="font-size: small;">small</span>'), value: '2' }, // 定义第二个选项：字体大小为 small
-            { $elem: $('<span>normal</span>'), value: '3' }, // 定义第三个选项：字体大小为 normal
-            { $elem: $('<span style="font-size: large;">large</span>'), value: '4' }, // 定义第四个选项：字体大小为 large
-            { $elem: $('<span style="font-size: x-large;">x-large</span>'), value: '5' }, // 定义第五个选项：字体大小为 x-large
-            { $elem: $('<span style="font-size: xx-large;">xx-large</span>'), value: '6' } // 定义第六个选项：字体大小为 xx-large
-        ],
-        onClick: function onClick(value) {
-            // 注意 this 是指向当前的 FontSize 对象
-            _this._command(value); // 调用当前对象的 _command 方法，并传递选中的值
-        }
-    });
-}
-
-
-FontSize.prototype = {
-    constructor: FontSize,
-
-   
-    _command: function _command(value) {
-        // 获取当前编辑器实例
-        var editor = this.editor;
-        // 调用编辑器的命令接口，设置字体大小
-        editor.cmd.do('fontSize', value);
-    }
-};
-
-
-function FontName(editor) {
-    var _this = this;
-
-    // 保存编辑器实例
-    this.editor = editor;
-    // 创建菜单元素，包含一个图标
-    this.$elem = $('<div class="w-e-menu"><i class="w-e-icon-font"></i></div>');
-    // 设置菜单类型为下拉列表
-    this.type = 'droplist';
-
-    // 当前是否 active 状态
-    this._active = false;
-
-    // 获取配置的字体
-    var config = editor.config;
-    var fontNames = config.fontNames || [];
-
-    // 初始化 droplist
-    this.droplist = new DropList(this, {
-        width: 100, // 设置下拉列表宽度
-        $title: $('<p>字体</p>'), // 设置下拉列表标题
-        type: 'list', // 设置下拉列表类型为列表形式展示
-        list: fontNames.map(function (fontName) {
-            // 将每个字体名称映射为一个对象，包含显示的元素和值
-            return { $elem: $('<span style="font-family: ' + fontName + ';">' + fontName + '</span>'), value: fontName };
-        }),
-        onClick: function onClick(value) {
-            // 注意 this 是指向当前的 FontName 对象
-            // 当点击某个字体时，执行命令
-            _this._command(value);
-        }
-    });
-}
-
-
-FontName.prototype = {
-    // 构造函数，指向FontName类
-    constructor: FontName,
-
-   
-    _command: function _command(value) {
-        // 获取当前编辑器实例
-        var editor = this.editor;
-        // 调用编辑器的命令接口，设置字体名称
-        editor.cmd.do('fontName', value);
-    }
-};
-
-
-
-var emptyFn = function emptyFn() {};
-// 定义一个空函数，用于占位或默认回调
-
-// 记录已经显示 panel 的菜单
-var _isCreatedPanelMenus = [];
-// 初始化一个数组，用于存储已经创建的 panel 菜单
-
-// 构造函数
-function Panel(menu, opt) {
-    this.menu = menu;
-    // 将传入的 menu 参数赋值给实例的 menu 属性
-    this.opt = opt;
-    // 将传入的 opt 参数赋值给实例的 opt 属性
-}
-
-
-Panel.prototype = {
-    constructor: Panel,
-
-   
-    show: function show() {
-        // 保存当前对象的引用
-        var _this = this;
-
-        // 获取当前面板的菜单
-        var menu = this.menu;
-        // 如果菜单已经创建过，则直接返回
-        if (_isCreatedPanelMenus.indexOf(menu) >= 0) {
-            // 如果菜单已经创建，则直接返回
-            return;
-        }
-        var editor = menu.editor; // 获取编辑器实例
-        var $body = $('body'); // 获取 body 元素
-        var $textContainerElem = editor.$textContainerElem; // 获取文本容器元素
-        var opt = this.opt; // 获取配置选项
-        
-        // panel 的容器
-        var $container = $('<div class="w-e-panel-container"></div>'); // 创建一个新的 div 作为面板容器
-        var width = opt.width || 300; // 默认宽度为 300px，如果配置中有指定宽度则使用配置中的宽度
-        $container.css('width', width + 'px').css('margin-left', (0 - width) / 2 + 'px'); // 设置容器的宽度和左边距
-        
-        // 添加关闭按钮
-        var $closeBtn = $('<i class="w-e-icon-close w-e-panel-close"></i>'); // 创建一个关闭按钮
-        $container.append($closeBtn); // 将关闭按钮添加到容器中
-        $closeBtn.on('click', function () {
-            // 绑定点击事件，当点击关闭按钮时隐藏面板
-            _this.hide();
-        });
-
-
-        // 创建一个包含类名 'w-e-panel-tab-title' 的 <ul> 元素，并赋值给 $tabTitleContainer
-        var $tabTitleContainer = $('<ul class="w-e-panel-tab-title"></ul>');
-        // 创建一个包含类名 'w-e-panel-tab-content' 的 <div> 元素，并赋值给 $tabContentContainer
-        var $tabContentContainer = $('<div class="w-e-panel-tab-content"></div>');
-        // 将 $tabTitleContainer 和 $tabContentContainer 添加到 $container 中
-        $container.append($tabTitleContainer).append($tabContentContainer);
-
-        // 获取配置项中的 height 值
-        var height = opt.height;
-        // 如果 height 存在，则设置 $tabContentContainer 的高度，并启用垂直滚动条
-        if (height) {
-            $tabContentContainer.css('height', height + 'px').css('overflow-y', 'auto');
-        }
-
-        // 获取配置项中的 tabs 数组，如果不存在则默认为空数组
-        var tabs = opt.tabs || [];
-        // 初始化一个空数组，用于存储每个 tab 的标题
-        var tabTitleArr = [];
-        // 初始化一个空数组，用于存储每个 tab 的内容
-        var tabContentArr = [];
-        // 遍历 tabs 数组，对每一个 tab 进行处理
-        tabs.forEach(function (tab, tabIndex) {
-            if (!tab) {
-                // 如果 tab 对象不存在，则直接返回
-                return;
-            }
-            var title = tab.title || ''; // 获取 tab 的标题，如果不存在则为空字符串
-            var tpl = tab.tpl || ''; // 获取 tab 的模板内容，如果不存在则为空字符串
-            
-            // 替换语言变量
-            title = replaceLang(editor, title);
-            tpl = replaceLang(editor, tpl);
-            
-            // 创建一个新的 <li> 元素，并设置其类名为 "w-e-item"，内容为处理后的标题
-            var $title = $('<li class="w-e-item">' + title + '</li>');
-            // 将新创建的标题元素添加到 tab 标题容器中
-            $tabTitleContainer.append($title);
-            // 创建一个新的元素，内容为处理后的模板内容
-            var $content = $(tpl);
-            // 将新创建的内容元素添加到 tab 内容容器中
-            $tabContentContainer.append($content);
-            
-            // 记录到内存
-            $title._index = tabIndex; // 将当前 tab 索引赋值给标题元素的 _index 属性
-            tabTitleArr.push($title); // 将标题元素添加到 tabTitleArr 数组中
-            tabContentArr.push($content); // 将内容元素添加到 tabContentArr 数组中
-
-
-            // 判断当前选项卡索引是否为0
-            if (tabIndex === 0) {
-                // 将标题的_active属性设置为true，表示该标题处于激活状态
-                $title._active = true;
-                // 给标题添加'w-e-active'类，用于样式控制
-                $title.addClass('w-e-active');
-            } else {
-                // 如果当前选项卡索引不为0，隐藏内容区域
-                $content.hide();
-            }
-
-$title.on('click', function (e) {
-    // 如果当前标题已经是激活状态，则直接返回，不进行后续操作
-    if ($title._active) {
-        return;
-    }
-    
-    // 遍历所有标题，将它们的激活状态设为false，并移除激活样式
-    tabTitleArr.forEach(function ($title) {
-        $title._active = false;
-        $title.removeClass('w-e-active');
-    });
-    
-    // 隐藏所有内容区域
-    tabContentArr.forEach(function ($content) {
-        $content.hide();
-    });
-
-    // 设置当前点击的标题为激活状态，并添加激活样式
-    $title._active = true;
-    $title.addClass('w-e-active');
-    
-    // 显示对应的内容区域
-    $content.show();
-});
-
-        
-        $container.on('click', function (e) {
-            // 点击时阻止冒泡，防止事件传播到父元素
-            e.stopPropagation();
-        });
-        
-        $body.on('click', function (e) {
-            // 隐藏当前对象
-            _this.hide();
-        });
-        
-        // 将容器元素添加到 DOM 中
-        $textContainerElem.append($container);
-        
-        // 绑定 tabs 的事件，只有在添加到 DOM 之后才能成功绑定
-        tabs.forEach(function (tab, index) {
-            if (!tab) {
-                // 如果 tab 不存在，则跳过本次循环
-                return;
-            }
-            var events = tab.events || [];
-            events.forEach(function (event) {
-                var selector = event.selector; // 获取事件选择器
-                var type = event.type; // 获取事件类型
-                var fn = event.fn || emptyFn; // 获取事件处理函数，如果没有则使用空函数
-                var $content = tabContentArr[index]; // 获取对应的内容元素
-                $content.find(selector).on(type, function (e) {
-                    // 在内容元素上绑定事件处理函数
-                    e.stopPropagation(); // 阻止事件冒泡
-                    var needToHide = fn(e); // 执行事件处理函数并获取是否需要隐藏的结果
-                    // 执行完事件之后，是否要关闭 panel
-                    if (needToHide) {
-                        // 如果需要隐藏，则调用 hide 方法
-                        _this.hide();
-                    }
-                    
-                    // 查找容器中的所有文本输入框和文本区域
-                    var $inputs = $container.find('input[type=text],textarea');
-                    if ($inputs.length) {
-                        // 如果找到输入框或文本区域，则将焦点设置到第一个元素上
-                        $inputs.get(0).focus();
-                    }
-                    
-                    // 将当前容器赋值给实例的 $container 属性
-                    this.$container = $container;
-                    
-                    // 调用私有方法隐藏其他面板
-                    this._hideOtherPanels();
-                    // 记录该菜单已经创建了面板
-                    _isCreatedPanelMenus.push(menu);
-
-hide: function hide() {
-    // 获取当前对象的menu属性
-    var menu = this.menu;
-    // 获取当前对象的$container属性
-    var $container = this.$container;
-    
-    // 如果$container存在，则移除该元素
-    if ($container) {
-        $container.remove();
-    }
-
-    // 过滤_isCreatedPanelMenus数组，移除与当前menu匹配的元素
-    _isCreatedPanelMenus = _isCreatedPanelMenus.filter(function (item) {
-        // 如果item等于menu，返回false表示移除该元素
-        if (item === menu) {
-            return false;
-        } else {
-            // 否则保留该元素
-            return true;
-        }
-    });
-},
-
-
-   
-    _hideOtherPanels: function _hideOtherPanels() {
-        // 如果未创建任何面板菜单，则直接返回
-        if (!_isCreatedPanelMenus.length) {
-            return;
-        }
-        // 遍历所有已创建的面板菜单
-        _isCreatedPanelMenus.forEach(function (menu) {
-            // 获取当前菜单对应的面板对象，如果不存在则为空对象
-            var panel = menu.panel || {};
-            // 如果面板对象存在且具有 hide 方法，则调用该方法隐藏面板
-            if (panel.hide) {
-                panel.hide();
-            }
-        });
-    }
-};
-
-
-
-function Link(editor) {
-    // 将传入的编辑器实例赋值给当前对象的 editor 属性
-    this.editor = editor;
-    
-    // 创建一个包含链接图标的 div 元素，并赋值给当前对象的 $elem 属性
-    this.$elem = $('<div class="w-e-menu"><i class="w-e-icon-link"></i></div>');
-    
-    // 设置当前对象类型为 'panel'
-    this.type = 'panel';
-
-    // 初始化当前对象的 active 状态为 false
-    this._active = false;
-}
-
-
-Link.prototype = {
-    constructor: Link,
-
-   
-    onClick: function onClick(e) {
-        // 获取当前编辑器实例
-        var editor = this.editor;
-        // 定义一个变量用于存储链接元素
-        var $linkelem = void 0;
-
-        if (this._active) {
-            // 当前选区在链接里面
-            $linkelem = editor.selection.getSelectionContainerElem();
-            if (!$linkelem) {
-                // 如果选区没有包含任何元素，直接返回
-                return;
-            }
-            // 将该元素都包含在选取之内，以便后面整体替换
-            editor.selection.createRangeByElem($linkelem);
-            editor.selection.restoreSelection();
-            // 显示 panel，并传入链接文本和链接地址
-            this._createPanel($linkelem.text(), $linkelem.attr('href'));
-        } else {
-            // 当前选区不在链接里面
-            if (editor.selection.isSelectionEmpty()) {
-                // 选区是空的，未选中内容
-                this._createPanel('', '');
-            } else {
-                // 选中内容了
-                this._createPanel(editor.selection.getSelectionText(), '');
-            }
-        }
-
-  
-    _createPanel: function _createPanel(text, link) {
-        var _this = this;
-    
-        // 生成一个随机的ID，用于输入链接的input元素
-        var inputLinkId = getRandom('input-link');
-        // 生成一个随机的ID，用于输入文本的input元素
-        var inputTextId = getRandom('input-text');
-        // 生成一个随机的ID，用于确认按钮的button元素
-        var btnOkId = getRandom('btn-ok');
-        // 生成一个随机的ID，用于删除按钮的button元素
-        var btnDelId = getRandom('btn-del');
-
-        // 是否显示“删除链接”按钮，根据当前状态决定
-        var delBtnDisplay = this._active ? 'inline-block' : 'none';
-
-        // 初始化并显示 panel
-        var panel = new Panel(this, {
-            width: 300,
-            // panel 中可包含多个 tab
-            tabs: [{
-                // tab 的标题
-                title: '链接',
-                // 模板，定义了输入框和按钮的 HTML 结构
-                tpl: '<div>\n                            <input id="' + inputTextId + '" type="text" class="block" value="' + text + '" placeholder="\u94FE\u63A5\u6587\u5B57"/></td>\n                            <input id="' + inputLinkId + '" type="text" class="block" value="' + link + '" placeholder="http://..."/></td>\n                            <div class="w-e-button-container">\n                                <button id="' + btnOkId + '" class="right">\u63D2\u5165</button>\n                                <button id="' + btnDelId + '" class="gray right" style="display:' + delBtnDisplay + '">\u5220\u9664\u94FE\u63A5</button>\n                            </div>\n                        </div>',
-                // 事件绑定
-                events: [
-                // 插入链接
-                {
-                    selector: '#' + btnOkId, // 选择器，用于绑定点击事件到按钮上
-                    type: 'click', // 事件类型为点击事件
-                    fn: function fn() {
-                        // 执行插入链接
-                        var $link = $('#' + inputLinkId); // 获取输入框中的链接值
-                        var $text = $('#' + inputTextId); // 获取输入框中的文本值
-                        var link = $link.val(); // 获取链接的实际值
-                        var text = $text.val(); // 获取文本的实际值
-                        _this._insertLink(text, link); // 调用方法插入链接和文本
-                    
-        // 返回 true，表示该事件执行完之后，panel 要关闭。否则 panel 不会关闭
-        return true;
-    }
-
-    {
-        selector: '#' + btnDelId, // 选择器，用于绑定点击事件的元素ID
-        type: 'click', // 事件类型，这里是点击事件
-        fn: function fn() { // 事件处理函数
-            // 执行删除链接操作
-            _this._delLink();
-
-            // 返回 true，表示该事件执行完之后，panel 要关闭。否则 panel 不会关闭
-            return true;
-        }
-    }]
-} 
-
-        // 显示 panel
-        panel.show();
-
-        // 记录属性
-        this.panel = panel;
-    },
-
-   
-    _delLink: function _delLink() {
-        // 如果当前对象未激活，则直接返回
-        if (!this._active) {
-            return;
-        }
-        // 获取编辑器实例
-        var editor = this.editor;
-        // 获取当前选中的容器元素
-        var $selectionELem = editor.selection.getSelectionContainerElem();
-        // 如果没有选中的容器元素，则直接返回
-        if (!$selectionELem) {
-            return;
-        }
-        // 获取当前选中的文本内容
-        var selectionText = editor.selection.getSelectionText();
-        // 使用插入HTML命令将选中的文本包裹在<span>标签中
-        editor.cmd.do('insertHTML', '<span>' + selectionText + '</span>');
-    },
-
-  
-    _insertLink: function _insertLink(text, link) {
-        // 获取编辑器实例
-        var editor = this.editor;
-        // 获取编辑器配置
-        var config = editor.config;
-        // 获取链接检查函数
-        var linkCheck = config.linkCheck;
-        // 初始化检查结果为 true
-        var checkResult = true; // 默认为 true
-        // 如果存在链接检查函数且其类型为函数，则执行检查
-        if (linkCheck && typeof linkCheck === 'function') {
-            // 调用链接检查函数并获取结果
-            checkResult = linkCheck(text, link);
-        }
-        // 如果检查结果为 true，插入 HTML 链接
-        if (checkResult === true) {
-            // 使用编辑器命令插入 HTML 链接
-            editor.cmd.do('insertHTML', '<a href="' + link + '" target="_blank">' + text + '</a>');
-        } else {
-            // 如果检查结果不为 true，弹出警告信息
-            alert(checkResult);
-        }
-    },
-
-   
-    tryChangeActive: function tryChangeActive(e) {
-        // 获取编辑器实例
-        var editor = this.editor;
-        // 获取当前元素的jQuery对象
-        var $elem = this.$elem;
-        // 获取当前选中的容器元素
-        var $selectionELem = editor.selection.getSelectionContainerElem();
-        
-        // 如果未选中任何元素，则直接返回
-        if (!$selectionELem) {
-            return;
-        }
-        
-        // 判断选中的元素是否为链接（<a>标签）
-        if ($selectionELem.getNodeName() === 'A') {
-            // 如果是链接，设置_active属性为true，并添加'w-e-active'类
-            this._active = true;
-            $elem.addClass('w-e-active');
-        } else {
-            // 如果不是链接，设置_active属性为false，并移除'w-e-active'类
-            this._active = false;
-            $elem.removeClass('w-e-active');
-        }
-    }
-
-
-function Italic(editor) {
-    // 将传入的编辑器实例赋值给当前对象的 editor 属性
-    this.editor = editor;
-    
-    // 创建一个包含斜体图标的 div 元素，并赋值给当前对象的 $elem 属性
-    this.$elem = $('<div class="w-e-menu">\n            <i class="w-e-icon-italic"></i>\n        </div>');
-    
-    // 设置事件类型为点击事件
-    this.type = 'click';
-
-    // 初始化当前对象是否处于 active 状态的属性，默认值为 false
-    this._active = false;
-}
-
-
-Italic.prototype = {
-    constructor: Italic,
-
-    
-    onClick: function onClick(e) {
-        // 获取编辑器实例
-        var editor = this.editor;
-        // 检查当前选区是否为空
-        var isSeleEmpty = editor.selection.isSelectionEmpty();
-
-        if (isSeleEmpty) {
-            // 如果选区为空，则创建一个空的选区
-            editor.selection.createEmptyRange();
-        }
-
-        // 执行斜体命令
-        editor.cmd.do('italic');
-    }
-};
-
-        if (isSeleEmpty) {
-            // 如果选择为空，则折叠选区并恢复选区
-            editor.selection.collapseRange();
-            editor.selection.restoreSelection();
-        }
-        },
-        
-        // 试图改变 active 状态
-        tryChangeActive: function tryChangeActive(e) {
-            var editor = this.editor; // 获取编辑器实例
-            var $elem = this.$elem; // 获取当前元素的 jQuery 对象
-            if (editor.cmd.queryCommandState('italic')) {
-                // 如果编辑器命令状态为斜体，则设置 active 状态为 true 并添加 'w-e-active' 类
-                this._active = true;
-                $elem.addClass('w-e-active');
-            } else {
-                // 否则设置 active 状态为 false 并移除 'w-e-active' 类
-                this._active = false;
-                $elem.removeClass('w-e-active');
-            }
-        }
-        };
-
-
-function Redo(editor) {
-    // 将传入的编辑器实例赋值给当前对象的 editor 属性
-    this.editor = editor;
-    
-    // 创建一个包含重做图标的 div 元素，并赋值给当前对象的 $elem 属性
-    this.$elem = $('<div class="w-e-menu">\n            <i class="w-e-icon-redo"></i>\n        </div>');
-    
-    // 设置事件类型为 'click'
-    this.type = 'click';
-
-    // 初始化当前是否处于 active 状态的属性，默认值为 false
-    this._active = false;
-}
-
-
-Redo.prototype = {
-    constructor: Redo,
-
-    
-    onClick: function onClick(e) {
-        // 获取当前编辑器实例
-        var editor = this.editor;
-
-        // 执行重做命令
-        editor.cmd.do('redo');
-    }
-};
-
-
-function StrikeThrough(editor) {
-    // 初始化编辑器实例
-    this.editor = editor;
-    // 创建菜单元素并设置类名和图标
-    this.$elem = $('<div class="w-e-menu">\n            <i class="w-e-icon-strikethrough"></i>\n        </div>');
-    // 设置事件类型为点击
-    this.type = 'click';
-
-    // 当前是否 active 状态
-    this._active = false;
-}
-
-StrikeThrough.prototype = {
-    constructor: StrikeThrough,
-
-    // 点击事件处理函数
-    onClick: function onClick(e) {
-        // 获取编辑器实例
-        var editor = this.editor;
-        // 判断当前选区是否为空
-        var isSeleEmpty = editor.selection.isSelectionEmpty();
-
-        if (isSeleEmpty) {
-            // 选区是空的，插入并选中一个“空白”
-            editor.selection.createEmptyRange();
-        }
-
-        // 执行 strikeThrough 命令
-        editor.cmd.do('strikeThrough');
-
-        if (isSeleEmpty) {
-            // 需要将选取折叠起来
-            editor.selection.collapseRange();
-            // 恢复之前的选取范围
-            editor.selection.restoreSelection();
-        }
-        },
-        
-        
-        tryChangeActive: function tryChangeActive(e) {
-            var editor = this.editor; // 获取编辑器实例
-            var $elem = this.$elem; // 获取当前元素
-            if (editor.cmd.queryCommandState('strikeThrough')) {
-                // 如果命令状态为删除线，则设置 active 状态为 true
-                this._active = true;
-                // 添加 'w-e-active' 类以表示激活状态
-                $elem.addClass('w-e-active');
-            } else {
-                // 否则设置 active 状态为 false
-                this._active = false;
-                // 移除 'w-e-active' 类以表示非激活状态
-                $elem.removeClass('w-e-active');
-            }
-        }
-        };
-
-
-function Underline(editor) {
-    // 初始化Underline对象，并设置编辑器实例
-    this.editor = editor;
-    // 创建菜单元素，包含下划线图标
-    this.$elem = $('<div class="w-e-menu">\n            <i class="w-e-icon-underline"></i>\n        </div>');
-    // 设置事件类型为点击
-    this.type = 'click';
-
-    // 当前是否激活状态
-    this._active = false;
-}
-
-Underline.prototype = {
-    constructor: Underline,
-
-   
-    onClick: function onClick(e) {
-        // 阻止默认行为和冒泡
-        e.preventDefault();
-        e.stopPropagation();
-
-        // 获取编辑器实例
-        var editor = this.editor;
-        // 判断当前选区是否为空
-        var isSeleEmpty = editor.selection.isSelectionEmpty();
-        if (isSeleEmpty) {
-            // 如果当前选择为空，则创建一个空的选择范围
-            editor.selection.createEmptyRange();
-        }
-
-        // 执行下划线命令
-        editor.cmd.do('underline');
-
-        if (isSeleEmpty) {
-            // 如果当前选择为空，则将光标折叠到起始位置并恢复之前的选择
-            editor.selection.collapseRange();
-            editor.selection.restoreSelection();
-        }
-    },
-
-    
-    tryChangeActive: function tryChangeActive(e) {
-        // 获取编辑器实例
-        var editor = this.editor;
-        // 获取当前元素的jQuery对象
-        var $elem = this.$elem;
-        // 检查编辑器命令'underline'的状态
-        if (editor.cmd.queryCommandState('underline')) {
-            // 如果命令状态为激活，设置_active属性为true
-            this._active = true;
-            // 给元素添加'w-e-active'类
-            $elem.addClass('w-e-active');
-        } else {
-            // 如果命令状态为未激活，设置_active属性为false
-            this._active = false;
-            // 从元素中移除'w-e-active'类
-            $elem.removeClass('w-e-active');
-        }
-    }
-
-function Undo(editor) {
-    // 保存编辑器实例
-    this.editor = editor;
-    // 创建菜单元素并设置类名和图标
-    this.$elem = $('<div class="w-e-menu">\n            <i class="w-e-icon-undo"></i>\n        </div>');
-    // 设置事件类型为点击
-    this.type = 'click';
-
-    // 当前是否 active 状态
-    this._active = false;
-}
-
-Undo.prototype = {
-    constructor: Undo,
-
-    
-    onClick: function onClick(e) {
-        // 获取编辑器实例
-        var editor = this.editor;
-
-        // 执行撤销命令
-        editor.cmd.do('undo');
-    }
-};
-
-
-function List(editor) {
-    var _this = this; // 保存当前对象的引用，以便在嵌套函数中使用
-
-    this.editor = editor; // 将传入的编辑器实例赋值给当前对象
-    this.$elem = $('<div class="w-e-menu"><i class="w-e-icon-list2"></i></div>'); // 创建菜单元素并添加到当前对象
-    this.type = 'droplist'; // 设置菜单类型为下拉列表
-
-    // 当前是否 active 状态
-    this._active = false; // 初始化 active 状态为 false
-
-    // 初始化 droplist
-    this.droplist = new DropList(this, {
-        width: 120, // 设置下拉列表宽度为 120
-        $title: $('<p>设置列表</p>'), // 设置下拉列表标题
-        type: 'list', // 设置下拉列表展示形式为列表
-        list: [
-            { $elem: $('<span><i class="w-e-icon-list-numbered"></i> 有序列表</span>'), value: 'insertOrderedList' }, // 添加有序列表选项
-            { $elem: $('<span><i class="w-e-icon-list2"></i> 无序列表</span>'), value: 'insertUnorderedList' } // 添加无序列表选项
-        ],
-        onClick: function onClick(value) {
-            // 注意 this 是指向当前的 List 对象
-            _this._command(value); // 调用命令方法执行相应的操作
-        }
-    });
-}
-
-
-ist.prototype = {
-    constructor: List,
-
-    // 执行命令的方法
-    _command: function _command(value) {
-        // 获取编辑器实例
-        var editor = this.editor;
-        // 获取文本元素
-        var $textElem = editor.$textElem;
-        // 恢复之前的选区
-        editor.selection.restoreSelection();
-        // 如果命令已经处于激活状态，则直接返回
-        if (editor.cmd.queryCommandState(value)) {
-            return;
-        }
-        // 否则执行该命令
-        editor.cmd.do(value);
-    },
-        
-        var $selectionElem = editor.selection.getSelectionContainerElem(); // 获取当前选中的元素
-        if ($selectionElem.getNodeName() === 'LI') { // 如果选中的元素是列表项
-            $selectionElem = $selectionElem.parent(); // 将选中元素设置为其父元素
-        }
-        if (/^ol|ul$/i.test($selectionElem.getNodeName()) === false) { // 如果选中的元素不是有序或无序列表
-            return; // 退出函数
-        }
-        if ($selectionElem.equal($textElem)) { // 如果选中的元素等于文本元素
-            // 如果是根节点，则不处理
-            return; // 退出函数
-        }
-        var $parent = $selectionElem.parent(); // 获取选中元素的父元素
-        if ($parent.equal($textElem)) { // 如果父元素等于文本元素
-            // 如果是根节点，则不处理
-            return; // 退出函数
-        }
-        
-        $selectionElem.insertAfter($parent); // 将选中元素插入到父元素的后面
-        $parent.remove(); // 移除父元素
-        },
-        
-        
-        tryChangeActive: function tryChangeActive(e) {
-            var editor = this.editor; // 获取编辑器实例
-            var $elem = this.$elem; // 获取当前元素
-            if (editor.cmd.queryCommandState('insertUnOrderedList') || editor.cmd.queryCommandState('insertOrderedList')) {
-                // 如果命令状态为无序列表或有序列表
-                this._active = true; // 设置活动状态为真
-                $elem.addClass('w-e-active'); // 添加活动样式类
-            } else {
-                this._active = false; // 设置活动状态为假
-                $elem.removeClass('w-e-active'); // 移除活动样式类
-            }
-        }
-        };
-
-
-function Justify(editor) {
-    // 保存当前对象的引用
-    var _this = this;
-
-    // 将传入的编辑器对象赋值给当前实例的 editor 属性
-    this.editor = editor;
-    // 创建一个包含图标和样式的 div 元素，并赋值给当前实例的 $elem 属性
-    this.$elem = $('<div class="w-e-menu"><i class="w-e-icon-paragraph-left"></i></div>');
-    // 设置类型为 'droplist'
-    this.type = 'droplist';
-
-    // 初始化一个布尔值，表示当前是否处于 active 状态
-    this._active = false;
-
-    // 初始化 droplist 组件
-    this.droplist = new DropList(this, {
-        // 设置 droplist 的宽度
-        width: 100,
-        // 设置 droplist 的标题
-        $title: $('<p>对齐方式</p>'),
-        // 设置 droplist 的类型为列表形式展示
-        type: 'list',
-        // 定义列表项及其对应的值
-        list: [
-            { $elem: $('<span><i class="w-e-icon-paragraph-left"></i> 靠左</span>'), value: 'justifyLeft' },
-            { $elem: $('<span><i class="w-e-icon-paragraph-center"></i> 居中</span>'), value: 'justifyCenter' },
-            { $elem: $('<span><i class="w-e-icon-paragraph-right"></i> 靠右</span>'), value: 'justifyRight' }
-        ],
-        // 定义点击列表项时的回调函数
-        onClick: function onClick(value) {
-            // 注意 this 是指向当前的 List 对象
-            _this._command(value);
-        }
-    });
-}
-
-
-Justify.prototype = {
-    constructor: Justify,
-
-    
-    _command: function _command(value) {
-        // 获取编辑器实例
-        var editor = this.editor;
-        // 调用编辑器的cmd对象的do方法，执行传入的命令
-        editor.cmd.do(value);
-    }
-};
-
-
-function ForeColor(editor) {
-    var _this = this;
-
-    // 保存编辑器实例
-    this.editor = editor;
-    // 创建菜单元素，包含一个图标
-    this.$elem = $('<div class="w-e-menu"><i class="w-e-icon-pencil2"></i></div>');
-    // 设置菜单类型为下拉列表
-    this.type = 'droplist';
-
-    // 获取配置的颜色
-    var config = editor.config;
-    var colors = config.colors || [];
-
-    // 当前是否 active 状态
-    this._active = false;
-
-    // 初始化 droplist
-    this.droplist = new DropList(this, {
-        width: 120, // 设置下拉列表宽度
-        $title: $('<p>文字颜色</p>'), // 设置下拉列表标题
-        type: 'inline-block', // 设置下拉列表内容以 inline-block 形式展示
-        list: colors.map(function (color) {
-            // 将颜色数组映射为包含颜色样式和值的对象数组
-            return { $elem: $('<i style="color:' + color + ';" class="w-e-icon-pencil2"></i>'), value: color };
-        }),
-        onClick: function onClick(value) {
-            // 注意 this 是指向当前的 ForeColor 对象
-            // 当点击某个颜色时执行命令
-            _this._command(value);
-        }
-    });
-}
-
-
-ForeColor.prototype = {
-    constructor: ForeColor,
-
-    // 私有方法，用于执行设置前景色的命令
-    _command: function _command(value) {
-        // 获取编辑器实例
-        var editor = this.editor;
-        // 调用编辑器命令接口，执行设置前景色的命令
-        editor.cmd.do('foreColor', value);
-    }
-};
-
-
-function BackColor(editor) {
-    var _this = this; // 保存当前对象的引用，以便在回调函数中使用
-
-    this.editor = editor; // 将传入的编辑器对象赋值给当前实例的 editor 属性
-    this.$elem = $('<div class="w-e-menu"><i class="w-e-icon-paint-brush"></i></div>'); // 创建菜单元素并添加到当前实例的 $elem 属性中
-    this.type = 'droplist'; // 设置菜单类型为下拉列表
-
-    // 获取配置的颜色
-    var config = editor.config; // 从编辑器配置中获取配置对象
-    var colors = config.colors || []; // 获取配置中的颜色数组，如果没有则使用空数组
-
-    // 当前是否 active 状态
-    this._active = false; // 初始化 active 状态为 false
-
-    // 初始化 droplist
-    this.droplist = new DropList(this, {
-        width: 120, // 设置下拉列表的宽度
-        $title: $('<p>背景色</p>'), // 设置下拉列表的标题
-        type: 'inline-block', // 设置下拉列表内容以 inline-block 形式展示
-        list: colors.map(function (color) {
-            return { $elem: $('<i style="color:' + color + ';" class="w-e-icon-paint-brush"></i>'), value: color }; // 生成颜色选项列表
-        }),
-        onClick: function onClick(value) {
-            // 注意 this 是指向当前的 BackColor 对象
-            _this._command(value); // 调用命令方法，应用选中的背景色
-        }
-    });
-}
-
-
-BackColor.prototype = {
-    constructor: BackColor,
-
-   
-    _command: function _command(value) {
-        // 获取编辑器实例
-        var editor = this.editor;
-        // 调用编辑器的命令接口，设置背景颜色
-        editor.cmd.do('backColor', value);
-    }
-};
-
-
-function Quote(editor) {
-    // 将传入的编辑器实例赋值给当前对象的 editor 属性
-    this.editor = editor;
-    
-    // 创建一个包含特定 HTML 结构的 jQuery 对象，并赋值给当前对象的 $elem 属性
-    this.$elem = $('<div class="w-e-menu">\n            <i class="w-e-icon-quotes-left"></i>\n        </div>');
-    
-    // 设置事件类型为 'click'
-    this.type = 'click';
-
-    // 初始化当前对象的 active 状态为 false
-    this._active = false;
-}
-
-// 原型
-Quote.prototype = {
-    constructor: Quote,
-
-    onClick: function onClick(e) {
-        // 获取编辑器实例
-        var editor = this.editor;
-        // 获取当前选中的容器元素
-        var $selectionElem = editor.selection.getSelectionContainerElem();
-        // 获取选中元素的节点名称
-        var nodeName = $selectionElem.getNodeName();
-
-        // 判断是否为非IE浏览器
-        if (!UA.isIE()) {
-            // 如果选中的元素是 BLOCKQUOTE，则撤销引用格式
-            if (nodeName === 'BLOCKQUOTE') {
-                editor.cmd.do('formatBlock', '<P>');
-            } else {
-                // 否则，将选中的元素转换为引用格式
-                editor.cmd.do('formatBlock', '<BLOCKQUOTE>');
-            }
-            return;
-        }
-
-        // 定义变量 content 和 $targetELem，初始值为 undefined
-        var content = void 0,
-            $targetELem = void 0;
-        if (nodeName === 'P') {
-            // 如果当前节点是 P 标签
-            // 将 P 标签的内容赋值给 content
-            content = $selectionElem.text();
-            // 创建一个新的 blockquote 元素，并将 P 标签的内容插入其中
-            $targetELem = $('<blockquote>' + content + '</blockquote>');
-            // 将新的 blockquote 元素插入到 P 标签之后
-            $targetELem.insertAfter($selectionElem);
-            // 移除原来的 P 标签
-            $selectionElem.remove();
-            // 结束函数执行
-            return;
-        }
-        if (nodeName === 'BLOCKQUOTE') {
-            // 如果当前节点是 BLOCKQUOTE 标签
-            // 将 BLOCKQUOTE 标签的内容赋值给 content
-            content = $selectionElem.text();
-            // 创建一个新的 P 元素，并将 BLOCKQUOTE 标签的内容插入其中
-            $targetELem = $('<p>' + content + '</p>');
-            // 将新的 P 元素插入到 BLOCKQUOTE 标签之后
-            $targetELem.insertAfter($selectionElem);
-            // 移除原来的 BLOCKQUOTE 标签
-            $selectionElem.remove();
-        }
-    },
-
-    tryChangeActive: function tryChangeActive(e) {
-        // 获取编辑器实例
-        var editor = this.editor;
-        // 获取当前元素的jQuery对象
-        var $elem = this.$elem;
-        // 定义正则表达式，用于匹配BLOCKQUOTE标签
-        var reg = /^BLOCKQUOTE$/i;
-        // 查询当前命令的值，判断是否为BLOCKQUOTE格式
-        var cmdValue = editor.cmd.queryCommandValue('formatBlock');
-        // 如果当前命令值为BLOCKQUOTE格式
-        if (reg.test(cmdValue)) {
-            // 设置_active属性为true
-            this._active = true;
-            // 给元素添加'w-e-active'类
-            $elem.addClass('w-e-active');
-        } else {
-            // 设置_active属性为false
-            this._active = false;
-            // 移除元素的'w-e-active'类
-            $elem.removeClass('w-e-active');
-        }
-    }
-
-
-
-function Code(editor) {
-    // 将传入的编辑器实例赋值给当前对象的editor属性
-    this.editor = editor;
-    // 创建一个包含特定HTML结构的jQuery元素，并赋值给当前对象的$elem属性
-    this.$elem = $('<div class="w-e-menu">\n            <i class="w-e-icon-terminal"></i>\n        </div>');
-    // 设置当前对象的类型为'panel'
-    this.type = 'panel';
-
-    // 当前未使用
-    // 初始化_active属性为false，表示当前状态未激活
-    this._active = false;
-}
-
-Code.prototype = {
-    constructor: Code,
-
-    onClick: function onClick(e) {
-        // 获取编辑器实例
-        var editor = this.editor;
-        // 获取选择区域的起始元素
-        var $startElem = editor.selection.getSelectionStartElem();
-        // 获取选择区域的结束元素
-        var $endElem = editor.selection.getSelectionEndElem();
-        // 判断当前选择区域是否为空
-        var isSeleEmpty = editor.selection.isSelectionEmpty();
-        // 获取当前选择的文本内容
-        var selectionText = editor.selection.getSelectionText();
-        // 定义一个变量用于存储代码块元素
-        var $code = void 0;
-
-        if (!$startElem.equal($endElem)) {
-            // 如果起始元素和结束元素不相等，则恢复选区并返回
-            editor.selection.restoreSelection();
-            return;
-        }
-        if (!isSeleEmpty) {
-            // 如果选区不为空，则将选中的文本包裹在<code>标签中并插入到编辑器中
-            $code = $('<code>' + selectionText + '</code>');
-            editor.cmd.do('insertElem', $code);
-            // 创建一个新的选区范围，并将其设置为包含新插入的<code>元素
-            editor.selection.createRangeByElem($code, false);
-            // 恢复选区
-            editor.selection.restoreSelection();
-            return;
-        }
-        
-        // 如果选区为空，则显示代码块面板
-        if (this._active) {
-            // 如果当前插件已经激活，则显示带有当前HTML内容的代码块面板
-            this._createPanel($startElem.html());
-        } else {
-            // 如果当前插件未激活，则显示一个空的代码块面板
-            this._createPanel();
-        }
-        },
-
-    _createPanel: function _createPanel(value) {
-        var _this = this;
-    
-        // 如果 value 为空，则设置为空字符串
-        value = value || '';
-        // 根据 value 是否为空判断是新建还是编辑模式
-        var type = !value ? 'new' : 'edit';
-        // 生成随机的文本框 ID
-        var textId = getRandom('texxt');
-        // 生成随机的按钮 ID
-        var btnId = getRandom('btn');
-    
-        // 创建一个新的 Panel 对象
-        var panel = new Panel(this, {
-            width: 500,
-            // 一个 Panel 包含多个 tab
-            tabs: [{
-                // 标题
-                title: '插入代码',
-                // 模板，包含一个文本框和一个按钮
-                tpl: '<div>\n                        <textarea id="' + textId + '" style="height:145px;;">' + value + '</textarea>\n                        <div class="w-e-button-container">\n                            <button id="' + btnId + '" class="right">\u63D2\u5165</button>\n                        </div>\n                    <div>',
-                // 事件绑定
-                events: [
-                // 插入代码的事件处理函数
-                {
-                    selector: '#' + btnId,
-                    type: 'click',
-                    fn: function fn() {
-                        // 获取文本框的值或 HTML 内容
-                        var $text = $('#' + textId);
-                        var text = $text.val() || $text.html();
-                        // 替换 HTML 特殊字符
-                        text = replaceHtmlSymbol(text);
-                        if (type === 'new') {
-                            // 新插入操作
-                            _this._insertCode(text);
-                        } else {
-                            // 编辑更新操作
-                            _this._updateCode(text);
-                        }
-                        
-                        // 返回 true，表示该事件执行完之后，panel 要关闭。否则 panel 不会关闭
-                        return true;
-                    }
-                }]
-            } 
-            ] 
-        }); 
-
-        // 显示 panel
-        panel.show();
-
-        // 记录属性
-        this.panel = panel;
-    },
-
-    // 插入代码
-    _insertCode: function _insertCode(value) {
-        // 获取当前编辑器实例
-        var editor = this.editor;
-        // 执行插入HTML命令，将传入的代码值包裹在<pre><code>标签中并插入到编辑器中
-        editor.cmd.do('insertHTML', '<pre><code>' + value + '</code></pre><p><br></p>');
-    },
-
-    // 更新代码
-    _updateCode: function _updateCode(value) {
-        // 获取编辑器实例
-        var editor = this.editor;
-        // 获取当前选中的DOM元素
-        var $selectionELem = editor.selection.getSelectionContainerElem();
-        // 如果未选中任何元素，则直接返回
-        if (!$selectionELem) {
-            return;
-        }
-        // 将选中元素的HTML内容更新为传入的值
-        $selectionELem.html(value);
-        // 恢复选区到之前的位置
-        editor.selection.restoreSelection();
-    },
-
-    // 试图改变 active 状态
-    tryChangeActive: function tryChangeActive(e) {
-        // 获取编辑器实例
-        var editor = this.editor;
-        // 获取当前元素的 jQuery 对象
-        var $elem = this.$elem;
-        // 获取当前选中的容器元素
-        var $selectionELem = editor.selection.getSelectionContainerElem();
-        // 如果未选中任何元素，则直接返回
-        if (!$selectionELem) {
-            return;
-        }
-        // 获取选中元素的父元素
-        var $parentElem = $selectionELem.parent();
-        // 判断选中的元素是否为 <code> 且其父元素是否为 <pre>
-        if ($selectionELem.getNodeName() === 'CODE' && $parentElem.getNodeName() === 'PRE') {
-            // 设置 active 状态为 true
-            this._active = true;
-            // 给当前元素添加 'w-e-active' 类
-            $elem.addClass('w-e-active');
-        } else {
-            // 设置 active 状态为 false
-            this._active = false;
-            // 移除当前元素的 'w-e-active' 类
-            $elem.removeClass('w-e-active');
-        }
-    }
-
-
-function Emoticon(editor) {
-    // 初始化表情对象，传入编辑器实例
-    this.editor = editor;
-    // 创建表情菜单的DOM元素
-    this.$elem = $('<div class="w-e-menu">\n            <i class="w-e-icon-happy"></i>\n        </div>');
-    // 设置菜单类型为面板
-    this.type = 'panel';
-
-    // 当前是否激活状态
-    this._active = false;
-}
-
-Emoticon.prototype = {
-    constructor: Emoticon,
-
-   
-    onClick: function onClick() {
-        // 调用创建面板的方法
-        this._createPanel();
-    },
-
-  
-    _createPanel: function _createPanel() {
-        var _this = this; // 保存当前上下文引用
-
-        var editor = this.editor; // 获取编辑器实例
-        var config = editor.config; // 获取编辑器配置
-        // 获取表情配置
-        var emotions = config.emotions || [];
-
-        // 创建表情 dropPanel 的配置
-        var tabConfig = [];
-        emotions.forEach(function (emotData) {
-            var emotType = emotData.type; // 表情类型
-            var content = emotData.content || []; // 表情内容数组
-
-            // 这一组表情最终拼接出来的 html
-            var faceHtml = '';
-
-           
-            if (emotType === 'emoji') {
-                // 遍历表情内容数组
-                content.forEach(function (item) {
-                    // 如果当前项存在，则将其包裹在 <span> 标签中并添加到 faceHtml 字符串中
-                    if (item) {
-                        faceHtml += '<span class="w-e-item">' + item + '</span>';
-                    }
-                });
-            }
-            // 图片表情处理
-            if (emotType === 'image') {
-                // 遍历图片内容数组
-                content.forEach(function (item) {
-                    // 获取图片的 src 和 alt 属性
-                    var src = item.src;
-                    var alt = item.alt;
-                    // 如果 src 存在，则生成包含图片的 <span> 标签，并添加 data-w-e 属性
-                    if (src) {
-                        // 加一个 data-w-e 属性，点击图片的时候不再提示编辑图片
-                        faceHtml += '<span class="w-e-item"><img src="' + src + '" alt="' + alt + '" data-w-e="1"/></span>';
-                    }
-                });
-            }
-                        // 加一个 data-w-e 属性，点击图片的时候不再提示编辑图片
-                        faceHtml += '<span class="w-e-item"><img src="' + src + '" alt="' + alt + '" data-w-e="1"/></span>';
-                    }
-                });
-            }
-
-            tabConfig.push({
-                // 设置标签页的标题
-                title: emotData.title,
-                // 设置标签页的内容模板，包含表情 HTML
-                tpl: '<div class="w-e-emoticon-container">' + faceHtml + '</div>',
-                events: [{
-                    // 选择器，用于匹配表情项
-                    selector: 'span.w-e-item',
-                    // 事件类型，点击事件
-                    type: 'click',
-                    fn: function fn(e) {
-                        // 获取触发事件的目标元素
-                        var target = e.target;
-                        // 将目标元素转换为 jQuery 对象
-                        var $target = $(target);
-                        // 获取目标元素的节点名称
-                        var nodeName = $target.getNodeName();
-            
-                        var insertHtml = void 0;
-                        if (nodeName === 'IMG') {
-                            // 如果目标元素是图片，则插入图片的 HTML
-                            insertHtml = $target.parent().html();
-                        } else {
-                            // 如果目标元素不是图片，则插入 emoji 的 HTML
-                            insertHtml = '<span>' + $target.html() + '</span>';
-                        }
-            
-                        // 调用插入方法，将生成的 HTML 插入到编辑器中
-                        _this._insert(insertHtml);
-                        // 返回 true，表示该事件执行完之后，面板要关闭。否则面板不会关闭
-                        return true;
-                    }
-                }]
-            });
-        });
-
-        var panel = new Panel(this, {
-            // 设置面板的宽度为300
-            width: 300,
-            // 设置面板的高度为200
-            height: 200,
-            // 一个 Panel 包含多个 tab，tabConfig 是 tab 的配置信息
-            tabs: tabConfig
-        });
-        
-        // 显示 panel
-        panel.show();
-        
-        // 记录属性，将创建的 panel 对象赋值给当前对象的 panel 属性
-        this.panel = panel;
-        },
-
-    // 插入表情
-    _insert: function _insert(emotHtml) {
-        // 获取当前编辑器实例
-        var editor = this.editor;
-        // 执行插入HTML命令，将表情HTML插入到编辑器中
-        editor.cmd.do('insertHTML', emotHtml);
-    }
-
-
-function Table(editor) {
-    // 将传入的编辑器实例赋值给当前对象的 editor 属性
-    this.editor = editor;
-    
-    // 创建一个包含特定类名和图标的 div 元素，并赋值给当前对象的 $elem 属性
-    this.$elem = $('<div class="w-e-menu"><i class="w-e-icon-table2"></i></div>');
-    
-    // 设置当前对象类型为 'panel'
-    this.type = 'panel';
-
-    // 初始化当前对象的活动状态为 false
-    this._active = false;
-}
-
-// 原型
-Table.prototype = {
-    constructor: Table,
-
-    onClick: function onClick() {
-        // 检查表格是否处于活动状态
-        if (this._active) {
-            // 如果表格处于活动状态，则创建编辑面板
-            this._createEditPanel();
-        } else {
-            // 如果表格不处于活动状态，则创建插入面板
-            this._createInsertPanel();
-        }
-    },
-
-    // 创建插入新表格的 panel
-    _createInsertPanel: function _createInsertPanel() {
-        var _this = this;
-
-        // 生成随机 id，用于按钮和输入框
-        var btnInsertId = getRandom('btn');
-        var textRowNum = getRandom('row');
-        var textColNum = getRandom('col');
-
-        // 创建一个新的 Panel 对象
-        var panel = new Panel(this, {
-            width: 250,
-            // panel 包含多个 tab
-            tabs: [{
-                // 设置 tab 的标题
-                title: '插入表格',
-                // 定义 tab 的内容模板
-                tpl: '<div>\n                        <p style="text-align:left; padding:5px 0;">\n                            \u521B\u5EFA\n                            <input id="' + textRowNum + '" type="text" value="5" style="width:40px;text-align:center;"/>\n                            \u884C\n                            <input id="' + textColNum + '" type="text" value="5" style="width:40px;text-align:center;"/>\n                            \u5217\u7684\u8868\u683C\n                        </p>\n                        <div class="w-e-button-container">\n                            <button id="' + btnInsertId + '" class="right">\u63D2\u5165</button>\n                        </div>\n                    </div>',
-                // 绑定事件处理函数
-                events: [{
-                    // 点击按钮时触发的事件
-                    selector: '#' + btnInsertId,
-                    type: 'click',
-                    fn: function fn() {
-                        // 获取用户输入的行数和列数
-                        var rowNum = parseInt($('#' + textRowNum).val());
-                        var colNum = parseInt($('#' + textColNum).val());
-
-                        if (rowNum && colNum && rowNum > 0 && colNum > 0) {
-                            // 如果行数和列数都有效且大于0，则执行插入操作
-                            _this._insert(rowNum, colNum);
-                        }
-                        
-                        // 返回 true，表示该事件执行完之后，panel 要关闭。否则 panel 不会关闭
-                        return true;
-                        } 
-                        ] 
-                        } 
-
-        // 展示 panel
-        panel.show();
-
-        // 记录属性
-        this.panel = panel;
-    },
-
-    // 插入表格
-    _insert: function _insert(rowNum, colNum) {
-        // 定义行和列的变量
-        var r = void 0,
-            c = void 0;
-        // 初始化 HTML 字符串，包含 table 标签和样式属性
-        var html = '<table border="0" width="100%" cellpadding="0" cellspacing="0">';
-        // 循环生成每一行
-        for (r = 0; r < rowNum; r++) {
-            html += '<tr>'; // 添加行开始标签
-            if (r === 0) { // 如果是第一行
-                for (c = 0; c < colNum; c++) {
-                    html += '<th>&nbsp;</th>'; // 添加表头单元格
-                }
-            } else { // 如果不是第一行
-                for (c = 0; c < colNum; c++) {
-                    html += '<td>&nbsp;</td>'; // 添加普通单元格
-                }
-            }
-            html += '</tr>'; // 添加行结束标签
-        }
-        // 关闭 table 标签并添加换行符
-        html += '</table><p><br></p>';
-
-        // 执行命令
-        var editor = this.editor;
-        editor.cmd.do('insertHTML', html);
-
-        // 防止 firefox 下出现 resize 的控制点
-        editor.cmd.do('enableObjectResizing', false);
-        editor.cmd.do('enableInlineTableEditing', false);
-    },
-
-    // 创建编辑表格的 panel
-    _createEditPanel: function _createEditPanel() {
-        var _this2 = this;
-
-        // 生成一个随机的ID，用于添加行按钮
-        var addRowBtnId = getRandom('add-row');
-        // 生成一个随机的ID，用于添加列按钮
-        var addColBtnId = getRandom('add-col');
-        // 生成一个随机的ID，用于删除行按钮
-        var delRowBtnId = getRandom('del-row');
-        // 生成一个随机的ID，用于删除列按钮
-        var delColBtnId = getRandom('del-col');
-        // 生成一个随机的ID，用于删除表格按钮
-        var delTableBtnId = getRandom('del-table');
-
-        // 创建 panel 对象
-        var panel = new Panel(this, {
-            width: 320,
-            // panel 包含多个 tab
-            tabs: [{
-                // 标题
-                title: '编辑表格',
-                // 模板，定义了按钮的 HTML 结构
-                tpl: '<div>\n                        <div class="w-e-button-container" style="border-bottom:1px solid #f1f1f1;padding-bottom:5px;margin-bottom:5px;">\n                            <button id="' + addRowBtnId + '" class="left">\u589E\u52A0\u884C</button>\n                            <button id="' + delRowBtnId + '" class="red left">\u5220\u9664\u884C</button>\n                            <button id="' + addColBtnId + '" class="left">\u589E\u52A0\u5217</button>\n                            <button id="' + delColBtnId + '" class="red left">\u5220\u9664\u5217</button>\n                        </div>\n                        <div class="w-e-button-container">\n                            <button id="' + delTableBtnId + '" class="gray left">\u5220\u9664\u8868\u683C</button>\n                        </dv>\n                    </div>',
-                // 事件绑定
-                events: [{
-                    // 增加行
-                    selector: '#' + addRowBtnId,
-                    type: 'click',
-                    fn: function fn() {
-                        _this2._addRow();
-                        // 返回 true，表示该事件执行完之后，panel 要关闭。否则 panel 不会关闭
-                        return true;
-                    }
-                }, {
-                    // 选择器，用于绑定点击事件到指定的按钮上
-                    selector: '#' + addColBtnId,
-                    // 事件类型，这里是一个点击事件
-                    type: 'click',
-                    // 事件处理函数
-                    fn: function fn() {
-                        // 调用当前对象的 _addCol 方法，增加列
-                        _this2._addCol();
-                        // 返回 true，表示该事件执行完之后，panel 要关闭。否则 panel 不会关闭
-                        return true;
-                    }
-                }, {
-                    // 删除行
-                    selector: '#' + delRowBtnId,
-                    type: 'click',
-                    fn: function fn() {
-                        // 调用 _delRow 方法，执行删除行操作
-                        _this2._delRow();
-                        // 返回 true，表示该事件执行完之后，panel 要关闭。否则 panel 不会关闭
-                        return true;
-                    }
-                }, {
-                    // 删除列
-                    selector: '#' + delColBtnId,
-                    type: 'click',
-                    fn: function fn() {
-                        _this2._delCol();
-                        // 返回 true，表示该事件执行完之后，panel 要关闭。否则 panel 不会关闭
-                        return true;
-                    }
-                }, {
-                    // 删除表格
-                    selector: '#' + delTableBtnId,
-                    type: 'click',
-                    fn: function fn() {
-                        _this2._delTable();
-                        // 返回 true，表示该事件执行完之后，panel 要关闭。否则 panel 不会关闭
-                        return true;
-                    }
-                }]
-            }]
-        });
-        // 显示 panel
-        panel.show();
-    },
-
-    // 获取选中的单元格的位置信息
-    _getLocationData: function _getLocationData() {
-        // 初始化结果对象
-        var result = {};
-        // 获取编辑器实例
-        var editor = this.editor;
-        // 获取当前选中的元素容器
-        var $selectionELem = editor.selection.getSelectionContainerElem();
-        // 如果未选中任何元素，则返回空
-        if (!$selectionELem) {
-            return;
-        }
-        // 获取选中元素的节点名称
-        var nodeName = $selectionELem.getNodeName();
-        if (nodeName !== 'TD' && nodeName !== 'TH') {
-            // 如果节点名称不是 TD 或 TH，则直接返回
-            return;
-        }
-        
-        // 获取 td index
-        var $tr = $selectionELem.parent(); // 获取当前选中元素的父元素（即 tr）
-        var $tds = $tr.children(); // 获取 tr 的所有子元素（即所有 td 和 th）
-        var tdLength = $tds.length; // 获取子元素的数量
-        $tds.forEach(function (td, index) {
-            // 遍历所有子元素
-            if (td === $selectionELem[0]) {
-                // 如果当前子元素是选中的元素
-                // 记录并跳出循环
-                result.td = {
-                    index: index, // 记录选中元素的索引
-                    elem: td, // 记录选中元素本身
-                    length: tdLength // 记录子元素的数量
-                };
-                return false; // 跳出循环
-            }
-        });
-
-        // 获取 tr 的父元素，即 tbody
-        var $tbody = $tr.parent();
-        // 获取 tbody 中的所有子元素，即所有的 tr
-        var $trs = $tbody.children();
-        // 获取所有 tr 的数量
-        var trLength = $trs.length;
-        // 遍历所有的 tr
-        $trs.forEach(function (tr, index) {
-            // 如果当前遍历到的 tr 是目标 tr
-            if (tr === $tr[0]) {
-                // 记录目标 tr 的索引、元素和总数量，并跳出循环
-                result.tr = {
-                    index: index,
-                    elem: tr,
-                    length: trLength
-                };
-                return false;
-            }
-        });
-
-        // 返回结果
-        return result;
-    },
-
-    // 增加行
-    _addRow: function _addRow() {
-        // 获取当前单元格的位置信息
-        var locationData = this._getLocationData();
-        if (!locationData) {
-            // 如果 locationData 为空，则直接返回
-            return;
-        }
-        var trData = locationData.tr;
-        // 获取当前行的数据
-        var $currentTr = $(trData.elem);
-        // 将当前行元素转换为 jQuery 对象
-        var tdData = locationData.td;
-        // 获取单元格数据
-        var tdLength = tdData.length;
-        // 获取单元格的数量
-        
-        // 创建一个新的表格行元素
-        var newTr = document.createElement('tr');
-        var tpl = '',
-            i = void 0;
-        for (i = 0; i < tdLength; i++) {
-            // 循环生成与原单元格数量相同的空白单元格
-            tpl += '<td>&nbsp;</td>';
-        }
-        newTr.innerHTML = tpl;
-        // 设置新行的 HTML 内容为生成的空白单元格字符串
-        
-        // 将新行插入到当前行之后
-        $(newTr).insertAfter($currentTr);
-
-    // 增加列
-    _addCol: function _addCol() {
-        // 获取当前单元格的位置信息
-        var locationData = this._getLocationData();
-        if (!locationData) {
-            // 如果 locationData 为空，则直接返回
-            return;
-        }
-        var trData = locationData.tr; // 获取行数据
-        var tdData = locationData.td; // 获取单元格数据
-        var tdIndex = tdData.index; // 获取单元格索引
-        var $currentTr = $(trData.elem); // 获取当前行的 jQuery 对象
-        var $trParent = $currentTr.parent(); // 获取当前行的父元素
-        var $trs = $trParent.children(); // 获取所有子行
-        
-        // 遍历所有行
-        $trs.forEach(function (tr) {
-            var $tr = $(tr); // 将当前行转换为 jQuery 对象
-            var $tds = $tr.children(); // 获取当前行的所有单元格
-            var $currentTd = $tds.get(tdIndex); // 获取指定索引的单元格
-            var name = $currentTd.getNodeName().toLowerCase(); // 获取单元格的标签名并转换为小写
-        
-            // 创建一个新的单元格，并插入到当前单元格之后
-            var newTd = document.createElement(name); // 创建新的单元格元素
-            $(newTd).insertAfter($currentTd); // 将新单元格插入到当前单元格之后
-        });
-        },
-
-    // 删除行
-    _delRow: function _delRow() {
-        // 获取当前单元格的位置信息
-        var locationData = this._getLocationData();
-        if (!locationData) {
-            // 如果位置数据不存在，则直接返回
-            return;
-        }
-        var trData = locationData.tr;
-        // 获取当前行的数据
-        var $currentTr = $(trData.elem);
-        // 将当前行从DOM中移除
-        $currentTr.remove();
-        },
-        
-        // 删除列
-        _delCol: function _delCol() {
-            // 获取当前单元格的位置信息
-            var locationData = this._getLocationData();
-            if (!locationData) {
-                // 如果位置数据不存在，则直接返回
-                return;
-            }
-            var trData = locationData.tr;
-            // 获取当前单元格的列数据
-            var tdData = locationData.td;
-            // 获取当前单元格的索引
-            var tdIndex = tdData.index;
-            var $currentTr = $(trData.elem);
-            // 获取当前行的父元素（即表格）
-            var $trParent = $currentTr.parent();
-            // 获取所有行元素
-            var $trs = $trParent.children();
-
-        // 遍历所有行
-        $trs.forEach(function (tr) {
-            // 将当前遍历到的 tr 元素转换为 jQuery 对象
-            var $tr = $(tr);
-            // 获取当前 tr 元素的所有子元素（即所有 td 元素）
-            var $tds = $tr.children();
-            // 获取指定索引位置的 td 元素
-            var $currentTd = $tds.get(tdIndex);
-            // 删除当前索引位置的 td 元素
-            $currentTd.remove();
-        });
-
-    // 删除表格
-    _delTable: function _delTable() {
-  // 获取当前编辑器实例
-  var editor = this.editor;
-  
-  // 获取当前选中的容器元素
-  var $selectionELem = editor.selection.getSelectionContainerElem();
-  
-  // 如果未选中任何元素，则直接返回
-  if (!$selectionELem) {
-      return;
-  }
-  
-  // 查找选中元素的父级元素，直到找到表格元素为止
-  var $table = $selectionELem.parentUntil('table');
-        if (!$table) {
-            // 如果 $table 不存在，则直接返回
-            return;
-        }
-        $table.remove();
-        // 移除 $table 元素
-        },
-        
-       
-        tryChangeActive: function tryChangeActive(e) {
-            var editor = this.editor;
-            // 获取当前编辑器实例
-            var $elem = this.$elem;
-            // 获取当前元素的 jQuery 对象
-            var $selectionELem = editor.selection.getSelectionContainerElem();
-            // 获取当前选中的容器元素
-        if (!$selectionELem) {
-            // 如果 $selectionELem 不存在，则直接返回，不执行后续代码
-            return;
-        }
-        var nodeName = $selectionELem.getNodeName();
-        // 获取 $selectionELem 的节点名称
-        if (nodeName === 'TD' || nodeName === 'TH') {
-            // 如果节点名称是 'TD' 或 'TH'
-            this._active = true;
-            // 将对象的 _active 属性设置为 true
-            $elem.addClass('w-e-active');
-            // 为 $elem 添加 'w-e-active' 类
-        } else {
-            // 如果节点名称不是 'TD' 或 'TH'
-            this._active = false;
-            // 将对象的 _active 属性设置为 false
-            $elem.removeClass('w-e-active');
-            // 从 $elem 移除 'w-e-active' 类
-        }
-
-
-function Video(editor) {
-    // 将传入的编辑器实例赋值给当前对象的 editor 属性
-    this.editor = editor;
-    
-    // 创建一个包含播放图标的 div 元素，并赋值给当前对象的 $elem 属性
-    this.$elem = $('<div class="w-e-menu"><i class="w-e-icon-play"></i></div>');
-    
-    // 设置当前对象的类型为 'panel'
-    this.type = 'panel';
-
-    // 初始化当前对象是否处于 active 状态，默认为 false
-    this._active = false;
-}
-
-
-Video.prototype = {
-    constructor: Video,
-
-    onClick: function onClick() {
-        // 当点击事件触发时，调用创建面板的方法
-        this._createPanel();
-    },
-
-    _createPanel: function _createPanel() {
-        var _this = this;
-
-        // 生成随机的文本输入框和按钮的 ID
-        var textValId = getRandom('text-val');
-        var btnId = getRandom('btn');
-
-        // 创建一个新的面板对象
-        var panel = new Panel(this, {
-            width: 350,
-            // 一个面板包含多个标签页
-            tabs: [{
-                // 设置标签页的标题
-                title: '插入视频',
-                // 定义标签页的内容模板
-                tpl: '<div>\n                        <input id="' + textValId + '" type="text" class="block" placeholder="\u683C\u5F0F\u5982\uFF1A<iframe src=... ></iframe>"/>\n                        <div class="w-e-button-container">\n                            <button id="' + btnId + '" class="right">\u63D2\u5165</button>\n                        </div>\n                    </div>',
-                // 绑定事件处理函数
-                events: [{
-                    selector: '#' + btnId,
-                    type: 'click',
-                    fn: function fn() {
-                        // 获取文本输入框的值并去除首尾空格
-                        var $text = $('#' + textValId);
-                        var val = $text.val().trim();
-
-
-                        if (val) {
-                            // 插入视频
-                            _this._insert(val);
-                        }
-
-                        // 返回 true，表示该事件执行完之后，panel 要关闭。否则 panel 不会关闭
-                        return true;
-                    }
-                }]
-            } 
-            ] 
-        }); 
-
-        // 显示 panel
-        panel.show();
-
-        // 记录属性
-        this.panel = panel;
-    },
-
-    // 插入视频
-    _insert: function _insert(val) {
-        var editor = this.editor;
-        editor.cmd.do('insertHTML', val + '<p><br></p>');
-    }
-};
-
-
-function Image(editor) {
-    // 将编辑器实例赋值给当前对象
-    this.editor = editor;
-    // 生成一个随机的菜单ID
-    var imgMenuId = getRandom('w-e-img');
-    // 创建一个包含图标的div元素，并设置其ID为生成的菜单ID
-    this.$elem = $('<div class="w-e-menu" id="' + imgMenuId + '"><i class="w-e-icon-image"></i></div>');
-    // 将菜单ID存储在编辑器实例中
-    editor.imgMenuId = imgMenuId;
-    // 设置菜单类型为面板
-    this.type = 'panel';
-
-    // 当前是否 active 状态
-    this._active = false;
-}
-
-// 原型
-Image.prototype = {
-    constructor: Image,
-
-    
-    onClick: function onClick() {
-        // 获取编辑器实例
-        var editor = this.editor;
-        // 获取编辑器配置
-        var config = editor.config;
-        if (config.qiniu) {
-            // 如果配置中包含 qiniu，则直接返回，不执行后续代码
-            return;
-        }
-        if (this._active) {
-            // 如果当前对象处于激活状态，创建编辑面板
-            this._createEditPanel();
-        } else {
-            // 否则，创建插入面板
-            this._createInsertPanel();
-        }
-        },
-        
-       
-        _createEditPanel: function _createEditPanel() {
-            var editor = this.editor;
-        
-            // 生成随机的 id，用于按钮和标签的唯一标识
-            var width30 = getRandom('width-30');
-            var width50 = getRandom('width-50');
-            var width100 = getRandom('width-100');
-            var delBtn = getRandom('del-btn');
-        
-            // 配置选项卡
-            var tabsConfig = [{
-                title: '编辑图片',
-                tpl: '<div>\n' +
-                     '                    <div class="w-e-button-container" style="border-bottom:1px solid #f1f1f1;padding-bottom:5px;margin-bottom:5px;">\n' +
-                     '                        <span style="float:left;font-size:14px;margin:4px 5px 0 5px;color:#333;">最大宽度：</span>\n' +
-                     '                        <button id="' + width30 + '" class="left">30%</button>\n' +
-                     '                        <button id="' + width50 + '" class="left">50%</button>\n' +
-                     '                        <button id="' + width100 + '" class="left">100%</button>\n' +
-                     '                    </div>\n' +
-                     '                    <div class="w-e-button-container">\n' +
-                     '                        <button id="' + delBtn + '" class="gray left">删除图片</button>\n' +
-                     '                    </dv>\n' +
-                     '                </div>',
-                events: [{
-                    selector: '#' + width30,
-                    type: 'click',
-                    fn: function fn() {
-                        // 获取选中的图片元素
-                        var $img = editor._selectedImg;
-                    if ($img) {
-                        // 如果存在选中的图片，则将图片的最大宽度设置为30%
-                        $img.css('max-width', '30%');
-                    }
-                    // 返回 true，表示该事件执行完之后，panel 要关闭。否则 panel 不会关闭
-                    return true;
-                    }
-                    }, {
-                        selector: '#' + width50,
-                        type: 'click',
-                        fn: function fn() {
-                            // 获取当前编辑器中被选中的图片元素
-                            var $img = editor._selectedImg;
-                    if ($img) {
-                        // 如果存在选中的图片，则将图片的最大宽度设置为50%
-                        $img.css('max-width', '50%');
-                    }
-                    // 返回 true，表示该事件执行完之后，panel 要关闭。否则 panel 不会关闭
-                    return true;
-                    }
-                    }, {
-                        selector: '#' + width100,
-                        type: 'click',
-                        fn: function fn() {
-                            // 获取当前编辑器中被选中的图片元素
-                            var $img = editor._selectedImg;
-                    if ($img) {
-                        // 设置图片的最大宽度为100%
-                        $img.css('max-width', '100%');
-                    }
-                    // 返回 true，表示该事件执行完之后，panel 要关闭。否则 panel 不会关闭
-                    return true;
-                    }
-                    }, {
-                        selector: '#' + delBtn,
-                        type: 'click',
-                        fn: function fn() {
-                            var $img = editor._selectedImg;
-                            if ($img) {
-                                // 移除选中的图片元素
-                                $img.remove();
-                            }
-                            // 返回 true，表示该事件执行完之后，panel 要关闭。否则 panel 不会关闭
-                            return true;
-                        }
-                    }]
-                    }];
-
-        // 创建 panel 并显示
-        var panel = new Panel(this, {
-            width: 300,
-            tabs: tabsConfig
-        });
-        panel.show();
-
-        // 记录属性
-        this.panel = panel;
-    },
-
-    _createInsertPanel: function _createInsertPanel() {
-            // 获取编辑器实例
-            var editor = this.editor;
-            // 获取上传图片功能
-            var uploadImg = editor.uploadImg;
-            // 获取编辑器配置
-            var config = editor.config;
-    
-            // 生成随机ID，用于唯一标识不同的DOM元素
-            var upTriggerId = getRandom('up-trigger');
-            var upFileId = getRandom('up-file');
-            var linkUrlId = getRandom('link-url');
-            var linkBtnId = getRandom('link-btn');
-    
-            // 配置选项卡
-            var tabsConfig = [{
-                title: '上传图片',
-                // 设置选项卡模板，包含上传按钮和隐藏的文件输入框
-                tpl: '<div class="w-e-up-img-container">\n                    <div id="' + upTriggerId + '" class="w-e-up-btn">\n                        <i class="w-e-icon-upload2"></i>\n                    </div>\n                    <div style="display:none;">\n                        <input id="' + upFileId + '" type="file" multiple="multiple" accept="image/jpg,image/jpeg,image/png,image/gif,image/bmp"/>\n                    </div>\n                </div>',
-                events: [{
-                    // 绑定点击事件到上传按钮，触发选择图片文件
-                    selector: '#' + upTriggerId,
-                    type: 'click',
-                    fn: function fn() {
-                        // 获取文件输入框的jQuery对象
-                        var $file = $('#' + upFileId);
-                        // 获取文件输入框的DOM元素
-                        var fileElem = $file[0];
-                    if (fileElem) {
-                        // 如果 fileElem 存在，则触发点击事件
-                        fileElem.click();
-                    } else {
-                        // 如果 fileElem 不存在，返回 true 可关闭 panel
-                        return true;
-                    }
-                    }
-                    }, {
-                        // 选择图片完毕
-                        selector: '#' + upFileId,
-                        type: 'change',
-                        fn: function fn() {
-                            // 获取文件输入元素
-                            var $file = $('#' + upFileId);
-                            // 获取原生的 file 元素
-                            var fileElem = $file[0];
-                            if (!fileElem) {
-                                // 如果 fileElem 不存在，返回 true 可关闭 panel
-                                return true;
-                            }
-                    
-                            // 获取选中的 file 对象列表
-                            var fileList = fileElem.files;
-                    if (fileList.length) {
-                        // 如果文件列表不为空，则调用 uploadImg 方法上传图片
-                        uploadImg.uploadImg(fileList);
-                    }
-                    
-                    // 返回 true 可关闭 panel
-                    return true;
-                    }
-                    }]
-                    }, // first tab end
-                    {
-                        title: '网络图片',
-                        tpl: '<div>\n                    <input id="' + linkUrlId + '" type="text" class="block" placeholder="\u56FE\u7247\u94FE\u63A5"/></td>\n                    <div class="w-e-button-container">\n                        <button id="' + linkBtnId + '" class="right">\u63D2\u5165</button>\n                    </div>\n                </div>',
-                        events: [{
-                            selector: '#' + linkBtnId,
-                            type: 'click',
-                            fn: function fn() {
-                                // 获取输入框元素
-                                var $linkUrl = $('#' + linkUrlId);
-                                // 获取输入框中的 URL 并去除首尾空格
-                                var url = $linkUrl.val().trim();
-
-                    if (url) {
-                        // 如果 url 存在，则调用 insertLinkImg 方法插入链接图片
-                        uploadImg.insertLinkImg(url);
-                    }
-                    
-                    // 返回 true 表示函数执行结束之后关闭 panel
-                    return true;
-                    } // second tab end
-                    ]; // tabs end
-
-        // 判断 tabs 的显示
-        var tabsConfigResult = [];
-        if ((config.uploadImgShowBase64 || config.uploadImgServer || config.customUploadImg) && window.FileReader) {
-            // 如果配置允许上传图片（包括 Base64 编码、服务器上传或自定义上传）并且浏览器支持 FileReader，则显示“上传图片”选项卡
-            tabsConfigResult.push(tabsConfig[0]);
-        }
-        if (config.showLinkImg) {
-            // 如果配置允许显示网络图片链接，则显示“网络图片”选项卡
-            tabsConfigResult.push(tabsConfig[1]);
-        }
-        
-        // 创建一个新的 Panel 实例，并设置宽度和选项卡配置
-        var panel = new Panel(this, {
-            width: 300,
-            tabs: tabsConfigResult
-        });
-        // 显示面板
-        panel.show();
-        
-        // 将创建的面板实例保存到当前对象的 panel 属性中
-        this.panel = panel;
-        },
-
-    // 试图改变 active 状态
-    tryChangeActive: function tryChangeActive(e) {
-        // 获取当前编辑器实例
-        var editor = this.editor;
-        // 获取当前元素的jQuery对象
-        var $elem = this.$elem;
-        // 如果编辑器中选中了图片
-        if (editor._selectedImg) {
-            // 将当前对象的活动状态设为true
-            this._active = true;
-            // 给当前元素添加'w-e-active'类，表示激活状态
-            $elem.addClass('w-e-active');
-        } else {
-            // 将当前对象的活动状态设为false
-            this._active = false;
-            // 从当前元素移除'w-e-active'类，表示非激活状态
-            $elem.removeClass('w-e-active');
-        }
-    }
-
-
-var MenuConstructors = {}; // 创建一个空对象，用于存储菜单构造函数
-
-// 将 Bold 构造函数赋值给 MenuConstructors 对象的 bold 属性
-MenuConstructors.bold = Bold;
-
-// 将 Head 构造函数赋值给 MenuConstructors 对象的 head 属性
-MenuConstructors.head = Head;
-
-// 将 FontSize 构造函数赋值给 MenuConstructors 对象的 fontSize 属性
-MenuConstructors.fontSize = FontSize;
-
-// 将 FontName 构造函数赋值给 MenuConstructors 对象的 fontName 属性
-MenuConstructors.fontName = FontName;
-
-// 将 Link 构造函数赋值给 MenuConstructors 对象的 link 属性
-MenuConstructors.link = Link;
-
-// 将 Italic 构造函数赋值给 MenuConstructors 对象的 italic 属性
-MenuConstructors.italic = Italic;
-
-// 将 Redo 构造函数赋值给 MenuConstructors 对象的 redo 属性
-MenuConstructors.redo = Redo;
-
-// 将 StrikeThrough 构造函数赋值给 MenuConstructors 对象的 strikeThrough 属性
-MenuConstructors.strikeThrough = StrikeThrough;
-
-// 将 Underline 构造函数赋值给 MenuConstructors 对象的 underline 属性
-MenuConstructors.underline = Underline;
-
-// 将 Undo 构造函数赋值给 MenuConstructors 对象的 undo 属性
-MenuConstructors.undo = Undo;
-
-// 将 List 构造函数赋值给 MenuConstructors 对象的 list 属性
-MenuConstructors.list = List;
-
-// 将 Justify 构造函数赋值给 MenuConstructors 对象的 justify 属性
-MenuConstructors.justify = Justify;
-// 将 ForeColor 构造函数赋值给 MenuConstructors 的 foreColor 属性
-MenuConstructors.foreColor = ForeColor;
-
-// 将 BackColor 构造函数赋值给 MenuConstructors 的 backColor 属性
-MenuConstructors.backColor = BackColor;
-
-// 将 Quote 构造函数赋值给 MenuConstructors 的 quote 属性
-MenuConstructors.quote = Quote;
-
-// 将 Code 构造函数赋值给 MenuConstructors 的 code 属性
-MenuConstructors.code = Code;
-
-// 将 Emoticon 构造函数赋值给 MenuConstructors 的 emoticon 属性
-MenuConstructors.emoticon = Emoticon;
-
-// 将 Table 构造函数赋值给 MenuConstructors 的 table 属性
-MenuConstructors.table = Table;
-
-// 将 Video 构造函数赋值给 MenuConstructors 的 video 属性
-MenuConstructors.video = Video;
-
-// 将 Image 构造函数赋值给 MenuConstructors 的 image 属性
-MenuConstructors.image = Image;
-
-
-function Menus(editor) {
-    // 初始化菜单类，传入编辑器实例
-    this.editor = editor;
-    // 存储菜单的容器对象
-    this.menus = {};
-}
-
-// 修改原型
-Menus.prototype = {
-    constructor: Menus,
-
-    // 初始化菜单
-    init: function init() {
-        var _this = this; // 保存当前上下文的引用
-
-        var editor = this.editor; // 获取编辑器实例
-        var config = editor.config || {}; // 获取编辑器配置，如果没有则使用空对象
-        var configMenus = config.menus || []; // 获取配置中的菜单，如果没有则使用空数组
-
-        // 根据配置信息，创建菜单
-        configMenus.forEach(function (menuKey) {
-            var MenuConstructor = MenuConstructors[menuKey]; // 获取对应菜单构造函数
-            if (MenuConstructor && typeof MenuConstructor === 'function') {
-                // 创建单个菜单
-                _this.menus[menuKey] = new MenuConstructor(editor);
-            }
-            });
-            
-            // 添加到菜单栏
-            this._addToToolbar();
-            
-            // 绑定事件
-            this._bindEvent();
-            },
-            
-            
-            _addToToolbar: function _addToToolbar() {
-                var editor = this.editor; // 获取编辑器实例
-                var $toolbarElem = editor.$toolbarElem; // 获取工具栏元素
-                var menus = this.menus; // 获取所有菜单
-                var config = editor.config; // 获取编辑器配置
-                // config.zIndex 是配置的编辑区域的 z-index，菜单的 z-index 得在其基础上 +1
-                var zIndex = config.zIndex + 1; // 计算菜单的 z-index
-                objForEach(menus, function (key, menu) {
-                    var $elem = menu.$elem; // 获取菜单元素
-            if ($elem) {
-                // 设置 z-index 属性，使元素在 z 轴上的位置发生变化
-                $elem.css('z-index', zIndex);
-                // 将元素添加到工具栏元素中
-                $toolbarElem.append($elem);
-            }
-
-    // 绑定菜单 click mouseenter 事件
-    _bindEvent: function _bindEvent() {
-        // 获取菜单对象
-        var menus = this.menus;
-        // 获取编辑器对象
-        var editor = this.editor;
-        // 遍历菜单对象
-        objForEach(menus, function (key, menu) {
-            // 获取菜单类型
-            var type = menu.type;
-            // 如果菜单类型不存在，则跳过该菜单
-            if (!type) {
-                // 如果 type 为空，则直接返回
-                return;
-            }
-            
-            // 获取菜单元素
-            var $elem = menu.$elem;
-            // 获取下拉列表
-            var droplist = menu.droplist;
-            // 获取面板
-            var panel = menu.panel;
-            
-            // 点击类型，例如 bold
-            if (type === 'click' && menu.onClick) {
-                // 为菜单元素绑定点击事件
-                $elem.on('click', function (e) {
-                    // 如果编辑器中没有选中的文本范围，则直接返回
-                    if (editor.selection.getRange() == null) {
-                        return;
-                    }
-                    // 调用菜单的 onClick 方法并传递事件对象
-                    menu.onClick(e);
-                });
-            }
-
-            // 下拉框，例如 head
-            if (type === 'droplist' && droplist) {
-                // 为元素绑定鼠标进入事件
-                $elem.on('mouseenter', function (e) {
-                    // 如果编辑器中没有选中的范围，则直接返回
-                    if (editor.selection.getRange() == null) {
-                        return;
-                    }
-                    // 显示下拉列表，设置延迟200毫秒后执行
-                    droplist.showTimeoutId = setTimeout(function () {
-                        droplist.show();
-                    }, 200);
-                }).on('mouseleave', function (e) {
-                    // 隐藏下拉列表，立即执行
-                    droplist.hideTimeoutId = setTimeout(function () {
-                        droplist.hide();
-                    }, 0);
-                });
-            }
-
-            // 弹框类型，例如 link
-            if (type === 'panel' && menu.onClick) {
-                // 为元素添加点击事件监听器
-                $elem.on('click', function (e) {
-                    // 阻止事件冒泡
-                    e.stopPropagation();
-                    // 如果编辑器中没有选中的范围，则直接返回
-                    if (editor.selection.getRange() == null) {
-                        return;
-                    }
-                    // 在自定义事件中显示 panel
-                    menu.onClick(e);
-                });
-            }
-
-    // 尝试修改菜单状态
-    changeActive: function changeActive() {
-        // 获取当前对象的menus属性
-        var menus = this.menus;
-        
-        // 遍历menus对象的每一个键值对
-        objForEach(menus, function (key, menu) {
-            // 如果menu对象有tryChangeActive方法
-            if (menu.tryChangeActive) {
-                // 设置一个定时器，在100毫秒后调用menu的tryChangeActive方法
-                setTimeout(function () {
-                    menu.tryChangeActive();
-                }, 100);
-            }
-        });
-    }
-
-
-/**
- * 获取粘贴的文本内容
- * @param {Event} e - 事件对象，包含剪贴板数据
- * @returns {string} - 处理后的粘贴文本内容
- */
-function getPasteText(e) {
-    // 获取剪贴板数据，如果事件对象中没有则尝试从原始事件中获取
-    var clipboardData = e.clipboardData || e.originalEvent && e.originalEvent.clipboardData;
-    var pasteText = void 0;
-    
-    // 如果剪贴板数据为空，则尝试从window.clipboardData中获取
-    if (clipboardData == null) {
-        pasteText = window.clipboardData && window.clipboardData.getData('text');
-    } else {
-        // 否则从剪贴板数据中获取纯文本格式的数据
-        pasteText = clipboardData.getData('text/plain');
-    }
-
-    // 返回替换HTML符号后的文本内容
-    return replaceHtmlSymbol(pasteText);
-}
-
-
-
-function getPasteHtml(e, filterStyle, ignoreImg) {
-    // 获取剪贴板数据，如果事件对象中没有则尝试从原始事件中获取
-    var clipboardData = e.clipboardData || e.originalEvent && e.originalEvent.clipboardData;
-    // 定义变量用于存储粘贴的文本和HTML内容
-    var pasteText = void 0,
-        pasteHtml = void 0;
-    // 如果剪贴板数据为空，则尝试从window.clipboardData中获取文本数据
-    if (clipboardData == null) {
-            // 如果 clipboardData 为空，则尝试从 window.clipboardData 获取纯文本数据
-            pasteText = window.clipboardData && window.clipboardData.getData('text');
-        } else {
-            // 否则从剪贴板数据中获取纯文本和HTML内容
-            pasteText = clipboardData.getData('text/plain');
-            pasteHtml = clipboardData.getData('text/html');
-        }
-        if (!pasteHtml && pasteText) {
-            // 如果只有纯文本没有HTML，则将纯文本转换为简单的HTML段落
-            pasteHtml = '<p>' + replaceHtmlSymbol(pasteText) + '</p>';
-        }
-        if (!pasteHtml) {
-            // 如果没有获取到任何HTML内容，则直接返回
-            return;
-        }
-    
-        // 过滤word中状态过来的无用字符
-        var docSplitHtml = pasteHtml.split('</html>');
-    if (docSplitHtml.length === 2) {
-        // 如果 docSplitHtml 数组的长度为 2，则将 pasteHtml 设置为数组的第一个元素
-        pasteHtml = docSplitHtml[0];
-    }
-    
-    // 过滤无用标签，移除 <meta>、<script> 和 <link> 标签
-    pasteHtml = pasteHtml.replace(/<(meta|script|link).+?>/igm, '');
-    // 去掉 HTML 注释
-    pasteHtml = pasteHtml.replace(/<!--.*?-->/mg, '');
-    // 过滤 data-xxx 属性，移除所有以 data- 开头的属性
-    pasteHtml = pasteHtml.replace(/\s?data-.+?=('|").+?('|")/igm, '');
-    if (ignoreImg) {
-            // 忽略图片，将HTML中的<img>标签替换为空字符串
-            pasteHtml = pasteHtml.replace(/<img.+?>/igm, '');
-        }
-    
-        if (filterStyle) {
-            // 过滤样式，将HTML中的class和style属性移除
-            pasteHtml = pasteHtml.replace(/\s?(class|style)=('|").*?('|")/igm, '');
-        } else {
-            // 保留样式，仅移除HTML中的class属性
-            pasteHtml = pasteHtml.replace(/\s?class=('|").*?('|")/igm, '');
-        }
-    
-        // 返回处理后的HTML字符串
-        return pasteHtml;
-    }
-
-
-function getPasteImgs(e) {
-    // 初始化结果数组，用于存储粘贴的图片文件
-    var result = [];
-    // 获取粘贴的文本内容
-    var txt = getPasteText(e);
-    if (txt) {
-        // 如果存在文本内容，则忽略图片并返回空结果数组
-        return result;
-    }
-
-    // 获取剪贴板数据对象，兼容不同浏览器的事件对象
-    var clipboardData = e.clipboardData || e.originalEvent && e.originalEvent.clipboardData || {};
-    // 获取剪贴板中的项目列表
-    var items = clipboardData.items;
-    if (!items) {
-        // 如果没有项目列表，则返回空结果数组
-        return result;
-    }
-
-    // 遍历剪贴板中的每个项目
-    objForEach(items, function (key, value) {
-        // 获取项目的MIME类型
-        var type = value.type;
-        // 如果项目是图片类型
-        if (/image/i.test(type)) {
-            // 将图片文件添加到结果数组中
-            result.push(value.getAsFile());
-        }
-    });
-
-    // 返回包含所有粘贴图片文件的结果数组
-    return result;
-}
-}
-
-
-function getChildrenJSON($elem) {
-    // 初始化结果数组
-    var result = [];
-    // 获取子节点，如果不存在则返回空数组
-    var $children = $elem.childNodes() || []; // 注意 childNodes() 可以获取文本节点
-    // 遍历每一个子节点
-    $children.forEach(function (curElem) {
-        // 初始化当前元素的结果变量
-        var elemResult = void 0;
-        // 获取当前节点的类型
-        var nodeType = curElem.nodeType;
-
-        // 如果当前节点是文本节点（nodeType === 3）
-        if (nodeType === 3) {
-            // 获取文本内容
-            elemResult = curElem.textContent;
-            // 替换 HTML 符号
-            elemResult = replaceHtmlSymbol(elemResult);
-        }
-
-        // 普通 DOM 节点
-        if (nodeType === 1) {
-            // 如果节点类型为元素节点（nodeType === 1）
-            elemResult = {};
-        
-            // 获取元素的标签名，并转换为小写字母
-            elemResult.tag = curElem.nodeName.toLowerCase();
-            
-            // 初始化属性数据数组
-            var attrData = [];
-            // 获取当前元素的属性列表，如果没有则设置为空对象
-            var attrList = curElem.attributes || {};
-            // 获取属性列表的长度，如果没有则为0
-            var attrListLength = attrList.length || 0;
-            
-            // 遍历属性列表
-            for (var i = 0; i < attrListLength; i++) {
-                var attr = attrList[i];
-                // 将每个属性的名称和值存入attrData数组中
-                attrData.push({
-                    name: attr.name,
-                    value: attr.value
-                });
-            }
-            // 将属性数据数组赋值给elemResult的attrs属性
-            elemResult.attrs = attrData;
-            
-            // 递归获取子元素的数据，并赋值给elemResult的children属性
-            elemResult.children = getChildrenJSON($(curElem));
-        }
-        
-        // 将当前元素的结果对象推入结果数组中
-        result.push(elemResult);
-        return result;
-
-
-function Text(editor) {
-    this.editor = editor;
-}
-
-// 修改原型
-Text.prototype = {
-    constructor: Text,
-
-    // 初始化
-    init: function init() {
-        // 绑定事件
-        this._bindEvent();
-    },
-
-    // 清空内容
-    clear: function clear() {
-        this.html('<p><br></p>');
-    },
-
-    // 获取 设置 html
-    html: function html(val) {
-        // 获取编辑器实例
-        var editor = this.editor;
-        // 获取编辑器的文本元素
-        var $textElem = editor.$textElem;
-        var html = void 0;
-        
-        // 如果传入的值为空，则获取当前文本元素的HTML内容
-        if (val == null) {
-            // 获取文本元素的HTML内容
-            html = $textElem.html();
-            // 替换掉所有的零宽度空格字符（&#8203）
-            html = html.replace(/\u200b/gm, '');
-            // 返回处理后的HTML内容
-            return html;
-        } else {
-            // 如果传入的值不为空，则设置文本元素的HTML内容为传入的值
-            $textElem.html(val);
-    
-            // 初始化选取，将光标定位到内容尾部
-            editor.initSelection();
-        }
-    },
-    
-    getJSON: function getJSON() {
-        // 获取当前编辑器实例
-        var editor = this.editor;
-        // 获取编辑器的文本元素
-        var $textElem = editor.$textElem;
-        // 调用getChildrenJSON函数，将文本元素转换为JSON并返回
-        return getChildrenJSON($textElem);
-    },
-
-    // 获取 设置 text
-    text: function text(val) {
-        // 获取编辑器实例
-        var editor = this.editor;
-        // 获取编辑器中的文本元素
-        var $textElem = editor.$textElem;
-        var text = void 0;
-        
-        // 如果传入的值为空，则获取当前文本内容
-        if (val == null) {
-            // 获取文本元素的文本内容
-            text = $textElem.text();
-            // 替换掉文本中的零宽度空格字符（&#8203）
-            text = text.replace(/\u200b/gm, '');
-            return text;
-        } else {
-            // 设置文本元素的HTML内容为传入的值，并包裹在<p>标签中
-            $textElem.text('<p>' + val + '</p>');
-    
-            // 初始化选取，将光标定位到内容尾部
-            editor.initSelection();
-        }
-    },
-
-    // 追加内容
-    append: function append(html) {
-        var editor = this.editor;
-        var $textElem = editor.$textElem;
-        $textElem.append($(html));
-
-        // 初始化选取，将光标定位到内容尾部
-        editor.initSelection();
-    },
-
-    // 绑定事件
-    _bindEvent: function _bindEvent() {
-        // 实时保存选取
-        this._saveRangeRealTime();
-
-        // 按回车建时的特殊处理
-        this._enterKeyHandle();
-
-        // 清空时保留 <p><br></p>
-        this._clearHandle();
-
-        // 粘贴事件（粘贴文字，粘贴图片）
-        this._pasteHandle();
-
-        // tab 特殊处理
-        this._tabHandle();
-
-        // img 点击
-        this._imgHandle();
-
-        // 拖拽事件
-        this._dragHandle();
-    },
-
-    // 实时保存选取
-    _saveRangeRealTime: function _saveRangeRealTime() {
-        var editor = this.editor;
-        var $textElem = editor.$textElem;
-
-        // 保存当前的选区
-        function saveRange(e) {
-            // 随时保存选区
-            editor.selection.saveRange();
-            // 更新按钮 active 状态
-            editor.menus.changeActive();
-        }
-        
-        // 按键后保存
-        $textElem.on('keyup', saveRange);
-        
-        $textElem.on('mousedown', function (e) {
-            // mousedown 状态下，鼠标滑动到编辑区域外面，也需要保存选区
-            $textElem.on('mouseleave', saveRange);
-        });
-        
-        $textElem.on('mouseup', function (e) {
-            saveRange();
-            // 在编辑器区域之内完成点击，取消鼠标滑动到编辑区外面的事件
-            $textElem.off('mouseleave', saveRange);
-        });
-        },
-
-    // 按回车键时的特殊处理
-    _enterKeyHandle: function _enterKeyHandle() {
-            // 获取编辑器实例
-            var editor = this.editor;
-            // 获取编辑器中的文本元素
-            var $textElem = editor.$textElem;
-            
-            function insertEmptyP($selectionElem) {
-                // 创建一个新的<p>标签，其中包含一个<br>标签
-                var $p = $('<p><br></p>');
-                // 将新的<p>标签插入到当前选中元素的前面
-                $p.insertBefore($selectionElem);
-                // 创建一个范围，选中新插入的<p>标签
-                editor.selection.createRangeByElem($p, true);
-                // 恢复选区
-                editor.selection.restoreSelection();
-                // 移除当前选中的元素
-                $selectionElem.remove();
-            }
-
-        // 将回车之后生成的非 <p> 的顶级标签，改为 <p>
-        function pHandle(e) {
-            // 获取当前选中的容器元素
-            var $selectionElem = editor.selection.getSelectionContainerElem();
-            // 获取选中元素的父元素
-            var $parentElem = $selectionElem.parent();
-        
-            // 检查父元素的HTML内容是否为 '<code><br></code>'
-            if ($parentElem.html() === '<code><br></code>') {
-                // 如果光标之前在一个 <p><code>.....</code></p> 标签内，回车后会生成一个空的 <p><code><br></code></p>
-                // 并且继续回车无法跳出这个状态，因此需要特殊处理
-                insertEmptyP($selectionElem);
-                return;
-            }
-        }
-            if (!$parentElem.equal($textElem)) {
-                // 检查父元素是否等于文本元素，如果不是顶级标签则返回
-                return;
-            }
-            
-            var nodeName = $selectionElem.getNodeName();
-            if (nodeName === 'P') {
-                // 如果当前选中的元素是 <p> 标签，则无需处理，直接返回
-                return;
-            }
-            
-            if ($selectionElem.text()) {
-                // 如果当前选中的元素有内容，则无需处理，直接返回
-                return;
-            }
-            
-            // 插入一个空的 <p> 标签，并将光标定位到新插入的 <p> 标签，同时删除当前选中的标签
-            insertEmptyP($selectionElem);
-        $textElem.on('keyup', function (e) {
-            // 检查按键是否为回车键（keyCode 13）
-            if (e.keyCode !== 13) {
-                // 如果不是回车键，则直接返回，不执行后续操作
-                return;
-            }
-            // 调用 pHandle 函数处理回车事件
-            pHandle(e);
-        });
-        // <pre><code></code></pre> 回车时 特殊处理
-        function codeHandle(e) {
-            // 获取当前选中的容器元素
-            var $selectionElem = editor.selection.getSelectionContainerElem();
-            
-            // 如果未选中任何元素，则直接返回
-            if (!$selectionElem) {
-                return;
-            }
-            
-            // 获取选中元素的父元素
-            var $parentElem = $selectionElem.parent();
-            
-            // 获取选中元素和父元素的节点名称
-            var selectionNodeName = $selectionElem.getNodeName();
-            var parentNodeName = $parentElem.getNodeName();
-        
-            // 如果选中的元素不是<code>标签或其父元素不是<pre>标签，则忽略处理
-            if (selectionNodeName !== 'CODE' || parentNodeName !== 'PRE') {
-                // 不符合要求 忽略
-                return;
-            }
-        
-            // 检查编辑器是否支持原生的insertHTML命令
-            if (!editor.cmd.queryCommandSupported('insertHTML')) {
-                // 必须原生支持 insertHTML 命令
-                return;
-            }
-
-            // 处理：光标定位到代码末尾，联系点击两次回车，即跳出代码块
-            if (editor._willBreakCode === true) {
-                // 此时可以跳出代码块
-                // 插入 <p> ，并将选取定位到 <p>
-                var $p = $('<p><br></p>');
-                $p.insertAfter($parentElem);
-                editor.selection.createRangeByElem($p, true);
-                editor.selection.restoreSelection();
-
-                // 修改状态
-                editor._willBreakCode = false;
-
-                e.preventDefault();
-                return;
-            }
-
-            var _startOffset = editor.selection.getRange().startOffset;
-
-            // 处理：回车时，不能插入 <br> 而是插入 \n ，因为是在 pre 标签里面
-            editor.cmd.do('insertHTML', '\n');
-            editor.selection.saveRange();
-            if (editor.selection.getRange().startOffset === _startOffset) {
-                // 没起作用，再来一遍
-                editor.cmd.do('insertHTML', '\n');
-            }
-
-            var codeLength = $selectionElem.html().length;
-            if (editor.selection.getRange().startOffset + 1 === codeLength) {
-                // 说明光标在代码最后的位置，执行了回车操作
-                // 记录下来，以便下次回车时候跳出 code
-                editor._willBreakCode = true;
-            }
-
-            // 阻止默认行为
-            e.preventDefault();
-        }
-
-        $textElem.on('keydown', function (e) {
-            if (e.keyCode !== 13) {
-                // 不是回车键
-                // 取消即将跳转代码块的记录
-                editor._willBreakCode = false;
-                return;
-            }
-            // <pre><code></code></pre> 回车时 特殊处理
-            codeHandle(e);
-        });
-    },
-
-    // 清空时保留 <p><br></p>
-    _clearHandle: function _clearHandle() {
-            // 获取编辑器实例
-            var editor = this.editor;
-            // 获取编辑器的文本元素
-            var $textElem = editor.$textElem;
-    
-            // 为文本元素绑定键盘按下事件
-            $textElem.on('keydown', function (e) {
-                // 如果按下的键不是退格键，则直接返回
-                if (e.keyCode !== 8) {
-                    return;
-                }
-                // 获取文本元素的HTML内容并转换为小写和去除首尾空格
-                var txtHtml = $textElem.html().toLowerCase().trim();
-                // 如果文本内容只剩下一个空行，则阻止默认行为，不再删除
-                if (txtHtml === '<p><br></p>') {
-                    // 最后剩下一个空行，就不再删除了
-                    e.preventDefault();
-                    return;
-                }
-            });
-
-        $textElem.on('keyup', function (e) {
-            // 当按键抬起时触发事件处理函数
-            if (e.keyCode !== 8) {
-                // 如果按下的键不是退格键，则直接返回
-                return;
-            }
-            var $p = void 0; // 定义一个未初始化的变量 $p
-            var txtHtml = $textElem.html().toLowerCase().trim(); // 获取文本元素的 HTML 内容并转换为小写和去除首尾空格
-        
-            // 在 Firefox 浏览器中用 '<br>' 判断，其他浏览器用空字符串判断
-            if (!txtHtml || txtHtml === '<br>') {
-                // 如果文本内容为空或等于 '<br>'
-                $p = $('<p><br/></p>'); // 创建一个新的 <p> 元素，包含一个 <br/>
-                $textElem.html(''); // 清空文本元素的内容，否则在 Firefox 下会有问题
-                $textElem.append($p); // 将新的 <p> 元素添加到文本元素中
-                editor.selection.createRangeByElem($p, false, true); // 创建一个范围选择器，选中新添加的 <p> 元素
-                editor.selection.restoreSelection(); // 恢复选区
-            }
-        });
-
-    // 粘贴事件（粘贴文字 粘贴图片）
-    _pasteHandle: function _pasteHandle() {
-            // 获取编辑器实例
-            var editor = this.editor;
-            // 获取编辑器配置
-            var config = editor.config;
-            // 获取粘贴过滤样式的配置
-            var pasteFilterStyle = config.pasteFilterStyle;
-            // 获取粘贴文本处理函数的配置
-            var pasteTextHandle = config.pasteTextHandle;
-            // 获取是否忽略图片的配置
-            var ignoreImg = config.pasteIgnoreImg;
-            // 获取编辑器的文本元素
-            var $textElem = editor.$textElem;
-
-        // 粘贴图片、文本的事件，每次只能执行一个
-        // 判断该次粘贴事件是否可以执行
-        var pasteTime = 0; // 初始化粘贴时间变量为0
-        
-       
-        function canDo() {
-            var now = Date.now(); // 获取当前时间的时间戳（毫秒）
-            var flag = false; // 初始化标志位为false
-            if (now - pasteTime >= 100) {
-                // 如果当前时间与上次粘贴时间的间隔大于等于100毫秒，可以执行操作
-                flag = true; // 设置标志位为true
-            }
-            pasteTime = now; // 更新粘贴时间为当前时间
-            return flag; // 返回标志位
-        }
-        
-        
-        function resetTime() {
-            pasteTime = 0; // 将粘贴时间重置为0
-        }
-        
-        // 粘贴文字
-        $textElem.on('paste', function (e) {
-            if (UA.isIE()) {
-                return; // 如果是IE浏览器，直接返回，不执行后续代码
-            } else {
-                // 阻止默认行为，使用 execCommand 的粘贴命令
-                e.preventDefault();
-            }
-        
-            // 粘贴图片和文本，只能同时使用一个
-            if (!canDo()) {
-                // 如果当前不能执行操作，则直接返回
-                return;
-            }
-            
-            // 获取粘贴的文字
-            var pasteHtml = getPasteHtml(e, pasteFilterStyle, ignoreImg);
-            var pasteText = getPasteText(e);
-            // 将换行符替换为HTML的<br>标签
-            pasteText = pasteText.replace(/\n/gm, '<br>');
-            
-            // 获取当前选中的元素
-            var $selectionElem = editor.selection.getSelectionContainerElem();
-            if (!$selectionElem) {
-                // 如果没有选中的元素，则直接返回
-                return;
-            }
-            var nodeName = $selectionElem.getNodeName();
-            
-            // code 中只能粘贴纯文本
-            if (nodeName === 'CODE' || nodeName === 'PRE') {
-                if (pasteTextHandle && isFunction(pasteTextHandle)) {
-                    // 用户自定义过滤处理粘贴内容
-                    pasteText = '' + (pasteTextHandle(pasteText) || '');
-                }
-                // 插入处理后的纯文本到编辑器中
-                editor.cmd.do('insertHTML', '<p>' + pasteText + '</p>');
-                return;
-            }
-
-           
-
-            if (!pasteHtml) {
-                // 如果没有粘贴的 HTML 内容，重置时间并返回
-                resetTime();
-                return;
-            }
-            try {
-                // 在 Firefox 中，获取的 pasteHtml 可能是没有 <ul> 包裹的 <li>
-                // 因此执行 insertHTML 会报错
-                if (pasteTextHandle && isFunction(pasteTextHandle)) {
-                    // 如果用户定义了粘贴文本处理函数，则使用该函数过滤粘贴内容
-                    pasteHtml = '' + (pasteTextHandle(pasteHtml) || '');
-                }
-                // 插入过滤后的 HTML 内容到编辑器中
-                editor.cmd.do('insertHTML', pasteHtml);
-            } catch (ex) {
-                // 如果发生错误，使用 pasteText 来兼容一下
-                if (pasteTextHandle && isFunction(pasteTextHandle)) {
-                    // 如果用户定义了粘贴文本处理函数，则使用该函数过滤粘贴内容
-                    pasteText = '' + (pasteTextHandle(pasteText) || '');
-                }
-                // 将过滤后的文本插入到编辑器中，用 <p> 标签包裹
-                editor.cmd.do('insertHTML', '<p>' + pasteText + '</p>');
-            }
-
-        // 粘贴图片
-        $textElem.on('paste', function (e) {
-            // 检查是否为IE浏览器，如果是则直接返回
-            if (UA.isIE()) {
-                return;
-            } else {
-                // 阻止默认的粘贴行为
-                e.preventDefault();
-            }
-        
-            // 检查是否可以执行粘贴操作，如果不允许则直接返回
-            if (!canDo()) {
-                return;
-            }
-        
-            // 获取粘贴的图片文件
-            var pasteFiles = getPasteImgs(e);
-            // 如果未获取到图片文件或文件列表为空，则直接返回
-            if (!pasteFiles || !pasteFiles.length) {
-                return;
-            }
-
-            // 获取当前的元素
-            var $selectionElem = editor.selection.getSelectionContainerElem();  // 获取当前选中的容器元素
-            if (!$selectionElem) {  // 如果未选中任何元素，则直接返回
-                return;
-            }
-            var nodeName = $selectionElem.getNodeName();  // 获取选中元素的节点名称
-            
-            // 如果选中的元素是代码块或预格式化文本，则忽略粘贴操作
-            if (nodeName === 'CODE' || nodeName === 'PRE') {
-                return;
-            }
-            
-            // 上传图片功能
-            var uploadImg = editor.uploadImg;  // 获取编辑器的图片上传功能
-            uploadImg.uploadImg(pasteFiles);  // 调用上传图片方法，并传入粘贴的文件
-            });
-            },
-
-    // tab 特殊处理
-    _tabHandle: function _tabHandle() {
-            // 获取编辑器实例
-            var editor = this.editor;
-            // 获取编辑器的文本元素
-            var $textElem = editor.$textElem;
-    
-            // 为文本元素绑定键盘按下事件
-            $textElem.on('keydown', function (e) {
-                // 如果按下的键不是Tab键，则直接返回
-                if (e.keyCode !== 9) {
-                    return;
-                }
-                // 如果编辑器不支持插入HTML命令，则直接返回
-                if (!editor.cmd.queryCommandSupported('insertHTML')) {
-                    // 必须原生支持 insertHTML 命令
-                    return;
-                }
-                // 获取当前选中的元素容器
-                var $selectionElem = editor.selection.getSelectionContainerElem();
-            if (!$selectionElem) {
-                // 如果未选择元素，则直接返回
-                return;
-            }
-            var $parentElem = $selectionElem.parent();
-            // 获取选中元素的父元素
-            var selectionNodeName = $selectionElem.getNodeName();
-            // 获取选中元素的节点名称
-            var parentNodeName = $parentElem.getNodeName();
-            // 获取父元素的节点名称
-            
-            if (selectionNodeName === 'CODE' && parentNodeName === 'PRE') {
-                // 如果选中的元素是<code>且其父元素是<pre>
-                // <pre><code> 里面
-                editor.cmd.do('insertHTML', '    ');
-                // 插入四个空格的HTML代码
-            } else {
-                // 普通文字
-                editor.cmd.do('insertHTML', '&nbsp;&nbsp;&nbsp;&nbsp;');
-                // 插入四个不间断空格的HTML代码
-            }
-            
-            e.preventDefault();
-            // 阻止默认事件行为
-            });
-            },
-
-    // img 点击
-    _imgHandle: function _imgHandle() {
-        // 获取编辑器实例
-        var editor = this.editor;
-        // 获取编辑器的文本元素
-        var $textElem = editor.$textElem;
-    
-        // 为图片增加 selected 样式
-        $textElem.on('click', 'img', function (e) {
-            // 获取当前点击的图片元素
-            var img = this;
-            // 将图片元素转换为 jQuery 对象
-            var $img = $(img);
-    
-            if ($img.attr('data-w-e') === '1') {
-                // 是表情图片，忽略
-                return;
-            }
-    
-            // 记录当前点击过的图片
-            editor._selectedImg = $img;
-    
-            // 修改选区并 restore ，防止用户此时点击退格键，会删除其他内容
-            editor.selection.createRangeByElem($img);
-            editor.selection.restoreSelection();
-        });
-
-        // 去掉图片的 selected 样式
-        $textElem.on('click keyup', function (e) {
-            // 检查点击或键盘事件的目标是否是图片元素
-            if (e.target.matches('img')) {
-                // 如果是图片，忽略该事件
-                return;
-            }
-            // 清空编辑器中选中的图片记录
-            editor._selectedImg = null;
-        });
-        },
-        
-        // 拖拽事件处理函数
-        _dragHandle: function _dragHandle() {
-            var editor = this.editor;
-        
-            // 获取 document 对象
-            var $document = $(document);
-            // 禁用 document 上的拖拽相关事件
-            $document.on('dragleave drop dragenter dragover', function (e) {
-                // 阻止默认行为，防止浏览器处理拖拽事件
-                e.preventDefault();
-            });
-
-        // 添加编辑区域拖拽事件
-        var $textElem = editor.$textElem; // 获取编辑器的文本元素
-        $textElem.on('drop', function (e) { // 为文本元素绑定'drop'事件处理函数
-            e.preventDefault(); // 阻止默认的拖放行为
-            var files = e.dataTransfer && e.dataTransfer.files; // 获取拖放的文件对象
-            if (!files || !files.length) { // 如果文件对象不存在或文件长度为0，则返回
-                return;
-            }
-        
-            // 上传图片
-            var uploadImg = editor.uploadImg; // 获取编辑器的图片上传功能
-            uploadImg.uploadImg(files); // 调用上传图片的方法，传入文件对象
-        });
-
-
-function Command(editor) {
-    // 初始化Command对象，并设置编辑器实例
-    this.editor = editor;
-}
-
-// 修改原型
-Command.prototype = {
-    constructor: Command,
-
-    // 执行命令
-    do: function _do(name, value) {
-        // 获取当前编辑器实例
-        var editor = this.editor;
-
-        // 使用 styleWithCSS
-        if (!editor._useStyleWithCSS) {
-            // 如果编辑器未使用 CSS 样式，则启用它
-            document.execCommand('styleWithCSS', null, true);
-            // 标记编辑器已使用 CSS 样式
-            editor._useStyleWithCSS = true;
-        }
-        
-        // 如果无选区，忽略
-        if (!editor.selection.getRange()) {
-            return;
-        }
-        
-        // 恢复选取
-        editor.selection.restoreSelection();
-        
-        // 执行命令或自定义事件
-        var _name = '_' + name;
-        if (this[_name]) {
-            // 如果有自定义事件，调用自定义事件处理函数
-            this[_name](value);
-        } else {
-            // 否则，执行默认的 command
-            this._execCommand(name, value);
-        }
-
-        // 修改菜单状态
-        editor.menus.changeActive();
-
-        // 最后，恢复选取保证光标在原来的位置闪烁
-        editor.selection.saveRange();
-        editor.selection.restoreSelection();
-
-        // 触发 onchange
-        editor.change && editor.change();
-    },
-
-    // 自定义 insertHTML 事件
-    _insertHTML: function _insertHTML(html) {
-        var editor = this.editor;
-        var range = editor.selection.getRange();
-
-        if (this.queryCommandSupported('insertHTML')) {
-            // 检查浏览器是否支持 'insertHTML' 命令，如果支持则使用 W3C 标准方法插入 HTML
-            this._execCommand('insertHTML', html);
-        } else if (range.insertNode) {
-            // 如果不支持 'insertHTML' 命令，但支持 insertNode 方法（IE 浏览器）
-            range.deleteContents(); // 删除当前选区的内容
-            range.insertNode($(html)[0]); // 将新的 HTML 节点插入到选区中
-        } else if (range.pasteHTML) {
-            // 如果不支持 insertNode 方法，但支持 pasteHTML 方法（IE <= 10 浏览器）
-            range.pasteHTML(html); // 使用 pasteHTML 方法插入 HTML
-        }
-
-    // 插入 elem
-    _insertElem: function _insertElem($elem) {
-        var editor = this.editor;
-        var range = editor.selection.getRange();
-
-        if (range.insertNode) {
-            // 如果 range 对象支持 insertNode 方法
-            range.deleteContents();
-            // 删除当前选区的内容
-            range.insertNode($elem[0]);
-            // 在当前选区插入指定的节点
-        }
-        },
-        
-        // 封装 execCommand 方法，用于执行文档命令
-        _execCommand: function _execCommand(name, value) {
-            document.execCommand(name, false, value);
-            // 调用 document.execCommand 方法执行指定命令
-        },
-        
-        // 封装 queryCommandValue 方法，用于查询命令的值
-        queryCommandValue: function queryCommandValue(name) {
-            return document.queryCommandValue(name);
-            // 返回指定命令的当前值
-        },
-        
-        // 封装 queryCommandState 方法，用于查询命令的状态
-        queryCommandState: function queryCommandState(name) {
-            return document.queryCommandState(name);
-            // 返回指定命令的启用状态
-        },
-        
-        // 封装 queryCommandSupported 方法，用于查询是否支持某命令
-        queryCommandSupported: function queryCommandSupported(name) {
-            return document.queryCommandSupported(name);
-            // 返回指定命令是否被支持
-        }
-        };
-
-
-function API(editor) {
-    // 初始化 API 对象，并设置编辑器实例
-    this.editor = editor;
-    // 初始化当前选区为 null
-    this._currentRange = null;
-}
-
-// 修改原型
-API.prototype = {
-    constructor: API,
-
-    // 获取 range 对象
-    getRange: function getRange() {
-        // 返回当前的选区对象
-        return this._currentRange;
-    },
-
-    // 保存选区
-    saveRange: function saveRange(_range) {
-        // 将传入的选区对象保存到当前对象的 _currentRange 属性中
-        if (_range) {
-            // 保存已有选区
-            this._currentRange = _range;
-            return;
-        }
-
-        // 获取当前的选区
-        var selection = window.getSelection();
-        if (selection.rangeCount === 0) {
-            // 如果当前没有选区，则直接返回
-            return;
-        }
-        var range = selection.getRangeAt(0);
-
-        // 判断选区内容是否在编辑内容之内
-        var $containerElem = this.getSelectionContainerElem(range);
-        if (!$containerElem) {
-            // 如果选区内容不在编辑内容之内，则直接返回
-            return;
-        }
-        // 判断选区内容是否在不可编辑区域之内
-        if ($containerElem.attr('contenteditable') === 'false' || $containerElem.parentUntil('[contenteditable=false]')) {
-            // 如果容器元素不可编辑或其父级元素中存在不可编辑的元素，则直接返回
-            return;
-        }
-        
-        var editor = this.editor;
-        var $textElem = editor.$textElem;
-        if ($textElem.isContain($containerElem)) {
-            // 判断容器元素是否在编辑器的文本内容之内
-            this._currentRange = range;
-            // 如果是，则将当前选区设置为该范围
-        }
-        },
-    
-        collapseRange: function collapseRange(toStart) {
-            if (toStart == null) {
-                // 如果未传入参数，则默认为 false
-                toStart = false;
-            }
-            var range = this._currentRange;
-            if (range) {
-                // 如果当前有选区，则根据参数折叠选区
-                range.collapse(toStart);
-            }
-        },
-
-    // 获取当前选中区域的文字
-    getSelectionText: function getSelectionText() {
-        // 获取当前的选区对象
-        var range = this._currentRange;
-        // 如果存在选区对象，返回选区中的文本内容
-        if (range) {
-            return this._currentRange.toString();
-        } else {
-            // 如果不存在选区对象，返回空字符串
-            return '';
-        }
-    },
-    // 选区的 $Elem
-    getSelectionContainerElem: function getSelectionContainerElem(range) {
-        // 如果没有传入 range，则使用当前范围
-        range = range || this._currentRange;
-        var elem = void 0;
-        // 如果 range 存在
-        if (range) {
-            // 获取公共祖先容器
-            elem = range.commonAncestorContainer;
-            // 返回包装后的节点，如果节点类型为元素节点（1），则直接返回，否则返回其父节点
-            return $(elem.nodeType === 1 ? elem : elem.parentNode);
-        }
-    },
-    
-    getSelectionStartElem: function getSelectionStartElem(range) {
-        // 如果没有传入 range，则使用当前范围
-        range = range || this._currentRange;
-        var elem = void 0;
-        // 如果 range 存在
-        if (range) {
-            // 获取起始容器
-            elem = range.startContainer;
-            // 返回包装后的节点，如果节点类型为元素节点（1），则直接返回，否则返回其父节点
-            return $(elem.nodeType === 1 ? elem : elem.parentNode);
-        }
-    },
-    
-    getSelectionEndElem: function getSelectionEndElem(range) {
-        // 如果没有传入 range，则使用当前范围
-        range = range || this._currentRange;
-        var elem = void 0;
-        // 如果 range 存在
-        if (range) {
-            // 获取结束容器
-            elem = range.endContainer;
-            // 返回包装后的节点，如果节点类型为元素节点（1），则直接返回，否则返回其父节点
-            return $(elem.nodeType === 1 ? elem : elem.parentNode);
-        }
-    },
-    
-    isSelectionEmpty: function isSelectionEmpty() {
-        // 获取当前的选区对象
-        var range = this._currentRange;
-        // 检查选区对象和起始容器是否存在
-        if (range && range.startContainer) {
-            // 检查起始容器和结束容器是否相同
-            if (range.startContainer === range.endContainer) {
-                // 检查起始偏移量和结束偏移量是否相同
-                if (range.startOffset === range.endOffset) {
-                    // 如果起始和结束位置相同，则选区为空
-                    return true;
-                }
-            }
-        }
-        // 如果上述条件不满足，则选区不为空
-        return false;
-    },
-    // 恢复选区
-    restoreSelection: function restoreSelection() {
-            // 获取当前窗口的选区对象
-            var selection = window.getSelection();
-            // 移除所有选区范围
-            selection.removeAllRanges();
-            // 将之前保存的选区范围添加回去
-            selection.addRange(this._currentRange);
-        },
-    
-        // 创建一个空白（即 &#8203 字符）选区
-        createEmptyRange: function createEmptyRange() {
-            // 获取编辑器实例
-            var editor = this.editor;
-            // 获取当前选区范围
-            var range = this.getRange();
-            // 定义一个未初始化的元素变量
-            var $elem = void 0;
-
-        if (!range) {
-            // 如果 range 为空，则直接返回，不进行后续操作
-            return;
-        }
-        if (!this.isSelectionEmpty()) {
-            // 如果当前选区不为空，则直接返回，不进行后续操作
-            return;
-        }
-        try {
-            // 目前只支持 webkit 内核
-            if (UA.isWebkit()) {
-                // 插入 &#8203; 字符，这是一个零宽空格，用于占位
-                editor.cmd.do('insertHTML', '&#8203;');
-                // 修改 offset 位置，将光标移动到插入的零宽空格之后
-                range.setEnd(range.endContainer, range.endOffset + 1);
-                // 存储当前范围
-                this.saveRange(range);
-            } else {
-                // 创建一个包含零宽空格的 <strong> 元素
-                $elem = $('<strong>&#8203;</strong>');
-                // 插入该元素到编辑器中
-                editor.cmd.do('insertElem', $elem);
-                // 根据插入的元素创建一个新的范围
-                this.createRangeByElem($elem, true);
-            }
-        } catch (ex) {
-            // 部分情况下会报错，兼容一下
-        }
-    },
-
-    // 根据 $Elem 设置选区
-    createRangeByElem: function createRangeByElem($elem, toStart, isContent) {
-        // $elem - 经过封装的 elem
-        // toStart - true 开始位置，false 结束位置
-        // isContent - 是否选中Elem的内容
-        if (!$elem.length) {
-            // 如果 $elem 为空，则直接返回
-            return;
-        }
-    
-        var elem = $elem[0];
-        // 获取原生的 DOM 元素
-        var range = document.createRange();
-        // 创建一个新的 Range 对象
-    
-        if (isContent) {
-            range.selectNodeContents(elem);
-            // 如果 isContent 为 true，则选择 elem 的所有内容
-        } else {
-            range.selectNode(elem);
-            // 如果 isContent 为 false，则选择整个 elem
-        }
-    
-        if (typeof toStart === 'boolean') {
-            range.collapse(toStart);
-            // 根据 toStart 的值折叠范围到起始或结束位置
-        }
-    
-        // 存储 range
-        this.saveRange(range);
-        // 调用 saveRange 方法保存当前的范围
-    }
-    };
-
-
-
-function Progress(editor) {
-    // 初始化编辑器实例
-    this.editor = editor;
-    // 初始化时间变量
-    this._time = 0;
-    // 初始化显示状态为false
-    this._isShow = false;
-    // 初始化渲染状态为false
-    this._isRender = false;
-    // 初始化超时ID
-    this._timeoutId = 0;
-    // 获取文本容器元素
-    this.$textContainer = editor.$textContainerElem;
-    // 创建进度条的DOM元素
-    this.$bar = $('<div class="w-e-progress"></div>');
-}
-
-Progress.prototype = {
-    constructor: Progress,
-
-    show: function show(progress) {
-        var _this = this;
-
-        // 如果进度条已经显示，则直接返回
-        if (this._isShow) {
-            return;
-        }
-        // 设置进度条显示状态为true
-        this._isShow = true;
-
-        // 获取进度条的DOM元素
-        var $bar = this.$bar;
-        // 检查是否已经渲染过
-        if (!this._isRender) {
-            // 获取文本容器的引用
-            var $textContainer = this.$textContainer;
-            // 将进度条添加到文本容器中
-            $textContainer.append($bar);
-        } else {
-            // 如果已经渲染过，则设置渲染标志为 true
-            this._isRender = true;
-        }
-        
-        // 改变进度（节流，100ms 渲染一次）
-        // 检查当前时间与上次记录时间的差值是否大于 100ms
-        if (Date.now() - this._time > 100) {
-            // 如果进度值小于等于 1
-            if (progress <= 1) {
-                // 设置进度条的宽度为当前进度的百分比
-                $bar.css('width', progress * 100 + '%');
-                // 更新上次记录时间为当前时间
-                this._time = Date.now();
-            }
-        }
-
-       var timeoutId = this._timeoutId;
-       // 获取当前对象的超时ID
-       if (timeoutId) {
-           clearTimeout(timeoutId);
-           // 如果存在超时ID，则清除该超时
-       }
-       timeoutId = setTimeout(function () {
-           _this._hide();
-       }, 500);
-       // 设置一个新的超时，在500毫秒后调用_hide方法
-       
-       _hide: function _hide() {
-           var $bar = this.$bar;
-           $bar.remove();
-           // 移除进度条元素
-       
-           this._time = 0;
-           // 重置时间变量为0
-           this._isShow = false;
-           // 设置显示状态为false
-           this._isRender = false;
-           // 设置渲染状态为false
-       }
-       
-       var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
-         return typeof obj;
-       } : function (obj) {
-         return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
-       };
-       // 定义一个函数用于判断对象类型，兼容ES6的Symbol类型
-
-
-function UploadImg(editor) {
-    // 构造函数，初始化编辑器实例
-    this.editor = editor;
-}
-
-UploadImg.prototype = {
-    constructor: UploadImg,
-
-    
-    _alert: function _alert(alertInfo, debugInfo) {
-        var editor = this.editor; // 获取编辑器实例
-        var debug = editor.config.debug; // 获取是否处于调试模式的配置
-        var customAlert = editor.config.customAlert; // 获取自定义警告函数的配置
-
-        if (debug) {
-            // 如果处于调试模式，抛出错误并包含调试信息
-            throw new Error('wangEditor: ' + (debugInfo || alertInfo));
-        } else {
-            if (customAlert && typeof customAlert === 'function') {
-                // 如果配置了自定义警告函数且其类型为函数，调用自定义警告函数
-                customAlert(alertInfo);
-            } else {
-                // 否则使用默认的alert函数显示警告信息
-                alert(alertInfo);
-            }
-        }
-    },
-    
-    insertLinkImg: function insertLinkImg(link) {
-            // 保存当前上下文的引用
-            var _this2 = this;
-    
-            // 如果链接为空，直接返回
-            if (!link) {
-                return;
-            }
-            // 获取编辑器实例
-            var editor = this.editor;
-            // 获取编辑器配置
-            var config = editor.config;
-    
-            // 校验链接是否合法
-            var linkImgCheck = config.linkImgCheck;
-            var checkResult = void 0;
-            // 如果配置了链接图片校验函数并且该函数是有效的
-            if (linkImgCheck && typeof linkImgCheck === 'function') {
-                // 执行校验函数并获取结果
-                checkResult = linkImgCheck(link);
-                // 如果校验结果是字符串类型，表示校验失败
-                if (typeof checkResult === 'string') {
-                    // 弹出提示信息
-                    alert(checkResult);
-                    // 终止函数执行
-                    return;
-                }
-            }
-
-        // 使用 editor.cmd.do 方法插入 HTML 代码，将图片链接嵌入到编辑器中
-        editor.cmd.do('insertHTML', '<img src="' + link + '" style="max-width:100%;"/>');
-        
-        // 创建一个新的 img 元素用于验证图片 URL 是否有效
-        var img = document.createElement('img');
-        
-        // 当图片加载成功时执行的回调函数
-        img.onload = function () {
-            // 获取配置中的图片链接回调函数
-            var callback = config.linkImgCallback;
-            if (callback && typeof callback === 'function') {
-                // 如果回调函数存在且为函数类型，则调用该回调函数并传入图片链接
-                callback(link);
-            }
-        
-            // 释放 img 对象引用
-            img = null;
-        };
-        
-        // 当图片加载失败时执行的回调函数
-        img.onerror = function () {
-            // 释放 img 对象引用
-            img = null;
-            // 弹出提示框，告知用户无法成功下载图片，并提供错误信息
-            _this2._alert('插入图片错误', 'wangEditor: \u63D2\u5165\u56FE\u7247\u51FA\u9519\uFF0C\u56FE\u7247\u94FE\u63A5\u662F "' + link + '"\uFF0C\u4E0B\u8F7D\u8BE5\u94FE\u63A5\u5931\u8D25');
-            return;
-        };
-        
-        // 当图片加载被中断时执行的回调函数
-        img.onabort = function () {
-            // 释放 img 对象引用
-            img = null;
-        };
-        
-        // 设置 img 元素的 src 属性为图片链接，开始加载图片
-        img.src = link;
-        },
-
-    // 上传图片
-    uploadImg: function uploadImg(files) {
-        var _this3 = this;
-    
-        // 如果文件列表为空，则直接返回
-        if (!files || !files.length) {
-            return;
-        }
-    
-        // ------------------------------ 获取配置信息 ------------------------------
-        // 获取编辑器实例
-        var editor = this.editor;
-        // 获取编辑器的配置对象
-        var config = editor.config;
-        // 获取上传图片的服务器地址
-        var uploadImgServer = config.uploadImgServer;
-        // 是否显示Base64编码的图片
-        var uploadImgShowBase64 = config.uploadImgShowBase64;
-    
-        // 获取上传图片的最大尺寸（字节）
-        var maxSize = config.uploadImgMaxSize;
-        // 将最大尺寸转换为MB
-        var maxSizeM = maxSize / 1024 / 1024;
-        // 获取上传图片的最大长度，默认值为10000
-        var maxLength = config.uploadImgMaxLength || 10000;
-        // 获取上传文件的名称，默认值为空字符串
-        var uploadFileName = config.uploadFileName || '';
-        // 获取上传图片时附带的参数，默认值为空对象
-        var uploadImgParams = config.uploadImgParams || {};
-        // 是否在上传图片时附带URL参数
-        var uploadImgParamsWithUrl = config.uploadImgParamsWithUrl;
-        // 获取上传图片时的请求头，默认值为空对象
-        var uploadImgHeaders = config.uploadImgHeaders || {};
-        // 获取上传图片的钩子函数，默认值为空对象
-        var hooks = config.uploadImgHooks || {};
-        // 获取上传图片的超时时间，默认值为3000毫秒
-        var timeout = config.uploadImgTimeout || 3000;
-        // 是否在上传图片时携带凭证信息
-        var withCredentials = config.withCredentials;
-        if (withCredentials == null) {
-            // 如果 withCredentials 为空，则将其设置为 false
-            withCredentials = false;
-        }
-        var customUploadImg = config.customUploadImg;
-        
-        if (!customUploadImg) {
-            // 如果没有自定义上传图片的方法，则需要以下两个配置才能继续进行图片上传
-            if (!uploadImgServer && !uploadImgShowBase64) {
-                // 如果既没有上传服务器地址也没有显示 Base64 的选项，则直接返回
-                return;
-            }
-        }
-        
-        // ------------------------------ 验证文件信息 ------------------------------
-        var resultFiles = [];
-        var errInfo = [];
-        arrForEach(files, function (file) {
-            var name = file.name;
-            var size = file.size;
-        
-            // chrome 低版本中 name 可能为 undefined
-            if (!name || !size) {
-                // 如果文件名或文件大小为空，直接返回
-                return;
-            }
-            
-            if (/\.(jpg|jpeg|png|bmp|gif|webp)$/i.test(name) === false) {
-                // 检查文件后缀名是否合法，如果不是图片格式，则加入错误信息并返回
-                errInfo.push('\u3010' + name + '\u3011\u4E0D\u662F\u56FE\u7247');
-                return;
-            }
-            if (maxSize < size) {
-                // 检查文件大小是否超过最大限制，如果超过，则加入错误信息并返回
-                errInfo.push('\u3010' + name + '\u3011\u5927\u4E8E ' + maxSizeM + 'M');
-                return;
-            }
-            
-            // 如果文件验证通过，将其加入结果列表
-            resultFiles.push(file);
-        // 抛出验证信息
-        if (errInfo.length) {
-            // 如果有错误信息，弹出提示框并返回
-            this._alert('图片验证未通过: \n' + errInfo.join('\n'));
-            return;
-        }
-        if (resultFiles.length > maxLength) {
-            // 如果上传的图片数量超过最大限制，弹出提示框并返回
-            this._alert('一次最多上传' + maxLength + '张图片');
-            return;
-        }
-        
-        // ------------------------------ 自定义上传 ------------------------------
-        if (customUploadImg && typeof customUploadImg === 'function') {
-            // 如果存在自定义上传函数，调用该函数进行上传
-            customUploadImg(resultFiles, this.insertLinkImg.bind(this));
-        
-            // 阻止以下代码执行
-            return;
-        }
-        
-        // 添加图片数据
-        var formdata = new FormData();
-        arrForEach(resultFiles, function (file) {
-            // 遍历每个文件，将其添加到FormData对象中
-            var name = uploadFileName || file.name;
-            formdata.append(name, file);
-        });
-
-        // ------------------------------ 上传图片 ------------------------------
-        if (uploadImgServer && typeof uploadImgServer === 'string') {
-            // 检查 uploadImgServer 是否存在且为字符串类型
-            var uploadImgServerArr = uploadImgServer.split('#');
-            // 将上传图片服务器地址按 '#' 分割成数组
-            uploadImgServer = uploadImgServerArr[0];
-            // 获取分割后的第一个元素，即上传图片服务器地址
-            var uploadImgServerHash = uploadImgServerArr[1] || '';
-            // 获取分割后的第二个元素（如果有），否则为空字符串
-            objForEach(uploadImgParams, function (key, val) {
-                // 遍历上传图片参数对象
-                // val = encodeURIComponent(val)
-                // 编码参数值，但因用户反馈，自定义参数不能默认编码，从 v3.1.1 版本开始注释掉
-        
-                if (uploadImgParamsWithUrl) {
-                    // 如果需要将参数拼接到 URL 中
-                    if (uploadImgServer.indexOf('?') > 0) {
-                        // 如果 URL 中已经包含查询参数，则添加 '&'
-                        uploadImgServer += '&';
-                    } else {
-                        // 如果 URL 中不包含查询参数，则添加 '?'
-                        uploadImgServer += '?';
-                    }
-                    uploadImgServer = uploadImgServer + key + '=' + val;
-                    // 将参数键值对拼接到 URL 中
-                }
-        
-                formdata.append(key, val);
-                // 将参数添加到 FormData 对象中
-            });
-            if (uploadImgServerHash) {
-                // 如果存在上传图片服务器的哈希值，则将其添加到上传图片服务器的URL中
-                uploadImgServer += '#' + uploadImgServerHash;
-            }
-            
-            // 定义 xhr 对象，用于发送 HTTP 请求
-            var xhr = new XMLHttpRequest();
-            // 初始化一个 POST 请求，目标 URL 为 uploadImgServer
-            xhr.open('POST', uploadImgServer);
-            
-            // 设置请求超时时间
-            xhr.timeout = timeout;
-            // 当请求超时时触发的事件处理函数
-            xhr.ontimeout = function () {
-                // hook - timeout
-                // 如果定义了超时钩子函数且其类型为函数，则调用该钩子函数
-                if (hooks.timeout && typeof hooks.timeout === 'function') {
-                    hooks.timeout(xhr, editor);
-                }
-            
-                // 显示上传图片超时的提示信息
-                _this3._alert('上传图片超时');
-            };
-
-            // 监控 progress
-            if (xhr.upload) {
-                // 当上传进度发生变化时触发
-                xhr.upload.onprogress = function (e) {
-                    var percent = void 0;
-                    // 创建一个新的进度条实例
-                    var progressBar = new Progress(editor);
-                    if (e.lengthComputable) {
-                        // 计算上传的百分比
-                        percent = e.loaded / e.total;
-                        // 显示进度条
-                        progressBar.show(percent);
-                    }
-                };
-            }
-            
-            // 当请求状态变化时触发
-            xhr.onreadystatechange = function () {
-                var result = void 0;
-                if (xhr.readyState === 4) { // 请求完成
-                    if (xhr.status < 200 || xhr.status >= 300) { // 请求失败
-                        // 如果定义了错误钩子函数，则调用它
-                        if (hooks.error && typeof hooks.error === 'function') {
-                            hooks.error(xhr, editor);
-                        }
-            
-                        // 弹出错误提示框，显示错误信息
-                        _this3._alert('上传图片发生错误', '\u4E0A\u4F20\u56FE\u7247\u53D1\u751F\u9519\u8BEF\uFF0C\u670D\u52A1\u5668\u8FD4\u56DE\u72B6\u6001\u662F ' + xhr.status);
-                        return;
-                    }
-            
-                    // 获取响应文本
-                    result = xhr.responseText;
-                    // 检查 result 是否为对象，如果不是则尝试将其解析为 JSON 对象
-                    if ((typeof result === 'undefined' ? 'undefined' : _typeof(result)) !== 'object') {
-                        try {
-                            // 尝试将 result 解析为 JSON 对象
-                            result = JSON.parse(result);
-                        } catch (ex) {
-                            // 如果解析失败，调用 hooks.fail 方法并显示错误提示
-                            if (hooks.fail && typeof hooks.fail === 'function') {
-                                hooks.fail(xhr, editor, result);
-                            }
-                    
-                            // 显示上传图片失败的提示信息
-                            _this3._alert('上传图片失败', '上传图片返回结果错误，返回结果是: ' + result);
-                            return;
-                        }
-                    }
-                    
-                    // 如果 hooks.customInsert 不存在且 result.errno 不为 '0'，表示上传失败
-                    if (!hooks.customInsert && result.errno != '0') {
-                        // 调用 hooks.fail 方法并显示错误提示
-                        if (hooks.fail && typeof hooks.fail === 'function') {
-                            hooks.fail(xhr, editor, result);
-                        }
-                    
-                        // 显示数据错误的提示信息
-                        _this3._alert('上传图片失败', '上传图片返回结果错误，返回结果 errno=' + result.errno);
-                    } else {
-                        // 如果存在自定义插入方法，则调用该方法
-                        if (hooks.customInsert && typeof hooks.customInsert === 'function') {
-                            hooks.customInsert(_this3.insertLinkImg.bind(_this3), result, editor);
-                        } else {
-                            // 否则，将图片链接插入编辑器
-                            var data = result.data || [];
-                            data.forEach(function (link) {
-                                _this3.insertLinkImg(link);
-                            });
-                        }
-                    }
-
-                        // hook - success
-                        if (hooks.success && typeof hooks.success === 'function') {
-                            // 如果存在成功钩子函数，并且其类型为函数，则调用该钩子函数
-                            hooks.success(xhr, editor, result);
-                        }
-                        
-                        // hook - before
-                        if (hooks.before && typeof hooks.before === 'function') {
-                            // 如果存在前置钩子函数，并且其类型为函数，则调用该钩子函数
-                            var beforeResult = hooks.before(xhr, editor, resultFiles);
-                            // 检查前置钩子函数的返回值是否为对象
-                            if (beforeResult && (typeof beforeResult === 'undefined' ? 'undefined' : _typeof(beforeResult)) === 'object') {
-                                // 如果返回的对象包含 prevent 属性且值为 true，表示用户放弃上传
-                                if (beforeResult.prevent) {
-                                    // 显示提示信息给用户
-                                    this._alert(beforeResult.msg);
-                                    // 终止后续操作
-                                    return;
-                                }
-                            }
-                        }
-
-            // 遍历上传图片的自定义 headers，并设置到 xhr 对象中
-            objForEach(uploadImgHeaders, function (key, val) {
-                xhr.setRequestHeader(key, val);
-            });
-
-            // 设置 xhr 对象的 withCredentials 属性，以支持跨域请求时传递 cookie
-            xhr.withCredentials = withCredentials;
-
-            // 发送包含表单数据的请求
-            xhr.send(formdata);
-
-            // 注意，要 return 。不去操作接下来的 base64 显示方式
-            return;
-
-        // ------------------------------ 显示 base64 格式 ------------------------------
-        if (uploadImgShowBase64) {
-            // 遍历文件数组
-            arrForEach(files, function (file) {
-                var _this = _this3; // 保存当前上下文的引用
-                var reader = new FileReader(); // 创建FileReader对象，用于读取文件内容
-                reader.readAsDataURL(file); // 以Data URL的形式读取文件内容
-                reader.onload = function () {
-                    // 当文件读取完成时，调用insertLinkImg方法插入图片链接
-                    _this.insertLinkImg(this.result);
-                };
-            });
-        }
-
-
-
-// id，累加
-var editorId = 1;
-
-// 构造函数
-function Editor(toolbarSelector, textSelector) {
-    if (toolbarSelector == null) {
-        // 没有传入任何参数，报错
-        throw new Error('错误：初始化编辑器时候未传入任何参数，请查阅文档');
-    }
-    // id，用以区分单个页面不同的编辑器对象
-    this.id = 'wangEditor-' + editorId++;
-
-    this.toolbarSelector = toolbarSelector;
-    this.textSelector = textSelector;
-
-    // 自定义配置
-    this.customConfig = {};
-}
-
-// 修改原型
-Editor.prototype = {
-    constructor: Editor,
-
-    // 初始化配置
-    _initConfig: function _initConfig() {
-        // 创建一个空对象 target，用于存储合并后的配置
-        var target = {};
-        // 将默认配置 config 和用户自定义配置 this.customConfig 合并到 target 中，并赋值给 this.config
-        this.config = Object.assign(target, config, this.customConfig);
-
-        // 获取语言配置，生成正则表达式
-        var langConfig = this.config.lang || {};
-        // 初始化一个数组，用于存储正则表达式和对应的替换值
-        var langArgs = [];
-        // 遍历语言配置对象，为每个规则生成正则表达式
-        objForEach(langConfig, function (key, val) {
-            // key 即需要生成正则表达式的规则，如“插入链接”
-            // val 即需要被替换成的语言，如“insert link”
-            langArgs.push({
-                reg: new RegExp(key, 'img'), // 创建正则表达式对象
-                val: val // 设置替换值
-            });
-        });
-        // 将生成的正则表达式数组赋值给 this.config.langArgs
-        this.config.langArgs = langArgs;
-    },
-
-    // 初始化 DOM
-    _initDom: function _initDom() {
-        var _this = this;
-    
-        // 获取工具栏选择器
-        var toolbarSelector = this.toolbarSelector;
-        // 将工具栏选择器转换为 jQuery 对象
-        var $toolbarSelector = $(toolbarSelector);
-        // 获取文本选择器
-        var textSelector = this.textSelector;
-    
-        // 获取配置对象
-        var config$$1 = this.config;
-        // 从配置中获取 zIndex 值
-        var zIndex = config$$1.zIndex;
-    
-        // 定义变量
-        var $toolbarElem = void 0,
-            $textContainerElem = void 0,
-            $textElem = void 0,
-            $children = void 0;
-    
-        if (textSelector == null) {
-            // 如果未传入文本选择器，则创建新的工具栏和文本容器元素
-            $toolbarElem = $('<div></div>');
-            $textContainerElem = $('<div></div>');
-    
-            // 将编辑器区域原有的内容暂存起来
-            $children = $toolbarSelector.children();
-    
-            // 将新创建的工具栏和文本容器添加到 DOM 结构中
-            $toolbarSelector.append($toolbarElem).append($textContainerElem);
-            // 自行创建的，需要配置默认的样式
-            $toolbarElem.css('background-color', '#f1f1f1').css('border', '1px solid #ccc');
-            $textContainerElem.css('border', '1px solid #ccc').css('border-top', 'none').css('height', '300px');
-        } else {
-            // toolbar 和 text 的选择器都有值，记录属性
-            $toolbarElem = $toolbarSelector;
-            $textContainerElem = $(textSelector);
-            // 将编辑器区域原有的内容，暂存起来
-            $children = $textContainerElem.children();
-        }
-
-        // 编辑区域
-        $textElem = $('<div></div>');
-        $textElem.attr('contenteditable', 'true').css('width', '100%').css('height', '100%');
-
-        // 初始化编辑区域内容
-        if ($children && $children.length) {
-            $textElem.append($children);
-        } else {
-            $textElem.append($('<p><br></p>'));
-        }
-        // 将文本元素添加到文本容器中
-        $textContainerElem.append($textElem);
-
-        // 设置工具栏和文本容器的通用 class
-        $toolbarElem.addClass('w-e-toolbar');
-        $textContainerElem.addClass('w-e-text-container');
-        // 设置文本容器的 z-index 属性，确保层级关系
-        $textContainerElem.css('z-index', zIndex);
-        // 为文本元素添加 class
-        $textElem.addClass('w-e-text');
-
-        // 生成随机 ID 并赋值给工具栏和文本元素
-        // 生成一个随机的ID，用于工具栏元素
-        var toolbarElemId = getRandom('toolbar-elem');
-        // 将生成的ID设置为工具栏元素的ID属性
-        $toolbarElem.attr('id', toolbarElemId);
-        
-        // 生成一个随机的ID，用于文本元素
-        var textElemId = getRandom('text-elem');
-        // 将生成的ID设置为文本元素的ID属性
-        $textElem.attr('id', textElemId);
-
-        // 记录当前实例的属性，方便后续操作
-        // 将传入的$toolbarElem参数赋值给当前对象的$toolbarElem属性
-        this.$toolbarElem = $toolbarElem;
-        // 将传入的$textContainerElem参数赋值给当前对象的$textContainerElem属性
-        this.$textContainerElem = $textContainerElem;
-        // 将传入的$textElem参数赋值给当前对象的$textElem属性
-        this.$textElem = $textElem;
-        // 将传入的toolbarElemId参数赋值给当前对象的toolbarElemId属性
-        this.toolbarElemId = toolbarElemId;
-        // 将传入的textElemId参数赋值给当前对象的textElemId属性
-        this.textElemId = textElemId;
-
-        // 记录输入法的开始和结束
-        var compositionEnd = true; // 初始化变量compositionEnd为true，表示输入法输入结束
-                $textContainerElem.on('compositionstart', function () {
-                    // 当输入法开始输入时触发此事件
-                    compositionEnd = false; // 将compositionEnd设置为false，表示输入法正在输入
-                });
-                $textContainerElem.on('compositionend', function () {
-                    // 当输入法结束输入时触发此事件
-                    compositionEnd = true; // 将compositionEnd设置为true，表示输入法输入结束
-                });
-
-        // 绑定 onchange
-        $textContainerElem.on('click keyup', function () {
-            // 输入法结束才触发 onchange 事件
-            compositionEnd && _this.change && _this.change();
-        });
-        
-        $toolbarElem.on('click', function () {
-            // 当点击工具栏时，如果存在 change 方法则调用它
-            this.change && this.change();
-        });
-        //绑定 onfocus 与 onblur 事件
-        if (config$$1.onfocus || config$$1.onblur) {
-            // 当前编辑器是否是焦点状态
-            this.isFocus = false;
-        
-            $(document).on('click', function (e) {
-                //判断当前点击元素是否在编辑器内
-                var isChild = $textElem.isContain($(e.target));
-        
-                //判断当前点击元素是否为工具栏
-                var isToolbar = $toolbarElem.isContain($(e.target));
-                var isMenu = $toolbarElem[0] == e.target ? true : false;
-
-                if (!isChild) {
-                    // 若为选择工具栏中的功能，则不视为成blur操作
-                    if (isToolbar && !isMenu) {
-                        return; // 直接返回，不执行后续代码
-                    }
-                
-                    // 如果当前对象处于焦点状态
-                    if (_this.isFocus) {
-                        // 调用onblur方法，如果存在的话
-                        _this.onblur && _this.onblur();
-                    }
-                    // 将焦点状态设为false
-                    _this.isFocus = false;
-                } else {
-                    // 如果当前对象不处于焦点状态
-                    if (!_this.isFocus) {
-                        // 调用onfocus方法，如果存在的话
-                        _this.onfocus && _this.onfocus();
-                    }
-                    // 将焦点状态设为true
-                    _this.isFocus = true;
-                }
-
-    // 封装 command
-    _initCommand: function _initCommand() {
-        // 创建一个新的 Command 实例并赋值给 this.cmd
-        this.cmd = new Command(this);
-    },
-
-    // 封装 selection range API
-    _initSelectionAPI: function _initSelectionAPI() {
-        // 创建一个新的 API 实例并赋值给 this.selection
-        this.selection = new API(this);
-    },
-
-    // 添加图片上传功能
-    _initUploadImg: function _initUploadImg() {
-        // 创建一个新的 UploadImg 实例并赋值给 this.uploadImg
-        this.uploadImg = new UploadImg(this);
-    },
-
-    // 初始化菜单
-    _initMenus: function _initMenus() {
-        // 创建一个新的 Menus 实例并赋值给 this.menus
-        this.menus = new Menus(this);
-        // 调用 menus 的 init 方法进行初始化
-        this.menus.init();
-    },
-
-    // 添加 text 区域
-    _initText: function _initText() {
-        this.txt = new Text(this);
-        this.txt.init();
-    },
-
-    // 初始化选区，将光标定位到内容尾部
-    initSelection: function initSelection(newLine) {
-        // 获取编辑器的文本元素
-        var $textElem = this.$textElem;
-        // 获取文本元素的子元素
-        var $children = $textElem.children();
-        // 如果文本元素没有子元素
-        if (!$children.length) {
-            // 如果编辑器区域无内容，添加一个空行，重新设置选区
-            $textElem.append($('<p><br></p>'));
-            // 递归调用自身以初始化选区
-            this.initSelection();
-            return;
-        }
-
-        var $last = $children.last();
-        // 获取最后一个子元素
-        
-        if (newLine) {
-            // 如果需要新增一个空行
-            var html = $last.html().toLowerCase();
-            // 获取最后一个子元素的HTML内容并转换为小写
-            var nodeName = $last.getNodeName();
-            // 获取最后一个子元素的节点名称
-            if (html !== '<br>' && html !== '<br\/>' || nodeName !== 'P') {
-                // 如果最后一个元素不是 <p><br></p>，添加一个空行，重新设置选区
-                $textElem.append($('<p><br></p>'));
-                // 在文本元素中追加一个包含换行符的段落
-                this.initSelection();
-                // 初始化选区
-                return;
-                // 结束方法执行
-            }
-        }
-        
-        this.selection.createRangeByElem($last, false, true);
-        // 根据最后一个元素创建选区范围
-        this.selection.restoreSelection();
-        // 恢复选区
-
-    // 绑定事件
-    _bindEvent: function _bindEvent() {
-        // -------- 绑定 onchange 事件 --------
-        var onChangeTimeoutId = 0; // 初始化 onchange 事件的定时器 ID
-        var beforeChangeHtml = this.txt.html(); // 获取当前文本框的 HTML 内容
-        var config$$1 = this.config; // 获取配置对象
-    
-        // onchange 触发延迟时间
-        var onchangeTimeout = config$$1.onchangeTimeout; // 从配置中获取 onchange 触发延迟时间
-        onchangeTimeout = parseInt(onchangeTimeout, 10); // 将延迟时间转换为整数
-        if (!onchangeTimeout || onchangeTimeout <= 0) { // 如果延迟时间无效或小于等于 0
-            onchangeTimeout = 200; // 设置默认延迟时间为 200 毫秒
-        }
-    
-        var onchange = config$$1.onchange; // 从配置中获取 onchange 回调函数
-        if (onchange && typeof onchange === 'function') {
-            this.change = function () {
-                // 获取当前文本内容
-                var currentHtml = this.txt.html();
-        
-                if (currentHtml.length === beforeChangeHtml.length) {
-                    // 如果当前文本长度与之前保存的长度相同，则需要比较每一个字符
-                    if (currentHtml === beforeChangeHtml) {
-                        // 如果当前文本内容与之前保存的内容完全相同，则无需处理
-                        return;
-                    }
-                }
-
-                // 如果存在 onChangeTimeoutId，则清除之前的定时器
-                if (onChangeTimeoutId) {
-                    clearTimeout(onChangeTimeoutId);
-                }
-                // 设置一个新的定时器，在指定的延迟后执行回调函数
-                onChangeTimeoutId = setTimeout(function () {
-                    // 触发配置的 onchange 函数，并传入当前的 HTML 内容
-                    onchange(currentHtml);
-                    // 更新 beforeChangeHtml 为当前的 HTML 内容
-                    beforeChangeHtml = currentHtml;
-                }, onchangeTimeout);
-            };
-        }
-
-        // -------- 绑定 onblur 事件 --------
-        // 获取配置中的onblur属性
-        var onblur = config$$1.onblur;
-        
-        // 检查onblur是否存在且为函数类型
-        if (onblur && typeof onblur === 'function') {
-            // 定义当前对象的onblur方法
-            this.onblur = function () {
-                // 获取当前文本框的HTML内容
-                var currentHtml = this.txt.html();
-                // 调用传入的onblur函数，并传递当前HTML内容作为参数
-                onblur(currentHtml);
-            };
-        }
-
-        // -------- 绑定 onfocus 事件 --------
-        var onfocus = config$$1.onfocus; // 从配置对象中获取onfocus属性
-        if (onfocus && typeof onfocus === 'function') { // 检查onfocus是否存在且为函数类型
-            this.onfocus = function () { // 定义当前对象的onfocus方法
-                onfocus(); // 调用传入的onfocus函数
-            };
-        }
-
-    // 创建编辑器
-    create: function create() {
-        // 初始化配置信息
-        this._initConfig();
-
-        // 初始化 DOM
-        this._initDom();
-
-        // 封装 command API
-        this._initCommand();
-
-        // 封装 selection range API
-        this._initSelectionAPI();
-
-        // 添加 text
-        this._initText();
-
-        // 初始化菜单
-        this._initMenus();
-
-        // 添加 图片上传
-        this._initUploadImg();
-
-        // 初始化选区，将光标定位到内容尾部
-        this.initSelection(true);
-
-        // 绑定事件
-        this._bindEvent();
-    },
-
-    // 解绑所有事件（暂时不对外开放）
-    _offAllEvent: function _offAllEvent() {
-        $.offAll();
-    }
-};
-
-// 检验是否浏览器环境
-try {
-    document;
-} catch (ex) {
-    throw new Error('请在浏览器环境下运行');
-}
-
-// polyfill
-polyfill();
-
-// 这里的 `inlinecss` 将被替换成 css 代码的内容，详情可去 ./gulpfile.js 中搜索 `inlinecss` 关键字
-var inlinecss = '.w-e-toolbar,.w-e-text-container,.w-e-menu-panel {  padding: 0;  margin: 0;  box-sizing: border-box;}.w-e-toolbar *,.w-e-text-container *,.w-e-menu-panel * {  padding: 0;  margin: 0;  box-sizing: border-box;}.w-e-clear-fix:after {  content: "";  display: table;  clear: both;}.w-e-toolbar .w-e-droplist {  position: absolute;  left: 0;  top: 0;  background-color: #fff;  border: 1px solid #f1f1f1;  border-right-color: #ccc;  border-bottom-color: #ccc;}.w-e-toolbar .w-e-droplist .w-e-dp-title {  text-align: center;  color: #999;  line-height: 2;  border-bottom: 1px solid #f1f1f1;  font-size: 13px;}.w-e-toolbar .w-e-droplist ul.w-e-list {  list-style: none;  line-height: 1;}.w-e-toolbar .w-e-droplist ul.w-e-list li.w-e-item {  color: #333;  padding: 5px 0;}.w-e-toolbar .w-e-droplist ul.w-e-list li.w-e-item:hover {  background-color: #f1f1f1;}.w-e-toolbar .w-e-droplist ul.w-e-block {  list-style: none;  text-align: left;  padding: 5px;}.w-e-toolbar .w-e-droplist ul.w-e-block li.w-e-item {  display: inline-block;  *display: inline;  *zoom: 1;  padding: 3px 5px;}.w-e-toolbar .w-e-droplist ul.w-e-block li.w-e-item:hover {  background-color: #f1f1f1;}@font-face {  font-family: \'w-e-icon\';  src: url(data:application/x-font-woff;charset=utf-8;base64,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) format(\'truetype\');  font-weight: normal;  font-style: normal;}[class^="w-e-icon-"],[class*=" w-e-icon-"] {  /* use !important to prevent issues with browser extensions that change fonts */  font-family: \'w-e-icon\' !important;  speak: none;  font-style: normal;  font-weight: normal;  font-variant: normal;  text-transform: none;  line-height: 1;  /* Better Font Rendering =========== */  -webkit-font-smoothing: antialiased;  -moz-osx-font-smoothing: grayscale;}.w-e-icon-close:before {  content: "\\f00d";}.w-e-icon-upload2:before {  content: "\\e9c6";}.w-e-icon-trash-o:before {  content: "\\f014";}.w-e-icon-header:before {  content: "\\f1dc";}.w-e-icon-pencil2:before {  content: "\\e906";}.w-e-icon-paint-brush:before {  content: "\\f1fc";}.w-e-icon-image:before {  content: "\\e90d";}.w-e-icon-play:before {  content: "\\e912";}.w-e-icon-location:before {  content: "\\e947";}.w-e-icon-undo:before {  content: "\\e965";}.w-e-icon-redo:before {  content: "\\e966";}.w-e-icon-quotes-left:before {  content: "\\e977";}.w-e-icon-list-numbered:before {  content: "\\e9b9";}.w-e-icon-list2:before {  content: "\\e9bb";}.w-e-icon-link:before {  content: "\\e9cb";}.w-e-icon-happy:before {  content: "\\e9df";}.w-e-icon-bold:before {  content: "\\ea62";}.w-e-icon-underline:before {  content: "\\ea63";}.w-e-icon-italic:before {  content: "\\ea64";}.w-e-icon-strikethrough:before {  content: "\\ea65";}.w-e-icon-table2:before {  content: "\\ea71";}.w-e-icon-paragraph-left:before {  content: "\\ea77";}.w-e-icon-paragraph-center:before {  content: "\\ea78";}.w-e-icon-paragraph-right:before {  content: "\\ea79";}.w-e-icon-terminal:before {  content: "\\f120";}.w-e-icon-page-break:before {  content: "\\ea68";}.w-e-icon-cancel-circle:before {  content: "\\ea0d";}.w-e-icon-font:before {  content: "\\ea5c";}.w-e-icon-text-heigh:before {  content: "\\ea5f";}.w-e-toolbar {  display: -webkit-box;  display: -ms-flexbox;  display: flex;  padding: 0 5px;  /* flex-wrap: wrap; */  /* 单个菜单 */}.w-e-toolbar .w-e-menu {  position: relative;  text-align: center;  padding: 5px 10px;  cursor: pointer;}.w-e-toolbar .w-e-menu i {  color: #999;}.w-e-toolbar .w-e-menu:hover i {  color: #333;}.w-e-toolbar .w-e-active i {  color: #1e88e5;}.w-e-toolbar .w-e-active:hover i {  color: #1e88e5;}.w-e-text-container .w-e-panel-container {  position: absolute;  top: 0;  left: 50%;  border: 1px solid #ccc;  border-top: 0;  box-shadow: 1px 1px 2px #ccc;  color: #333;  background-color: #fff;  /* 为 emotion panel 定制的样式 */  /* 上传图片的 panel 定制样式 */}.w-e-text-container .w-e-panel-container .w-e-panel-close {  position: absolute;  right: 0;  top: 0;  padding: 5px;  margin: 2px 5px 0 0;  cursor: pointer;  color: #999;}.w-e-text-container .w-e-panel-container .w-e-panel-close:hover {  color: #333;}.w-e-text-container .w-e-panel-container .w-e-panel-tab-title {  list-style: none;  display: -webkit-box;  display: -ms-flexbox;  display: flex;  font-size: 14px;  margin: 2px 10px 0 10px;  border-bottom: 1px solid #f1f1f1;}.w-e-text-container .w-e-panel-container .w-e-panel-tab-title .w-e-item {  padding: 3px 5px;  color: #999;  cursor: pointer;  margin: 0 3px;  position: relative;  top: 1px;}.w-e-text-container .w-e-panel-container .w-e-panel-tab-title .w-e-active {  color: #333;  border-bottom: 1px solid #333;  cursor: default;  font-weight: 700;}.w-e-text-container .w-e-panel-container .w-e-panel-tab-content {  padding: 10px 15px 10px 15px;  font-size: 16px;  /* 输入框的样式 */  /* 按钮的样式 */}.w-e-text-container .w-e-panel-container .w-e-panel-tab-content input:focus,.w-e-text-container .w-e-panel-container .w-e-panel-tab-content textarea:focus,.w-e-text-container .w-e-panel-container .w-e-panel-tab-content button:focus {  outline: none;}.w-e-text-container .w-e-panel-container .w-e-panel-tab-content textarea {  width: 100%;  border: 1px solid #ccc;  padding: 5px;}.w-e-text-container .w-e-panel-container .w-e-panel-tab-content textarea:focus {  border-color: #1e88e5;}.w-e-text-container .w-e-panel-container .w-e-panel-tab-content input[type=text] {  border: none;  border-bottom: 1px solid #ccc;  font-size: 14px;  height: 20px;  color: #333;  text-align: left;}.w-e-text-container .w-e-panel-container .w-e-panel-tab-content input[type=text].small {  width: 30px;  text-align: center;}.w-e-text-container .w-e-panel-container .w-e-panel-tab-content input[type=text].block {  display: block;  width: 100%;  margin: 10px 0;}.w-e-text-container .w-e-panel-container .w-e-panel-tab-content input[type=text]:focus {  border-bottom: 2px solid #1e88e5;}.w-e-text-container .w-e-panel-container .w-e-panel-tab-content .w-e-button-container button {  font-size: 14px;  color: #1e88e5;  border: none;  padding: 5px 10px;  background-color: #fff;  cursor: pointer;  border-radius: 3px;}.w-e-text-container .w-e-panel-container .w-e-panel-tab-content .w-e-button-container button.left {  float: left;  margin-right: 10px;}.w-e-text-container .w-e-panel-container .w-e-panel-tab-content .w-e-button-container button.right {  float: right;  margin-left: 10px;}.w-e-text-container .w-e-panel-container .w-e-panel-tab-content .w-e-button-container button.gray {  color: #999;}.w-e-text-container .w-e-panel-container .w-e-panel-tab-content .w-e-button-container button.red {  color: #c24f4a;}.w-e-text-container .w-e-panel-container .w-e-panel-tab-content .w-e-button-container button:hover {  background-color: #f1f1f1;}.w-e-text-container .w-e-panel-container .w-e-panel-tab-content .w-e-button-container:after {  content: "";  display: table;  clear: both;}.w-e-text-container .w-e-panel-container .w-e-emoticon-container .w-e-item {  cursor: pointer;  font-size: 18px;  padding: 0 3px;  display: inline-block;  *display: inline;  *zoom: 1;}.w-e-text-container .w-e-panel-container .w-e-up-img-container {  text-align: center;}.w-e-text-container .w-e-panel-container .w-e-up-img-container .w-e-up-btn {  display: inline-block;  *display: inline;  *zoom: 1;  color: #999;  cursor: pointer;  font-size: 60px;  line-height: 1;}.w-e-text-container .w-e-panel-container .w-e-up-img-container .w-e-up-btn:hover {  color: #333;}.w-e-text-container {  position: relative;}.w-e-text-container .w-e-progress {  position: absolute;  background-color: #1e88e5;  bottom: 0;  left: 0;  height: 1px;}.w-e-text {  padding: 0 10px;  overflow-y: scroll;}.w-e-text p,.w-e-text h1,.w-e-text h2,.w-e-text h3,.w-e-text h4,.w-e-text h5,.w-e-text table,.w-e-text pre {  margin: 10px 0;  line-height: 1.5;}.w-e-text ul,.w-e-text ol {  margin: 10px 0 10px 20px;}.w-e-text blockquote {  display: block;  border-left: 8px solid #d0e5f2;  padding: 5px 10px;  margin: 10px 0;  line-height: 1.4;  font-size: 100%;  background-color: #f1f1f1;}.w-e-text code {  display: inline-block;  *display: inline;  *zoom: 1;  background-color: #f1f1f1;  border-radius: 3px;  padding: 3px 5px;  margin: 0 3px;}.w-e-text pre code {  display: block;}.w-e-text table {  border-top: 1px solid #ccc;  border-left: 1px solid #ccc;}.w-e-text table td,.w-e-text table th {  border-bottom: 1px solid #ccc;  border-right: 1px solid #ccc;  padding: 3px 5px;}.w-e-text table th {  border-bottom: 2px solid #ccc;  text-align: center;}.w-e-text:focus {  outline: none;}.w-e-text img {  cursor: pointer;}.w-e-text img:hover {  box-shadow: 0 0 5px #333;}';
-
-// 将 css 代码添加到 <style> 中
-var style = document.createElement('style'); // 创建一个新的<style>元素
-style.type = 'text/css'; // 设置<style>元素的类型为CSS
-style.innerHTML = inlinecss; // 将内联CSS内容插入到<style>元素中
-document.getElementsByTagName('HEAD').item(0).appendChild(style); // 将<style>元素添加到文档的<head>部分
-
-// 返回
-var index = window.wangEditor || Editor; // 获取全局对象window中的wangEditor属性，如果不存在则使用Editor
-
-return index; // 返回index变量
-
-})));
-
-layui.define(function(exports) {
-    exports('wangEditor', window.wangEditor); // 定义模块并导出wangEditor对象
-});