mm_ip 1.0.2 → 1.0.3

package/index.js

@@ -9,50 +9,62 @@ require('mm_expand');
  * @class
  */
 class Ip {
-    /**
-     * 创建IP管理实例
-     * @param {Object} config - 配置选项
-     */
-    constructor(config) {
-        this._config = Object.assign({
-            max_white: 1000,
-            max_black: 1000,
-            check_interval: 60000, // 1分钟
-            max_req_per_min: 100,
-            auto_black_enable: true, // 启用自动高频拉黑
-            auto_black_threshold: 50, // 自动拉黑阈值（每分钟请求数）
-            auto_black_duration: 3600000, // 自动拉黑持续时间（1小时）
-            violation_enable: true, // 启用违规记录
-            violation_max_count: 10, // 最大违规次数
-            violation_reset_time: 86400000, // 违规记录重置时间（24小时）
-            violation_auto_black: true, // 违规次数超限自动拉黑
-            dir: './cache/ip' // 持久化存储目录
-        }, config || {});
-        
-        this._white = new Set();
-        this._black = new Set();
-        this._req_count = new Map();
-        this._req_time = new Map();
-        this._black_time = new Map(); // 记录拉黑时间
-        this._violation_count = new Map(); // 违规次数记录
-        this._violation_time = new Map(); // 违规时间记录
-        this._logger = $.log || console;
-        
-        // 自动加载持久化数据
-        if (this._config.dir) {
-            this.load();
-        }
-    }
+	static config = {
+		max_white: 1000,
+		max_black: 1000,
+		check_interval: 60000, // 1分钟
+		max_req_per_min: 100,
+		auto_black_enable: true, // 启用自动高频拉黑
+		auto_black_threshold: 50, // 自动拉黑阈值（每分钟请求数）
+		auto_black_duration: 3600000, // 自动拉黑持续时间（1小时）
+		violation_enable: true, // 启用违规记录
+		violation_max_count: 10, // 最大违规次数
+		violation_reset_time: 86400000, // 违规记录重置时间（24小时）
+		violation_auto_black: true, // 违规次数超限自动拉黑
+		dir: './cache/ip' // 持久化存储目录
+	}
+	/**
+	 * 创建IP管理实例
+	 * @param {Object} config - 配置选项
+	 */
+	constructor(config) {
+		this._config = Object.assign({}, Ip.config);
+
+		this._white = new Set();
+		this._black = new Set();
+		this._req_count = new Map();
+		this._req_time = new Map();
+		this._black_time = new Map(); // 记录拉黑时间
+		this._violation_count = new Map(); // 违规次数记录
+		this._violation_time = new Map(); // 违规时间记录
+		this._logger = $.log || console;
+
+		this.setConfig(config);
+		// 自动加载持久化数据
+		if (this._config.dir) {
+			this.load();
+		}
+	}
+}
+
+/**
+ * 设置配置选项
+ * @param {Object} config - 配置选项
+ */
+Ip.prototype.setConfig = function(config) {
+	if (config) {
+		Object.assign(this._config, config);
+	}
 }
 
 /**
  * 设置日志器
  * @param {Object} logger - 日志对象
  */
