node-karin 1.15.5 → 1.16.1

package/dist/redis-aLJ7wbJH.mjs

@@ -0,0 +1,1556 @@
+import { t as __exportAll } from "./chunk-NzVPYdc1.mjs";
+import { redisSqlite3Path } from "./root.mjs";
+import { Ir as diffSimpleArray, Mi as isWin, n as redis$1 } from "./file-ZGuqNDd-.mjs";
+import { f as exec } from "./uptime-C121X_rq.mjs";
+import { t as SQLiteWrapper } from "./sqlite-Dcj9jlW9.mjs";
+import path from "node:path";
+import lodash from "lodash";
+import { EventEmitter } from "node:events";
+import os from "node:os";
+import moment from "moment";
+import { createClient } from "redis";
+
+//#region src/core/db/redis/mock/index.ts
+/**
+* @description 轻量化的 Redis 客户端 仅支持部分命令
+* @class RedisClient
+*/
+var RedisClient = class extends EventEmitter {
+	id;
+	/** 键、类型、过期时间映射 */
+	store = {};
+	/** 键值对 */
+	#str = {};
+	/** 数字对 */
+	#num = {};
+	/** 哈希表 */
+	#hash = {};
+	/** 列表 */
+	#list = {};
+	/** 集合 */
+	#set = {};
+	/** 有序集合 */
+	#zset = {};
+	/** HyperLogLog */
+	#pf = {};
+	/** 位图 */
+	#bit = {};
+	/** sqlite3 */
+	#sqlite;
+	constructor(sqlite) {
+		super();
+		this.id = "mock";
+		this.store = {};
+		this.#str = {};
+		this.#num = {};
+		this.#hash = {};
+		this.#list = {};
+		this.#set = {};
+		this.#zset = {};
+		this.#pf = {};
+		this.#bit = {};
+		this.#sqlite = sqlite;
+	}
+	async init() {
+		await this.loadData();
+		/** 每30秒检查过期 */
+		setInterval(() => {
+			Object.keys(this.store).forEach((key) => this.checkExpire(key));
+		}, 3e4);
+		/** 每5分钟存一次sqlite */
+		setInterval(() => this.save(), 300 * 1e3);
+		return this;
+	}
+	/**
+	* @description 加载数据
+	*/
+	async loadData() {
+		const list = await this.#sqlite.getAllData();
+		const keyMap = {
+			["str"]: (key, value) => {
+				this.#str[key] = value;
+			},
+			["num"]: (key, value) => {
+				this.#num[key] = Number(value);
+			},
+			["hash"]: (key, value) => {
+				const hash = JSON.parse(value);
+				for (const field in hash) if (typeof hash[field] !== "string") hash[field] = Buffer.from(hash[field]);
+				this.#hash[key] = hash;
+			},
+			["list"]: (key, value) => {
+				this.#list[key] = JSON.parse(value);
+			},
+			["set"]: (key, value) => {
+				this.#set[key] = new Set(JSON.parse(value));
+			},
+			["zset"]: (key, value) => {
+				this.#zset[key] = JSON.parse(value);
+			},
+			["pf"]: (key, value) => {
+				this.#pf[key] = new Set(JSON.parse(value));
+			},
+			["bit"]: (key, value) => {
+				this.#bit[key] = Buffer.from(value);
+			}
+		};
+		const isKey = (type) => {
+			return keyMap[type] !== void 0;
+		};
+		list.forEach((item) => {
+			const { key, type, expire, value } = item;
+			if (isKey(type)) {
+				this.store[key] = {
+					type,
+					expire
+				};
+				keyMap[type](key, value);
+			} else this.#sqlite.del(key);
+		});
+		logger.debug(`[Redis-mock] 加载数据完成: ${list.length}`);
+	}
+	/**
+	* @description 检查过期
+	* @param key 键
+	* @param isRemove 是否删除 默认删除
+	* @returns 是否过期或值
+	*/
+	checkExpire(key, isRemove = true) {
+		if (!this.store[key]) return false;
+		if (this.store[key].expire !== -1 && this.store[key].expire < moment().valueOf()) {
+			if (!isRemove) return true;
+			this.#del(key);
+			return true;
+		}
+		return false;
+	}
+	/**
+	* @description 直接删除键 不检查是否存在
+	* @param key 键
+	*/
+	#del(key) {
+		const { type } = this.store[key];
+		delete this.store[key];
+		switch (type) {
+			case "str":
+				delete this.#str[key];
+				break;
+			case "num":
+				delete this.#num[key];
+				break;
+			case "hash":
+				delete this.#hash[key];
+				break;
+			case "list":
+				delete this.#list[key];
+				break;
+			case "set":
+				delete this.#set[key];
+				break;
+			case "zset":
+				delete this.#zset[key];
+				break;
+			case "pf":
+				delete this.#pf[key];
+				break;
+			case "bit":
+				delete this.#bit[key];
+				break;
+		}
+		this.#sqlite.del(key);
+		logger.trace(`[Redis-mock] 删除键 ${key}`);
+	}
+	/**
+	* @description 获取键的类型
+	* @param key 键
+	* @returns 键的类型
+	*/
+	type(key) {
+		return this.store[key]?.type;
+	}
+	/**
+	* @description 存储键值对
+	* @param key 键
+	* @param value 值
+	* @param options 其他参数
+	*/
+	async set(key, value, options = {}) {
+		let expire = -1;
+		if (!Buffer.isBuffer(value) && typeof value !== "string") value = String(value);
+		else if (Buffer.isBuffer(value)) value = value.toString();
+		/** 参数3如果为空直接保存即可 */
+		if (lodash.isEmpty(options)) {
+			this.store[key] = {
+				type: "str",
+				expire
+			};
+			this.#str[key] = value;
+			this.#sqlite.set(key, value, "str", expire);
+			return "OK";
+		}
+		/** EX */
+		if (options?.EX !== void 0) {
+			const EX = Number(options.EX);
+			if (!isNaN(EX)) expire = moment().add(EX, "seconds").valueOf();
+			this.store[key] = {
+				type: "str",
+				expire
+			};
+			this.#str[key] = value;
+		} else if (options?.PX !== void 0) {
+			const PX = Number(options.PX);
+			if (!isNaN(PX)) expire = moment().add(PX, "milliseconds").valueOf();
+			this.store[key] = {
+				type: "str",
+				expire
+			};
+			this.#str[key] = value;
+		} else if (options?.EXAT !== void 0) {
+			const EXAT = Number(options.EXAT);
+			if (!isNaN(EXAT)) expire = EXAT;
+			this.store[key] = {
+				type: "str",
+				expire
+			};
+			this.#str[key] = value;
+		} else if (options?.PXAT !== void 0) {
+			const PXAT = Number(options.PXAT);
+			if (!isNaN(PXAT)) expire = PXAT;
+			this.store[key] = {
+				type: "str",
+				expire
+			};
+			this.#str[key] = value;
+		} else if (options?.KEEPTTL) if (this.#str[key] && this.store[key]) {
+			this.#str[key] = value;
+			expire = this.store[key].expire;
+		} else {
+			this.store[key] = {
+				type: "str",
+				expire: -1
+			};
+			this.#str[key] = value;
+			expire = -1;
+		}
+		else if (options?.NX) {
+			if (!this.store[key] || this.checkExpire(key, false)) {
+				this.store[key] = {
+					type: "str",
+					expire: -1
+				};
+				this.#str[key] = value;
+				this.#sqlite.set(key, value, "str", -1);
+			}
+			return "OK";
+		} else if (options?.XX) if (this.store[key]) {
+			const currentExpire = this.store[key].expire;
+			const oldType = this.store[key].type;
+			if (oldType !== "str") switch (oldType) {
+				case "num":
+					delete this.#num[key];
+					break;
+				case "hash":
+					delete this.#hash[key];
+					break;
+				case "list":
+					delete this.#list[key];
+					break;
+				case "set":
+					delete this.#set[key];
+					break;
+				case "zset":
+					delete this.#zset[key];
+					break;
+				case "pf":
+					delete this.#pf[key];
+					break;
+				case "bit":
+					delete this.#bit[key];
+					break;
+			}
+			this.store[key] = {
+				type: "str",
+				expire: currentExpire
+			};
+			this.#str[key] = value;
+			this.#sqlite.set(key, value, "str", currentExpire);
+			return "OK";
+		} else return null;
+		else if (options?.GET) {
+			this.store[key] = {
+				type: "str",
+				expire: -1
+			};
+			if (this.#str[key]) {
+				const oldValue = this.#str[key];
+				this.#str[key] = value;
+				this.#sqlite.set(key, value, "str", expire);
+				return oldValue;
+			}
+			this.#str[key] = value;
+			this.#sqlite.set(key, value, "str", expire);
+			return null;
+		} else {
+			this.store[key] = {
+				type: "str",
+				expire: -1
+			};
+			this.#str[key] = value;
+		}
+		this.#sqlite.set(key, value, "str", expire);
+		return "OK";
+	}
+	/**
+	* @description 获取键值
+	* @param key 键
+	*/
+	async get(key) {
+		if (!this.store[key]) return null;
+		/** 检查过期 */
+		if (this.checkExpire(key)) return null;
+		const { type } = this.store[key];
+		if (type === "num") return String(this.#num[key]);
+		else return this.#str[key].toString();
+	}
+	/**
+	* @description 设置键值对并指定过期时间（秒）
+	* @param key 键
+	* @param seconds 过期时间（秒）
+	* @param value 值
+	*/
+	async setEx(key, seconds, value) {
+		return await this.set(key, value, { EX: seconds });
+	}
+	/**
+	* @description 设置键值对并指定过期时间（毫秒）
+	* @param key 键
+	* @param milliseconds 过期时间（毫秒）
+	* @param value 值
+	*/
+	async pSetEx(key, milliseconds, value) {
+		return await this.set(key, value, { PX: milliseconds });
+	}
+	/**
+	* @description 仅当键不存在时设置键值对
+	* @param key 键
+	* @param value 值
+	* @returns 返回 1 表示键已设置，0 表示键已存在
+	*/
+	async setNX(key, value) {
+		if (this.store[key] && !this.checkExpire(key)) return 0;
+		await this.set(key, value, { NX: true });
+		return 1;
+	}
+	/**
+	* @description 获取键值并设置过期时间
+	* @param key 键
+	* @param options 过期时间选项（EX: 秒, PX: 毫秒, EXAT: 秒级时间戳, PXAT: 毫秒级时间戳）
+	*/
+	async getEx(key, options) {
+		const value = await this.get(key);
+		if (value === null) return null;
+		if (options?.PERSIST) {
+			if (this.store[key]) {
+				this.store[key].expire = -1;
+				const { type } = this.store[key];
+				const currentValue = this.getValueStringByKey(key);
+				this.#sqlite.set(key, currentValue, type, -1);
+			}
+		} else if (options?.EX !== void 0) await this.expire(key, options.EX);
+		else if (options?.PX !== void 0) {
+			const expire = moment().add(options.PX, "milliseconds").valueOf();
+			this.store[key].expire = expire;
+			const { type } = this.store[key];
+			const currentValue = this.getValueStringByKey(key);
+			this.#sqlite.set(key, currentValue, type, expire);
+		} else if (options?.EXAT !== void 0) {
+			this.store[key].expire = options.EXAT * 1e3;
+			const { type } = this.store[key];
+			const currentValue = this.getValueStringByKey(key);
+			this.#sqlite.set(key, currentValue, type, options.EXAT * 1e3);
+		} else if (options?.PXAT !== void 0) {
+			this.store[key].expire = options.PXAT;
+			const { type } = this.store[key];
+			const currentValue = this.getValueStringByKey(key);
+			this.#sqlite.set(key, currentValue, type, options.PXAT);
+		}
+		return value;
+	}
+	/**
+	* @description 获取键值并删除键
+	* @param key 键
+	*/
+	async getDel(key) {
+		const value = await this.get(key);
+		if (value !== null) await this.del(key);
+		return value;
+	}
+	/**
+	* @description 删除键
+	* @param key 键
+	*/
+	async del(key) {
+		if (!this.store[key]) return 0;
+		this.#del(key);
+		return 1;
+	}
+	/**
+	* @description 检查键是否存在
+	* @param key 键
+	*/
+	async exists(key) {
+		if (!this.store[key]) return 0;
+		if (this.checkExpire(key)) return 0;
+		return 1;
+	}
+	/**
+	* @description 设置键的过期时间
+	* @param key 键
+	* @param seconds 过期时间（秒）
+	*/
+	async expire(key, seconds) {
+		if (!this.store[key]) return 0;
+		const expire = moment().add(seconds, "seconds").valueOf();
+		this.store[key].expire = expire;
+		this.#sqlite.expire(key, expire);
+		return 1;
+	}
+	/**
+	* @description 设置键的过期时间戳（秒）
+	* @param key 键
+	* @param timestamp 过期时间戳（秒）
+	*/
+	async expireAt(key, timestamp) {
+		if (!this.store[key]) return 0;
+		this.store[key].expire = timestamp * 1e3;
+		this.#sqlite.expire(key, timestamp * 1e3);
+		return 1;
+	}
+	/**
+	* @description 设置键的过期时间（毫秒）
+	* @param key 键
+	* @param milliseconds 过期时间（毫秒）
+	*/
+	async pExpire(key, milliseconds) {
+		if (!this.store[key]) return 0;
+		const expire = moment().add(milliseconds, "milliseconds").valueOf();
+		this.store[key].expire = expire;
+		this.#sqlite.expire(key, expire);
+		return 1;
+	}
+	/**
+	* @description 设置键的过期时间戳（毫秒）
+	* @param key 键
+	* @param timestamp 过期时间戳（毫秒）
+	*/
+	async pExpireAt(key, timestamp) {
+		if (!this.store[key]) return 0;
+		this.store[key].expire = timestamp;
+		this.#sqlite.expire(key, timestamp);
+		return 1;
+	}
+	/**
+	* @description 移除键的过期时间
+	* @param key 键
+	*/
+	async persist(key) {
+		if (!this.store[key]) return 0;
+		if (this.store[key].expire === -1) return 0;
+		this.store[key].expire = -1;
+		const { type } = this.store[key];
+		const currentValue = this.getValueStringByKey(key);
+		this.#sqlite.set(key, currentValue, type, -1);
+		return 1;
+	}
+	/**
+	* @description 获取键的过期时间
+	* @param key 键
+	*/
+	async ttl(key) {
+		if (!this.store[key]) return -2;
+		if (this.store[key].expire === -1) return -1;
+		if (this.checkExpire(key)) return -2;
+		return moment(this.store[key].expire).diff(moment(), "seconds");
+	}
+	/**
+	* @description 获取键的过期时间（毫秒）
+	* @param key 键
+	*/
+	async pTTL(key) {
+		if (!this.store[key]) return -2;
+		if (this.store[key].expire === -1) return -1;
+		if (this.checkExpire(key)) return -2;
+		return moment(this.store[key].expire).diff(moment(), "milliseconds");
+	}
+	/**
+	* @description 获取字符串长度
+	* @param key 键
+	*/
+	async strLen(key) {
+		if (!this.store[key]) return 0;
+		if (this.checkExpire(key)) return 0;
+		const { type } = this.store[key];
+		if (type === "str") return this.#str[key].length;
+		return 0;
+	}
+	/**
+	* @description 重命名键
+	* @param key 原键名
+	* @param newKey 新键名
+	*/
+	async rename(key, newKey) {
+		if (!this.store[key]) throw new Error("no such key");
+		const { type, expire } = this.store[key];
+		const value = this.getValueStringByKey(key);
+		this.#del(key);
+		this.store[newKey] = {
+			type,
+			expire
+		};
+		switch (type) {
+			case "str":
+				this.#str[newKey] = value;
+				break;
+			case "num":
+				this.#num[newKey] = Number(value);
+				break;
+			case "hash":
+				this.#hash[newKey] = JSON.parse(value);
+				break;
+			case "list":
+				this.#list[newKey] = JSON.parse(value);
+				break;
+			case "set":
+				this.#set[newKey] = new Set(JSON.parse(value));
+				break;
+			case "zset":
+				this.#zset[newKey] = JSON.parse(value);
+				break;
+			case "pf":
+				this.#pf[newKey] = new Set(JSON.parse(value));
+				break;
+			case "bit":
+				this.#bit[newKey] = Buffer.from(value, "base64");
+				break;
+		}
+		this.#sqlite.set(newKey, value, type, expire);
+		return "OK";
+	}
+	/**
+	* @description 仅当新键不存在时重命名键
+	* @param key 原键名
+	* @param newKey 新键名
+	*/
+	async renameNX(key, newKey) {
+		if (!this.store[key]) return 0;
+		if (this.store[newKey] && !this.checkExpire(newKey)) return 0;
+		await this.rename(key, newKey);
+		return 1;
+	}
+	/**
+	* @description 返回数据库中键的数量
+	*/
+	async dbSize() {
+		Object.keys(this.store).forEach((key) => this.checkExpire(key));
+		return Object.keys(this.store).length;
+	}
+	/**
+	* @description 从数据库中随机返回一个键
+	*/
+	async randomKey() {
+		const keys = Object.keys(this.store);
+		if (keys.length === 0) return null;
+		keys.forEach((key) => this.checkExpire(key));
+		const validKeys = Object.keys(this.store);
+		if (validKeys.length === 0) return null;
+		return validKeys[Math.floor(Math.random() * validKeys.length)];
+	}
+	/**
+	* @description 获取所有键
+	* @param pattern 匹配规则
+	*/
+	async keys(pattern) {
+		const reg = new RegExp(pattern.replace(/\*/g, ".*"));
+		const keys = Object.keys(this.store);
+		const result = [];
+		await Promise.all(keys.map(async (key) => {
+			if (this.checkExpire(key)) return;
+			if (reg.test(key)) result.push(key);
+		}));
+		return result;
+	}
+	/**
+	* @description 清空所有键
+	*/
+	async flushAll() {
+		this.#str = {};
+		this.#num = {};
+		this.#hash = {};
+		this.#list = {};
+		this.#set = {};
+		this.#zset = {};
+		this.#pf = {};
+		this.#bit = {};
+		this.store = {};
+		return "OK";
+	}
+	/**
+	* @description 自增
+	* @param key 键
+	*/
+	async incr(key) {
+		if (!this.#num[key]) {
+			this.#num[key] = 0;
+			this.store[key] = {
+				type: "num",
+				expire: -1
+			};
+		} else if (this.checkExpire(key, false)) {
+			this.store[key].expire = -1;
+			this.#num[key] = 0;
+		}
+		this.#num[key] += 1;
+		this.#sqlite.set(key, String(this.#num[key]), "num", this.store[key].expire);
+		return this.#num[key];
+	}
+	/**
+	* @description 自增指定值
+	* @param key 键
+	* @param increment 增量
+	*/
+	async incrBy(key, increment) {
+		if (!this.#num[key]) {
+			this.#num[key] = 0;
+			this.store[key] = {
+				type: "num",
+				expire: -1
+			};
+		} else if (this.checkExpire(key, false)) {
+			this.store[key].expire = -1;
+			this.#num[key] = 0;
+		}
+		this.#num[key] += increment;
+		this.#sqlite.set(key, String(this.#num[key]), "num", this.store[key].expire);
+		return this.#num[key];
+	}
+	/**
+	* @description 自增指定浮点值
+	* @param key 键
+	* @param increment 增量（浮点数）
+	*/
+	async incrByFloat(key, increment) {
+		if (!this.#num[key]) {
+			this.#num[key] = 0;
+			this.store[key] = {
+				type: "num",
+				expire: -1
+			};
+		} else if (this.checkExpire(key, false)) {
+			this.store[key].expire = -1;
+			this.#num[key] = 0;
+		}
+		this.#num[key] += increment;
+		this.#sqlite.set(key, String(this.#num[key]), "num", this.store[key].expire);
+		return this.#num[key];
+	}
+	/**
+	* @description 自减
+	* @param key 键
+	*/
+	async decr(key) {
+		if (!this.#num[key]) {
+			this.#num[key] = 0;
+			this.store[key] = {
+				type: "num",
+				expire: -1
+			};
+		} else if (this.checkExpire(key, false)) {
+			this.store[key].expire = -1;
+			this.#num[key] = 0;
+		}
+		this.#num[key] -= 1;
+		this.#sqlite.set(key, String(this.#num[key]), "num", this.store[key].expire);
+		return this.#num[key];
+	}
+	/**
+	* @description 自减指定值
+	* @param key 键
+	* @param decrement 减量
+	*/
+	async decrBy(key, decrement) {
+		if (!this.#num[key]) {
+			this.#num[key] = 0;
+			this.store[key] = {
+				type: "num",
+				expire: -1
+			};
+		} else if (this.checkExpire(key, false)) {
+			this.store[key].expire = -1;
+			this.#num[key] = 0;
+		}
+		this.#num[key] -= decrement;
+		this.#sqlite.set(key, String(this.#num[key]), "num", this.store[key].expire);
+		return this.#num[key];
+	}
+	/**
+	* @description 追加字符串
+	* @param key 键
+	* @param value 值
+	*/
+	async append(key, value) {
+		if (!this.#str[key]) {
+			this.#str[key] = "";
+			this.store[key] = {
+				type: "str",
+				expire: -1
+			};
+		} else if (this.checkExpire(key, false)) {
+			this.store[key].expire = -1;
+			this.#str[key] = "";
+		}
+		if (Buffer.isBuffer(value)) this.#str[key] += Buffer.concat([Buffer.from(this.#str[key]), value]).toString();
+		else this.#str[key] += value;
+		this.#sqlite.set(key, this.#str[key], "str", this.store[key].expire);
+		return this.#str[key].length;
+	}
+	/**
+	* @description
+	* @param key
+	* @param field
+	* @param value
+	* @returns
+	*/
+	/**
+	* 将字段和值设置到指定键的哈希表中
+	* 如果键不存在，则创建一个新的哈希表
+	* @param key 哈希表的键
+	* @param field 哈希表中的字段
+	* @param value 要设置的值，可以是字符串或缓冲区
+	* @returns 返回 1 表示设置成功，0 表示设置失败
+	*/
+	async hSet(key, field, value) {
+		if (!this.#hash[key]) {
+			this.store[key] = {
+				type: "hash",
+				expire: -1
+			};
+			this.#hash[key] = {};
+		} else if (this.checkExpire(key, false)) {
+			this.store[key].expire = -1;
+			this.#hash[key] = {};
+		}
+		this.#hash[key][field] = value;
+		this.#sqlite.set(key, JSON.stringify(this.#hash[key]), "hash", this.store[key].expire);
+		return 1;
+	}
+	/**
+	* 获取哈希表字段的值
+	* @param key 哈希表的键
+	* @param field 哈希表中的字段
+	* @returns 返回字段的值，如果字段不存在则返回 null
+	*/
+	async hGet(key, field) {
+		if (!this.#hash[key] || !this.#hash[key][field]) return null;
+		if (this.checkExpire(key)) return null;
+		return this.#hash[key][field].toString();
+	}
+	/**
+	* 删除哈希表中的一个或多个字段
+	* @param key 哈希表的键
+	* @param field 要删除的字段
+	* @returns 返回成功删除的字段数量
+	*/
+	async hDel(key, field) {
+		if (!this.#hash[key] || !this.#hash[key][field]) return 0;
+		if (this.checkExpire(key)) return 0;
+		delete this.#hash[key][field];
+		this.#sqlite.set(key, JSON.stringify(this.#hash[key]), "hash", this.store[key].expire);
+		return 1;
+	}
+	/**
+	* 获取哈希表中所有字段的值
+	* @param key 哈希表的键
+	* @returns 返回所有字段的值
+	*/
+	async hGetAll(key) {
+		if (!this.#hash[key]) return {};
+		if (this.checkExpire(key)) return {};
+		return lodash.mapValues(this.#hash[key], (value) => value.toString());
+	}
+	/**
+	* 将一个或多个值插入到列表的头部
+	* @param key 列表的键
+	* @param values 要插入的值
+	*/
+	async lPush(key, ...values) {
+		if (!this.#list[key]) {
+			this.store[key] = {
+				type: "list",
+				expire: -1
+			};
+			this.#list[key] = [];
+		} else if (this.checkExpire(key, false)) {
+			this.store[key].expire = -1;
+			this.#list[key] = [];
+		}
+		this.#list[key].unshift(...values);
+		this.#sqlite.set(key, JSON.stringify(this.#list[key]), "list", this.store[key].expire);
+		return this.#list[key].length;
+	}
+	/**
+	* 将一个或多个值插入到列表的尾部
+	* @param key 列表的键
+	* @param values 要插入的值
+	*/
+	async rPush(key, ...values) {
+		if (!this.#list[key]) {
+			this.store[key] = {
+				type: "list",
+				expire: -1
+			};
+			this.#list[key] = [];
+		} else if (this.checkExpire(key, false)) {
+			this.store[key].expire = -1;
+			this.#list[key] = [];
+		}
+		this.#list[key].push(...values);
+		this.#sqlite.set(key, JSON.stringify(this.#list[key]), "list", this.store[key].expire);
+		return this.#list[key].length;
+	}
+	/**
+	* 移除并返回列表的第一个元素
+	* @param key 列表的键
+	* @returns 返回列表的第一个元素，如果列表为空则返回 null
+	*/
+	async lPop(key) {
+		if (!this.#list[key] || this.#list[key].length === 0) return null;
+		if (this.checkExpire(key)) return null;
+		const value = this.#list[key].shift();
+		this.#sqlite.set(key, JSON.stringify(this.#list[key]), "list", this.store[key].expire);
+		return value ? value.toString() : null;
+	}
+	/**
+	* 移除并返回列表的最后一个元素
+	* @param key 列表的键
+	* @returns 返回列表的最后一个元素，如果列表为空则返回 null
+	*/
+	async rPop(key) {
+		if (!this.#list[key] || this.#list[key].length === 0) return null;
+		if (this.checkExpire(key)) return null;
+		const value = this.#list[key].pop();
+		this.#sqlite.set(key, JSON.stringify(this.#list[key]), "list", this.store[key].expire);
+		return value ? value.toString() : null;
+	}
+	/**
+	* 返回列表指定范围内的元素
+	* @param key 列表的键
+	* @returns 返回列表指定范围内的元素
+	*/
+	async lRange(key, start, stop) {
+		if (!this.#list[key]) return [];
+		if (this.checkExpire(key)) return [];
+		const value = this.#list[key].slice(start, stop + 1).map((value) => value.toString());
+		this.#sqlite.set(key, JSON.stringify(this.#list[key]), "list", this.store[key].expire);
+		return value;
+	}
+	/**
+	* 向集合添加一个或多个成员
+	* @param key 集合的键
+	* @param members 要添加的成员
+	* @returns 返回成功添加的成员数量
+	*/
+	async sAdd(key, ...members) {
+		if (!this.#set[key]) {
+			this.store[key] = {
+				type: "set",
+				expire: -1
+			};
+			this.#set[key] = /* @__PURE__ */ new Set();
+		} else if (this.checkExpire(key, false)) {
+			this.store[key].expire = -1;
+			this.#set[key] = /* @__PURE__ */ new Set();
+		}
+		let added = 0;
+		for (const member of members) if (!this.#set[key].has(member.toString())) {
+			this.#set[key].add(member.toString());
+			added++;
+		}
+		this.#sqlite.set(key, JSON.stringify(this.#set[key]), "set", this.store[key].expire);
+		return added;
+	}
+	/**
+	* 从集合中移除一个或多个成员
+	* @param key 集合的键
+	* @param members 要移除的成员
+	* @returns 返回成功移除的成员数量
+	*/
+	async sRem(key, ...members) {
+		if (!this.#set[key]) return 0;
+		if (this.checkExpire(key)) return 0;
+		let removed = 0;
+		for (const member of members) if (this.#set[key].has(member.toString())) {
+			this.#set[key].delete(member.toString());
+			removed++;
+		}
+		this.#sqlite.set(key, JSON.stringify(this.#set[key]), "set", this.store[key].expire);
+		return removed;
+	}
+	/**
+	* 返回集合的所有成员
+	* @param key 集合的键
+	* @returns 返回集合的所有成员
+	*/
+	async sMembers(key) {
+		if (!this.#set[key]) return [];
+		if (this.checkExpire(key)) return [];
+		return Array.from(this.#set[key]).map((member) => member.toString());
+	}
+	/**
+	* 检查成员是否是集合的成员
+	* @param key 集合的键
+	* @param member 要检查的成员
+	* @returns 返回 1 表示是集合的成员，0 表示不是集合的成员
+	*/
+	async sismember(key, member) {
+		if (!this.#set[key]) return 0;
+		if (this.checkExpire(key)) return 0;
+		return this.#set[key].has(member.toString()) ? 1 : 0;
+	}
+	/**
+	* 向有序集合添加一个或多个成员
+	* @param key 有序集合的键
+	* @param score 分数
+	* @param member 成员
+	* @returns 返回成功添加的成员数量
+	*/
+	async zAdd(key, score, member) {
+		if (!this.#zset[key]) {
+			this.store[key] = {
+				type: "zset",
+				expire: -1
+			};
+			this.#zset[key] = [];
+		} else if (this.checkExpire(key, false)) {
+			this.store[key].expire = -1;
+			this.#zset[key] = [];
+		}
+		const index = this.#zset[key].findIndex((entry) => entry.member === member.toString());
+		if (index === -1) this.#zset[key].push({
+			score,
+			member
+		});
+		else this.#zset[key][index] = {
+			score,
+			member
+		};
+		this.#sqlite.set(key, JSON.stringify(this.#zset[key]), "zset", this.store[key].expire);
+		return 1;
+	}
+	/**
+	* 返回有序集合的成员数量
+	* @param key 有序集合的键
+	* @returns 返回有序集合的成员数量
+	*/
+	async zcard(key) {
+		if (!this.#list[key]) return 0;
+		if (this.checkExpire(key)) return 0;
+		return this.#list[key].length;
+	}
+	/**
+	* 返回有序集合中指定成员的排名
+	* @param key 有序集合的键
+	* @param member 成员
+	* @returns 返回成员的排名，如果成员不存在则返回 null
+	*/
+	async zRank(key, member) {
+		if (!this.#list[key]) return null;
+		if (this.checkExpire(key)) return null;
+		const index = this.#list[key].findIndex((entry) => entry === member.toString());
+		return index !== -1 ? index : null;
+	}
+	/**
+	* 返回有序集合中指定成员的分数
+	* @param key 有序集合的键
+	* @param member 成员
+	* @returns 返回成员的分数，如果成员不存在则返回 null
+	*/
+	async zScore(key, member) {
+		if (!this.#list[key]) return null;
+		if (this.checkExpire(key)) return null;
+		const entry = this.#list[key].find((entry) => entry === member.toString());
+		return entry ? entry.length : null;
+	}
+	/**
+	* 从 HyperLogLog 中添加一个或多个元素
+	* @param key HyperLogLog 的键
+	* @param elements 要添加的元素
+	* @returns 返回 1 表示添加成功，0 表示添加失败
+	*/
+	async pfAdd(key, ...elements) {
+		if (!this.#pf[key]) {
+			this.store[key] = {
+				type: "pf",
+				expire: -1
+			};
+			this.#pf[key] = /* @__PURE__ */ new Set();
+		} else if (this.checkExpire(key, false)) {
+			this.store[key].expire = -1;
+			this.#pf[key] = /* @__PURE__ */ new Set();
+		}
+		let added = 0;
+		for (const element of elements) if (!this.#pf[key].has(element.toString())) {
+			this.#pf[key].add(element.toString());
+			added++;
+		}
+		this.#sqlite.set(key, JSON.stringify(this.#pf[key]), "pf", this.store[key].expire);
+		return added > 0;
+	}
+	/**
+	* 返回 HyperLogLog 的基数估算值
+	* @param key HyperLogLog 的键
+	* @returns 返回基数估算值
+	*/
+	async pfCount(key) {
+		if (!this.#pf[key]) return 0;
+		if (this.checkExpire(key)) return 0;
+		return this.#pf[key].size;
+	}
+	/**
+	* @description 发布消息到频道
+	* @param channel 频道
+	* @param message 消息
+	* @returns 返回订阅者数量
+	*/
+	async publish(channel, message) {
+		this.emit(channel, message.toString());
+		return this.listenerCount(channel);
+	}
+	/**
+	* @description 订阅一个或多个频道
+	* @param channels 频道
+	* @param listener 监听器
+	* @returns 返回订阅的频道数量
+	*/
+	async subscribe(channels, listener) {
+		channels.forEach((channel) => this.on(channel, listener));
+		return channels.length;
+	}
+	/**
+	* @description 取消订阅一个或多个频道
+	* @param channels 频道
+	* @param listener 监听器
+	* @returns 返回取消订阅的频道数量
+	*/
+	async unsubscribe(channels, listener) {
+		channels.forEach((channel) => this.off(channel, listener));
+		return channels.length;
+	}
+	/**
+	* @description 设置位图指定偏移量的值
+	* @param key 键
+	* @param offset 偏移量
+	* @param value 值
+	* @returns 返回设置前的位
+	*/
+	async setBit(key, offset, value) {
+		if (!this.#bit[key]) {
+			this.store[key] = {
+				type: "bit",
+				expire: -1
+			};
+			this.#bit[key] = Buffer.alloc(0);
+		} else if (this.checkExpire(key, false)) {
+			this.store[key].expire = -1;
+			this.#bit[key] = Buffer.alloc(0);
+		}
+		const byteOffset = Math.floor(offset / 8);
+		const bitOffset = offset % 8;
+		const oldValue = this.#bit[key].readUInt8(byteOffset);
+		const newValue = value ? oldValue | 1 << bitOffset : oldValue & ~(1 << bitOffset);
+		this.#bit[key].writeUInt8(newValue, byteOffset);
+		this.#sqlite.set(key, this.#bit[key].toString("base64"), "bit", this.store[key].expire);
+		return oldValue;
+	}
+	/**
+	* @description 获取位图指定偏移量的值
+	* @param key 键
+	* @param offset 偏移量
+	* @returns 返回位
+	*/
+	async getBit(key, offset) {
+		if (!this.#bit[key]) return 0;
+		if (this.checkExpire(key)) return 0;
+		const byteOffset = Math.floor(offset / 8);
+		const bitOffset = offset % 8;
+		return this.#bit[key].readUInt8(byteOffset) & 1 << bitOffset ? 1 : 0;
+	}
+	/**
+	* @description 获取位图的指定范围内的位
+	* @param key 键
+	* @param start 起始偏移量
+	* @param end 结束偏移量
+	* @returns 返回位数组
+	*/
+	async getRange(key, start, end) {
+		if (!this.#bit[key]) return [];
+		if (this.checkExpire(key)) return [];
+		const result = [];
+		for (let i = start; i <= end; i++) result.push(await this.getBit(key, i));
+		return result;
+	}
+	/**
+	* 获取哈希表中字段是否存在
+	* @param key 哈希表的键
+	* @param field 哈希表中的字段
+	* @returns 返回1表示字段存在，0表示字段不存在
+	*/
+	async hExists(key, field) {
+		if (!this.#hash[key]) return 0;
+		if (this.checkExpire(key)) return 0;
+		return this.#hash[key][field] !== void 0 ? 1 : 0;
+	}
+	/**
+	* 获取哈希表中所有字段名
+	* @param key 哈希表的键
+	* @returns 返回所有字段名数组
+	*/
+	async hKeys(key) {
+		if (!this.#hash[key]) return [];
+		if (this.checkExpire(key)) return [];
+		return Object.keys(this.#hash[key]);
+	}
+	/**
+	* 获取哈希表中所有值
+	* @param key 哈希表的键
+	* @returns 返回所有值数组
+	*/
+	async hVals(key) {
+		if (!this.#hash[key]) return [];
+		if (this.checkExpire(key)) return [];
+		return Object.values(this.#hash[key]).map((value) => value.toString());
+	}
+	/**
+	* 获取哈希表中字段数量
+	* @param key 哈希表的键
+	* @returns 返回字段数量
+	*/
+	async hLen(key) {
+		if (!this.#hash[key]) return 0;
+		if (this.checkExpire(key)) return 0;
+		return Object.keys(this.#hash[key]).length;
+	}
+	/**
+	* 批量获取哈希表中字段的值
+	* @param key 哈希表的键
+	* @param fields 要获取的字段数组
+	* @returns 返回字段值数组，不存在的字段返回null
+	*/
+	async hMGet(key, ...fields) {
+		if (!this.#hash[key]) return fields.map(() => null);
+		if (this.checkExpire(key)) return fields.map(() => null);
+		return fields.map((field) => {
+			const value = this.#hash[key][field];
+			return value !== void 0 ? value.toString() : null;
+		});
+	}
+	/**
+	* 批量设置哈希表中字段的值
+	* @param key 哈希表的键
+	* @param fieldValues 字段和值的数组，格式为[field1, value1, field2, value2, ...]
+	* @returns 返回"OK"
+	*/
+	async hMSet(key, ...fieldValues) {
+		if (!this.#hash[key]) {
+			this.store[key] = {
+				type: "hash",
+				expire: -1
+			};
+			this.#hash[key] = {};
+		} else if (this.checkExpire(key, false)) {
+			this.store[key].expire = -1;
+			this.#hash[key] = {};
+		}
+		for (let i = 0; i < fieldValues.length; i += 2) if (i + 1 < fieldValues.length) {
+			const field = fieldValues[i].toString();
+			const value = fieldValues[i + 1];
+			this.#hash[key][field] = value;
+		}
+		this.#sqlite.set(key, JSON.stringify(this.#hash[key]), "hash", this.store[key].expire);
+		return "OK";
+	}
+	/**
+	* 获取列表长度
+	* @param key 列表的键
+	* @returns 返回列表长度
+	*/
+	async lLen(key) {
+		if (!this.#list[key]) return 0;
+		if (this.checkExpire(key)) return 0;
+		return this.#list[key].length;
+	}
+	/**
+	* 获取列表指定索引的元素
+	* @param key 列表的键
+	* @param index 索引，0表示第一个元素，-1表示最后一个元素
+	* @returns 返回元素值，索引超出范围返回null
+	*/
+	async lIndex(key, index) {
+		if (!this.#list[key]) return null;
+		if (this.checkExpire(key)) return null;
+		const list = this.#list[key];
+		if (index < 0) index = list.length + index;
+		if (index < 0 || index >= list.length) return null;
+		return list[index].toString();
+	}
+	/**
+	* 设置列表指定索引的元素值
+	* @param key 列表的键
+	* @param index 索引
+	* @param value 值
+	* @returns 成功返回"OK"，失败返回错误
+	*/
+	async lSet(key, index, value) {
+		if (!this.#list[key]) return null;
+		if (this.checkExpire(key)) return null;
+		const list = this.#list[key];
+		if (index < 0) index = list.length + index;
+		if (index < 0 || index >= list.length) return null;
+		list[index] = value;
+		this.#sqlite.set(key, JSON.stringify(list), "list", this.store[key].expire);
+		return "OK";
+	}
+	/**
+	* 移除列表中与指定值相等的元素
+	* @param key 列表的键
+	* @param count 移除的数量，0表示移除所有匹配的元素，正数表示从头部开始移除，负数表示从尾部开始移除
+	* @param value 要移除的值
+	* @returns 返回移除的元素数量
+	*/
+	async lRem(key, count, value) {
+		if (!this.#list[key]) return 0;
+		if (this.checkExpire(key)) return 0;
+		const list = this.#list[key];
+		const strValue = value.toString();
+		let removed = 0;
+		if (count === 0) {
+			const newList = list.filter((item) => item.toString() !== strValue);
+			removed = list.length - newList.length;
+			this.#list[key] = newList;
+		} else if (count > 0) {
+			for (let i = 0; i < list.length && removed < count; i++) if (list[i].toString() === strValue) {
+				list.splice(i, 1);
+				removed++;
+				i--;
+			}
+		} else {
+			count = Math.abs(count);
+			for (let i = list.length - 1; i >= 0 && removed < count; i--) if (list[i].toString() === strValue) {
+				list.splice(i, 1);
+				removed++;
+			}
+		}
+		this.#sqlite.set(key, JSON.stringify(list), "list", this.store[key].expire);
+		return removed;
+	}
+	/**
+	* 获取集合中元素数量
+	* @param key 集合的键
+	* @returns 返回集合中元素数量
+	*/
+	async sCard(key) {
+		if (!this.#set[key]) return 0;
+		if (this.checkExpire(key)) return 0;
+		return this.#set[key].size;
+	}
+	/**
+	* 计算集合的差集
+	* @param keys 集合的键数组
+	* @returns 返回差集数组
+	*/
+	async sDiff(...keys) {
+		if (keys.length === 0) return [];
+		const firstKey = keys[0];
+		if (!this.#set[firstKey]) return [];
+		if (this.checkExpire(firstKey)) return [];
+		const result = /* @__PURE__ */ new Set();
+		for (const item of this.#set[firstKey]) result.add(item.toString());
+		for (let i = 1; i < keys.length; i++) {
+			const key = keys[i];
+			if (!this.#set[key] || this.checkExpire(key)) continue;
+			for (const item of this.#set[key]) result.delete(item.toString());
+		}
+		return Array.from(result);
+	}
+	/**
+	* 计算集合的交集
+	* @param keys 集合的键数组
+	* @returns 返回交集数组
+	*/
+	async sInter(...keys) {
+		if (keys.length === 0) return [];
+		const validKeys = keys.filter((key) => this.#set[key] && !this.checkExpire(key));
+		if (validKeys.length === 0) return [];
+		const result = /* @__PURE__ */ new Set();
+		const firstKey = validKeys[0];
+		for (const item of this.#set[firstKey]) {
+			let inAllSets = true;
+			for (let i = 1; i < validKeys.length; i++) {
+				const key = validKeys[i];
+				if (!this.#set[key].has(item.toString())) {
+					inAllSets = false;
+					break;
+				}
+			}
+			if (inAllSets) result.add(item.toString());
+		}
+		return Array.from(result);
+	}
+	/**
+	* 计算集合的并集
+	* @param keys 集合的键数组
+	* @returns 返回并集数组
+	*/
+	async sUnion(...keys) {
+		const result = /* @__PURE__ */ new Set();
+		for (const key of keys) {
+			if (!this.#set[key] || this.checkExpire(key)) continue;
+			for (const item of this.#set[key]) result.add(item.toString());
+		}
+		return Array.from(result);
+	}
+	/**
+	* 将多个键的值同时获取
+	* @param keys 要获取的键数组
+	* @returns 返回值数组，不存在的键返回null
+	*/
+	async mGet(...keys) {
+		return Promise.all(keys.map((key) => this.get(key)));
+	}
+	/**
+	* 同时设置多个键值对
+	* @param keyValues 键值对数组，格式为[key1, value1, key2, value2, ...]
+	* @returns 返回"OK"
+	*/
+	async mSet(...keyValues) {
+		for (let i = 0; i < keyValues.length; i += 2) if (i + 1 < keyValues.length) {
+			const key = keyValues[i].toString();
+			const value = keyValues[i + 1];
+			await this.set(key, value);
+		}
+		return "OK";
+	}
+	/**
+	* 设置键的新值并返回旧值
+	* @param key 键
+	* @param value 新值
+	* @returns 返回旧值，如果键不存在则返回null
+	*/
+	async getSet(key, value) {
+		const oldValue = await this.get(key);
+		await this.set(key, value);
+		return oldValue;
+	}
+	/**
+	* 修复zRange方法，使用正确的zset数据结构
+	* 返回有序集合的成员数量
+	* @param key 有序集合的键
+	* @returns 返回有序集合的成员数量
+	*/
+	async zRange(key, start, stop) {
+		if (!this.#zset[key]) return [];
+		if (this.checkExpire(key)) return [];
+		return [...this.#zset[key]].sort((a, b) => a.score - b.score).slice(start, stop + 1).map((entry) => entry.member.toString());
+	}
+	/**
+	* 按分数范围返回有序集合的成员
+	* @param key 有序集合的键
+	* @param min 最小分数
+	* @param max 最大分数
+	* @returns 返回指定分数范围的成员数组
+	*/
+	async zRangeByScore(key, min, max) {
+		if (!this.#zset[key]) return [];
+		if (this.checkExpire(key)) return [];
+		return this.#zset[key].filter((entry) => entry.score >= min && entry.score <= max).sort((a, b) => a.score - b.score).map((entry) => entry.member.toString());
+	}
+	/**
+	* 按分数降序返回有序集合的成员
+	* @param key 有序集合的键
+	* @param start 起始索引
+	* @param stop 结束索引
+	* @returns 返回指定范围的成员数组（按分数降序）
+	*/
+	async zRevRange(key, start, stop) {
+		if (!this.#zset[key]) return [];
+		if (this.checkExpire(key)) return [];
+		return [...this.#zset[key]].sort((a, b) => b.score - a.score).slice(start, stop + 1).map((entry) => entry.member.toString());
+	}
+	/**
+	* 获取有序集合中指定成员的排名（按分数降序）
+	* @param key 有序集合的键
+	* @param member 成员
+	* @returns 返回成员的排名，不存在返回null
+	*/
+	async zRevRank(key, member) {
+		if (!this.#zset[key]) return null;
+		if (this.checkExpire(key)) return null;
+		const strMember = member.toString();
+		const sortedEntries = [...this.#zset[key]].sort((a, b) => b.score - a.score);
+		for (let i = 0; i < sortedEntries.length; i++) if (sortedEntries[i].member.toString() === strMember) return i;
+		return null;
+	}
+	/**
+	* 从有序集合中移除一个或多个成员
+	* @param key 有序集合的键
+	* @param member 要移除的成员
+	* @returns 返回成功移除的成员数量
+	*/
+	async zRem(key, member) {
+		if (!this.#zset[key]) return 0;
+		if (this.checkExpire(key)) return 0;
+		const strMember = member.toString();
+		const index = this.#zset[key].findIndex((entry) => entry.member.toString() === strMember);
+		if (index !== -1) {
+			this.#zset[key].splice(index, 1);
+			this.#sqlite.set(key, JSON.stringify(this.#zset[key]), "zset", this.store[key].expire);
+			return 1;
+		}
+		return 0;
+	}
+	/**
+	* 根据键类型获取值的字符串表示
+	* @param key 键名
+	* @returns 值的字符串表示
+	*/
+	getValueStringByKey(key) {
+		const { type } = this.store[key];
+		switch (type) {
+			case "str": return this.#str[key];
+			case "num": return String(this.#num[key]);
+			case "hash": return JSON.stringify(this.#hash[key]);
+			case "list": return JSON.stringify(this.#list[key]);
+			case "set": return JSON.stringify(Array.from(this.#set[key]));
+			case "zset": return JSON.stringify(this.#zset[key]);
+			case "pf": return JSON.stringify(Array.from(this.#pf[key]));
+			case "bit": return this.#bit[key].toString("base64");
+			default: return "";
+		}
+	}
+	async save() {
+		const { removed, added, common } = diffSimpleArray(await this.#sqlite.keys(), Object.keys(this.store));
+		removed.forEach((key) => {
+			this.#sqlite.del(key);
+		});
+		added.forEach((key) => {
+			const { type, expire } = this.store[key];
+			const value = this.getValueStringByKey(key);
+			this.#sqlite.set(key, value, type, expire);
+		});
+		await Promise.all(common.map(async (key) => {
+			const data = this.store[key];
+			if (!data) return;
+			const { type, expire } = data;
+			const currentValue = this.getValueStringByKey(key);
+			const sql = await this.#sqlite.get(key);
+			if (sql?.expire !== expire || sql?.value !== currentValue) this.#sqlite.set(key, currentValue, type, expire);
+		}));
+		return "OK";
+	}
+};
+
+//#endregion
+//#region src/core/db/redis/redis.ts
+var redis_exports = /* @__PURE__ */ __exportAll({
+	createRedis: () => createRedis,
+	redis: () => redis
+});
+/**
+* @public
+* @description Redis数据库
+*/
+let redis;
+/**
+* @description 创建 Redis 客户端
+* @param options Redis 客户端配置
+* @returns Redis 客户端
+*/
+const create = async (options) => {
+	try {
+		const client = createClient(options);
+		await client.connect();
+		Object.defineProperty(client, "id", { value: "Redis" });
+		return client;
+	} catch (error) {
+		logger.debug(`${logger.red("[redis] 启动失败:")} ${JSON.stringify(options)}`);
+		logger.debug(error);
+	}
+};
+/**
+* @description 尝试主动拉起 Redis
+* @returns 是否成功
+*/
+const start = async () => {
+	logger.debug("[redis] 正在尝试启动 Redis...");
+	if (isWin()) {
+		const result = await exec("redis-server.exe redis.conf", { booleanResult: true });
+		if (result) return result;
+		return await exec("net start Redis", { booleanResult: true });
+	}
+	return await exec("redis-server --save 300 10 --daemonize yes" + await isArm64(), { booleanResult: true });
+};
+/**
+* @description Redis 服务
+* @returns Redis 客户端
+*/
+const createRedis = async () => {
+	try {
+		const options = redis$1();
+		let client = await create(options);
+		if (client) {
+			logger.info(`[redis] ${logger.green("Redis 连接成功")}`);
+			redis = client;
+			return redis;
+		}
+		if (await start()) {
+			logger.debug(logger.green("[redis] 主动拉起 Redis 成功"));
+			client = await create(options);
+		} else logger.debug(logger.red("[redis] 主动拉起 Redis 失败"));
+		if (client) {
+			redis = client;
+			return redis;
+		}
+		throw new Error("Redis 启动失败");
+	} catch (error) {
+		logger.debug(`[redis] ${logger.red("Redis 连接失败")}`);
+		logger.debug(error);
+		logger.debug(logger.yellow("[redis] 将降级为 redis-mock 实现"));
+		redis = await mock();
+		return redis;
+	}
+};
+/**
+* @description 判断是否为 arm64 架构
+* @returns 返回 arm64 专属参数
+*/
+const isArm64 = async () => {
+	if (os.arch() !== "arm64") return "";
+	/** 提取版本 只有>=6的版本才忽略警告 */
+	const { stdout } = await exec("redis-server -v");
+	const version = stdout.toString();
+	if (!version) return "";
+	const RedisVersion = version.match(/v=(\d)./);
+	if (RedisVersion && Number(RedisVersion[1]) >= 6) return " --ignore-warnings ARM64-COW-BUG";
+	return "";
+};
+/**
+* @description 伪 Redis 实现
+* @returns Redis 客户端
+*/
+const mock = async () => {
+	const redis = await new RedisClient(await new SQLiteWrapper(path.join(redisSqlite3Path, "redis.db")).init()).init();
+	Object.defineProperty(redis, "id", { value: "mock" });
+	return redis;
+};
+
+//#endregion
+export { redis as n, redis_exports as r, createRedis as t };