-Ip.prototype.setup = function (logger) {
-    if (logger && typeof logger === 'object') {
-        this._logger = logger;
-    }
+Ip.prototype.init = function(logger) {
+	if (logger) {
+		this._logger = logger;
+	}
 };
 
 /**
@@ -61,8 +73,8 @@ Ip.prototype.setup = function (logger) {
  * @param {string} message - 日志消息
  * @param {...*} args - 可选的日志参数
  */
-Ip.prototype.logger = function (level, message, ...args) {
-    this._logger[level](`${this.constructor.name} ${message}`, ...args);
+Ip.prototype.log = function(level, message, ...args) {
+	this._logger[level](`${this.constructor.name} ${message}`, ...args);
 };
 
 /**
@@ -71,23 +83,23 @@ Ip.prototype.logger = function (level, message, ...args) {
  * @returns {boolean} 是否添加成功
  * @throws {TypeError} 当IP非字符串时
  */
-Ip.prototype.addWhite = function (ip) {
-    if (typeof ip !== 'string') throw new TypeError('ip must be string');
+Ip.prototype.addWhite = function(ip) {
+	if (typeof ip !== 'string') throw new TypeError('ip must be string');
 
-    if (this.getAllWhite().length >= this._config.max_white) {
-        this.logger('warn', '白名单已满，无法添加IP:', ip);
-        return false;
-    }
+	if (this.getAllWhite().length >= this._config.max_white) {
+		this.log('warn', '白名单已满，无法添加IP:', ip);
+		return false;
+	}
 
-    this._white.add(ip);
-    this.logger('info', '添加白名单IP:', ip);
-    
-    // 自动保存到持久化存储
-    if (this._config.dir) {
-        this.save();
-    }
-    
-    return true;
+	this._white.add(ip);
+	this.log('info', '添加白名单IP:', ip);
+
+	// 自动保存到持久化存储
+	if (this._config.dir) {
+		this.save();
+	}
+
+	return true;
 };
 
 /**
@@ -96,23 +108,23 @@ Ip.prototype.addWhite = function (ip) {
  * @returns {boolean} 是否添加成功
  * @throws {TypeError} 当IP非字符串时
  */
-Ip.prototype.addBlack = function (ip) {
-    if (typeof ip !== 'string') throw new TypeError('ip must be string');
+Ip.prototype.addBlack = function(ip) {
+	if (typeof ip !== 'string') throw new TypeError('ip must be string');
+
+	if (this.getAllBlack().length >= this._config.max_black) {
+		this.log('warn', '黑名单已满，无法添加IP:', ip);
+		return false;
+	}
 
-    if (this.getAllBlack().length >= this._config.max_black) {
-        this.logger('warn', '黑名单已满，无法添加IP:', ip);
-        return false;
-    }
+	this._black.add(ip);
+	this.log('info', '添加黑名单IP:', ip);
 
-    this._black.add(ip);
-    this.logger('info', '添加黑名单IP:', ip);
-    
-    // 自动保存到持久化存储
-    if (this._config.dir) {
-        this.save();
-    }
-    
-    return true;
+	// 自动保存到持久化存储
+	if (this._config.dir) {
+		this.save();
+	}
+
+	return true;
 };
 
 /**
@@ -121,19 +133,19 @@ Ip.prototype.addBlack = function (ip) {
  * @returns {boolean} 是否删除成功
  * @throws {TypeError} 当IP非字符串时
  */
-Ip.prototype.delWhite = function (ip) {
-    if (typeof ip !== 'string') throw new TypeError('ip must be string');
+Ip.prototype.delWhite = function(ip) {
+	if (typeof ip !== 'string') throw new TypeError('ip must be string');
+
+	const result = this._white.delete(ip);
+	if (result) {
+		this.log('info', '删除白名单IP:', ip);
 
-    const result = this._white.delete(ip);
-    if (result) {
-        this.logger('info', '删除白名单IP:', ip);
-        
-        // 自动保存到持久化存储
-        if (this._config.dir) {
-            this.save();
-        }
-    }
-    return result;
+		// 自动保存到持久化存储
+		if (this._config.dir) {
+			this.save();
+		}
+	}
+	return result;
 };
 
 /**
@@ -142,19 +154,19 @@ Ip.prototype.delWhite = function (ip) {
  * @returns {boolean} 是否删除成功
  * @throws {TypeError} 当IP非字符串时
  */
-Ip.prototype.delBlack = function (ip) {
-    if (typeof ip !== 'string') throw new TypeError('ip must be string');
+Ip.prototype.delBlack = function(ip) {
+	if (typeof ip !== 'string') throw new TypeError('ip must be string');
 
-    const result = this._black.delete(ip);
-    if (result) {
-        this.logger('info', '删除黑名单IP:', ip);
-        
-        // 自动保存到持久化存储
-        if (this._config.dir) {
-            this.save();
-        }
-    }
-    return result;
+	const result = this._black.delete(ip);
+	if (result) {
+		this.log('info', '删除黑名单IP:', ip);
+
+		// 自动保存到持久化存储
+		if (this._config.dir) {
+			this.save();
+		}
+	}
+	return result;
 };
 
 /**
@@ -163,9 +175,9 @@ Ip.prototype.delBlack = function (ip) {
  * @returns {boolean} 是否在白名单
  * @throws {TypeError} 当IP非字符串时
  */
-Ip.prototype.isWhite = function (ip) {
-    if (typeof ip !== 'string') throw new TypeError('ip must be string');
-    return this._white.has(ip);
+Ip.prototype.isWhite = function(ip) {
+	if (typeof ip !== 'string') throw new TypeError('ip must be string');
+	return this._white.has(ip);
 };
 
 /**
@@ -174,9 +186,9 @@ Ip.prototype.isWhite = function (ip) {
  * @returns {boolean} 是否在黑名单
  * @throws {TypeError} 当IP非字符串时
  */
-Ip.prototype.isBlack = function (ip) {
-    if (typeof ip !== 'string') throw new TypeError('ip must be string');
-    return this._black.has(ip);
+Ip.prototype.isBlack = function(ip) {
+	if (typeof ip !== 'string') throw new TypeError('ip must be string');
+	return this._black.has(ip);
 };
 
 /**
@@ -185,54 +197,54 @@ Ip.prototype.isBlack = function (ip) {
  * @returns {boolean} 是否允许请求
  * @throws {TypeError} 当IP非字符串时
  */
-Ip.prototype.record = function (ip) {
-    if (typeof ip !== 'string') throw new TypeError('ip must be string');
-
-    // 检查黑名单（包括过期检查）
-    if (this.isBlack(ip)) {
-        // 检查是否过期
-        if (this._isBlackExpired(ip)) {
-            this.delBlack(ip);
-            this.logger('info', '黑名单IP已过期，自动移除:', ip);
-        } else {
-            this.logger('warn', '黑名单IP请求被拒绝:', ip);
-            // 记录违规：黑名单IP尝试访问
-            if (this._config.violation_enable) {
-                this.recordViolation(ip, '黑名单IP尝试访问');
-            }
-            return false;
-        }
-    }
-
-    // 白名单直接通过
-    if (this.isWhite(ip)) {
-        this._updateReqCount(ip);
-        return true;
-    }
-
-    // 检查频率限制
-    if (!this._checkRateLimit(ip)) {
-        this.logger('warn', 'IP请求频率超限:', ip);
-
-        // 记录违规：请求频率超限
-        if (this._config.violation_enable) {
-            this.recordViolation(ip, '请求频率超限');
-        }
-
-        // 检查是否触发自动拉黑
-        if (this._config.auto_black_enable) {
-            const rate = this.getReqRate(ip);
-            if (rate >= this._config.auto_black_threshold) {
-                this._autoBlack(ip);
-                return false;
-            }
-        }
-
-        return false;
-    }
-
-    this._updateReqCount(ip);
-    return true;
+Ip.prototype.record = function(ip) {
+	if (typeof ip !== 'string') throw new TypeError('ip must be string');
+
+	// 检查黑名单（包括过期检查）
+	if (this.isBlack(ip)) {
+		// 检查是否过期
+		if (this._isBlackExpired(ip)) {
+			this.delBlack(ip);
+			this.log('info', '黑名单IP已过期，自动移除:', ip);
+		} else {
+			this.log('warn', '黑名单IP请求被拒绝:', ip);
+			// 记录违规：黑名单IP尝试访问
+			if (this._config.violation_enable) {
+				this.recordViolation(ip, '黑名单IP尝试访问');
+			}
+			return false;
+		}
+	}
+
+	// 白名单直接通过
+	if (this.isWhite(ip)) {
+		this._updateReqCount(ip);
+		return true;
+	}
+
+	// 检查频率限制
+	if (!this._checkRateLimit(ip)) {
+		this.log('warn', 'IP请求频率超限:', ip);
+
+		// 记录违规：请求频率超限
+		if (this._config.violation_enable) {
+			this.recordViolation(ip, '请求频率超限');
+		}
+
+		// 检查是否触发自动拉黑
+		if (this._config.auto_black_enable) {
+			const rate = this.getReqRate(ip);
+			if (rate >= this._config.auto_black_threshold) {
+				this._autoBlack(ip);
+				return false;
+			}
+		}
+
+		return false;
+	}
+
+	this._updateReqCount(ip);
+	return true;
 };
 
 /**
@@ -241,9 +253,9 @@ Ip.prototype.record = function (ip) {
  * @returns {number} 请求次数
  * @throws {TypeError} 当IP非字符串时
  */
-Ip.prototype.getReqCount = function (ip) {
-    if (typeof ip !== 'string') throw new TypeError('ip must be string');
-    return this._req_count.get(ip) || 0;
+Ip.prototype.getReqCount = function(ip) {
+	if (typeof ip !== 'string') throw new TypeError('ip must be string');
+	return this._req_count.get(ip) || 0;
 };
 
 /**
@@ -252,106 +264,106 @@ Ip.prototype.getReqCount = function (ip) {
  * @returns {number} 请求频率（每分钟请求数）
  * @throws {TypeError} 当IP非字符串时
  */
-Ip.prototype.getReqRate = function (ip) {
-    if (typeof ip !== 'string') throw new TypeError('ip must be string');
+Ip.prototype.getReqRate = function(ip) {
+	if (typeof ip !== 'string') throw new TypeError('ip must be string');
 
-    const now = Date.now();
-    const lastTime = this._req_time.get(ip) || now;
-    const count = this._req_count.get(ip) || 0;
+	const now = Date.now();
+	const lastTime = this._req_time.get(ip) || now;
+	const count = this._req_count.get(ip) || 0;
 
-    if (now - lastTime < this._config.check_interval) {
-        // 在检查间隔内，计算实际频率
-        const elapsed = Math.max(1, now - lastTime); // 避免除零
-        return Math.round((count / elapsed) * this._config.check_interval);
-    } else {
-        // 超过检查间隔，频率为0
-        return 0;
-    }
+	if (now - lastTime < this._config.check_interval) {
+		// 在检查间隔内，计算实际频率
+		const elapsed = Math.max(1, now - lastTime); // 避免除零
+		return Math.round((count / elapsed) * this._config.check_interval);
+	} else {
+		// 超过检查间隔，频率为0
+		return 0;
+	}
 };
 
 /**
  * 获取所有IP的请求统计信息
  * @returns {Object} IP统计信息对象
  */
-Ip.prototype.getAllStats = function () {
-    const stats = {};
-    const now = Date.now();
+Ip.prototype.getAllStats = function() {
+	const stats = {};
+	const now = Date.now();
 
-    // 收集所有有请求记录的IP
-    for (const ip of this.getAllReqIps()) {
-        const lastTime = this._req_time.get(ip) || now;
-        const isActive = now - lastTime < this._config.check_interval;
+	// 收集所有有请求记录的IP
+	for (const ip of this.getAllReqIps()) {
+		const lastTime = this._req_time.get(ip) || now;
+		const isActive = now - lastTime < this._config.check_interval;
 
-        stats[ip] = {
-            count: this.getReqCount(ip),
-            rate: isActive ? this.getReqRate(ip) : 0,
-            last_time: lastTime,
-            is_white: this.isWhite(ip),
-            is_black: this.isBlack(ip),
-            black_time: this.getBlackExpireTime(ip)
-        };
-    }
+		stats[ip] = {
+			count: this.getReqCount(ip),
+			rate: isActive ? this.getReqRate(ip) : 0,
+			last_time: lastTime,
+			is_white: this.isWhite(ip),
+			is_black: this.isBlack(ip),
+			black_time: this.getBlackExpireTime(ip)
+		};
+	}
 
-    return stats;
+	return stats;
 };
 
 /**
  * 获取所有白名单IP
  * @returns {Array} 白名单IP数组
  */
-Ip.prototype.getAllWhite = function () {
-    return Array.from(this._white);
+Ip.prototype.getAllWhite = function() {
+	return Array.from(this._white);
 };
 
 /**
  * 获取所有黑名单IP
  * @returns {Array} 黑名单IP数组
  */
-Ip.prototype.getAllBlack = function () {
-    return Array.from(this._black);
+Ip.prototype.getAllBlack = function() {
+	return Array.from(this._black);
 };
 
 /**
  * 获取所有有请求记录的IP
  * @returns {Array} 有请求记录的IP数组
  */
-Ip.prototype.getAllReqIps = function () {
-    return Array.from(this._req_count.keys());
+Ip.prototype.getAllReqIps = function() {
+	return Array.from(this._req_count.keys());
 };
 
 /**
  * 清空白名单
  */
 Ip.prototype.clearWhite = function() {
-    this._white.clear();
-    this.logger('info', '清空白名单');
-    
-    // 自动保存到持久化存储
-    if (this._config.dir) {
-        this.save();
-    }
+	this._white.clear();
+	this.log('info', '清空白名单');
+
+	// 自动保存到持久化存储
+	if (this._config.dir) {
+		this.save();
+	}
 };
 
 /**
  * 清空黑名单
  */
 Ip.prototype.clearBlack = function() {
-    this._black.clear();
-    this.logger('info', '清空黑名单');
-    
-    // 自动保存到持久化存储
-    if (this._config.dir) {
-        this.save();
-    }
+	this._black.clear();
+	this.log('info', '清空黑名单');
+
+	// 自动保存到持久化存储
+	if (this._config.dir) {
+		this.save();
+	}
 };
 
 /**
  * 清空所有请求记录
  */
-Ip.prototype.clearReq = function () {
-    this._req_count.clear();
-    this._req_time.clear();
-    this.logger('info', '清空请求记录');
+Ip.prototype.clearReq = function() {
+	this._req_count.clear();
+	this._req_time.clear();
+	this.log('info', '清空请求记录');
 };
 
 /**
@@ -360,22 +372,22 @@ Ip.prototype.clearReq = function () {
  * @param {string} ip - IP地址
  * @returns {boolean} 是否允许请求
  */
-Ip.prototype._checkRateLimit = function (ip) {
-    const now = Date.now();
-    const lastTime = this._req_time.get(ip) || 0;
+Ip.prototype._checkRateLimit = function(ip) {
+	const now = Date.now();
+	const lastTime = this._req_time.get(ip) || 0;
 
-    // 检查时间间隔
-    if (now - lastTime < this._config.check_interval) {
-        const count = this.getReqCount(ip);
-        if (count >= this._config.max_req_per_min) {
-            return false;
-        }
-    } else {
-        // 重置计数
-        this._req_count.set(ip, 0);
-    }
+	// 检查时间间隔
+	if (now - lastTime < this._config.check_interval) {
+		const count = this.getReqCount(ip);
+		if (count >= this._config.max_req_per_min) {
+			return false;
+		}
+	} else {
+		// 重置计数
+		this._req_count.set(ip, 0);
+	}
 
-    return true;
+	return true;
 };
 
 /**
@@ -383,10 +395,10 @@ Ip.prototype._checkRateLimit = function (ip) {
  * @private
  * @param {string} ip - IP地址
  */
-Ip.prototype._updateReqCount = function (ip) {
-    const count = this.getReqCount(ip) + 1;
-    this._req_count.set(ip, count);
-    this._req_time.set(ip, Date.now());
+Ip.prototype._updateReqCount = function(ip) {
+	const count = this.getReqCount(ip) + 1;
+	this._req_count.set(ip, count);
+	this._req_time.set(ip, Date.now());
 };
 
 /**
@@ -395,9 +407,9 @@ Ip.prototype._updateReqCount = function (ip) {
  * @param {string} ip - IP地址
  * @returns {boolean} 是否有效IP
  */
-Ip.prototype._validIp = function (ip) {
-    const ipRegex = /^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$/;
-    return ipRegex.test(ip);
+Ip.prototype._validIp = function(ip) {
+	const ipRegex = /^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$/;
+	return ipRegex.test(ip);
 };
 
 /**
@@ -405,18 +417,18 @@ Ip.prototype._validIp = function (ip) {
  * @param {Array} ip_list - IP地址数组
  * @returns {number} 成功添加的数量
  */
-Ip.prototype.addWhiteBatch = function (ip_list) {
-    if (!Array.isArray(ip_list)) throw new TypeError('ip_list must be array');
+Ip.prototype.addWhiteBatch = function(ip_list) {
+	if (!Array.isArray(ip_list)) throw new TypeError('ip_list must be array');
 
-    let success = 0;
-    for (const ip of ip_list) {
-        if (typeof ip === 'string' && this._validIp(ip)) {
-            if (this.addWhite(ip)) {
-                success++;
-            }
-        }
-    }
-    return success;
+	let success = 0;
+	for (const ip of ip_list) {
+		if (typeof ip === 'string' && this._validIp(ip)) {
+			if (this.addWhite(ip)) {
+				success++;
+			}
+		}
+	}
+	return success;
 };
 
 /**
@@ -424,18 +436,18 @@ Ip.prototype.addWhiteBatch = function (ip_list) {
  * @param {Array} ip_list - IP地址数组
  * @returns {number} 成功添加的数量
  */
-Ip.prototype.addBlackBatch = function (ip_list) {
-    if (!Array.isArray(ip_list)) throw new TypeError('ip_list must be array');
+Ip.prototype.addBlackBatch = function(ip_list) {
+	if (!Array.isArray(ip_list)) throw new TypeError('ip_list must be array');
 
-    let success = 0;
-    for (const ip of ip_list) {
-        if (typeof ip === 'string' && this._validIp(ip)) {
-            if (this.addBlack(ip)) {
-                success++;
-            }
-        }
-    }
-    return success;
+	let success = 0;
+	for (const ip of ip_list) {
+		if (typeof ip === 'string' && this._validIp(ip)) {
+			if (this.addBlack(ip)) {
+				success++;
+			}
+		}
+	}
+	return success;
 };
 
 /**
@@ -445,41 +457,41 @@ Ip.prototype.addBlackBatch = function (ip_list) {
  * @returns {boolean} 是否拉黑成功
  * @throws {TypeError} 当IP非字符串时
  */
-Ip.prototype.blackByHighFreq = function (ip, duration) {
-    if (typeof ip !== 'string') throw new TypeError('ip must be string');
+Ip.prototype.blackByHighFreq = function(ip, duration) {
+	if (typeof ip !== 'string') throw new TypeError('ip must be string');
 
-    const black_duration = duration || this._config.auto_black_duration;
+	const black_duration = duration || this._config.auto_black_duration;
 
-    if (this.addBlack(ip)) {
-        this._black_time.set(ip, Date.now() + black_duration);
-        this.logger('warn', '手动高频拉黑IP:', ip, '持续时间:', black_duration + 'ms');
-        return true;
-    }
+	if (this.addBlack(ip)) {
+		this._black_time.set(ip, Date.now() + black_duration);
+		this.log('warn', '手动高频拉黑IP:', ip, '持续时间:', black_duration + 'ms');
+		return true;
+	}
 
-    return false;
+	return false;
 };
 
 /**
  * 检查并清理过期的黑名单IP（私有方法）
  * @private
  */
-Ip.prototype._cleanExpiredBlack = function () {
-    const now = Date.now();
-    const expired = [];
+Ip.prototype._cleanExpiredBlack = function() {
+	const now = Date.now();
+	const expired = [];
 
-    // 获取所有有过期时间的黑名单IP
-    for (const ip of this.getAllBlack()) {
-        const expireTime = this.getBlackExpireTime(ip);
-        if (expireTime && now > expireTime) {
-            expired.push(ip);
-        }
-    }
+	// 获取所有有过期时间的黑名单IP
+	for (const ip of this.getAllBlack()) {
+		const expireTime = this.getBlackExpireTime(ip);
+		if (expireTime && now > expireTime) {
+			expired.push(ip);
+		}
+	}
 
-    for (const ip of expired) {
-        this.delBlack(ip);
-        this._black_time.delete(ip);
-        this.logger('info', '清理过期黑名单IP:', ip);
-    }
+	for (const ip of expired) {
+		this.delBlack(ip);
+		this._black_time.delete(ip);
+		this.log('info', '清理过期黑名单IP:', ip);
+	}
 };
 
 /**
@@ -488,11 +500,11 @@ Ip.prototype._cleanExpiredBlack = function () {
  * @param {string} ip - IP地址
  * @returns {boolean} 是否过期
  */
-Ip.prototype._isBlackExpired = function (ip) {
-    const expireTime = this.getBlackExpireTime(ip);
-    if (!expireTime) return false; // 没有设置过期时间，永不过期
+Ip.prototype._isBlackExpired = function(ip) {
+	const expireTime = this.getBlackExpireTime(ip);
+	if (!expireTime) return false; // 没有设置过期时间，永不过期
 
-    return Date.now() > expireTime;
+	return Date.now() > expireTime;
 };
 
 /**
@@ -500,13 +512,13 @@ Ip.prototype._isBlackExpired = function (ip) {
  * @private
  * @param {string} ip - IP地址
  */
-Ip.prototype._autoBlack = function (ip) {
-    if (this.addBlack(ip)) {
-        this._black_time.set(ip, Date.now() + this._config.auto_black_duration);
-        this.logger('warn', '自动高频拉黑IP:', ip,
-            '频率:', this.getReqRate(ip) + '/分钟',
-            '持续时间:', this._config.auto_black_duration + 'ms');
-    }
+Ip.prototype._autoBlack = function(ip) {
+	if (this.addBlack(ip)) {
+		this._black_time.set(ip, Date.now() + this._config.auto_black_duration);
+		this.log('warn', '自动高频拉黑IP:', ip,
+			'频率:', this.getReqRate(ip) + '/分钟',
+			'持续时间:', this._config.auto_black_duration + 'ms');
+	}
 };
 
 /**
@@ -515,23 +527,23 @@ Ip.prototype._autoBlack = function (ip) {
  * @returns {number|null} 过期时间戳（毫秒），null表示永不过期
  * @throws {TypeError} 当IP非字符串时
  */
-Ip.prototype.getBlackExpireTime = function (ip) {
-    if (typeof ip !== 'string') throw new TypeError('ip must be string');
+Ip.prototype.getBlackExpireTime = function(ip) {
+	if (typeof ip !== 'string') throw new TypeError('ip must be string');
 
-    if (!this.isBlack(ip)) return null;
+	if (!this.isBlack(ip)) return null;
 
-    const expireTime = this._black_time.get(ip);
-    return expireTime || null;
+	const expireTime = this._black_time.get(ip);
+	return expireTime || null;
 };
 
 /**
  * 清理所有过期的黑名单IP
  * @returns {number} 清理的数量
  */
-Ip.prototype.cleanExpiredBlack = function () {
-    const beforeCount = this.getAllBlack().length;
-    this._cleanExpiredBlack();
-    return beforeCount - this.getAllBlack().length;
+Ip.prototype.cleanExpiredBlack = function() {
+	const beforeCount = this.getAllBlack().length;
+	this._cleanExpiredBlack();
+	return beforeCount - this.getAllBlack().length;
 };
 
 /**
@@ -541,26 +553,35 @@ Ip.prototype.cleanExpiredBlack = function () {
  * @returns {number} 当前违规次数
  */
 Ip.prototype.recordViolation = function(ip, reason) {
-    if (typeof ip !== 'string') throw new TypeError('ip must be string');
-    if (!this._config.violation_enable) return 0;
-    
-    this._cleanExpiredViolation();
-    
-    const now = Date.now();
-    const count = this.getViolationCount(ip) + 1;
-    
-    this._violation_count.set(ip, count);
-    this._violation_time.set(ip, now);
-    
-    this.logger('info', 'IP违规记录:', { ip, reason, count, time: new Date(now).toISOString() });
-    
-    // 检查是否达到自动拉黑条件
-    if (this._config.violation_auto_black && count >= this._config.violation_max_count) {
-        this.blackByHighFreq(ip, this._config.auto_black_duration);
-        this.logger('warn', 'IP因违规次数超限自动拉黑:', { ip, count, duration: this._config.auto_black_duration });
-    }
-    
-    return count;
+	if (typeof ip !== 'string') throw new TypeError('ip must be string');
+	if (!this._config.violation_enable) return 0;
+
+	this._cleanExpiredViolation();
+
+	const now = Date.now();
+	const count = this.getViolationCount(ip) + 1;
+
+	this._violation_count.set(ip, count);
+	this._violation_time.set(ip, now);
+
+	this.log('info', 'IP违规记录:', {
+		ip,
+		reason,
+		count,
+		time: new Date(now).toISOString()
+	});
+
+	// 检查是否达到自动拉黑条件
+	if (this._config.violation_auto_black && count >= this._config.violation_max_count) {
+		this.blackByHighFreq(ip, this._config.auto_black_duration);
+		this.log('warn', 'IP因违规次数超限自动拉黑:', {
+			ip,
+			count,
+			duration: this._config.auto_black_duration
+		});
+	}
+
+	return count;
 };
 
 /**
@@ -569,10 +590,10 @@ Ip.prototype.recordViolation = function(ip, reason) {
  * @returns {number} 违规次数
  */
 Ip.prototype.getViolationCount = function(ip) {
-    if (typeof ip !== 'string') throw new TypeError('ip must be string');
-    
-    this._cleanExpiredViolation();
-    return this._violation_count.get(ip) || 0;
+	if (typeof ip !== 'string') throw new TypeError('ip must be string');
+
+	this._cleanExpiredViolation();
+	return this._violation_count.get(ip) || 0;
 };
 
 /**
@@ -581,13 +602,13 @@ Ip.prototype.getViolationCount = function(ip) {
  * @returns {boolean} 是否成功重置
  */
 Ip.prototype.resetViolation = function(ip) {
-    if (typeof ip !== 'string') throw new TypeError('ip must be string');
-    
-    const hadRecord = this._violation_count.has(ip);
-    this._violation_count.delete(ip);
-    this._violation_time.delete(ip);
-    
-    return hadRecord;
+	if (typeof ip !== 'string') throw new TypeError('ip must be string');
+
+	const hadRecord = this._violation_count.has(ip);
+	this._violation_count.delete(ip);
+	this._violation_time.delete(ip);
+
+	return hadRecord;
 };
 
 /**
@@ -595,7 +616,7 @@ Ip.prototype.resetViolation = function(ip) {
  * @returns {Array} 有违规记录的IP数组
  */
 Ip.prototype.getAllViolationIps = function() {
-    return Array.from(this._violation_count.keys());
+	return Array.from(this._violation_count.keys());
 };
 
 /**
@@ -604,15 +625,15 @@ Ip.prototype.getAllViolationIps = function() {
  * @returns {Object|null} 违规信息
  */
 Ip.prototype.getViolationInfo = function(ip) {
-    if (typeof ip !== 'string') throw new TypeError('ip must be string');
-    
-    const count = this.getViolationCount(ip);
-    if (count === 0) return null;
-    
-    return {
-        count: count,
-        time: this._violation_time.get(ip)
-    };
+	if (typeof ip !== 'string') throw new TypeError('ip must be string');
+
+	const count = this.getViolationCount(ip);
+	if (count === 0) return null;
+
+	return {
+		count: count,
+		time: this._violation_time.get(ip)
+	};
 };
 
 /**
@@ -620,14 +641,14 @@ Ip.prototype.getViolationInfo = function(ip) {
  * @returns {Object} 违规统计信息
  */
 Ip.prototype.getAllViolations = function() {
-    this._cleanExpiredViolation();
-    
-    const violations = {};
-    for (const ip of this.getAllViolationIps()) {
-        violations[ip] = this.getViolationInfo(ip);
-    }
-    
-    return violations;
+	this._cleanExpiredViolation();
+
+	const violations = {};
+	for (const ip of this.getAllViolationIps()) {
+		violations[ip] = this.getViolationInfo(ip);
+	}
+
+	return violations;
 };
 
 /**
@@ -635,34 +656,34 @@ Ip.prototype.getAllViolations = function() {
  * @private
  */
 Ip.prototype._cleanExpiredViolation = function() {
-    const now = Date.now();
-    const expired = [];
+	const now = Date.now();
+	const expired = [];
 
-    // 直接访问内部数据结构避免递归调用
-    for (const [ip, time] of this._violation_time) {
-        if (now - time > this._config.violation_reset_time) {
-            expired.push(ip);
-        }
-    }
+	// 直接访问内部数据结构避免递归调用
+	for (const [ip, time] of this._violation_time) {
+		if (now - time > this._config.violation_reset_time) {
+			expired.push(ip);
+		}
+	}
 
-    for (const ip of expired) {
-        this._violation_count.delete(ip);
-        this._violation_time.delete(ip);
-    }
+	for (const ip of expired) {
+		this._violation_count.delete(ip);
+		this._violation_time.delete(ip);
+	}
 };
 
 /**
  * 清空所有违规记录
  */
 Ip.prototype.clearViolations = function() {
-    this._violation_count.clear();
-    this._violation_time.clear();
-    this.logger('info', '清空所有违规记录');
-    
-    // 自动保存到持久化存储
-    if (this._config.dir) {
-        this.save();
-    }
+	this._violation_count.clear();
+	this._violation_time.clear();
+	this.log('info', '清空所有违规记录');
+
+	// 自动保存到持久化存储
+	if (this._config.dir) {
+		this.save();
+	}
 };
 
 /**
@@ -670,53 +691,53 @@ Ip.prototype.clearViolations = function() {
  * @returns {boolean} 是否保存成功
  */
 Ip.prototype.save = function() {
-    try {
-        const fs = require('fs');
-        const path = require('path');
-        
-        // 确保存储目录存在
-        const dir = this._config.dir;
-        dir.addDir();
-        
-        // 分别保存不同数据到不同文件
-        const timestamp = Date.now();
-        
-        // 保存白名单数据
-        const whiteData = {
-            white: this.getAllWhite(),
-            timestamp: timestamp
-        };
-        const whitePath = path.join(dir, 'white.json');
-        fs.writeFileSync(whitePath, JSON.stringify(whiteData, null, 2), 'utf8');
-        
-        // 保存黑名单数据
-        const blackData = {
-            black: this.getAllBlack(),
-            black_time: Array.from(this._black_time.entries()),
-            timestamp: timestamp
-        };
-        const blackPath = path.join(dir, 'black.json');
-        fs.writeFileSync(blackPath, JSON.stringify(blackData, null, 2), 'utf8');
-        
-        // 保存违规记录数据
-        const violationData = {
-            violation_count: Array.from(this._violation_count.entries()),
-            violation_time: Array.from(this._violation_time.entries()),
-            timestamp: timestamp
-        };
-        const violationPath = path.join(dir, 'violation.json');
-        fs.writeFileSync(violationPath, JSON.stringify(violationData, null, 2), 'utf8');
-        
-        this.logger('info', 'IP数据已分文件保存:', {
-            white: whitePath,
-            black: blackPath,
-            violation: violationPath
-        });
-        return true;
-    } catch (err) {
-        this.logger('error', '保存IP数据失败:', err.message);
-        return false;
-    }
+	try {
+		const fs = require('fs');
+		const path = require('path');
+
+		// 确保存储目录存在
+		const dir = this._config.dir;
+		dir.addDir();
+
+		// 分别保存不同数据到不同文件
+		const timestamp = Date.now();
+
+		// 保存白名单数据
+		const whiteData = {
+			white: this.getAllWhite(),
+			timestamp: timestamp
+		};
+		const whitePath = path.join(dir, 'white.json');
+		fs.writeFileSync(whitePath, JSON.stringify(whiteData, null, 2), 'utf8');
+
+		// 保存黑名单数据
+		const blackData = {
+			black: this.getAllBlack(),
+			black_time: Array.from(this._black_time.entries()),
+			timestamp: timestamp
+		};
+		const blackPath = path.join(dir, 'black.json');
+		fs.writeFileSync(blackPath, JSON.stringify(blackData, null, 2), 'utf8');
+
+		// 保存违规记录数据
+		const violationData = {
+			violation_count: Array.from(this._violation_count.entries()),
+			violation_time: Array.from(this._violation_time.entries()),
+			timestamp: timestamp
+		};
+		const violationPath = path.join(dir, 'violation.json');
+		fs.writeFileSync(violationPath, JSON.stringify(violationData, null, 2), 'utf8');
+
+		this.log('info', 'IP数据已分文件保存:', {
+			white: whitePath,
+			black: blackPath,
+			violation: violationPath
+		});
+		return true;
+	} catch (err) {
+		this.log('error', '保存IP数据失败:', err.message);
+		return false;
+	}
 };
 
 /**
@@ -724,101 +745,101 @@ Ip.prototype.save = function() {
  * @returns {boolean} 是否加载成功
  */
 Ip.prototype.load = function() {
-    try {
-        const fs = require('fs');
-        const path = require('path');
-        
-        const dir = this._config.dir;
-        let loadedCount = 0;
-        
-        // 加载白名单数据
-        const whitePath = path.join(dir, 'white.json');
-        if (fs.existsSync(whitePath)) {
-            const content = fs.readFileSync(whitePath, 'utf8');
-            const data = JSON.parse(content);
-            
-            if (Array.isArray(data.white)) {
-                for (const ip of data.white) {
-                    if (typeof ip === 'string') {
-                        this._white.add(ip);
-                    }
-                }
-                loadedCount++;
-                this.logger('info', '白名单数据已加载:', whitePath);
-            }
-        }
-        
-        // 加载黑名单数据
-        const blackPath = path.join(dir, 'black.json');
-        if (fs.existsSync(blackPath)) {
-            const content = fs.readFileSync(blackPath, 'utf8');
-            const data = JSON.parse(content);
-            
-            // 加载黑名单
-            if (Array.isArray(data.black)) {
-                for (const ip of data.black) {
-                    if (typeof ip === 'string') {
-                        this._black.add(ip);
-                    }
-                }
-            }
-            
-            // 加载黑名单过期时间
-            if (Array.isArray(data.black_time)) {
-                for (const [ip, time] of data.black_time) {
-                    if (typeof ip === 'string' && typeof time === 'number') {
-                        this._black_time.set(ip, time);
-                    }
-                }
-            }
-            
-            loadedCount++;
-            this.logger('info', '黑名单数据已加载:', blackPath);
-        }
-        
-        // 加载违规记录数据
-        const violationPath = path.join(dir, 'violation.json');
-        if (fs.existsSync(violationPath)) {
-            const content = fs.readFileSync(violationPath, 'utf8');
-            const data = JSON.parse(content);
-            
-            // 加载违规记录
-            if (Array.isArray(data.violation_count)) {
-                for (const [ip, count] of data.violation_count) {
-                    if (typeof ip === 'string' && typeof count === 'number') {
-                        this._violation_count.set(ip, count);
-                    }
-                }
-            }
-            
-            if (Array.isArray(data.violation_time)) {
-                for (const [ip, time] of data.violation_time) {
-                    if (typeof ip === 'string' && typeof time === 'number') {
-                        this._violation_time.set(ip, time);
-                    }
-                }
-            }
-            
-            loadedCount++;
-            this.logger('info', '违规记录数据已加载:', violationPath);
-        }
-        
-        if (loadedCount === 0) {
-            this.logger('info', '未找到任何IP数据文件，跳过加载');
-        } else {
-            this.logger('info', 'IP数据加载完成，统计:', {
-                white_count: this.getAllWhite().length,
-                black_count: this.getAllBlack().length,
-                violation_count: this.getAllViolationIps().length,
-                files_loaded: loadedCount
-            });
-        }
-        
-        return true;
-    } catch (err) {
-        this.logger('error', '加载IP数据失败:', err.message);
-        return false;
-    }
+	try {
+		const fs = require('fs');
+		const path = require('path');
+
+		const dir = this._config.dir;
+		let loadedCount = 0;
+
+		// 加载白名单数据
+		const whitePath = path.join(dir, 'white.json');
+		if (fs.existsSync(whitePath)) {
+			const content = fs.readFileSync(whitePath, 'utf8');
+			const data = JSON.parse(content);
+
+			if (Array.isArray(data.white)) {
+				for (const ip of data.white) {
+					if (typeof ip === 'string') {
+						this._white.add(ip);
+					}
+				}
+				loadedCount++;
+				this.log('info', '白名单数据已加载:', whitePath);
+			}
+		}
+
+		// 加载黑名单数据
+		const blackPath = path.join(dir, 'black.json');
+		if (fs.existsSync(blackPath)) {
+			const content = fs.readFileSync(blackPath, 'utf8');
+			const data = JSON.parse(content);
+
+			// 加载黑名单
+			if (Array.isArray(data.black)) {
+				for (const ip of data.black) {
+					if (typeof ip === 'string') {
+						this._black.add(ip);
+					}
+				}
+			}
+
+			// 加载黑名单过期时间
+			if (Array.isArray(data.black_time)) {
+				for (const [ip, time] of data.black_time) {
+					if (typeof ip === 'string' && typeof time === 'number') {
+						this._black_time.set(ip, time);
+					}
+				}
+			}
+
+			loadedCount++;
+			this.log('info', '黑名单数据已加载:', blackPath);
+		}
+
+		// 加载违规记录数据
+		const violationPath = path.join(dir, 'violation.json');
+		if (fs.existsSync(violationPath)) {
+			const content = fs.readFileSync(violationPath, 'utf8');
+			const data = JSON.parse(content);
+
+			// 加载违规记录
+			if (Array.isArray(data.violation_count)) {
+				for (const [ip, count] of data.violation_count) {
+					if (typeof ip === 'string' && typeof count === 'number') {
+						this._violation_count.set(ip, count);
+					}
+				}
+			}
+
+			if (Array.isArray(data.violation_time)) {
+				for (const [ip, time] of data.violation_time) {
+					if (typeof ip === 'string' && typeof time === 'number') {
+						this._violation_time.set(ip, time);
+					}
+				}
+			}
+
+			loadedCount++;
+			this.log('info', '违规记录数据已加载:', violationPath);
+		}
+
+		if (loadedCount === 0) {
+			this.log('info', '未找到任何IP数据文件，跳过加载');
+		} else {
+			this.log('info', 'IP数据加载完成，统计:', {
+				white_count: this.getAllWhite().length,
+				black_count: this.getAllBlack().length,
+				violation_count: this.getAllViolationIps().length,
+				files_loaded: loadedCount
+			});
+		}
+
+		return true;
+	} catch (err) {
+		this.log('error', '加载IP数据失败:', err.message);
+		return false;
+	}
 };
 
 /**
@@ -826,26 +847,26 @@ Ip.prototype.load = function() {
  * @param {number} interval - 保存间隔（毫秒），默认5分钟
  */
 Ip.prototype.autoSave = function(interval = 300000) {
-    if (this._autoSaveTimer) {
-        clearInterval(this._autoSaveTimer);
-    }
-    
-    this._autoSaveTimer = setInterval(() => {
-        this.save();
-    }, interval);
-    
-    this.logger('info', '自动保存已启动，间隔:', interval, 'ms');
+	if (this._autoSaveTimer) {
+		clearInterval(this._autoSaveTimer);
+	}
+
+	this._autoSaveTimer = setInterval(() => {
+		this.save();
+	}, interval);
+
+	this.log('info', '自动保存已启动，间隔:', interval, 'ms');
 };
 
 /**
  * 停止自动保存
  */
 Ip.prototype.stopAutoSave = function() {
-    if (this._autoSaveTimer) {
-        clearInterval(this._autoSaveTimer);
-        this._autoSaveTimer = null;
-        this.logger('info', '自动保存已停止');
-    }
+	if (this._autoSaveTimer) {
+		clearInterval(this._autoSaveTimer);
+		this._autoSaveTimer = null;
+		this.log('info', '自动保存已停止');
+	}
 };
 
 /**
@@ -855,61 +876,66 @@ Ip.prototype.stopAutoSave = function() {
  * @throws {TypeError} 当IP非字符串时
  */
 Ip.prototype.del = function(ip) {
-    if (typeof ip !== 'string') throw new TypeError('ip must be string');
-    
-    const result = {
-        black: false,
-        white: false,
-        violation: false,
-        black_time: false,
-        violation_count: false,
-        violation_time: false
-    };
-    
-    // 从黑名单删除
-    if (this._black.has(ip)) {
-        this._black.delete(ip);
-        result.black = true;
-    }
-    
-    // 从白名单删除
-    if (this._white.has(ip)) {
-        this._white.delete(ip);
-        result.white = true;
-    }
-    
-    // 从违规记录删除
-    if (this._violation_count.has(ip)) {
-        this._violation_count.delete(ip);
-        result.violation_count = true;
-    }
-    
-    if (this._violation_time.has(ip)) {
-        this._violation_time.delete(ip);
-        result.violation_time = true;
-    }
-    
-    // 从黑名单过期时间记录删除
-    if (this._black_time.has(ip)) {
-        this._black_time.delete(ip);
-        result.black_time = true;
-    }
-    
-    // 如果有任何删除操作，记录日志并自动保存
-    if (Object.values(result).some(Boolean)) {
-        this.logger('info', '删除IP记录:', { ip, result });
-        
-        // 自动保存到持久化存储
-        if (this._config.dir) {
-            this.save();
-        }
-    }
-    
-    return result;
+	if (typeof ip !== 'string') throw new TypeError('ip must be string');
+
+	const result = {
+		black: false,
+		white: false,
+		violation: false,
+		black_time: false,
+		violation_count: false,
+		violation_time: false
+	};
+
+	// 从黑名单删除
+	if (this._black.has(ip)) {
+		this._black.delete(ip);
+		result.black = true;
+	}
+
+	// 从白名单删除
+	if (this._white.has(ip)) {
+		this._white.delete(ip);
+		result.white = true;
+	}
+
+	// 从违规记录删除
+	if (this._violation_count.has(ip)) {
+		this._violation_count.delete(ip);
+		result.violation_count = true;
+	}
+
+	if (this._violation_time.has(ip)) {
+		this._violation_time.delete(ip);
+		result.violation_time = true;
+	}
+
+	// 从黑名单过期时间记录删除
+	if (this._black_time.has(ip)) {
+		this._black_time.delete(ip);
+		result.black_time = true;
+	}
+
+	// 如果有任何删除操作，记录日志并自动保存
+	if (Object.values(result).some(Boolean)) {
+		this.log('info', '删除IP记录:', {
+			ip,
+			result
+		});
+
+		// 自动保存到持久化存储
+		if (this._config.dir) {
+			this.save();
+		}
+	}
+
+	return result;
 };
 
 if (global.$ && !$.ip) {
-    $.ip = new Ip();
+	$.ip = new Ip();
 }
 
-module.exports = { Ip };
+module.exports = {
+	Ip
+};