mm_expand 2.4.1 → 2.4.3

package/lib/eventer.js

@@ -1,2406 +1,2294 @@
-/* eslint-disable mm_eslint/function-name */
-require('./global.js');
-
-/**
- * 事件类 - 增强版EventBus实现
- */
-class Eventer {
-  static config = {
-    max_list: 10, // 最大监听器数量
-    default_name: 'default', // 默认命名空间
-    chain_enabled: true, // 是否启用链式触发
-    auto_clean: true, // 是否自动清理空的事件列表
-    error: null, // 全局错误处理函数
-    pause_enabled: true, // 是否启用暂停功能
-  };
-
-  // 日志对象
-  #logger = $.log || console;
-
-  /**
-   * 构造函数
-   * @param {object} config 配置参数
-   */
-  constructor(config) {
-    this.config = {
-      ...Eventer.config,
-      ...config || {}
-    };
-    // 是否为插件
-    this.is_plugin = false;
-    // 事件字典 - 支持命名空间
-    this._dict = {};
-    // 事件中间件
-    this._middleware = [];
-    // 命名空间映射
-    this._space = {};
-    // 事件链映射 { 'event1': ['event2', 'event3'], 'space:event1': ['event4'] }
-    this._chain = {};
-    // 进行中的任务映射，用于取消操作
-    this._tasks = new Map();
-    // 暂停状态管理
-    this._paused = new Set(); // 暂停的单个事件
-    this._paused_space = new Set(); // 暂停的命名空间
-    this._paused_global = false; // 全局暂停状态
-    // 初始化默认命名空间
-    this._space[this.config.default_name] = true;
-  }
-
-  /**
-   * 设置日志记录器
-   * @param {object} logger 日志记录器对象
-   */
-  setLogger(logger) {
-    this.#logger = logger;
-  }
-
-  /**
-   * 获取日志记录器
-   * @returns {object} 日志记录器对象
-   */
-  getLogger() {
-    return this.#logger;
-  }
-
-  /**
-   * 日志输出
-   * @param {string} level 日志级别
-   * @param {string} message 日志消息
-   * @param  {...any} params 日志参数
-   */
-  log(level, message, ...params) {
-    this.getLogger()[level](`[${this.constructor.name}] ${message}`, ...params);
-  };
-}
-
-/**
- * 初始化事件管理器
- * @param  {...any} args 初始化参数
- * @returns {Eventer} 返回事件管理器实例
- * @private
- */
-Eventer.prototype._init = async function (...args) {
-  // 初始化逻辑
-  return this;
-};
-
-/**
- * 初始化事件管理器
- * @param  {...any} args 初始化参数
- * @returns {Eventer} 返回事件管理器实例
- */
-Eventer.prototype.init = async function (...args) {
-  return this._init(...args);
-};
-
-/**
- * 监听事件（支持命名空间和优先级）
- * @param {string} key 事件关键字，支持space:key格式
- * @param {object} func 触发函数
- * @throws {Error} 事件关键字必须是非空字符串
- * @throws {Error} 事件处理函数必须是一个函数
- */
-Eventer.prototype._validateOnParams = function (key, func) {
-  if (!key || typeof key !== 'string') {
-    throw new Error('事件关键字必须是非空字符串');
-  }
-  if (typeof func !== 'function') {
-    throw new Error('事件处理函数必须是一个函数');
-  }
-};
-
-Eventer.prototype._parseEventKey = function (key, ns) {
-  let parsed = this._parseKey(key);
-  let space = ns || parsed.space;
-  let event_key = parsed.key;
-  let full_key = `${space}:${event_key}`;
-  return { space, event_key, full_key };
-};
-
-Eventer.prototype._initNamespace = function (space, event_key) {
-  if (!this._dict[space]) {
-    this._dict[space] = {};
-    this._space[space] = true;
-  }
-  if (!this._dict[space][event_key]) {
-    this._dict[space][event_key] = [];
-  }
-};
-
-Eventer.prototype._generateDefaultName = function (func) {
-  return func.name || `handler_${Date.now()}_${Math.floor(Math.random() * 1000)}`;
-};
-
-Eventer.prototype._wrapFunction = function (func, params) {
-  let wrapped_func = func;
-
-  if (params.throttle) {
-    wrapped_func = this._throttle(func, params.throttle);
-  } else if (params.debounce) {
-    wrapped_func = this._debounce(func, params.debounce);
-  }
-
-  if (params.timeout && typeof params.timeout === 'number' && params.timeout > 0) {
-    let original_func = wrapped_func;
-    wrapped_func = async function (...args) {
-      const timeoutPromise = new Promise((resolve, reject) => {
-        setTimeout(() => reject(new Error(`事件执行超时 (${params.timeout}ms)`)), params.timeout);
-      });
-      return Promise.race([original_func.apply(this, args), timeoutPromise]);
-    };
-  }
-
-  return wrapped_func;
-};
-
-Eventer.prototype._createHandlerObj = function (config) {
-  var handler = {
-    name: config.name,
-    func: config.wrapped_func,
-    original_func: config.func,
-    times: config.times,
-    priority: config.priority,
-    created_at: Date.now(),
-    last_executed: null
-  };
-  return handler;
-};
-
-Eventer.prototype._findHandlerIndex = function (list, name) {
-  for (let i = 0; i < list.length; i++) {
-    if (list[i].name === name) {
-      return i;
-    }
-  }
-  return -1;
-};
-
-Eventer.prototype._checkListenerLimit = function (space, event_key, list) {
-  let max_list = this.config.max_list;
-  if (max_list > 0 && list.length >= max_list) {
-    this.log('warn', `警告: '${space}:${event_key}' 事件的监听器数量已达到 ${max_list}，可能导致内存泄漏。使用 set_max_listeners() 方法可以增加限制。`);
-  }
-};
-
-Eventer.prototype._createHandlerResult = function (space, index, name, full_key) {
-  return {
-    space,
-    index,
-    name,
-    remove: () => this.off(full_key, name)
-  };
-};
-
-/**
- * 监听事件（支持命名空间和优先级）
- * @param {string} key 事件关键字，支持space:key格式
- * @param {object} func 触发函数
- * @param {string} name 增加名称，方便删除，当出现相同名称时会被覆盖
- * @param {object} options 其他选项，如throttle、debounce、timeout等
- * @returns {object} 返回事件信息对象 {space, index, name, remove}，remove为移除该事件的函数
- */
-Eventer.prototype.on = function (key, func, name, options) {
-  // 处理参数
-  let params = this._processOnParams(key, func, name, options);
-
-  // 验证参数
-  this._validateOnParams(params.key, params.func);
-
-  // 处理事件添加
-  return this._addEventHandler(params);
-};
-
-Eventer.prototype._processOnParams = function (key, func, name, options) {
-  // 支持两种调用方式：便捷方式和配置对象方式
-  if (typeof key === 'object' && key !== null) {
-    // 配置对象方式
-    return this._extractOnParams(key);
-  } else {
-    // 便捷方式
-    let opts = options || {};
-    return {
-      key: key,
-      func: func,
-      name: name,
-      times: opts.times || -1,
-      priority: opts.priority || 0,
-      ns: opts.ns || null
-    };
-  }
-};
-
-Eventer.prototype._addEventHandler = function (params) {
-  const { key: eventKey, func: eventFunc, name: eventName,
-    times: eventTimes, priority: eventPriority, ns } = params;
-
-  // 解析命名空间
-  const { space, event_key, full_key } = this._parseEventKey(eventKey, ns);
-
-  // 初始化命名空间和事件数组
-  this._initNamespace(space, event_key);
-
-  // 设置默认名称
-  let final_name = eventName || this._generateDefaultName(eventFunc);
-
-  // 应用节流或防抖
-  let wrapped_func = this._wrapFunction(eventFunc, params);
-
-  // 创建事件对象
-  let obj = this._createHandlerObj({
-    name: final_name,
-    wrapped_func: wrapped_func,
-    func: eventFunc,
-    times: eventTimes,
-    priority: eventPriority
-  });
-
-  // 处理事件添加逻辑
-  return this._handleEventAddition({ space, event_key, full_key, final_name, obj });
-};
-
-Eventer.prototype._extractOnParams = function (config) {
-  return {
-    key: config.key,
-    func: config.func,
-    name: config.name,
-    times: config.times || -1,
-    priority: config.priority || 0,
-    ns: config.ns || null
-  };
-};
-
-Eventer.prototype._processOnceParams = function (key, func, name, options) {
-  // 支持两种调用方式：便捷方式和配置对象方式
-  if (typeof key === 'object' && key !== null) {
-    // 配置对象方式
-    let params = this._extractOnParams(key);
-    params.times = 1; // 强制设置为仅执行一次
-    return params;
-  } else {
-    // 便捷方式
-    let opts = options || {};
-    return {
-      key: key,
-      func: func,
-      name: name,
-      times: 1, // 强制设置为仅执行一次
-      priority: opts.priority || 0,
-      ns: opts.ns || null
-    };
-  }
-};
-
-Eventer.prototype._handleEventAddition = function (config) {
-  const { space, event_key, full_key, final_name, obj } = config;
-  let list = this._dict[space][event_key];
-  let idx = this._findHandlerIndex(list, final_name);
-
-  if (idx >= 0) {
-    // 覆盖已存在的同名监听器
-    Object.assign(list[idx], obj);
-    // 重新排序
-    this._sort(list);
-    return this._createHandlerResult(space, idx, final_name, full_key);
-  } else {
-    // 检查监听器数量是否超过限制
-    this._checkListenerLimit(space, event_key, list);
-
-    // 添加新事件
-    list.push(obj);
-    // 按优先级排序
-    this._sort(list);
-    return this._createHandlerResult(space, list.length - 1, final_name, full_key);
-  }
-};
-
-/**
- * 监听事件(仅执行一次)
- * @param {string | object} key 事件关键，支持space:key格式，或配置对象
- * @param {object} func 触发函数
- * @param {string} name 增加名称，方便删除，当出现相同名称时会被覆盖
- * @param {object} options 其他选项
- * @returns {object} 返回事件信息对象 {space, idx, name}
- */
-Eventer.prototype.once = function (key, func, name, options) {
-  // 处理参数
-  let params = this._processOnceParams(key, func, name, options);
-
-  // 验证参数
-  this._validateOnParams(params.key, params.func);
-
-  // 处理事件添加
-  return this._addEventHandler(params);
-};
-
-/**
- * 统一的事件执行引擎
- * @param {string} key 事件关键字，支持space:key格式
- * @throws {Error} 事件关键字必须是非空字符串
- * @private
- */
-Eventer.prototype._validateExec = function (key) {
-  if (!key || typeof key !== 'string') {
-    throw new Error('事件关键字必须是非空字符串');
-  }
-};
-
-Eventer.prototype._createCtx = function (key, params) {
-  let parsed = this._parseKey(key);
-  let space = parsed.space;
-  let event_key = parsed.key;
-  let full_key = `${space}:${event_key}`;
-  let start_time = Date.now();
-
-  const ctx = {
-    space,
-    event: event_key,
-    full_event: full_key,
-    params,
-    results: [],
-    start_time: start_time,
-    executed: 0,
-    error_count: 0,
-    cancelled: false,
-    cancel: () => {
-      ctx.cancelled = true;
-      this._cancelTasks(full_key);
-    }
-  };
-
-  return { ctx, space, event_key, full_key, start_time };
-};
-
-Eventer.prototype._cancelTasks = function (full_key) {
-  try {
-    if (this._tasks.has(full_key)) {
-      let tasks = this._tasks.get(full_key);
-      tasks.forEach(task => {
-        if (task && typeof task.cancel === 'function') {
-          try {
-            task.cancel();
-          } catch (cancel_error) {
-            this.log('error', `任务取消失败 [${full_key}] - ${task.id}`, cancel_error);
-          }
-        }
-      });
-      this._tasks.delete(full_key);
-    }
-  } catch (cancel_global_error) {
-    this.log('error', `任务取消过程异常 [${full_key}]`, cancel_global_error);
-  }
-};
-
-Eventer.prototype._initTaskList = function (full_key) {
-  try {
-    this._tasks.set(full_key, []);
-  } catch (task_init_error) {
-    this.log('error', `任务列表初始化失败 [${full_key}]`, task_init_error);
-  }
-};
-
-Eventer.prototype._runBeforeMiddleware = async function (ctx, full_key) {
-  try {
-    await this._runMiddleware('before', ctx);
-    if (ctx.cancelled) {
-      this._cleanupTasks(full_key);
-      return true;
-    }
-    return false;
-  } catch (error) {
-    this.log('error', `事件中间件执行失败 [${ctx.space}:${ctx.event}]`, error);
-    if (this.config.error_handler && typeof this.config.error_handler === 'function') {
-      this.config.error_handler(error, { type: 'middleware', stage: 'before', ctx });
-    }
-    return false;
-  }
-};
-
-Eventer.prototype._cleanupTasks = function (full_key) {
-  try {
-    this._tasks.delete(full_key);
-  } catch (cleanup_error) {
-    this.log('error', `任务清理失败 [${full_key}]`, cleanup_error);
-  }
-};
-
-Eventer.prototype._executeStrategy = async function (config) {
-  const { list, params, ctx, full_key, arr, options } = config;
-
-  try {
-    if (options.exec_mode === 'parallel') {
-      await this._executeParallel({ list, params, ctx, full_key, arr });
-    } else if (options.exec_mode === 'race') {
-      ctx.race_result = await this._executeRace({ list, params, ctx, full_key, arr });
-    } else if (options.exec_mode === 'waterfall') {
-      await this._executeWaterfall({
-        list, params, ctx, full_key, arr,
-        initial_value: options.initial_value
-      });
-    } else {
-      await this._executeSequential({ list, params, ctx, full_key, arr });
-    }
-  } catch (exec_error) {
-    this.log('error', `事件执行策略异常 [${full_key}]`, exec_error);
-    if (this.config.error_handler && typeof this.config.error_handler === 'function') {
-      this.config.error_handler(exec_error, { type: 'execution', ctx });
-    }
-  }
-};
-
-Eventer.prototype._removeEvents = function (space, key, arr) {
-  try {
-    for (let i = 0; i < arr.length; i++) {
-      this.del(`${space}:${key}`, arr[i]);
-    }
-  } catch (remove_error) {
-    this.log('error', `事件移除失败 [${space}:${key}]`, remove_error);
-  }
-};
-
-Eventer.prototype._autoCleanup = function (space, key) {
-  try {
-    if (this.config.auto_clean && this._dict[space] && this._dict[space][key] &&
-      this._dict[space][key].length === 0) {
-      delete this._dict[space][key];
-      if (this._dict[space] && Object.keys(this._dict[space]).length === 0) {
-        delete this._dict[space];
-        delete this._space[space];
-      }
-    }
-  } catch (cleanup_error) {
-    this.log('error', `自动清理失败 [${space}:${key}]`, cleanup_error);
-  }
-};
-
-Eventer.prototype._runAfterMiddleware = async function (ctx, start_time) {
-  try {
-    ctx.end_time = Date.now();
-    ctx.duration = ctx.end_time - start_time;
-    await this._runMiddleware('after', ctx);
-  } catch (error) {
-    this.log('error', `事件后置中间件执行失败 [${ctx.space}:${ctx.event}]`, error);
-    if (this.config.error_handler && typeof this.config.error_handler === 'function') {
-      this.config.error_handler(error, { type: 'middleware', stage: 'after', ctx });
-    }
-  }
-};
-
-Eventer.prototype._executeEventChain = async function (ctx, full_key, params) {
-  if (!ctx.cancelled && this.config.chain_enabled && this._chain[full_key]) {
-    try {
-      await this._triggerChain(full_key, params);
-    } catch (chain_error) {
-      this.log('error', `事件链执行失败 [${full_key}]`, chain_error);
-      if (this.config.error_handler && typeof this.config.error_handler === 'function') {
-        this.config.error_handler(chain_error, { type: 'chain', ctx });
-      }
-    }
-  }
-};
-
-Eventer.prototype._buildSafeResult = function (ctx) {
-  try {
-    return {
-      results: ctx.results || [],
-      cancelled: ctx.cancelled || false,
-      cancel: ctx.cancel || (() => { }),
-      race: ctx.race_result,
-      waterfall: ctx.results && ctx.results.length > 0 ? ctx.results[ctx.results.length - 1]
-        : undefined
-    };
-  } catch (return_error) {
-    this.log('error', `结果构造失败 [${ctx.full_event}]`, return_error);
-    return {
-      results: [],
-      cancelled: true,
-      cancel: () => { },
-      error: return_error
-    };
-  }
-};
-
-Eventer.prototype._execute = async function (key, options = {}, ...params) {
-  this._validateExec(key);
-
-  const { ctx, space, event_key, full_key, start_time } = this._createCtx(key, params);
-
-  if (this.isPaused(full_key)) {
-    return this._createPausedResult();
-  }
-
-  let list = this._dict[space] && this._dict[space][event_key];
-  const arr = [];
-
-  if (list && list.length > 0) {
-    await this._executeEventList({
-      list, params, ctx, full_key, arr, options, space, event_key, start_time
-    });
-  }
-
-  await this._executeEventChain(ctx, full_key, params);
-  return this._buildSafeResult(ctx);
-};
-
-/**
- * 创建暂停状态的结果对象
- * @returns {object} 暂停状态的结果
- * @private
- */
-Eventer.prototype._createPausedResult = function () {
-  return {
-    results: [],
-    cancelled: false,
-    paused: true,
-    /**
-     * 取消函数
-     */
-    cancel: () => { }
-  };
-};
-
-/**
- * 执行事件列表
- * @param {object} config 配置参数
- * @param {Array} config.list 事件列表
- * @param {Array} config.params 参数
- * @param {object} config.ctx 上下文
- * @param {string} config.full_key 完整键名
- * @param {Array} config.arr 数组
- * @param {object} config.options 选项
- * @param {string} config.space 命名空间
- * @param {string} config.event_key 事件键
- * @param {number} config.start_time 开始时间
- * @param {string} config.strategy 执行策略，默认sequential
- * @returns {object} 返回执行结果
- * @private
- */
-Eventer.prototype._executeEventList = async function (config) {
-  const { list, params, ctx, full_key, arr, options, space, event_key, start_time } = config;
-
-  this._initTaskList(full_key);
-
-  let cancelled = await this._runBeforeMiddleware(ctx, full_key);
-  if (cancelled) {
-    return {
-      results: [],
-      cancelled: true,
-      cancel: ctx.cancel
-    };
-  }
-
-  await this._executeStrategy({ list, params, ctx, full_key, arr, options });
-
-  this._cleanupTasks(full_key);
-  this._removeEvents(space, event_key, arr);
-  this._autoCleanup(space, event_key);
-  await this._runAfterMiddleware(ctx, start_time);
-};
-
-/**
- * 顺序执行事件处理函数
- * @param {object} config 配置参数
- * @private
- */
-Eventer.prototype._executeSequential = async function (config) {
-  const { list, params, ctx, full_key, arr } = config;
-
-  for (let i = 0; i < list.length && !ctx.cancelled; i++) {
-    let o = list[i];
-    ctx.executed++;
-    o.last_executed = Date.now();
-
-    // 创建并执行单个任务
-    await this._execSingleTask(o, params, ctx, { full_key, arr });
-  }
-};
-
-Eventer.prototype._execSingleTask = async function (o, params, ctx, options) {
-  const { full_key, arr } = options;
-
-  // 创建任务
-  let task = this._createTask(o, full_key);
-
-  try {
-    // 执行事件处理函数
-    let result = await o.func.apply(o, params);
-
-    // 处理成功结果
-    this._handleSuccessResult({ result, o, ctx, arr, task });
-  } catch (e) {
-    // 处理错误
-    this._handleSeqTaskError(e, o, ctx, task);
-  }
-};
-
-Eventer.prototype._createTask = function (o, full_key) {
-  let task_id = `${o.name}_${Date.now()}`;
-  let cancelled = false;
-  const task = {
-    id: task_id,
-    cancel: () => { cancelled = true; }
-  };
-
-  // 添加到进行中的任务列表
-  let tasks = this._tasks.get(full_key);
-  tasks.push(task);
-
-  return { task, tasks, cancelled };
-};
-
-Eventer.prototype._handleSuccessResult = function (config) {
-  const { result, o, ctx, arr, task } = config;
-
-  // 如果任务已取消，则不添加结果
-  if (!task.cancelled && !ctx.cancelled) {
-    ctx.results.push(result);
-
-    // 处理执行次数限制
-    if (o.times >= 0) {
-      o.times--;
-      if (o.times <= 0) {
-        arr.push(o.name);
-      }
-    }
-  }
-
-  // 从进行中的任务列表中移除
-  task.tasks.splice(task.tasks.indexOf(task.task), 1);
-};
-
-Eventer.prototype._handleSeqTaskError = function (e, o, ctx, task) {
-  ctx.error_count++;
-  this.log('error', `事件执行失败 [${ctx.space}:${ctx.event}] - ${o.name}`, e);
-
-  const error_result = {
-    _error: true,
-    error: e,
-    handler: o.name,
-    timestamp: Date.now()
-  };
-
-  ctx.results.push(error_result);
-
-  // 全局错误处理器
-  if (this.config.error_handler && typeof this.config.error_handler === 'function') {
-    this.config.error_handler(e, { type: 'handler', handler: o.name, ctx });
-  }
-
-  // 从进行中的任务列表中移除
-  task.tasks.splice(task.tasks.indexOf(task.task), 1);
-};
-
-/**
- * 并行执行事件处理函数
- * @param {object} config 配置参数
- * @private
- */
-Eventer.prototype._executeParallel = async function (config) {
-  const { list, params, ctx, full_key, arr } = config;
-  let concurrency = this._getConcurrency(params);
-  // eslint-disable-next-line mm_eslint/class-instance-name
-  const proc_results = new Array(list.length);
-
-  if (concurrency < Infinity) {
-    await this._executeBatches({
-      list, params, ctx, full_key, arr, concurrency, proc_results
-    });
-  } else {
-    await this._executeAllParallel({ list, params, ctx, full_key, arr, proc_results });
-  }
-
-  this._setResults(ctx, proc_results);
-};
-
-Eventer.prototype._getConcurrency = function (params) {
-  return params.options && typeof params.options.concurrency === 'number' ?
-    params.options.concurrency : Infinity;
-};
-
-Eventer.prototype._executeBatches = async function (config) {
-  const { list, params, ctx, full_key, arr, concurrency, proc_results } = config;
-
-  for (let i = 0; i < list.length && !ctx.cancelled; i += concurrency) {
-    let batch = list.slice(i, i + concurrency);
-    let batch_promises = batch.map((obj, batch_idx) => {
-      let global = i + batch_idx;
-      return this._executeSingleTask({
-        obj, params, ctx, full_key, arr, idx: global, proc_results
-      });
-    });
-
-    await Promise.allSettled(batch_promises);
-  }
-};
-
-Eventer.prototype._executeAllParallel = async function (config) {
-  const { list, params, ctx, full_key, arr, proc_results } = config;
-
-  let promises = list.map((obj, idx) => {
-    return this._executeSingleTask({ obj, params, ctx, full_key, arr, idx, proc_results });
-  });
-
-  await Promise.allSettled(promises);
-};
-
-Eventer.prototype._setResults = function (ctx, proc_results) {
-  ctx.results = proc_results.filter(result => result !== undefined);
-};
-
-/**
- * 瀑布流执行事件处理函数
- * @param {object} config 配置参数
- * @private
- */
-Eventer.prototype._executeWaterfall = async function (config) {
-  const { list, params, ctx, full_key, arr, initial_value } = config;
-  let wate_value = this._getInitialValue(params, initial_value);
-
-  for (let i = 0; i < list.length && !ctx.cancelled; i++) {
-    let obj = list[i];
-    ctx.executed++;
-    obj.last_executed = Date.now();
-
-    let task = this._createWaterfallTask(obj, full_key);
-    wate_value = await this._execWaterfallStep({
-      obj, params, ctx, arr, task, wate_value
-    });
-  }
-};
-
-Eventer.prototype._getInitialValue = function (params, initial_value) {
-  return initial_value !== undefined ? initial_value : (params.length > 0 ? params[0] : undefined);
-};
-
-Eventer.prototype._createWaterfallTask = function (obj, full_key) {
-  let task_id = `${obj.name}_${Date.now()}`;
-  let cancelled = false;
-  const task = {
-    id: task_id,
-    cancel: () => { cancelled = true; }
-  };
-
-  let tasks = this._tasks.get(full_key);
-  tasks.push(task);
-
-  return { task, tasks, cancelled };
-};
-
-Eventer.prototype._execWaterfallStep = async function (config) {
-  const { obj, params, ctx, arr, task, wate_value } = config;
-  try {
-    let result = await obj.func.apply(obj, [wate_value, ...params.slice(1)]);
-    this._handleWfSuccess({ result, obj, ctx, arr, task });
-    return result;
-  } catch (e) {
-    this._handleWfError({ e, obj, ctx, task });
-    return wate_value;
-  }
-};
-
-Eventer.prototype._handleWfSuccess = function (config) {
-  const { result, obj, ctx, arr, task } = config;
-  if (!task.cancelled && !ctx.cancelled) {
-    ctx.results.push(result);
-    this._handleTimesLimit(obj, arr);
-  }
-  this._removeTask(task);
-};
-
-Eventer.prototype._handleWfError = function (config) {
-  const { e, obj, ctx, task } = config;
-  ctx.error_count++;
-  this.log('error', `事件执行失败 [${ctx.space}:${ctx.event}] - ${obj.name}`, e);
-
-  const error_result = {
-    _error: true,
-    error: e,
-    handler: obj.name,
-    timestamp: Date.now()
-  };
-
-  ctx.results.push(error_result);
-  this._callErrorHandler(e, obj, ctx);
-  this._removeTask(task);
-};
-
-Eventer.prototype._handleTimesLimit = function (obj, arr) {
-  if (obj.times >= 0) {
-    obj.times--;
-    if (obj.times <= 0) {
-      arr.push(obj.name);
-    }
-  }
-};
-
-Eventer.prototype._removeTask = function (task) {
-  task.tasks.splice(task.tasks.indexOf(task.task), 1);
-};
-
-Eventer.prototype._callErrorHandler = function (e, obj, ctx) {
-  if (this.config.error_handler && typeof this.config.error_handler === 'function') {
-    this.config.error_handler(e, { type: 'handler', handler: obj.name, ctx });
-  }
-};
-
-/**
- * 竞争执行模式 - 返回第一个完成的结果
- * @param {object} config 配置参数
- * @param {Array} config.list 事件列表
- * @param {Array} config.params 参数
- * @param {object} config.ctx 上下文
- * @param {string} config.strategy 执行策略
- * @returns {Promise<object>} 返回包含results和cancel方法的对象
- * @private
- */
-Eventer.prototype._executeRace = async function (config) {
-  const { list, params, ctx, full_key, arr } = config;
-  let promises = this._createRacePromises({ list, params, ctx, full_key, arr });
-
-  return await this._runRace(promises);
-};
-
-Eventer.prototype._createRacePromises = function (config) {
-  const { list, params, ctx, full_key, arr } = config;
-  const promises = [];
-
-  for (let i = 0; i < list.length && !ctx.cancelled; i++) {
-    let obj = list[i];
-    ctx.executed++;
-    obj.last_executed = Date.now();
-
-    let promise = this._createRacePromise({ obj, params, ctx, full_key, arr });
-    promises.push(promise);
-  }
-
-  return promises;
-};
-
-Eventer.prototype._createRacePromise = function (config) {
-  const { obj, params, ctx, full_key, arr } = config;
-  let task = this._createRaceTask(obj, full_key);
-
-  return (async () => {
-    try {
-      let result = await obj.func.apply(obj, params);
-      return this._handleRaceSuccess({ result, obj, ctx, arr, task });
-    } catch (e) {
-      return this._handleRaceError(e, obj, ctx, task);
-    } finally {
-      this._removeTask(task);
-    }
-  })();
-};
-
-Eventer.prototype._createRaceTask = function (obj, full_key) {
-  let task_id = `${obj.name}_${Date.now()}`;
-  let cancelled = false;
-  const task = {
-    id: task_id,
-    cancel: () => { cancelled = true; }
-  };
-
-  let tasks = this._tasks.get(full_key);
-  tasks.push(task);
-
-  return { task, tasks, cancelled };
-};
-
-Eventer.prototype._handleRaceSuccess = function (config) {
-  const { result, obj, ctx, arr, task } = config;
-
-  if (!task.cancelled && !ctx.cancelled) {
-    ctx.results.push(result);
-    this._handleTimesLimit(obj, arr);
-    return { success: true, result, handler: obj.name };
-  }
-  return { success: false, cancelled: true };
-};
-
-Eventer.prototype._handleRaceError = function (e, obj, ctx, task) {
-  ctx.error_count++;
-  this.log('error', `事件执行失败 [${ctx.space}:${ctx.event}] - ${obj.name}`, e);
-
-  const error_result = {
-    _error: true,
-    error: e,
-    handler: obj.name,
-    timestamp: Date.now()
-  };
-
-  ctx.results.push(error_result);
-  this._callErrorHandler(e, obj, ctx);
-
-  return { success: false, error: e, handler: obj.name };
-};
-
-Eventer.prototype._runRace = async function (promises) {
-  if (promises.length > 0) {
-    let race = await Promise.race(promises);
-    return race;
-  }
-  return null;
-};
-
-/**
- * 执行单个任务（并行执行时使用）
- * @param {object} config 配置参数
- * @private
- */
-Eventer.prototype._executeSingleTask = async function (config) {
-  const { obj, params, ctx, full_key, arr, idx, proc_results } = config;
-  obj.last_executed = Date.now();
-
-  // 创建任务
-  let task_info = this._createParallelTask(obj, full_key);
-
-  try {
-    let result = await obj.func.apply(obj, params);
-    this._handleTaskSuccess({ result, obj, ctx, arr, idx, proc_results, task_info });
-  } catch (err) {
-    this._handleTaskError({ err, obj, ctx, idx, proc_results, task_info });
-  }
-};
-
-Eventer.prototype._createParallelTask = function (obj, full_key) {
-  let task_id = `${obj.name}_${Date.now()}`;
-  let cancelled = false;
-  const task = {
-    id: task_id,
-    cancel: () => { cancelled = true; }
-  };
-
-  // 添加到进行中的任务列表
-  let tasks = this._tasks.get(full_key);
-  tasks.push(task);
-
-  return { task, tasks, cancelled };
-};
-
-Eventer.prototype._handleTaskSuccess = function (config) {
-  const { result, obj, ctx, arr, idx, proc_results, task_info } = config;
-
-  // 从进行中的任务列表中移除
-  task_info.tasks.splice(task_info.tasks.indexOf(task_info.task), 1);
-
-  if (!task_info.cancelled && !ctx.cancelled) {
-    proc_results[idx] = result;
-
-    // 处理执行次数限制
-    if (obj.times >= 0) {
-      obj.times--;
-      if (obj.times <= 0) {
-        arr.push(obj.name);
-      }
-    }
-  }
-};
-
-Eventer.prototype._handleTaskError = function (config) {
-  const { err, obj, ctx, idx, proc_results, task_info } = config;
-
-  // 从进行中的任务列表中移除
-  task_info.tasks.splice(task_info.tasks.indexOf(task_info.task), 1);
-
-  if (!task_info.cancelled && !ctx.cancelled) {
-    const error_result = {
-      _error: true,
-      error: err,
-      handler: obj.name,
-      timestamp: Date.now()
-    };
-    proc_results[idx] = error_result;
-
-    // 全局错误处理器
-    if (this.config.error_handler && typeof this.config.error_handler === 'function') {
-      this.config.error_handler(err, { type: 'handler', handler: obj.name, ctx });
-    }
-  }
-};
-
-/**
- * 执行事件（支持中间件和命名空间）
- * @param {string} key 事件关键字，支持space:key格式
- * @param {object} params 传递参数
- * @returns {Promise<object>} 返回包含results和cancel方法的对象
- */
-Eventer.prototype.run = async function (key, ...params) {
-  return this._execute(key, { exec_mode: 'sequential' }, ...params);
-};
-
-/**
- * 触发事件
- * @param {string} key 事件关键，支持space:key格式
- * @param {object} params 传递参数
- * @returns {Promise<object>} 返回包含results和cancel方法的对象
- */
-Eventer.prototype.emit = function (key, ...params) {
-  // 内部调用 _execute 方法，但不等待结果
-  try {
-    let result = this._execute(key, { exec_mode: 'sequential' }, ...params);
-    result.catch(e => this.log('error', '事件异步执行失败:', e));
-    return {
-      ...result,
-      cancel: () => {
-        try {
-          return result.then(r => r && typeof r.cancel === 'function' && r.cancel());
-        } catch (cancel_error) {
-          this.log('error', `事件取消失败 [${key}]`, cancel_error);
-          return Promise.resolve();
-        }
-      }
-    };
-  } catch (error) {
-    this.log('error', `事件触发失败 [${key}]`, error);
-    // 返回一个安全的默认结果
-    return {
-      results: [],
-      cancelled: false,
-      cancel: () => { },
-      error: error
-    };
-  }
-};
-
-/**
- * 异步触发事件，按顺序执行等待完成
- * @param {string} key 事件关键字，支持space:key格式
- * @param  {...any} args 事件参数
- * @returns {Promise} - 事件触发结果
- */
-Eventer.prototype.emitWait = async function (key, ...args) {
-  try {
-    let result = await this._execute(key, { exec_mode: 'sequential' }, ...args);
-    return result.results || [];
-  } catch (error) {
-    this.log('error', `等待事件触发失败 [${key}]`, error);
-    return [];
-  }
-};
-
-/**
- * 异步触发事件，并发执行不等待
- * @param {string} key 事件关键字，支持space:key格式
- * @param  {...any} args 事件参数
- * @returns {boolean} - 是否有监听者
- */
-Eventer.prototype.emitAsync = async function (key, ...args) {
-  try {
-    return this._execAsync(key, args);
-  } catch (global_error) {
-    this.log('error', `异步事件触发失败 [${key}]`, global_error);
-    return false;
-  }
-};
-
-Eventer.prototype._execAsync = function (key, args) {
-  // 解析命名空间
-  let parsed = this._parseKey(key);
-  let space = parsed.space;
-  let event_key = parsed.key;
-  let full_key = `${space}:${event_key}`;
-
-  // 获取事件列表
-  let list = this._dict[space] && this._dict[space][event_key];
-
-  if (!list || list.length === 0) {
-    return false;
-  }
-
-  // 立即启动所有监听器，但不等待
-  list.forEach(handler => {
-    this._executeAsyncHandler(handler, args, full_key);
-  });
-
-  return true;
-};
-
-Eventer.prototype._executeAsyncHandler = function (handler, args, full_key) {
-  try {
-    // 使用 Promise.resolve 确保异步执行
-    Promise.resolve(handler.func(...args))
-      .catch(error => {
-        this._handleAsyncError(error, full_key, args);
-      });
-  } catch (sync_error) {
-    this._handleSyncError(sync_error, full_key, args);
-  }
-};
-
-Eventer.prototype._handleAsyncError = function (error, full_key, args) {
-  // 错误处理 - 记录但不抛出
-  this.log('error', `异步监听器错误 [${full_key}]:`, error);
-  try {
-    this.emit('async:error', error, full_key, args);
-  } catch (error) {
-    this.log('error', '错误事件触发失败 [async:error]', error);
-  }
-};
-
-Eventer.prototype._handleSyncError = function (sync_error, full_key, args) {
-  // 同步错误处理
-  this.log('error', `同步监听器错误 [${full_key}]:`, sync_error);
-  try {
-    this.emit('sync:error', sync_error, full_key, args);
-  } catch (error) {
-    this.log('error', '错误事件触发失败 [sync:error]', error);
-  }
-};
-
-/**
- * 异步触发事件，并发执行等待完成
- * @param {string} key 事件关键字，支持space:key格式
- * @param  {...any} args 事件参数
- * @returns {Promise<Array>} - 所有监听器的执行结果
- */
-Eventer.prototype.emitAll = async function (key, ...args) {
-  try {
-    let result = await this._execute(key, { exec_mode: 'parallel' }, ...args);
-    return result.results || [];
-  } catch (error) {
-    this.log('error', `并发事件触发失败 [${key}]`, error);
-    return [];
-  }
-};
-
-/**
- * 异步触发事件，竞争执行
- * @param {string} key 事件关键字，支持space:key格式
- * @param  {...any} args 事件参数
- * @returns {Promise} - 第一个完成的结果
- */
-Eventer.prototype.emitRace = async function (key, ...args) {
-  try {
-    let result = await this._execute(key, { exec_mode: 'race' }, ...args);
-    return result.race || null;
-  } catch (error) {
-    this.log('error', `竞争事件触发失败 [${key}]`, error);
-    return null;
-  }
-};
-
-/**
- * 异步触发事件，返回第一个有返回值的结果（不阻塞其他监听器）
- * @param {string} key 事件关键字，支持space:key格式
- * @param  {...any} args 事件参数
- * @returns {Promise} - 第一个有返回值（非 undefined）的监听器结果
- * 所有监听器并行执行，返回第一个有返回值（非 undefined）的结果，返回 undefined 的监听器被跳过，其他监听器继续在后台执行不受影响
- */
-Eventer.prototype.emitFirst = async function (key, ...args) {
-  try {
-    let parsed = this._parseKey(key);
-    let space = parsed.space;
-    let event_key = parsed.key;
-
-    let list = this._dict[space] && this._dict[space][event_key];
-    if (!list || list.length === 0) {
-      return undefined;
-    }
-
-    return await new Promise(resolve => {
-      let settled = false;
-      let pending = list.length;
-
-      for (let handler of list) {
-        Promise.resolve(handler.func(...args)).then(result => {
-          if (!settled && result !== undefined) {
-            settled = true;
-            resolve(result);
-          }
-          pending--;
-          if (pending === 0 && !settled) {
-            resolve(undefined);
-          }
-        }).catch(() => {
-          pending--;
-          if (pending === 0 && !settled) {
-            resolve(undefined);
-          }
-        });
-      }
-    });
-  } catch (error) {
-    this.log('error', `首个结果事件触发失败 [${key}]`, error);
-    return undefined;
-  }
-};
-
-/**
- * 异步触发事件，瀑布流执行
- * @param {string} key 事件关键字，支持space:key格式
- * @param {*} value 初始值
- * @param  {...any} args 事件参数
- * @returns {Promise} - 最后一个事件监听者的结果
- */
-Eventer.prototype.emitWaterfall = async function (key, value, ...args) {
-  try {
-    let result = await this._execute(key, {
-      exec_mode: 'waterfall',
-      initial_value: value
-    }, ...args);
-    return result.waterfall || value;
-  } catch (error) {
-    this.log('error', `瀑布流事件触发失败 [${key}]`, error);
-    return value;
-  }
-};
-
-/**
- * 确保命名空间在映射中
- * @private
- * @param {string} name 命名空间名称
- */
-Eventer.prototype._ensureNs = function (name) {
-  if (!this._space[name]) {
-    this._space[name] = true;
-  }
-};
-
-/**
- * 执行单个命名空间的事件处理函数
- * @private
- * @param {string} name 命名空间名称
- * @param {string} key 事件关键字
- * @param {Array} params 事件参数
- * @returns {object} 包含结果和需要移除的事件名称的对象
- */
-Eventer.prototype._execNsEvents = async function (name, key, params) {
-  let list = this._dict[name][key];
-  const name_results = [];
-  const arr = []; // 存储需要移除的事件
-
-  // 执行事件处理函数
-  for (let i = 0; i < list.length; i++) {
-    try {
-      let obj = list[i];
-      // 执行事件处理函数
-      let result = await obj.func.apply(obj, params);
-      name_results.push(result);
-
-      // 处理执行次数限制
-      if (obj.times >= 0) {
-        obj.times--;
-        if (obj.times <= 0) {
-          arr.push(obj.name);
-        }
-      }
-    } catch (e) {
-      // 记录错误但不中断执行
-      this.log('error', `事件执行失败 [${name}:${key}] - ${list[i].name}`, e);
-      name_results.push({
-        _error: true,
-        error: e,
-        handler: list[i].name
-      });
-    }
-  }
-
-  return { name_results, arr };
-};
-
-/**
- * 移除已执行完的事件
- * @private
- * @param {string} name 命名空间名称
- * @param {string} key 事件关键字
- * @param {Array} arr 需要移除的事件名称数组
- */
-Eventer.prototype._removeEvents = function (name, key, arr) {
-  for (let i = 0; i < arr.length; i++) {
-    this.del(`${name}:${key}`, arr[i]);
-  }
-};
-
-Eventer.prototype.emitAllNamespaces = async function (key, ...params) {
-  const results = {};
-  // 确保遍历所有命名空间，包括动态创建的
-  for (let name in this._dict) {
-    // 确保命名空间在space映射中
-    this._ensureNs(name);
-
-    // 检查该命名空间下是否存在该事件
-    if (this._dict[name] && this._dict[name][key]) {
-      const { name_results, arr } = await this._execNsEvents(name, key, params);
-
-      // 移除已执行完的事件
-      this._removeEvents(name, key, arr);
-
-      results[name] = name_results;
-    }
-  }
-  return results;
-};
-
-/**
- * 删除单个事件监听器
- * @private
- * @param {Array} events 事件列表
- * @param {string | number} index_or_name 事件索引或名称
- * @returns {boolean} 删除成功返回true，否则返回false
- */
-Eventer.prototype._removeSingleEvent = function (events, index_or_name) {
-  if (typeof (index_or_name) === 'number') {
-    // 按索引删除
-    if (index_or_name >= 0 && index_or_name < events.length) {
-      events.splice(index_or_name, 1);
-      return true;
-    }
-  } else {
-    // 根据名称删除事件
-    for (let j = events.length - 1; j >= 0; j--) {
-      if (events[j].name === index_or_name) {
-        events.splice(j, 1);
-        return true;
-      }
-    }
-  }
-  return false;
-};
-
-/**
- * 删除整个事件
- * @private
- * @param {string} space 命名空间
- * @param {string} event_key 事件键
- * @param {string} full_key 完整事件关键字
- * @returns {boolean} 删除成功返回true
- */
-Eventer.prototype._removeEntireEvent = function (space, event_key, full_key) {
-  // 安全检查：确保命名空间和事件存在
-  if (!this._dict[space] || !this._dict[space][event_key]) {
-    return false;
-  }
-
-  // 删除整个事件
-  delete this._dict[space][event_key];
-
-  // 清理相关的事件链
-  if (this._chain) {
-    for (let chain_key in this._chain) {
-      if (chain_key === full_key) {
-        delete this._chain[chain_key];
-      } else if (this._chain[chain_key] && Array.is_array(this._chain[chain_key]) &&
-        this._chain[chain_key].includes(full_key)) {
-        delete this._chain[chain_key];
-      }
-    }
-  }
-
-  return true;
-};
-
-/**
- * 自动清理空的事件列表和命名空间
- * @private
- * @param {string} space 命名空间
- * @param {string} key 事件关键字
- * @param {Array} events 事件列表
- * @param {string | number} index_or_name 事件索引或名称
- */
-Eventer.prototype._autoCleanEvents = function (space, key, events, index_or_name) {
-  if (!this.config.auto_clean) return;
-
-  // 安全检查：确保命名空间存在
-  if (!this._dict[space]) {
-    return;
-  }
-
-  // 清理空的事件列表
-  if (index_or_name && events && events.length === 0) {
-    // 安全检查：确保事件键存在
-    if (this._dict[space][key]) {
-      delete this._dict[space][key];
-    }
-  }
-
-  // 如果命名空间为空，则删除命名空间
-  if (this._dict[space] && Object.keys(this._dict[space]).length === 0) {
-    delete this._dict[space];
-    if (this._space && this._space[space]) {
-      delete this._space[space];
-    }
-  }
-};
-
-/**
- * 删除事件
- * @param {string} key 事件关键字，支持space:key格式
- * @param {number | string} index_or_name 事件集索引或名称
- * @returns {boolean} 删除成功返回true，否则返回false
- */
-Eventer.prototype.off = function (key, index_or_name) {
-  // 入参校验
-  if (!key || typeof key !== 'string') {
-    throw new Error('事件关键字必须是非空字符串');
-  }
-
-  // 解析命名空间
-  let parsed = this._parseKey(key);
-  let space = parsed.space;
-  let event_key = parsed.key;
-  let full_key = `${space}:${event_key}`;
-
-  // 检查事件是否存在
-  if (!this._dict[space] || !this._dict[space][event_key]) {
-    return false;
-  }
-
-  let events = this._dict[space][event_key];
-  let removed = false;
-
-  if (index_or_name) {
-    // 删除单个事件
-    removed = this._removeSingleEvent(events, index_or_name);
-  } else {
-    // 删除整个事件
-    removed = this._removeEntireEvent(space, event_key, full_key);
-  }
-
-  // 自动清理
-  if (removed) {
-    this._autoCleanEvents(space, event_key, events, index_or_name);
-  }
-
-  return removed;
-};
-
-Eventer.prototype.add = Eventer.prototype.on;
-Eventer.prototype.del = Eventer.prototype.off;
-
-/**
- * 删除命名空间中的所有事件
- * @param {string} name 命名空间
- * @returns {boolean} 删除成功返回true，否则返回false
- */
-Eventer.prototype.clearNamespace = function (name) {
-  if (!name || !this._dict[name]) {
-    return false;
-  }
-  delete this._dict[name];
-  delete this._space[name];
-  return true;
-};
-
-/**
- * 获取事件列表
- * @param {string} key 事件关键字，如果为空则获取所有事件，支持space:key格式
- * @returns {Array | object} 返回事件列表或所有事件对象
- */
-Eventer.prototype.getEvents = function (key) {
-  if (key) {
-    // 解析命名空间
-    const { space, key: event_key } = this._parseKey(key);
-    return this._dict[space] &&
-
-      this._dict[space][event_key] ? [...this._dict[space][event_key]] : [];
-  }
-  // 返回深拷贝的所有事件
-  const result = {};
-  for (let name in this._dict) {
-    result[name] = {};
-    for (let key in this._dict[name]) {
-      result[name][key] = [...this._dict[name][key]];
-    }
-  }
-  return result;
-};
-
-/**
- * 获取所有命名空间
- * @returns {Array} 返回所有命名空间数组
- */
-Eventer.prototype.getNamespace = function () {
-  return Object.keys(this._space);
-};
-
-/**
- * 清空所有事件和资源
- * @param {boolean} keep_space 是否保留命名空间定义，默认false
- * @returns {Eventer} 返回当前实例，支持链式调用
- */
-Eventer.prototype.clear = function (keep_space = false) {
-  // 取消所有进行中的任务
-  if (this._tasks) {
-    this._tasks.forEach((tasks, key) => {
-      tasks.forEach(task => {
-        if (task && typeof task.cancel === 'function') {
-          task.cancel();
-        }
-      });
-    });
-    this._tasks.clear();
-  }
-
-  // 清空事件字典
-  this._dict = {};
-
-  // 清空事件链
-  this._chain = {};
-
-  // 清空暂停状态
-  if (this._paused) {
-    this._paused.clear();
-  }
-  if (this._paused_space) {
-    this._paused_space.clear();
-  }
-  this._paused_global = false;
-
-  // 保留命名空间定义
-  if (!keep_space) {
-    this._space = {};
-    // 重新初始化默认命名空间
-    this._space[this.config.default_name] = true;
-  }
-
-  return this;
-};
-
-/**
- * 检查事件是否存在
- * @param {string} key 事件关键字，支持space:key格式
- * @param {string} name 事件名称（可选）
- * @returns {boolean} 事件存在返回true，否则返回false
- */
-Eventer.prototype.has = function (key, name) {
-  // 解析命名空间
-  let parsed = this._parseKey(key);
-  let space = parsed.space;
-  let event_key = parsed.key;
-
-  if (!this._dict[space] || !this._dict[space][event_key]) {
-    return false;
-  }
-
-  if (name) {
-    let list = this._dict[space][event_key];
-    for (let i = 0; i < list.length; i++) {
-      if (list[i].name === name) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  return true;
-};
-
-/**
- * 获取事件数量
- * @param {string} key 事件关键字，如果为空则获取所有事件数量，支持space:key格式或space:*格式
- * @returns {number} 返回事件数量
- */
-Eventer.prototype.count = function (key) {
-  if (key) {
-    // 解析可能的命名空间模式
-    if (key.endsWith(':*')) {
-      // 统计命名空间下所有事件
-      let space = key.split(':')[0];
-      if (this._dict[space]) {
-        let total = 0;
-        for (let key in this._dict[space]) {
-          total += this._dict[space][key].length;
-        }
-        return total;
-      }
-      return 0;
-    }
-
-    // 解析具体事件
-    const { space, key: event_key } = this._parseKey(key);
-    return this._dict[space] &&
-
-      this._dict[space][event_key] ? this._dict[space][event_key].length : 0;
-  }
-
-  // 统计所有事件
-  let total = 0;
-  for (let name in this._dict) {
-    for (let key in this._dict[name]) {
-      total += this._dict[name][key].length;
-    }
-  }
-  return total;
-};
-
-/**
- * 添加事件中间件
- * @param {string} type 中间件类型，'before' 或 'after'
- * @param {Function} middleware 中间件函数，接收ctx参数
- * @returns {Eventer} 返回当前实例，支持链式调用
- */
-Eventer.prototype.use = function (type, middleware) {
-  if (type !== 'before' && type !== 'after') {
-    throw new Error('中间件类型必须是 "before" 或 "after"');
-  }
-  if (typeof middleware !== 'function') {
-    throw new Error('中间件必须是一个函数');
-  }
-
-  if (!this._middleware[type]) {
-    this._middleware[type] = [];
-  }
-  this._middleware[type].push(middleware);
-  return this;
-};
-
-/**
- * 添加事件链式触发关系
- * @param {string} from_event 源事件，支持space:key格式
- * @param {string | Array} to_events 目标事件，可以是单个事件或事件数组
- * @returns {Eventer} 返回当前实例，支持链式调用
- */
-Eventer.prototype.chain = function (from_event, to_events) {
-  // 入参校验
-  this._validateChainInput(from_event, to_events);
-
-  // 解析源事件
-  let full_from_event = this._getFullEventKey(from_event);
-
-  // 初始化事件链
-  this._initEventChain(full_from_event);
-
-  // 添加目标事件
-  this._addTargetEvents(full_from_event, to_events);
-
-  return this;
-};
-
-Eventer.prototype._validateChainInput = function (from_event, to_events) {
-  if (!from_event || typeof from_event !== 'string') {
-    throw new Error('源事件必须是非空字符串');
-  }
-};
-
-Eventer.prototype._getFullEventKey = function (event) {
-  const { space, key } = this._parseKey(event);
-  return `${space}:${key}`;
-};
-
-Eventer.prototype._initEventChain = function (full_from_event) {
-  if (!this._chain[full_from_event]) {
-    this._chain[full_from_event] = [];
-  }
-};
-
-Eventer.prototype._addTargetEvents = function (full_from_event, to_events) {
-  // 确保目标事件是数组
-  let target_events = Array.isArray(to_events) ? to_events : [to_events];
-
-  for (let i = 0; i < target_events.length; i++) {
-    this._addTargetEvent(full_from_event, target_events[i]);
-  }
-};
-
-Eventer.prototype._addTargetEvent = function (full_from_event, to_event) {
-  if (typeof to_event !== 'string') {
-    throw new Error('目标事件必须是非空字符串');
-  }
-
-  // 解析目标事件
-  let full_to_event = this._getFullEventKey(to_event);
-
-  // 避免重复添加
-  if (!this._chain[full_from_event].includes(full_to_event)) {
-    this._chain[full_from_event].push(full_to_event);
-  }
-};
-
-/**
- * 移除事件链式触发关系
- * @param {string} from_event 源事件，支持space:key格式
- * @param {string | Array} to_events 目标事件，可以是单个事件或事件数组（可选，不提供则移除所有关联）
- * @returns {Eventer} 返回当前实例，支持链式调用
- */
-Eventer.prototype.unchain = function (from_event, to_events) {
-  // 入参校验
-  if (!from_event || typeof from_event !== 'string') {
-    throw new Error('源事件必须是非空字符串');
-  }
-
-  // 解析源事件
-  const { space: from_space, key: fromkey } = this._parseKey(from_event);
-  let full_from_event = `${from_space}:${fromkey}`;
-
-  // 如果源事件不存在事件链，直接返回
-  if (!this._chain[full_from_event]) {
-    return this;
-  }
-
-  if (to_events) {
-    this._removeTargetEvents(full_from_event, to_events);
-  } else {
-    // 移除整个事件链
-    delete this._chain[full_from_event];
-  }
-
-  return this;
-};
-
-Eventer.prototype._removeTargetEvents = function (full_from_event, to_events) {
-  let target_events = Array.isArray(to_events) ? to_events : [to_events];
-
-  for (let i = 0; i < target_events.length; i++) {
-    this._removeTargetEvent(full_from_event, target_events[i]);
-  }
-
-  // 如果事件链为空，则删除整个事件链
-  if (this._chain[full_from_event].length === 0) {
-    delete this._chain[full_from_event];
-  }
-};
-
-Eventer.prototype._removeTargetEvent = function (full_from_event, to_event) {
-  if (typeof to_event !== 'string') {
-    throw new Error('目标事件必须是非空字符串');
-  }
-
-  // 解析目标事件
-  const { space: to_space, key: tokey } = this._parseKey(to_event);
-  let full_to_event = `${to_space}:${tokey}`;
-
-  // 检查事件链是否存在
-  if (!this._chain[full_from_event]) {
-    this.log('warn', `事件链不存在: ${full_from_event} -> ${full_to_event}`);
-    return;
-  }
-
-  // 查找并删除事件链
-  let index = this._chain[full_from_event].indexOf(full_to_event);
-  if (index === -1) {
-    this.log('warn', `事件链不存在: ${full_from_event} -> ${full_to_event}`);
-    return;
-  }
-
-  this._chain[full_from_event].splice(index, 1);
-};
-
-/**
- * 获取事件链
- * @param {string} event 事件关键字，支持space:key格式
- * @returns {Array} 返回事件链数组
- */
-Eventer.prototype.getChains = function (event) {
-  if (!event) {
-    return Object.keys(this._chain);
-  }
-
-  // 解析事件
-  const { space, key } = this._parseKey(event);
-  let full_event = `${space}:${key}`;
-
-  return this._chain[full_event] ? [...this._chain[full_event]] : [];
-};
-
-/**
- * 触发下一级事件链事件
- * @private
- * @param {string} current_event 当前触发的事件
- * @param {Array} params 传递的参数
- * @returns {Promise<void>}
- */
-Eventer.prototype._triggerChain = async function (current_event, params) {
-  if (!this.config.chain_enabled || !this._chain[current_event]) {
-    return;
-  }
-
-  // 循环触发下一级事件
-  for (let next_event of this._chain[current_event]) {
-    await this._execChainItem(next_event, params);
-  }
-};
-
-/**
- * 执行单个链上事件（包含中间件）
- * @private
- * @param {string} key 要执行的事件
- * @param {Array} params 参数
- * @returns {Promise<Array>} 执行结果
- */
-Eventer.prototype._execChainItem = async function (key, params) {
-  // 解析命名空间
-  const { space, key: innerkey } = this._parseKey(key);
-  let list = this._dict[space] && this._dict[space][innerkey];
-  const results = [];
-
-  // 创建上下文对象
-  let ctx = this._createChainContext(space, innerkey, key, params);
-
-  // 如果有事件处理函数，执行它们
-  if (list && list.length > 0) {
-    await this._executeChainItemWithMiddleware(list, ctx, results);
-  }
-
-  // 递归触发下一级事件
-  if (this._chain[key]) {
-    await this._triggerChain(key, params);
-  }
-
-  return results;
-};
-
-Eventer.prototype._createChainContext = function (space, innerkey, key, params) {
-  let start_time = Date.now();
-  return {
-    space,
-    event: innerkey,
-    full_event: key,
-    params,
-    results: [],
-    start_time: start_time,
-    executed: 0,
-    error_count: 0
-  };
-};
-
-Eventer.prototype._execChainMware = async function (list, ctx, results) {
-  // 执行前置中间件
-  await this._runChainMiddleware('before', ctx);
-
-  // 执行事件处理函数
-  await this._executeChainHandlers(list, ctx, results);
-
-  // 执行后置中间件
-  await this._runChainMiddleware('after', ctx);
-};
-
-Eventer.prototype._runChainMiddleware = async function (type, ctx) {
-  try {
-    if (type === 'after') {
-      ctx.end_time = Date.now();
-      ctx.duration = ctx.end_time - ctx.start_time;
-    }
-    await this._runMiddleware(type, ctx);
-  } catch (error) {
-    this.log('error', `事件链${type}中间件执行失败 [${ctx.space}:${ctx.event}]`, error);
-  }
-};
-
-Eventer.prototype._execChainHandlers = async function (list, ctx, results) {
-  for (let i = 0; i < list.length; i++) {
-    await this._execChainHandler(list[i], ctx, results);
-  }
-};
-
-Eventer.prototype._execChainHandler = async function (obj, ctx, results) {
-  try {
-    ctx.executed++;
-
-    // 执行事件处理函数
-    let result = await obj.func.apply(obj, ctx.params);
-    results.push(result);
-    ctx.results.push(result);
-
-    // 处理执行次数限制
-    this._handleChainTimes(obj, ctx);
-  } catch (e) {
-    this._handleChainError(e, obj, ctx, results);
-  }
-};
-
-Eventer.prototype._handleChainTimes = function (obj, ctx) {
-  if (obj.times >= 0) {
-    obj.times--;
-    if (obj.times <= 0) {
-      this.del(`${ctx.space}:${ctx.event}`, obj.name);
-    }
-  }
-};
-
-Eventer.prototype._handleChainError = function (e, obj, ctx, results) {
-  ctx.error_count++;
-  this.log('error', `事件链执行失败 [${ctx.space}:${ctx.event}] - ${obj.name}`, e);
-
-  const error_result = {
-    _error: true,
-    error: e,
-    handler: obj.name
-  };
-
-  results.push(error_result);
-  ctx.results.push(error_result);
-};
-
-/**
- * 并行执行事件（提高性能）
- * @param {string} key 事件关键字，支持space:key格式
- * @param {object} params 传递参数
- * @returns {Promise<object>} 返回包含results和cancel方法的对象
- */
-Eventer.prototype.runParallel = async function (key, ...params) {
-  let result = await this._execute(key, {
-    exec_mode: 'parallel',
-    options: params.options
-  }, ...params);
-  return {
-    results: result.results,
-    cancelled: result.cancelled,
-    cancel: result.cancel
-  };
-};
-
-/**
- * 并行触发事件
- * @param {string} key 事件关键字，支持space:key格式
- * @param {object} params 传递参数
- * @returns {Promise<object>} 返回包含results和cancel方法的对象
- */
-Eventer.prototype.emitParallel = function (key, ...params) {
-  // 内部调用 _execute 方法，但不等待结果
-  let result = this._execute(key, {
-    exec_mode: 'parallel',
-    options: params.options
-  }, ...params);
-  result.catch(e => this.log('error', '事件并行执行失败:', e));
-  return {
-    ...result,
-    cancel: () => result.then(r => r && typeof r.cancel === 'function' && r.cancel())
-  };
-};
-
-/**
- * 防止内存泄漏警告
- * @param {number} max_listen 最大监听器数量
- * @returns {Eventer} 返回当前实例，支持链式调用
- */
-Eventer.prototype.setMaxListeners = function (max_listen) {
-  if (typeof max_listen !== 'number' || max_listen < 0) {
-    throw new Error('最大监听器数量必须是一个非负数');
-  }
-  this._max_listeners = max_listen;
-  return this;
-};
-
-/**
- * 批量添加事件
- * @param {object} events_map 事件映射对象 { key: [func1, func2...] 或 key: {func, options} }
- * @returns {Eventer} 返回当前实例，支持链式调用
- */
-Eventer.prototype.onMany = function (events_map) {
-  if (typeof events_map !== 'object' || events_map === null) {
-    throw new Error('事件对象必须是一个非空对象');
-  }
-
-  for (let event_name in events_map) {
-    if (Object.prototype.hasOwnProperty.call(events_map, event_name)) {
-      this.on(event_name, events_map[event_name]);
-    }
-  }
-  return this;
-};
-
-// 私有方法
-
-/**
- * 解析事件键，提取命名空间和事件键
- * @param {string} key 事件关键字
- * @returns {object} 包含space和key的对象
- * @private
- */
-Eventer.prototype._parseKey = function (key) {
-  let parts = key.split(':');
-  if (parts.length === 1) {
-    // 没有命名空间，使用默认命名空间
-    return {
-      space: this.config.default_name,
-      key: key
-    };
-  } else if (parts.length === 2) {
-    // 有命名空间
-    return {
-      space: parts[0],
-      key: parts[1]
-    };
-  } else {
-    // 多个冒号，将第一个作为命名空间，其余作为事件键
-    return {
-      space: parts[0],
-      key: parts.slice(1).join(':')
-    };
-  }
-};
-
-/**
- * 按优先级对事件列表进行排序
- * @param {Array} events 事件列表
- * @private
- */
-Eventer.prototype._sort = function (events) {
-  events.sort((a, b) => a.priority - b.priority);
-};
-
-/**
- * 运行中间件
- * @param {string} type 中间件类型：'before' 或 'after'
- * @param {object} ctx 上下文对象
- * @private
- */
-Eventer.prototype._runMiddleware = async function (type, ctx) {
-  if (!this._middleware || !this._middleware[type] || this._middleware[type].length === 0) return;
-
-  const mwList = this._middleware[type];
-  for (let i = 0; i < mwList.length; i++) {
-    await this._execMiddleware(mwList[i], type, ctx, i);
-    // 如果上下文被取消，则停止执行
-    if (ctx.cancelled) break;
-  }
-};
-
-Eventer.prototype._execMiddleware = async function (middleware, type, ctx, idx) {
-  if (middleware && typeof middleware[type] === 'function') {
-    try {
-      await middleware[type].call(this, ctx);
-    } catch (middleware_error) {
-      this._handleMwareError(middleware_error, type, idx, ctx);
-    }
-  }
-};
-
-Eventer.prototype._handleMwareError = function (middleware_error, type, index, ctx) {
-  this.log('error', `中间件执行失败 [${type}] - 索引:${index}`, middleware_error);
-
-  // 全局错误处理器
-  if (this.config.error_handler && typeof this.config.error_handler === 'function') {
-    try {
-      this.config.error_handler(middleware_error, {
-        type: 'middleware',
-        stage: type,
-        index: index,
-        ctx
-      });
-    } catch (handler_error) {
-      this.log('error', '全局错误处理器执行失败', handler_error);
-    }
-  }
-};
-
-/**
- * 触发下一级事件链
- * @param {string} current_event 当前事件键
- * @param {Array} params 参数数组
- * @private
- */
-Eventer.prototype._triggerChain = async function (current_event, params) {
-  // 获取当前事件的下级事件列表
-  var next_events = this._chain[current_event];
-  if (!next_events || next_events.length === 0) return;
-
-  // 遍历并触发所有下级事件
-  for (var i = 0; i < next_events.length; i++) {
-    await this._triggerChainEvent(next_events[i], current_event, params);
-  }
-};
-
-Eventer.prototype._triggerChainEvent = async function (key, current_event, params) {
-  // 避免重复执行当前事件
-  if (key === current_event) return;
-
-  // 创建下级事件的上下文
-  var ctx = this._createChainCtx(key, current_event, params);
-
-  // 执行前置中间件
-  await this._runChainMware('before', ctx);
-  if (ctx.cancelled) return;
-
-  // 触发下级事件
-  await this._executeChainEvent(key, params, ctx);
-
-  // 执行后置中间件
-  await this._runChainMware('after', ctx);
-
-  // 递归触发下级事件的下级事件
-  if (!ctx.cancelled) {
-    await this._triggerChain(ctx.full_event, params);
-  }
-};
-
-Eventer.prototype._createChainCtx = function (key, current_event, params) {
-  var { space, key: innerkey } = this._parseKey(key);
-  var fullkey = `${space}:${innerkey}`;
-
-  return {
-    space,
-    event: innerkey,
-    full_event: fullkey,
-    params,
-    parent_event: current_event,
-    start_time: Date.now(),
-    executed: 0,
-    error_count: 0,
-    cancelled: false,
-    /**
-     * 取消事件执行
-     */
-    cancel: () => { this.cancelled = true; }
-  };
-};
-
-Eventer.prototype._runChainMware = async function (type, ctx) {
-  try {
-    if (type === 'after') {
-      ctx.end_time = Date.now();
-      ctx.duration = ctx.end_time - ctx.start_time;
-    }
-    await this._runMiddleware(type, ctx);
-  } catch (error) {
-    this.log('error', `下级事件${type}中间件执行失败 [${ctx.full_event}]`, error);
-  }
-};
-
-Eventer.prototype._executeChainEvent = async function (key, params, ctx) {
-  try {
-    await this.run(key, ...params);
-  } catch (event_error) {
-    this.log('error', `下级事件执行失败 [${ctx.full_event}]`, event_error);
-  }
-};
-
-/**
- * 节流函数
- * @param {Function} func 要节流的函数
- * @param {number} limit 节流时间（毫秒）
- * @returns {Function} 节流后的函数
- * @private
- */
-Eventer.prototype._throttle = function (func, limit) {
-  let last_func;
-  let last_time = 0;
-  return function () {
-    let ctx = this;
-    let args = arguments;
-    if (!last_time) {
-      func.apply(ctx, args);
-      last_time = Date.now();
-    } else {
-      clearTimeout(last_func);
-      last_func = setTimeout(() => {
-        if ((Date.now() - last_time) >= limit) {
-          func.apply(ctx, args);
-          last_time = Date.now();
-        }
-      }, limit - (Date.now() - last_time));
-    }
-  };
-};
-
-/**
- * 防抖函数
- * @param {Function} func 要防抖的函数
- * @param {number} wait 防抖时间（毫秒）
- * @returns {Function} 防抖后的函数
- * @private
- */
-Eventer.prototype._debounce = function (func, wait) {
-  let timeout;
-  return function () {
-    let ctx = this;
-    let args = arguments;
-    clearTimeout(timeout);
-    timeout = setTimeout(() => {
-      func.apply(ctx, args);
-    }, wait);
-  };
-};
-
-
-/**
- * 暂停事件执行
- * @param {string} key 事件关键字或命名空间，支持space:key格式，为空表示全局暂停
- * @returns {boolean} 是否成功暂停
- */
-Eventer.prototype.pause = function (key = '') {
-  if (!this.config.pause_enabled) {
-    this.log('warn', '暂停功能未启用');
-    return false;
-  }
-
-  if (!key) {
-    return this._pauseGlobal();
-  }
-
-  // 解析关键字
-  let parsed = this._parseKey(key);
-  let space = parsed.space;
-  let event_key = parsed.key;
-  let full_key = `${space}:${event_key}`;
-
-  if (key) {
-    return this._pauseEvent(full_key);
-  } else {
-    return this._pauseNamespace(space);
-  }
-};
-
-Eventer.prototype._pauseGlobal = function () {
-  if (this._paused_global) {
-    this.log('warn', '事件总线已处于全局暂停状态');
-    return false;
-  }
-  this._paused_global = true;
-  this.log('info', '事件总线已全局暂停');
-  return true;
-};
-
-Eventer.prototype._pauseEvent = function (full_key) {
-  if (this._paused.has(full_key)) {
-    this.log('warn', `事件 '${full_key}' 已处于暂停状态`);
-    return false;
-  }
-  this._paused.add(full_key);
-  this.log('info', `事件 '${full_key}' 已暂停`);
-  return true;
-};
-
-Eventer.prototype._pauseNamespace = function (space) {
-  if (this._paused_space.has(space)) {
-    this.log('warn', `命名空间 '${space}' 已处于暂停状态`);
-    return false;
-  }
-  this._paused_space.add(space);
-  this.log('info', `命名空间 '${space}' 已暂停`);
-  return true;
-};
-
-/**
- * 恢复事件执行
- * @param {string} key 事件关键字或命名空间，支持space:key格式，为空表示恢复全局暂停
- * @returns {boolean} 是否成功恢复
- */
-Eventer.prototype.resume = function (key = '') {
-  if (!this.config.pause_enabled) {
-    this.log('warn', '暂停功能未启用');
-    return false;
-  }
-
-  if (!key) {
-    return this._resumeGlobal();
-  }
-
-  // 解析关键字
-  let parsed = this._parseKey(key);
-  let space = parsed.space;
-  let event_key = parsed.key;
-  let full_key = `${space}:${event_key}`;
-
-  if (key) {
-    return this._resumeEvent(full_key);
-  } else {
-    return this._resumeNamespace(space);
-  }
-};
-
-Eventer.prototype._resumeGlobal = function () {
-  if (!this._paused_global) {
-    this.log('warn', '事件总线未处于全局暂停状态');
-    return false;
-  }
-  this._paused_global = false;
-  this.log('info', '事件总线已恢复运行');
-  return true;
-};
-
-Eventer.prototype._resumeEvent = function (full_key) {
-  if (!this._paused.has(full_key)) {
-    this.log('warn', `事件 '${full_key}' 未处于暂停状态`);
-    return false;
-  }
-  this._paused.delete(full_key);
-  this.log('info', `事件 '${full_key}' 已恢复`);
-  return true;
-};
-
-Eventer.prototype._resumeNamespace = function (space) {
-  if (!this._paused_space.has(space)) {
-    this.log('warn', `命名空间 '${space}' 未处于暂停状态`);
-    return false;
-  }
-  this._paused_space.delete(space);
-  this.log('info', `命名空间 '${space}' 已恢复`);
-  return true;
-};
-
-/**
- * 检查事件是否被暂停
- * @param {string} key 事件关键字，支持space:key格式
- * @returns {boolean} 是否被暂停
- */
-Eventer.prototype.isPaused = function (key) {
-  if (!this.config.pause_enabled) {
-    return false;
-  }
-
-  // 全局暂停检查
-  if (this._paused_global) {
-    return true;
-  }
-
-  // 解析关键字
-  let parsed = this._parseKey(key);
-  let space = parsed.space;
-  let event_key = parsed.key;
-  let full_key = `${space}:${event_key}`;
-
-  // 命名空间暂停检查
-  if (this._paused_space.has(space)) {
-    return true;
-  }
-
-  // 单个事件暂停检查
-  if (this._paused.has(full_key)) {
-    return true;
-  }
-
-  return false;
-};
-
-/**
- * 获取所有暂停的事件和命名空间
- * @returns {object} 暂停状态信息
- */
-Eventer.prototype.getPausedStatus = function () {
-  return {
-    global_paused: this._paused_global,
-    paused_events: Array.from(this._paused),
-    paused_spaces: Array.from(this._paused_space)
-  };
-};
-
-/**
- * 清除所有暂停状态
- * @returns {boolean} 是否成功清除
- */
-Eventer.prototype.clearPaused = function () {
-  if (!this.config.pause_enabled) {
-    this.log('warn', '暂停功能未启用');
-    return false;
-  }
-
-  let cleared = false;
-
-  if (this._paused_global) {
-    this._paused_global = false;
-    cleared = true;
-  }
-
-  if (this._paused.size > 0) {
-    this._paused.clear();
-    cleared = true;
-  }
-
-  if (this._paused_space.size > 0) {
-    this._paused_space.clear();
-    cleared = true;
-  }
-
-  if (cleared) {
-    this.log('info', '所有暂停状态已清除');
-  }
-
-  return cleared;
-};
-
-let eventer = new Eventer();
-
-module.exports = {
-  Eventer,
-  eventer
-};
+/* eslint-disable mm_eslint/function-name */
+require('./global.js');
+
+/**
+ * 事件类 - 增强版EventBus实现
+ */
+class Eventer {
+  static config = {
+    max_list: 10, // 最大监听器数量
+    default_name: 'default', // 默认命名空间
+    chain_enabled: true, // 是否启用链式触发
+    auto_clean: true, // 是否自动清理空的事件列表
+    error: null, // 全局错误处理函数
+    pause_enabled: true, // 是否启用暂停功能
+  };
+
+  // 日志对象
+  #logger = $.log || console;
+
+  /**
+   * 构造函数
+   * @param {object} config 配置参数
+   */
+  constructor(config) {
+    this.config = {
+      ...Eventer.config,
+      ...config || {}
+    };
+    // 是否为插件
+    this.is_plugin = false;
+    // 事件字典 - 支持命名空间
+    this._dict = {};
+    // 事件中间件
+    this._middleware = [];
+    // 命名空间映射
+    this._space = {};
+    // 事件链映射 { 'event1': ['event2', 'event3'], 'space:event1': ['event4'] }
+    this._chain = {};
+    // 进行中的任务映射，用于取消操作
+    this._tasks = new Map();
+    // 暂停状态管理
+    this._paused = new Set(); // 暂停的单个事件
+    this._paused_space = new Set(); // 暂停的命名空间
+    this._paused_global = false; // 全局暂停状态
+    // 初始化默认命名空间
+    this._space[this.config.default_name] = true;
+  }
+
+  /**
+   * 设置日志记录器
+   * @param {object} logger 日志记录器对象
+   */
+  setLogger(logger) {
+    this.#logger = logger;
+  }
+
+  /**
+   * 获取日志记录器
+   * @returns {object} 日志记录器对象
+   */
+  getLogger() {
+    return this.#logger;
+  }
+
+  /**
+   * 日志输出
+   * @param {string} level 日志级别
+   * @param {string} message 日志消息
+   * @param  {...any} params 日志参数
+   */
+  log(level, message, ...params) {
+    this.getLogger()[level](`[${this.constructor.name}] ${message}`, ...params);
+  }
+}
+
+/**
+ * 初始化事件管理器
+ * @param  {...any} args 初始化参数
+ * @returns {Eventer} 返回事件管理器实例
+ * @private
+ */
+Eventer.prototype._init = async function (...args) {
+  // 初始化逻辑
+  return this;
+};
+
+/**
+ * 初始化事件管理器
+ * @param  {...any} args 初始化参数
+ * @returns {Eventer} 返回事件管理器实例
+ */
+Eventer.prototype.init = async function (...args) {
+  return this._init(...args);
+};
+
+/**
+ * 监听事件（支持命名空间和优先级）
+ * @param {string} key 事件关键字，支持space:key格式
+ * @param {object} func 触发函数
+ * @throws {Error} 事件关键字必须是非空字符串
+ * @throws {Error} 事件处理函数必须是一个函数
+ */
+Eventer.prototype._validateOnParams = function (key, func) {
+  if (!key || typeof key !== 'string') {
+    throw new Error('事件关键字必须是非空字符串');
+  }
+  if (typeof func !== 'function') {
+    throw new Error('事件处理函数必须是一个函数');
+  }
+};
+
+Eventer.prototype._parseEventKey = function (key, ns) {
+  let parsed = this._parseKey(key);
+  let space = ns || parsed.space;
+  let event_key = parsed.key;
+  let full_key = `${space}:${event_key}`;
+  return { space, event_key, full_key };
+};
+
+Eventer.prototype._initNamespace = function (space, event_key) {
+  if (!this._dict[space]) {
+    this._dict[space] = {};
+    this._space[space] = true;
+  }
+  if (!this._dict[space][event_key]) {
+    this._dict[space][event_key] = [];
+  }
+};
+
+Eventer.prototype._generateDefaultName = function (func) {
+  return func.name || `handler_${Date.now()}_${Math.floor(Math.random() * 1000)}`;
+};
+
+Eventer.prototype._wrapFunction = function (func, params) {
+  let wrapped_func = func;
+
+  if (params.throttle) {
+    wrapped_func = this._throttle(func, params.throttle);
+  } else if (params.debounce) {
+    wrapped_func = this._debounce(func, params.debounce);
+  }
+
+  if (params.timeout && typeof params.timeout === 'number' && params.timeout > 0) {
+    let original_func = wrapped_func;
+    wrapped_func = async function (...args) {
+      const timeoutPromise = new Promise((resolve, reject) => {
+        setTimeout(() => reject(new Error(`事件执行超时 (${params.timeout}ms)`)), params.timeout);
+      });
+      return Promise.race([original_func.apply(this, args), timeoutPromise]);
+    };
+  }
+
+  return wrapped_func;
+};
+
+Eventer.prototype._createHandlerObj = function (config) {
+  var handler = {
+    name: config.name,
+    func: config.wrapped_func,
+    original_func: config.func,
+    times: config.times,
+    priority: config.priority,
+    created_at: Date.now(),
+    last_executed: null
+  };
+  return handler;
+};
+
+Eventer.prototype._findHandlerIndex = function (list, name) {
+  for (let i = 0; i < list.length; i++) {
+    if (list[i].name === name) {
+      return i;
+    }
+  }
+  return -1;
+};
+
+Eventer.prototype._checkListenerLimit = function (space, event_key, list) {
+  let max_list = this.config.max_list;
+  if (max_list > 0 && list.length >= max_list) {
+    this.log('warn', `警告: '${space}:${event_key}' 事件的监听器数量已达到 ${max_list}，可能导致内存泄漏。使用 set_max_listeners() 方法可以增加限制。`);
+  }
+};
+
+Eventer.prototype._createHandlerResult = function (space, index, name, full_key) {
+  return {
+    space,
+    index,
+    name,
+    remove: () => this.off(full_key, name)
+  };
+};
+
+/**
+ * 监听事件（支持命名空间和优先级）
+ * @param {string} key 事件关键字，支持space:key格式
+ * @param {object} func 触发函数
+ * @param {string} name 增加名称，方便删除，当出现相同名称时会被覆盖
+ * @param {object} options 其他选项，如throttle、debounce、timeout等
+ * @returns {object} 返回事件信息对象 {space, index, name, remove}，remove为移除该事件的函数
+ */
+Eventer.prototype.on = function (key, func, name, options) {
+  // 处理参数
+  let params = this._processOnParams(key, func, name, options);
+
+  // 验证参数
+  this._validateOnParams(params.key, params.func);
+
+  // 处理事件添加
+  return this._addEventHandler(params);
+};
+
+Eventer.prototype._processOnParams = function (key, func, name, options) {
+  // 支持两种调用方式：便捷方式和配置对象方式
+  if (typeof key === 'object' && key !== null) {
+    // 配置对象方式
+    return this._extractOnParams(key);
+  } else {
+    // 便捷方式
+    let opts = options || {};
+    return {
+      key: key,
+      func: func,
+      name: name,
+      times: opts.times || -1,
+      priority: opts.priority || 0,
+      ns: opts.ns || null
+    };
+  }
+};
+
+Eventer.prototype._addEventHandler = function (params) {
+  const { key: event_key, func: event_func, name: event_name,
+    times: event_times, priority: event_priority, ns } = params;
+
+  // 解析命名空间
+  const { space, event_key: parsed_event_key, full_key } = this._parseEventKey(event_key, ns);
+
+  // 初始化命名空间和事件数组
+  this._initNamespace(space, parsed_event_key);
+
+  // 设置默认名称
+  let final_name = event_name || this._generateDefaultName(event_func);
+
+  // 应用节流或防抖
+  let wrapped_func = this._wrapFunction(event_func, params);
+
+  // 创建事件对象
+  let obj = this._createHandlerObj({
+    name: final_name,
+    wrapped_func: wrapped_func,
+    func: event_func,
+    times: event_times,
+    priority: event_priority
+  });
+
+  // 处理事件添加逻辑
+  return this._handleEventAddition({ space, event_key: parsed_event_key, full_key, final_name, obj });
+};
+
+Eventer.prototype._extractOnParams = function (config) {
+  return {
+    key: config.key,
+    func: config.func,
+    name: config.name,
+    times: config.times || -1,
+    priority: config.priority || 0,
+    ns: config.ns || null
+  };
+};
+
+Eventer.prototype._processOnceParams = function (key, func, name, options) {
+  // 支持两种调用方式：便捷方式和配置对象方式
+  if (typeof key === 'object' && key !== null) {
+    // 配置对象方式
+    let params = this._extractOnParams(key);
+    params.times = 1; // 强制设置为仅执行一次
+    return params;
+  } else {
+    // 便捷方式
+    let opts = options || {};
+    return {
+      key: key,
+      func: func,
+      name: name,
+      times: 1, // 强制设置为仅执行一次
+      priority: opts.priority || 0,
+      ns: opts.ns || null
+    };
+  }
+};
+
+Eventer.prototype._handleEventAddition = function (config) {
+  const { space, event_key, full_key, final_name, obj } = config;
+  let list = this._dict[space][event_key];
+  let idx = this._findHandlerIndex(list, final_name);
+
+  if (idx >= 0) {
+    // 覆盖已存在的同名监听器
+    Object.assign(list[idx], obj);
+    // 重新排序
+    this._sort(list);
+    return this._createHandlerResult(space, idx, final_name, full_key);
+  } else {
+    // 检查监听器数量是否超过限制
+    this._checkListenerLimit(space, event_key, list);
+
+    // 添加新事件
+    list.push(obj);
+    // 按优先级排序
+    this._sort(list);
+    return this._createHandlerResult(space, list.length - 1, final_name, full_key);
+  }
+};
+
+/**
+ * 监听事件(仅执行一次)
+ * @param {string | object} key 事件关键，支持space:key格式，或配置对象
+ * @param {object} func 触发函数
+ * @param {string} name 增加名称，方便删除，当出现相同名称时会被覆盖
+ * @param {object} options 其他选项
+ * @returns {object} 返回事件信息对象 {space, idx, name}
+ */
+Eventer.prototype.once = function (key, func, name, options) {
+  // 处理参数
+  let params = this._processOnceParams(key, func, name, options);
+
+  // 验证参数
+  this._validateOnParams(params.key, params.func);
+
+  // 处理事件添加
+  return this._addEventHandler(params);
+};
+
+/**
+ * 统一的事件执行引擎
+ * @param {string} key 事件关键字，支持space:key格式
+ * @throws {Error} 事件关键字必须是非空字符串
+ * @private
+ */
+Eventer.prototype._validateExec = function (key) {
+  if (!key || typeof key !== 'string') {
+    throw new Error('事件关键字必须是非空字符串');
+  }
+};
+
+Eventer.prototype._createCtx = function (key, params) {
+  let parsed = this._parseKey(key);
+  let space = parsed.space;
+  let event_key = parsed.key;
+  let full_key = `${space}:${event_key}`;
+  let start_time = Date.now();
+
+  const ctx = {
+    space,
+    event: event_key,
+    full_event: full_key,
+    params,
+    results: [],
+    start_time: start_time,
+    executed: 0,
+    error_count: 0,
+    cancelled: false,
+    cancel: () => {
+      ctx.cancelled = true;
+      this._cancelTasks(full_key);
+    }
+  };
+
+  return { ctx, space, event_key, full_key, start_time };
+};
+
+Eventer.prototype._cancelTasks = function (full_key) {
+  try {
+    if (this._tasks.has(full_key)) {
+      let tasks = this._tasks.get(full_key);
+      tasks.forEach(task => {
+        if (task && typeof task.cancel === 'function') {
+          try {
+            task.cancel();
+          } catch (cancel_error) {
+            this.log('error', `任务取消失败 [${full_key}] - ${task.id}`, cancel_error);
+          }
+        }
+      });
+      this._tasks.delete(full_key);
+    }
+  } catch (cancel_global_error) {
+    this.log('error', `任务取消过程异常 [${full_key}]`, cancel_global_error);
+  }
+};
+
+Eventer.prototype._initTaskList = function (full_key) {
+  try {
+    this._tasks.set(full_key, []);
+  } catch (task_init_error) {
+    this.log('error', `任务列表初始化失败 [${full_key}]`, task_init_error);
+  }
+};
+
+Eventer.prototype._runBeforeMiddleware = async function (ctx, full_key) {
+  try {
+    await this._runMiddleware('before', ctx);
+    if (ctx.cancelled) {
+      this._cleanupTasks(full_key);
+      return true;
+    }
+    return false;
+  } catch (error) {
+    this.log('error', `事件中间件执行失败 [${ctx.space}:${ctx.event}]`, error);
+    if (this.config.error_handler && typeof this.config.error_handler === 'function') {
+      this.config.error_handler(error, { type: 'middleware', stage: 'before', ctx });
+    }
+    return false;
+  }
+};
+
+Eventer.prototype._cleanupTasks = function (full_key) {
+  try {
+    this._tasks.delete(full_key);
+  } catch (cleanup_error) {
+    this.log('error', `任务清理失败 [${full_key}]`, cleanup_error);
+  }
+};
+
+Eventer.prototype._executeStrategy = async function (config) {
+  const { list, params, ctx, full_key, arr, options } = config;
+
+  try {
+    if (options.exec_mode === 'parallel') {
+      await this._executeParallel({ list, params, ctx, full_key, arr });
+    } else if (options.exec_mode === 'race') {
+      ctx.race_result = await this._executeRace({ list, params, ctx, full_key, arr });
+    } else if (options.exec_mode === 'waterfall') {
+      await this._executeWaterfall({
+        list, params, ctx, full_key, arr,
+        initial_value: options.initial_value
+      });
+    } else {
+      await this._executeSequential({ list, params, ctx, full_key, arr });
+    }
+  } catch (exec_error) {
+    this.log('error', `事件执行策略异常 [${full_key}]`, exec_error);
+    if (this.config.error_handler && typeof this.config.error_handler === 'function') {
+      this.config.error_handler(exec_error, { type: 'execution', ctx });
+    }
+  }
+};
+
+Eventer.prototype._removeEvents = function (space, key, arr) {
+  try {
+    for (let i = 0; i < arr.length; i++) {
+      this.del(`${space}:${key}`, arr[i]);
+    }
+  } catch (remove_error) {
+    this.log('error', `事件移除失败 [${space}:${key}]`, remove_error);
+  }
+};
+
+Eventer.prototype._autoCleanup = function (space, key) {
+  try {
+    if (this.config.auto_clean && this._dict[space] && this._dict[space][key] &&
+      this._dict[space][key].length === 0) {
+      delete this._dict[space][key];
+      if (this._dict[space] && Object.keys(this._dict[space]).length === 0) {
+        delete this._dict[space];
+        delete this._space[space];
+      }
+    }
+  } catch (cleanup_error) {
+    this.log('error', `自动清理失败 [${space}:${key}]`, cleanup_error);
+  }
+};
+
+Eventer.prototype._runAfterMiddleware = async function (ctx, start_time) {
+  try {
+    ctx.end_time = Date.now();
+    ctx.duration = ctx.end_time - start_time;
+    await this._runMiddleware('after', ctx);
+  } catch (error) {
+    this.log('error', `事件后置中间件执行失败 [${ctx.space}:${ctx.event}]`, error);
+    if (this.config.error_handler && typeof this.config.error_handler === 'function') {
+      this.config.error_handler(error, { type: 'middleware', stage: 'after', ctx });
+    }
+  }
+};
+
+Eventer.prototype._executeEventChain = async function (ctx, full_key, params) {
+  if (!ctx.cancelled && this.config.chain_enabled && this._chain[full_key]) {
+    try {
+      await this._triggerChain(full_key, params);
+    } catch (chain_error) {
+      this.log('error', `事件链执行失败 [${full_key}]`, chain_error);
+      if (this.config.error_handler && typeof this.config.error_handler === 'function') {
+        this.config.error_handler(chain_error, { type: 'chain', ctx });
+      }
+    }
+  }
+};
+
+Eventer.prototype._buildSafeResult = function (ctx) {
+  try {
+    return {
+      results: ctx.results || [],
+      cancelled: ctx.cancelled || false,
+      cancel: ctx.cancel || (() => { }),
+      race: ctx.race_result,
+      waterfall: ctx.results && ctx.results.length > 0 ? ctx.results[ctx.results.length - 1]
+        : undefined
+    };
+  } catch (return_error) {
+    this.log('error', `结果构造失败 [${ctx.full_event}]`, return_error);
+    return {
+      results: [],
+      cancelled: true,
+      cancel: () => { },
+      error: return_error
+    };
+  }
+};
+
+Eventer.prototype._execute = async function (key, options = {}, ...params) {
+  this._validateExec(key);
+
+  const { ctx, space, event_key, full_key, start_time } = this._createCtx(key, params);
+
+  if (this.isPaused(full_key)) {
+    return this._createPausedResult();
+  }
+
+  let list = this._dict[space] && this._dict[space][event_key];
+  const arr = [];
+
+  if (list && list.length > 0) {
+    await this._executeEventList({
+      list, params, ctx, full_key, arr, options, space, event_key, start_time
+    });
+  }
+
+  await this._executeEventChain(ctx, full_key, params);
+  return this._buildSafeResult(ctx);
+};
+
+/**
+ * 创建暂停状态的结果对象
+ * @returns {object} 暂停状态的结果
+ * @private
+ */
+Eventer.prototype._createPausedResult = function () {
+  return {
+    results: [],
+    cancelled: false,
+    paused: true,
+    /**
+     * 取消函数
+     */
+    cancel: () => { }
+  };
+};
+
+/**
+ * 执行事件列表
+ * @param {object} config 配置参数
+ * @param {Array} config.list 事件列表
+ * @param {Array} config.params 参数
+ * @param {object} config.ctx 上下文
+ * @param {string} config.full_key 完整键名
+ * @param {Array} config.arr 数组
+ * @param {object} config.options 选项
+ * @param {string} config.space 命名空间
+ * @param {string} config.event_key 事件键
+ * @param {number} config.start_time 开始时间
+ * @param {string} config.strategy 执行策略，默认sequential
+ * @returns {object} 返回执行结果
+ * @private
+ */
+Eventer.prototype._executeEventList = async function (config) {
+  const { list, params, ctx, full_key, arr, options, space, event_key, start_time } = config;
+
+  this._initTaskList(full_key);
+
+  let cancelled = await this._runBeforeMiddleware(ctx, full_key);
+  if (cancelled) {
+    return {
+      results: [],
+      cancelled: true,
+      cancel: ctx.cancel
+    };
+  }
+
+  await this._executeStrategy({ list, params, ctx, full_key, arr, options });
+
+  this._cleanupTasks(full_key);
+  this._removeEvents(space, event_key, arr);
+  this._autoCleanup(space, event_key);
+  await this._runAfterMiddleware(ctx, start_time);
+};
+
+/**
+ * 顺序执行事件处理函数
+ * @param {object} config 配置参数
+ * @private
+ */
+Eventer.prototype._executeSequential = async function (config) {
+  const { list, params, ctx, full_key, arr } = config;
+
+  for (let i = 0; i < list.length && !ctx.cancelled; i++) {
+    let o = list[i];
+    ctx.executed++;
+    o.last_executed = Date.now();
+
+    // 创建并执行单个任务
+    await this._execSingleTask(o, params, ctx, { full_key, arr });
+  }
+};
+
+Eventer.prototype._execSingleTask = async function (o, params, ctx, options) {
+  const { full_key, arr } = options;
+
+  // 创建任务
+  let task = this._createTask(o, full_key);
+
+  try {
+    // 执行事件处理函数
+    let result = await o.func.apply(o, params);
+
+    // 处理成功结果
+    this._handleSuccessResult({ result, o, ctx, arr, task });
+  } catch (e) {
+    // 处理错误
+    this._handleSeqTaskError(e, o, ctx, task);
+  }
+};
+
+Eventer.prototype._createTask = function (o, full_key) {
+  let task_id = `${o.name}_${Date.now()}`;
+  let cancelled = false;
+  const task = {
+    id: task_id,
+    cancel: () => { cancelled = true; }
+  };
+
+  // 添加到进行中的任务列表（防御性处理重入调用导致 key 已被清理的情况）
+  let tasks = this._tasks.get(full_key);
+  if (!tasks) {
+    tasks = [];
+    this._tasks.set(full_key, tasks);
+  }
+  tasks.push(task);
+
+  return { task, tasks, cancelled };
+};
+
+Eventer.prototype._handleSuccessResult = function (config) {
+  const { result, o, ctx, arr, task } = config;
+
+  // 如果任务已取消，则不添加结果
+  if (!task.cancelled && !ctx.cancelled) {
+    ctx.results.push(result);
+
+    // 处理执行次数限制
+    if (o.times >= 0) {
+      o.times--;
+      if (o.times <= 0) {
+        arr.push(o.name);
+      }
+    }
+  }
+
+  // 从进行中的任务列表中移除
+  task.tasks.splice(task.tasks.indexOf(task.task), 1);
+};
+
+Eventer.prototype._handleSeqTaskError = function (e, o, ctx, task) {
+  ctx.error_count++;
+  this.log('error', `事件执行失败 [${ctx.space}:${ctx.event}] - ${o.name}`, e);
+
+  const error_result = {
+    _error: true,
+    error: e,
+    handler: o.name,
+    timestamp: Date.now()
+  };
+
+  ctx.results.push(error_result);
+
+  // 全局错误处理器
+  if (this.config.error_handler && typeof this.config.error_handler === 'function') {
+    this.config.error_handler(e, { type: 'handler', handler: o.name, ctx });
+  }
+
+  // 从进行中的任务列表中移除
+  task.tasks.splice(task.tasks.indexOf(task.task), 1);
+};
+
+/**
+ * 并行执行事件处理函数
+ * @param {object} config 配置参数
+ * @private
+ */
+Eventer.prototype._executeParallel = async function (config) {
+  const { list, params, ctx, full_key, arr } = config;
+  let concurrency = this._getConcurrency(params);
+  // eslint-disable-next-line mm_eslint/class-instance-name
+  const proc_results = new Array(list.length);
+
+  if (concurrency < Infinity) {
+    await this._executeBatches({
+      list, params, ctx, full_key, arr, concurrency, proc_results
+    });
+  } else {
+    await this._executeAllParallel({ list, params, ctx, full_key, arr, proc_results });
+  }
+
+  this._setResults(ctx, proc_results);
+};
+
+Eventer.prototype._getConcurrency = function (params) {
+  return params.options && typeof params.options.concurrency === 'number' ?
+    params.options.concurrency : Infinity;
+};
+
+Eventer.prototype._executeBatches = async function (config) {
+  const { list, params, ctx, full_key, arr, concurrency, proc_results } = config;
+
+  for (let i = 0; i < list.length && !ctx.cancelled; i += concurrency) {
+    let batch = list.slice(i, i + concurrency);
+    let batch_promises = batch.map((obj, batch_idx) => {
+      let global = i + batch_idx;
+      return this._executeSingleTask({
+        obj, params, ctx, full_key, arr, idx: global, proc_results
+      });
+    });
+
+    await Promise.allSettled(batch_promises);
+  }
+};
+
+Eventer.prototype._executeAllParallel = async function (config) {
+  const { list, params, ctx, full_key, arr, proc_results } = config;
+
+  let promises = list.map((obj, idx) => {
+    return this._executeSingleTask({ obj, params, ctx, full_key, arr, idx, proc_results });
+  });
+
+  await Promise.allSettled(promises);
+};
+
+Eventer.prototype._setResults = function (ctx, proc_results) {
+  ctx.results = proc_results.filter(result => result !== undefined);
+};
+
+/**
+ * 瀑布流执行事件处理函数
+ * @param {object} config 配置参数
+ * @private
+ */
+Eventer.prototype._executeWaterfall = async function (config) {
+  const { list, params, ctx, full_key, arr, initial_value } = config;
+  let wate_value = this._getInitialValue(params, initial_value);
+
+  for (let i = 0; i < list.length && !ctx.cancelled; i++) {
+    let obj = list[i];
+    ctx.executed++;
+    obj.last_executed = Date.now();
+
+    let task = this._createWaterfallTask(obj, full_key);
+    wate_value = await this._execWaterfallStep({
+      obj, params, ctx, arr, task, wate_value
+    });
+  }
+};
+
+Eventer.prototype._getInitialValue = function (params, initial_value) {
+  return initial_value !== undefined ? initial_value : (params.length > 0 ? params[0] : undefined);
+};
+
+Eventer.prototype._createWaterfallTask = function (obj, full_key) {
+  let task_id = `${obj.name}_${Date.now()}`;
+  let cancelled = false;
+  const task = {
+    id: task_id,
+    cancel: () => { cancelled = true; }
+  };
+
+  let tasks = this._tasks.get(full_key);
+  if (!tasks) {
+    tasks = [];
+    this._tasks.set(full_key, tasks);
+  }
+  tasks.push(task);
+
+  return { task, tasks, cancelled };
+};
+
+Eventer.prototype._execWaterfallStep = async function (config) {
+  const { obj, params, ctx, arr, task, wate_value } = config;
+  try {
+    let result = await obj.func.apply(obj, [wate_value, ...params.slice(1)]);
+    this._handleWfSuccess({ result, obj, ctx, arr, task });
+    return result;
+  } catch (e) {
+    this._handleWfError({ e, obj, ctx, task });
+    return wate_value;
+  }
+};
+
+Eventer.prototype._handleWfSuccess = function (config) {
+  const { result, obj, ctx, arr, task } = config;
+  if (!task.cancelled && !ctx.cancelled) {
+    ctx.results.push(result);
+    this._handleTimesLimit(obj, arr);
+  }
+  this._removeTask(task);
+};
+
+Eventer.prototype._handleWfError = function (config) {
+  const { e, obj, ctx, task } = config;
+  ctx.error_count++;
+  this.log('error', `事件执行失败 [${ctx.space}:${ctx.event}] - ${obj.name}`, e);
+
+  const error_result = {
+    _error: true,
+    error: e,
+    handler: obj.name,
+    timestamp: Date.now()
+  };
+
+  ctx.results.push(error_result);
+  this._callErrorHandler(e, obj, ctx);
+  this._removeTask(task);
+};
+
+Eventer.prototype._handleTimesLimit = function (obj, arr) {
+  if (obj.times >= 0) {
+    obj.times--;
+    if (obj.times <= 0) {
+      arr.push(obj.name);
+    }
+  }
+};
+
+Eventer.prototype._removeTask = function (task) {
+  task.tasks.splice(task.tasks.indexOf(task.task), 1);
+};
+
+Eventer.prototype._callErrorHandler = function (e, obj, ctx) {
+  if (this.config.error_handler && typeof this.config.error_handler === 'function') {
+    this.config.error_handler(e, { type: 'handler', handler: obj.name, ctx });
+  }
+};
+
+/**
+ * 竞争执行模式 - 返回第一个完成的结果
+ * @param {object} config 配置参数
+ * @param {Array} config.list 事件列表
+ * @param {Array} config.params 参数
+ * @param {object} config.ctx 上下文
+ * @param {string} config.strategy 执行策略
+ * @returns {Promise<object>} 返回包含results和cancel方法的对象
+ * @private
+ */
+Eventer.prototype._executeRace = async function (config) {
+  const { list, params, ctx, full_key, arr } = config;
+  let promises = this._createRacePromises({ list, params, ctx, full_key, arr });
+
+  return await this._runRace(promises);
+};
+
+Eventer.prototype._createRacePromises = function (config) {
+  const { list, params, ctx, full_key, arr } = config;
+  const promises = [];
+
+  for (let i = 0; i < list.length && !ctx.cancelled; i++) {
+    let obj = list[i];
+    ctx.executed++;
+    obj.last_executed = Date.now();
+
+    let promise = this._createRacePromise({ obj, params, ctx, full_key, arr });
+    promises.push(promise);
+  }
+
+  return promises;
+};
+
+Eventer.prototype._createRacePromise = function (config) {
+  const { obj, params, ctx, full_key, arr } = config;
+  let task = this._createRaceTask(obj, full_key);
+
+  return (async () => {
+    try {
+      let result = await obj.func.apply(obj, params);
+      return this._handleRaceSuccess({ result, obj, ctx, arr, task });
+    } catch (e) {
+      return this._handleRaceError(e, obj, ctx, task);
+    } finally {
+      this._removeTask(task);
+    }
+  })();
+};
+
+Eventer.prototype._createRaceTask = function (obj, full_key) {
+  let task_id = `${obj.name}_${Date.now()}`;
+  let cancelled = false;
+  const task = {
+    id: task_id,
+    cancel: () => { cancelled = true; }
+  };
+
+  let tasks = this._tasks.get(full_key);
+  if (!tasks) {
+    tasks = [];
+    this._tasks.set(full_key, tasks);
+  }
+  tasks.push(task);
+
+  return { task, tasks, cancelled };
+};
+
+Eventer.prototype._handleRaceSuccess = function (config) {
+  const { result, obj, ctx, arr, task } = config;
+
+  if (!task.cancelled && !ctx.cancelled) {
+    ctx.results.push(result);
+    this._handleTimesLimit(obj, arr);
+    return { success: true, result, handler: obj.name };
+  }
+  return { success: false, cancelled: true };
+};
+
+Eventer.prototype._handleRaceError = function (e, obj, ctx, task) {
+  ctx.error_count++;
+  this.log('error', `事件执行失败 [${ctx.space}:${ctx.event}] - ${obj.name}`, e);
+
+  const error_result = {
+    _error: true,
+    error: e,
+    handler: obj.name,
+    timestamp: Date.now()
+  };
+
+  ctx.results.push(error_result);
+  this._callErrorHandler(e, obj, ctx);
+
+  return { success: false, error: e, handler: obj.name };
+};
+
+Eventer.prototype._runRace = async function (promises) {
+  if (promises.length > 0) {
+    let race = await Promise.race(promises);
+    return race;
+  }
+  return null;
+};
+
+/**
+ * 执行单个任务（并行执行时使用）
+ * @param {object} config 配置参数
+ * @private
+ */
+Eventer.prototype._executeSingleTask = async function (config) {
+  const { obj, params, ctx, full_key, arr, idx, proc_results } = config;
+  obj.last_executed = Date.now();
+
+  // 创建任务
+  let task_info = this._createParallelTask(obj, full_key);
+
+  try {
+    let result = await obj.func.apply(obj, params);
+    this._handleTaskSuccess({ result, obj, ctx, arr, idx, proc_results, task_info });
+  } catch (err) {
+    this._handleTaskError({ err, obj, ctx, idx, proc_results, task_info });
+  }
+};
+
+Eventer.prototype._createParallelTask = function (obj, full_key) {
+  let task_id = `${obj.name}_${Date.now()}`;
+  let cancelled = false;
+  const task = {
+    id: task_id,
+    cancel: () => { cancelled = true; }
+  };
+
+  // 添加到进行中的任务列表（防御性处理重入调用导致 key 已被清理的情况）
+  let tasks = this._tasks.get(full_key);
+  if (!tasks) {
+    tasks = [];
+    this._tasks.set(full_key, tasks);
+  }
+  tasks.push(task);
+
+  return { task, tasks, cancelled };
+};
+
+Eventer.prototype._handleTaskSuccess = function (config) {
+  const { result, obj, ctx, arr, idx, proc_results, task_info } = config;
+
+  // 从进行中的任务列表中移除
+  task_info.tasks.splice(task_info.tasks.indexOf(task_info.task), 1);
+
+  if (!task_info.cancelled && !ctx.cancelled) {
+    proc_results[idx] = result;
+
+    // 处理执行次数限制
+    if (obj.times >= 0) {
+      obj.times--;
+      if (obj.times <= 0) {
+        arr.push(obj.name);
+      }
+    }
+  }
+};
+
+Eventer.prototype._handleTaskError = function (config) {
+  const { err, obj, ctx, idx, proc_results, task_info } = config;
+
+  // 从进行中的任务列表中移除
+  task_info.tasks.splice(task_info.tasks.indexOf(task_info.task), 1);
+
+  if (!task_info.cancelled && !ctx.cancelled) {
+    const error_result = {
+      _error: true,
+      error: err,
+      handler: obj.name,
+      timestamp: Date.now()
+    };
+    proc_results[idx] = error_result;
+
+    // 全局错误处理器
+    if (this.config.error_handler && typeof this.config.error_handler === 'function') {
+      this.config.error_handler(err, { type: 'handler', handler: obj.name, ctx });
+    }
+  }
+};
+
+/**
+ * 执行事件（支持中间件和命名空间）
+ * @param {string} key 事件关键字，支持space:key格式
+ * @param {object} params 传递参数
+ * @returns {Promise<object>} 返回包含results和cancel方法的对象
+ */
+Eventer.prototype.run = async function (key, ...params) {
+  return this._execute(key, { exec_mode: 'sequential' }, ...params);
+};
+
+/**
+ * 触发事件
+ * @param {string} key 事件关键，支持space:key格式
+ * @param {object} params 传递参数
+ * @returns {Promise<object>} 返回包含results和cancel方法的对象
+ */
+Eventer.prototype.emit = function (key, ...params) {
+  // 内部调用 _execute 方法，但不等待结果
+  try {
+    let result = this._execute(key, { exec_mode: 'sequential' }, ...params);
+    result.catch(e => this.log('error', '事件异步执行失败:', e));
+    return {
+      ...result,
+      cancel: () => {
+        try {
+          return result.then(r => r && typeof r.cancel === 'function' && r.cancel());
+        } catch (cancel_error) {
+          this.log('error', `事件取消失败 [${key}]`, cancel_error);
+          return Promise.resolve();
+        }
+      }
+    };
+  } catch (error) {
+    this.log('error', `事件触发失败 [${key}]`, error);
+    // 返回一个安全的默认结果
+    return {
+      results: [],
+      cancelled: false,
+      cancel: () => { },
+      error: error
+    };
+  }
+};
+
+/**
+ * 异步触发事件，按顺序执行等待完成
+ * @param {string} key 事件关键字，支持space:key格式
+ * @param  {...any} args 事件参数
+ * @returns {Promise} - 事件触发结果
+ */
+Eventer.prototype.emitWait = async function (key, ...args) {
+  try {
+    let result = await this._execute(key, { exec_mode: 'sequential' }, ...args);
+    return result.results || [];
+  } catch (error) {
+    this.log('error', `等待事件触发失败 [${key}]`, error);
+    return [];
+  }
+};
+
+/**
+ * 异步触发事件，并发执行不等待
+ * @param {string} key 事件关键字，支持space:key格式
+ * @param  {...any} args 事件参数
+ * @returns {boolean} - 是否有监听者
+ */
+Eventer.prototype.emitAsync = async function (key, ...args) {
+  try {
+    return this._execAsync(key, args);
+  } catch (global_error) {
+    this.log('error', `异步事件触发失败 [${key}]`, global_error);
+    return false;
+  }
+};
+
+Eventer.prototype._execAsync = function (key, args) {
+  // 解析命名空间
+  let parsed = this._parseKey(key);
+  let space = parsed.space;
+  let event_key = parsed.key;
+  let full_key = `${space}:${event_key}`;
+
+  // 获取事件列表
+  let list = this._dict[space] && this._dict[space][event_key];
+
+  if (!list || list.length === 0) {
+    return false;
+  }
+
+  // 立即启动所有监听器，但不等待
+  list.forEach(handler => {
+    this._executeAsyncHandler(handler, args, full_key);
+  });
+
+  return true;
+};
+
+Eventer.prototype._executeAsyncHandler = function (handler, args, full_key) {
+  try {
+    // 使用 Promise.resolve 确保异步执行
+    Promise.resolve(handler.func(...args))
+      .catch(error => {
+        this._handleAsyncError(error, full_key, args);
+      });
+  } catch (sync_error) {
+    this._handleSyncError(sync_error, full_key, args);
+  }
+};
+
+Eventer.prototype._handleAsyncError = function (error, full_key, args) {
+  // 错误处理 - 记录但不抛出
+  this.log('error', `异步监听器错误 [${full_key}]:`, error);
+  try {
+    this.emit('async:error', error, full_key, args);
+  } catch (error) {
+    this.log('error', '错误事件触发失败 [async:error]', error);
+  }
+};
+
+Eventer.prototype._handleSyncError = function (sync_error, full_key, args) {
+  // 同步错误处理
+  this.log('error', `同步监听器错误 [${full_key}]:`, sync_error);
+  try {
+    this.emit('sync:error', sync_error, full_key, args);
+  } catch (error) {
+    this.log('error', '错误事件触发失败 [sync:error]', error);
+  }
+};
+
+/**
+ * 异步触发事件，并发执行等待完成
+ * @param {string} key 事件关键字，支持space:key格式
+ * @param  {...any} args 事件参数
+ * @returns {Promise<Array>} - 所有监听器的执行结果
+ */
+Eventer.prototype.emitAll = async function (key, ...args) {
+  try {
+    let result = await this._execute(key, { exec_mode: 'parallel' }, ...args);
+    return result.results || [];
+  } catch (error) {
+    this.log('error', `并发事件触发失败 [${key}]`, error);
+    return [];
+  }
+};
+
+/**
+ * 异步触发事件，竞争执行
+ * @param {string} key 事件关键字，支持space:key格式
+ * @param  {...any} args 事件参数
+ * @returns {Promise} - 第一个完成的结果
+ */
+Eventer.prototype.emitRace = async function (key, ...args) {
+  try {
+    let result = await this._execute(key, { exec_mode: 'race' }, ...args);
+    return result.race || null;
+  } catch (error) {
+    this.log('error', `竞争事件触发失败 [${key}]`, error);
+    return null;
+  }
+};
+
+/**
+ * 异步触发事件，返回第一个有返回值的结果（不阻塞其他监听器）
+ * @param {string} key 事件关键字，支持space:key格式
+ * @param  {...any} args 事件参数
+ * @returns {Promise} - 第一个有返回值（非 undefined）的监听器结果
+ * 所有监听器并行执行，返回第一个有返回值（非 undefined）的结果，返回 undefined 的监听器被跳过，其他监听器继续在后台执行不受影响
+ */
+Eventer.prototype.emitFirst = async function (key, ...args) {
+  try {
+    let parsed = this._parseKey(key);
+    let space = parsed.space;
+    let event_key = parsed.key;
+
+    let list = this._dict[space] && this._dict[space][event_key];
+    if (!list || list.length === 0) {
+      return undefined;
+    }
+
+    return await new Promise(resolve => {
+      let settled = false;
+      let pending = list.length;
+
+      for (let handler of list) {
+        Promise.resolve(handler.func(...args)).then(result => {
+          if (!settled && result !== undefined) {
+            settled = true;
+            resolve(result);
+          }
+          pending--;
+          if (pending === 0 && !settled) {
+            resolve(undefined);
+          }
+        }).catch(() => {
+          pending--;
+          if (pending === 0 && !settled) {
+            resolve(undefined);
+          }
+        });
+      }
+    });
+  } catch (error) {
+    this.log('error', `首个结果事件触发失败 [${key}]`, error);
+    return undefined;
+  }
+};
+
+/**
+ * 异步触发事件，瀑布流执行
+ * @param {string} key 事件关键字，支持space:key格式
+ * @param {*} value 初始值
+ * @param  {...any} args 事件参数
+ * @returns {Promise} - 最后一个事件监听者的结果
+ */
+Eventer.prototype.emitWaterfall = async function (key, value, ...args) {
+  try {
+    let result = await this._execute(key, {
+      exec_mode: 'waterfall',
+      initial_value: value
+    }, ...args);
+    return result.waterfall || value;
+  } catch (error) {
+    this.log('error', `瀑布流事件触发失败 [${key}]`, error);
+    return value;
+  }
+};
+
+/**
+ * 确保命名空间在映射中
+ * @private
+ * @param {string} name 命名空间名称
+ */
+Eventer.prototype._ensureNs = function (name) {
+  if (!this._space[name]) {
+    this._space[name] = true;
+  }
+};
+
+/**
+ * 执行单个命名空间的事件处理函数
+ * @private
+ * @param {string} name 命名空间名称
+ * @param {string} key 事件关键字
+ * @param {Array} params 事件参数
+ * @returns {object} 包含结果和需要移除的事件名称的对象
+ */
+Eventer.prototype._execNsEvents = async function (name, key, params) {
+  let list = this._dict[name][key];
+  const name_results = [];
+  const arr = []; // 存储需要移除的事件
+
+  // 执行事件处理函数
+  for (let i = 0; i < list.length; i++) {
+    try {
+      let obj = list[i];
+      // 执行事件处理函数
+      let result = await obj.func.apply(obj, params);
+      name_results.push(result);
+
+      // 处理执行次数限制
+      if (obj.times >= 0) {
+        obj.times--;
+        if (obj.times <= 0) {
+          arr.push(obj.name);
+        }
+      }
+    } catch (e) {
+      // 记录错误但不中断执行
+      this.log('error', `事件执行失败 [${name}:${key}] - ${list[i].name}`, e);
+      name_results.push({
+        _error: true,
+        error: e,
+        handler: list[i].name
+      });
+    }
+  }
+
+  return { name_results, arr };
+};
+
+/**
+  * 移除已执行完的事件
+  * @private
+  * @param {string} name 命名空间名称
+  * @param {string} key 事件关键字
+  * @param {Array} arr 需要移除的事件名称数组
+  */
+Eventer.prototype.emitAllNamespaces = async function (key, ...params) {
+  const results = {};
+  // 确保遍历所有命名空间，包括动态创建的
+  for (let name in this._dict) {
+    // 确保命名空间在space映射中
+    this._ensureNs(name);
+
+    // 检查该命名空间下是否存在该事件
+    if (this._dict[name] && this._dict[name][key]) {
+      const { name_results, arr } = await this._execNsEvents(name, key, params);
+
+      // 移除已执行完的事件
+      this._removeEvents(name, key, arr);
+
+      results[name] = name_results;
+    }
+  }
+  return results;
+};
+
+/**
+ * 删除单个事件监听器
+ * @private
+ * @param {Array} events 事件列表
+ * @param {string | number} index_or_name 事件索引或名称
+ * @returns {boolean} 删除成功返回true，否则返回false
+ */
+Eventer.prototype._removeSingleEvent = function (events, index_or_name) {
+  if (typeof (index_or_name) === 'number') {
+    // 按索引删除
+    if (index_or_name >= 0 && index_or_name < events.length) {
+      events.splice(index_or_name, 1);
+      return true;
+    }
+  } else {
+    // 根据名称删除事件
+    for (let j = events.length - 1; j >= 0; j--) {
+      if (events[j].name === index_or_name) {
+        events.splice(j, 1);
+        return true;
+      }
+    }
+  }
+  return false;
+};
+
+/**
+ * 删除整个事件
+ * @private
+ * @param {string} space 命名空间
+ * @param {string} event_key 事件键
+ * @param {string} full_key 完整事件关键字
+ * @returns {boolean} 删除成功返回true
+ */
+Eventer.prototype._removeEntireEvent = function (space, event_key, full_key) {
+  // 安全检查：确保命名空间和事件存在
+  if (!this._dict[space] || !this._dict[space][event_key]) {
+    return false;
+  }
+
+  // 删除整个事件
+  delete this._dict[space][event_key];
+
+  // 清理相关的事件链
+  if (this._chain) {
+    for (let chain_key in this._chain) {
+      if (chain_key === full_key) {
+        delete this._chain[chain_key];
+      } else if (this._chain[chain_key] && Array.isArray(this._chain[chain_key]) &&
+        this._chain[chain_key].includes(full_key)) {
+        delete this._chain[chain_key];
+      }
+    }
+  }
+
+  return true;
+};
+
+/**
+ * 自动清理空的事件列表和命名空间
+ * @private
+ * @param {string} space 命名空间
+ * @param {string} key 事件关键字
+ * @param {Array} events 事件列表
+ * @param {string | number} index_or_name 事件索引或名称
+ */
+Eventer.prototype._autoCleanEvents = function (space, key, events, index_or_name) {
+  if (!this.config.auto_clean) return;
+
+  // 安全检查：确保命名空间存在
+  if (!this._dict[space]) {
+    return;
+  }
+
+  // 清理空的事件列表
+  if (index_or_name && events && events.length === 0) {
+    // 安全检查：确保事件键存在
+    if (this._dict[space][key]) {
+      delete this._dict[space][key];
+    }
+  }
+
+  // 如果命名空间为空，则删除命名空间
+  if (this._dict[space] && Object.keys(this._dict[space]).length === 0) {
+    delete this._dict[space];
+    if (this._space && this._space[space]) {
+      delete this._space[space];
+    }
+  }
+};
+
+/**
+ * 删除事件
+ * @param {string} key 事件关键字，支持space:key格式
+ * @param {number | string} index_or_name 事件集索引或名称
+ * @returns {boolean} 删除成功返回true，否则返回false
+ */
+Eventer.prototype.off = function (key, index_or_name) {
+  // 入参校验
+  if (!key || typeof key !== 'string') {
+    throw new Error('事件关键字必须是非空字符串');
+  }
+
+  // 解析命名空间
+  let parsed = this._parseKey(key);
+  let space = parsed.space;
+  let event_key = parsed.key;
+  let full_key = `${space}:${event_key}`;
+
+  // 检查事件是否存在
+  if (!this._dict[space] || !this._dict[space][event_key]) {
+    return false;
+  }
+
+  let events = this._dict[space][event_key];
+  let removed = false;
+
+  if (index_or_name) {
+    // 删除单个事件
+    removed = this._removeSingleEvent(events, index_or_name);
+  } else {
+    // 删除整个事件
+    removed = this._removeEntireEvent(space, event_key, full_key);
+  }
+
+  // 自动清理
+  if (removed) {
+    this._autoCleanEvents(space, event_key, events, index_or_name);
+  }
+
+  return removed;
+};
+
+Eventer.prototype.add = Eventer.prototype.on;
+Eventer.prototype.del = Eventer.prototype.off;
+
+/**
+ * 删除命名空间中的所有事件
+ * @param {string} name 命名空间
+ * @returns {boolean} 删除成功返回true，否则返回false
+ */
+Eventer.prototype.clearNamespace = function (name) {
+  if (!name || !this._dict[name]) {
+    return false;
+  }
+  delete this._dict[name];
+  delete this._space[name];
+  return true;
+};
+
+/**
+ * 获取事件列表
+ * @param {string} key 事件关键字，如果为空则获取所有事件，支持space:key格式
+ * @returns {Array | object} 返回事件列表或所有事件对象
+ */
+Eventer.prototype.getEvents = function (key) {
+  if (key) {
+    // 解析命名空间
+    const { space, key: event_key } = this._parseKey(key);
+    return this._dict[space] &&
+
+      this._dict[space][event_key] ? [...this._dict[space][event_key]] : [];
+  }
+  // 返回深拷贝的所有事件
+  const result = {};
+  for (let name in this._dict) {
+    result[name] = {};
+    for (let key in this._dict[name]) {
+      result[name][key] = [...this._dict[name][key]];
+    }
+  }
+  return result;
+};
+
+/**
+ * 获取所有命名空间
+ * @returns {Array} 返回所有命名空间数组
+ */
+Eventer.prototype.getNamespace = function () {
+  return Object.keys(this._space);
+};
+
+/**
+ * 清空所有事件和资源
+ * @param {boolean} keep_space 是否保留命名空间定义，默认false
+ * @returns {Eventer} 返回当前实例，支持链式调用
+ */
+Eventer.prototype.clear = function (keep_space = false) {
+  // 取消所有进行中的任务
+  if (this._tasks) {
+    this._tasks.forEach((tasks, key) => {
+      tasks.forEach(task => {
+        if (task && typeof task.cancel === 'function') {
+          task.cancel();
+        }
+      });
+    });
+    this._tasks.clear();
+  }
+
+  // 清空事件字典
+  this._dict = {};
+
+  // 清空事件链
+  this._chain = {};
+
+  // 清空暂停状态
+  if (this._paused) {
+    this._paused.clear();
+  }
+  if (this._paused_space) {
+    this._paused_space.clear();
+  }
+  this._paused_global = false;
+
+  // 保留命名空间定义
+  if (!keep_space) {
+    this._space = {};
+    // 重新初始化默认命名空间
+    this._space[this.config.default_name] = true;
+  }
+
+  return this;
+};
+
+/**
+ * 检查事件是否存在
+ * @param {string} key 事件关键字，支持space:key格式
+ * @param {string} name 事件名称（可选）
+ * @returns {boolean} 事件存在返回true，否则返回false
+ */
+Eventer.prototype.has = function (key, name) {
+  // 解析命名空间
+  let parsed = this._parseKey(key);
+  let space = parsed.space;
+  let event_key = parsed.key;
+
+  if (!this._dict[space] || !this._dict[space][event_key]) {
+    return false;
+  }
+
+  if (name) {
+    let list = this._dict[space][event_key];
+    for (let i = 0; i < list.length; i++) {
+      if (list[i].name === name) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  return true;
+};
+
+/**
+ * 获取事件数量
+ * @param {string} key 事件关键字，如果为空则获取所有事件数量，支持space:key格式或space:*格式
+ * @returns {number} 返回事件数量
+ */
+Eventer.prototype.count = function (key) {
+  if (key) {
+    // 解析可能的命名空间模式
+    if (key.endsWith(':*')) {
+      // 统计命名空间下所有事件
+      let space = key.split(':')[0];
+      if (this._dict[space]) {
+        let total = 0;
+        for (let key in this._dict[space]) {
+          total += this._dict[space][key].length;
+        }
+        return total;
+      }
+      return 0;
+    }
+
+    // 解析具体事件
+    const { space, key: event_key } = this._parseKey(key);
+    return this._dict[space] &&
+
+      this._dict[space][event_key] ? this._dict[space][event_key].length : 0;
+  }
+
+  // 统计所有事件
+  let total = 0;
+  for (let name in this._dict) {
+    for (let key in this._dict[name]) {
+      total += this._dict[name][key].length;
+    }
+  }
+  return total;
+};
+
+/**
+ * 添加事件中间件
+ * @param {string} type 中间件类型，'before' 或 'after'
+ * @param {Function} middleware 中间件函数，接收ctx参数
+ * @returns {Eventer} 返回当前实例，支持链式调用
+ */
+Eventer.prototype.use = function (type, middleware) {
+  if (type !== 'before' && type !== 'after') {
+    throw new Error('中间件类型必须是 "before" 或 "after"');
+  }
+  if (typeof middleware !== 'function') {
+    throw new Error('中间件必须是一个函数');
+  }
+
+  if (!this._middleware[type]) {
+    this._middleware[type] = [];
+  }
+  this._middleware[type].push(middleware);
+  return this;
+};
+
+/**
+ * 添加事件链式触发关系
+ * @param {string} from_event 源事件，支持space:key格式
+ * @param {string | Array} to_events 目标事件，可以是单个事件或事件数组
+ * @returns {Eventer} 返回当前实例，支持链式调用
+ */
+Eventer.prototype.chain = function (from_event, to_events) {
+  // 入参校验
+  this._validateChainInput(from_event, to_events);
+
+  // 解析源事件
+  let full_from_event = this._getFullEventKey(from_event);
+
+  // 初始化事件链
+  this._initEventChain(full_from_event);
+
+  // 添加目标事件
+  this._addTargetEvents(full_from_event, to_events);
+
+  return this;
+};
+
+Eventer.prototype._validateChainInput = function (from_event, to_events) {
+  if (!from_event || typeof from_event !== 'string') {
+    throw new Error('源事件必须是非空字符串');
+  }
+};
+
+Eventer.prototype._getFullEventKey = function (event) {
+  const { space, key } = this._parseKey(event);
+  return `${space}:${key}`;
+};
+
+Eventer.prototype._initEventChain = function (full_from_event) {
+  if (!this._chain[full_from_event]) {
+    this._chain[full_from_event] = [];
+  }
+};
+
+Eventer.prototype._addTargetEvents = function (full_from_event, to_events) {
+  // 确保目标事件是数组
+  let target_events = Array.isArray(to_events) ? to_events : [to_events];
+
+  for (let i = 0; i < target_events.length; i++) {
+    this._addTargetEvent(full_from_event, target_events[i]);
+  }
+};
+
+Eventer.prototype._addTargetEvent = function (full_from_event, to_event) {
+  if (typeof to_event !== 'string') {
+    throw new Error('目标事件必须是非空字符串');
+  }
+
+  // 解析目标事件
+  let full_to_event = this._getFullEventKey(to_event);
+
+  // 避免重复添加
+  if (!this._chain[full_from_event].includes(full_to_event)) {
+    this._chain[full_from_event].push(full_to_event);
+  }
+};
+
+/**
+ * 移除事件链式触发关系
+ * @param {string} from_event 源事件，支持space:key格式
+ * @param {string | Array} to_events 目标事件，可以是单个事件或事件数组（可选，不提供则移除所有关联）
+ * @returns {Eventer} 返回当前实例，支持链式调用
+ */
+Eventer.prototype.unchain = function (from_event, to_events) {
+  // 入参校验
+  if (!from_event || typeof from_event !== 'string') {
+    throw new Error('源事件必须是非空字符串');
+  }
+
+  // 解析源事件
+  const { space: from_space, key: fromkey } = this._parseKey(from_event);
+  let full_from_event = `${from_space}:${fromkey}`;
+
+  // 如果源事件不存在事件链，直接返回
+  if (!this._chain[full_from_event]) {
+    return this;
+  }
+
+  if (to_events) {
+    this._removeTargetEvents(full_from_event, to_events);
+  } else {
+    // 移除整个事件链
+    delete this._chain[full_from_event];
+  }
+
+  return this;
+};
+
+Eventer.prototype._removeTargetEvents = function (full_from_event, to_events) {
+  let target_events = Array.isArray(to_events) ? to_events : [to_events];
+
+  for (let i = 0; i < target_events.length; i++) {
+    this._removeTargetEvent(full_from_event, target_events[i]);
+  }
+
+  // 如果事件链为空，则删除整个事件链
+  if (this._chain[full_from_event].length === 0) {
+    delete this._chain[full_from_event];
+  }
+};
+
+Eventer.prototype._removeTargetEvent = function (full_from_event, to_event) {
+  if (typeof to_event !== 'string') {
+    throw new Error('目标事件必须是非空字符串');
+  }
+
+  // 解析目标事件
+  const { space: to_space, key: tokey } = this._parseKey(to_event);
+  let full_to_event = `${to_space}:${tokey}`;
+
+  // 检查事件链是否存在
+  if (!this._chain[full_from_event]) {
+    this.log('warn', `事件链不存在: ${full_from_event} -> ${full_to_event}`);
+    return;
+  }
+
+  // 查找并删除事件链
+  let index = this._chain[full_from_event].indexOf(full_to_event);
+  if (index === -1) {
+    this.log('warn', `事件链不存在: ${full_from_event} -> ${full_to_event}`);
+    return;
+  }
+
+  this._chain[full_from_event].splice(index, 1);
+};
+
+/**
+ * 获取事件链
+ * @param {string} event 事件关键字，支持space:key格式
+ * @returns {Array} 返回事件链数组
+ */
+Eventer.prototype.getChains = function (event) {
+  if (!event) {
+    return Object.keys(this._chain);
+  }
+
+  // 解析事件
+  const { space, key } = this._parseKey(event);
+  let full_event = `${space}:${key}`;
+
+  return this._chain[full_event] ? [...this._chain[full_event]] : [];
+};
+
+/**
+ * 触发下一级事件链事件
+ * @private
+ * @param {string} current_event 当前触发的事件
+ * @param {Array} params 传递的参数
+ * @returns {Promise<void>}
+ */
+/**
+ * 并行执行事件（提高性能）
+ * @param {string} key 事件关键字，支持space:key格式
+ * @param {object} params 传递参数
+ * @returns {Promise<object>} 返回包含results和cancel方法的对象
+ */
+Eventer.prototype.runParallel = async function (key, ...params) {
+  let result = await this._execute(key, {
+    exec_mode: 'parallel',
+    options: params.options
+  }, ...params);
+  return {
+    results: result.results,
+    cancelled: result.cancelled,
+    cancel: result.cancel
+  };
+};
+
+/**
+ * 并行触发事件
+ * @param {string} key 事件关键字，支持space:key格式
+ * @param {object} params 传递参数
+ * @returns {Promise<object>} 返回包含results和cancel方法的对象
+ */
+Eventer.prototype.emitParallel = function (key, ...params) {
+  // 内部调用 _execute 方法，但不等待结果
+  let result = this._execute(key, {
+    exec_mode: 'parallel',
+    options: params.options
+  }, ...params);
+  result.catch(e => this.log('error', '事件并行执行失败:', e));
+  return {
+    ...result,
+    cancel: () => result.then(r => r && typeof r.cancel === 'function' && r.cancel())
+  };
+};
+
+/**
+ * 防止内存泄漏警告
+ * @param {number} max_listen 最大监听器数量
+ * @returns {Eventer} 返回当前实例，支持链式调用
+ */
+Eventer.prototype.setMaxListeners = function (max_listen) {
+  if (typeof max_listen !== 'number' || max_listen < 0) {
+    throw new Error('最大监听器数量必须是一个非负数');
+  }
+  this._max_listeners = max_listen;
+  return this;
+};
+
+/**
+ * 批量添加事件
+ * @param {object} events_map 事件映射对象 { key: [func1, func2...] 或 key: {func, options} }
+ * @returns {Eventer} 返回当前实例，支持链式调用
+ */
+Eventer.prototype.onMany = function (events_map) {
+  if (typeof events_map !== 'object' || events_map === null) {
+    throw new Error('事件对象必须是一个非空对象');
+  }
+
+  for (let event_name in events_map) {
+    if (Object.prototype.hasOwnProperty.call(events_map, event_name)) {
+      this.on(event_name, events_map[event_name]);
+    }
+  }
+  return this;
+};
+
+// 私有方法
+
+/**
+ * 解析事件键，提取命名空间和事件键
+ * @param {string} key 事件关键字
+ * @returns {object} 包含space和key的对象
+ * @private
+ */
+Eventer.prototype._parseKey = function (key) {
+  let parts = key.split(':');
+  if (parts.length === 1) {
+    // 没有命名空间，使用默认命名空间
+    return {
+      space: this.config.default_name,
+      key: key
+    };
+  } else if (parts.length === 2) {
+    // 有命名空间
+    return {
+      space: parts[0],
+      key: parts[1]
+    };
+  } else {
+    // 多个冒号，将第一个作为命名空间，其余作为事件键
+    return {
+      space: parts[0],
+      key: parts.slice(1).join(':')
+    };
+  }
+};
+
+/**
+ * 按优先级对事件列表进行排序
+ * @param {Array} events 事件列表
+ * @private
+ */
+Eventer.prototype._sort = function (events) {
+  events.sort((a, b) => a.priority - b.priority);
+};
+
+/**
+ * 运行中间件
+ * @param {string} type 中间件类型：'before' 或 'after'
+ * @param {object} ctx 上下文对象
+ * @private
+ */
+Eventer.prototype._runMiddleware = async function (type, ctx) {
+  if (!this._middleware || !this._middleware[type] || this._middleware[type].length === 0) return;
+
+  const mwList = this._middleware[type];
+  for (let i = 0; i < mwList.length; i++) {
+    await this._execMiddleware(mwList[i], type, ctx, i);
+    // 如果上下文被取消，则停止执行
+    if (ctx.cancelled) break;
+  }
+};
+
+Eventer.prototype._execMiddleware = async function (middleware, type, ctx, idx) {
+  if (middleware && typeof middleware[type] === 'function') {
+    try {
+      await middleware[type].call(this, ctx);
+    } catch (middleware_error) {
+      this._handleMwareError(middleware_error, type, idx, ctx);
+    }
+  }
+};
+
+Eventer.prototype._handleMwareError = function (middleware_error, type, index, ctx) {
+  this.log('error', `中间件执行失败 [${type}] - 索引:${index}`, middleware_error);
+
+  // 全局错误处理器
+  if (this.config.error_handler && typeof this.config.error_handler === 'function') {
+    try {
+      this.config.error_handler(middleware_error, {
+        type: 'middleware',
+        stage: type,
+        index: index,
+        ctx
+      });
+    } catch (handler_error) {
+      this.log('error', '全局错误处理器执行失败', handler_error);
+    }
+  }
+};
+
+/**
+ * 触发下一级事件链
+ * @param {string} current_event 当前事件键
+ * @param {Array} params 参数数组
+ * @private
+ */
+Eventer.prototype._triggerChain = async function (current_event, params) {
+  // 获取当前事件的下级事件列表
+  var next_events = this._chain[current_event];
+  if (!next_events || next_events.length === 0) return;
+
+  // 遍历并触发所有下级事件
+  for (var i = 0; i < next_events.length; i++) {
+    await this._triggerChainEvent(next_events[i], current_event, params);
+  }
+};
+
+Eventer.prototype._triggerChainEvent = async function (key, current_event, params) {
+  // 避免重复执行当前事件
+  if (key === current_event) return;
+
+  // 创建下级事件的上下文
+  var ctx = this._createChainCtx(key, current_event, params);
+
+  // 执行前置中间件
+  await this._runChainMware('before', ctx);
+  if (ctx.cancelled) return;
+
+  // 触发下级事件
+  await this._executeChainEvent(key, params, ctx);
+
+  // 执行后置中间件
+  await this._runChainMware('after', ctx);
+
+  // 递归触发下级事件的下级事件
+  if (!ctx.cancelled) {
+    await this._triggerChain(ctx.full_event, params);
+  }
+};
+
+Eventer.prototype._createChainCtx = function (key, current_event, params) {
+  var { space, key: inner_key } = this._parseKey(key);
+  var full_key = `${space}:${inner_key}`;
+
+  return {
+    space,
+    event: inner_key,
+    full_event: full_key,
+    params,
+    parent_event: current_event,
+    start_time: Date.now(),
+    executed: 0,
+    error_count: 0,
+    cancelled: false,
+    /**
+     * 取消事件执行
+     */
+    cancel: () => { this.cancelled = true; }
+  };
+};
+
+Eventer.prototype._runChainMware = async function (type, ctx) {
+  try {
+    if (type === 'after') {
+      ctx.end_time = Date.now();
+      ctx.duration = ctx.end_time - ctx.start_time;
+    }
+    await this._runMiddleware(type, ctx);
+  } catch (error) {
+    this.log('error', `下级事件${type}中间件执行失败 [${ctx.full_event}]`, error);
+  }
+};
+
+Eventer.prototype._executeChainEvent = async function (key, params, ctx) {
+  try {
+    await this.run(key, ...params);
+  } catch (event_error) {
+    this.log('error', `下级事件执行失败 [${ctx.full_event}]`, event_error);
+  }
+};
+
+/**
+ * 节流函数
+ * @param {Function} func 要节流的函数
+ * @param {number} limit 节流时间（毫秒）
+ * @returns {Function} 节流后的函数
+ * @private
+ */
+Eventer.prototype._throttle = function (func, limit) {
+  let last_func;
+  let last_time = 0;
+  return function () {
+    let ctx = this;
+    let args = arguments;
+    if (!last_time) {
+      func.apply(ctx, args);
+      last_time = Date.now();
+    } else {
+      clearTimeout(last_func);
+      last_func = setTimeout(() => {
+        if ((Date.now() - last_time) >= limit) {
+          func.apply(ctx, args);
+          last_time = Date.now();
+        }
+      }, limit - (Date.now() - last_time));
+    }
+  };
+};
+
+/**
+ * 防抖函数
+ * @param {Function} func 要防抖的函数
+ * @param {number} wait 防抖时间（毫秒）
+ * @returns {Function} 防抖后的函数
+ * @private
+ */
+Eventer.prototype._debounce = function (func, wait) {
+  let timeout;
+  return function () {
+    let ctx = this;
+    let args = arguments;
+    clearTimeout(timeout);
+    timeout = setTimeout(() => {
+      func.apply(ctx, args);
+    }, wait);
+  };
+};
+
+
+/**
+ * 暂停事件执行
+ * @param {string} key 事件关键字或命名空间，支持space:key格式，为空表示全局暂停
+ * @returns {boolean} 是否成功暂停
+ */
+Eventer.prototype.pause = function (key = '') {
+  if (!this.config.pause_enabled) {
+    this.log('warn', '暂停功能未启用');
+    return false;
+  }
+
+  if (!key) {
+    return this._pauseGlobal();
+  }
+
+  // 解析关键字
+  let parsed = this._parseKey(key);
+  let space = parsed.space;
+  let event_key = parsed.key;
+  let full_key = `${space}:${event_key}`;
+
+  if (key) {
+    return this._pauseEvent(full_key);
+  } else {
+    return this._pauseNamespace(space);
+  }
+};
+
+Eventer.prototype._pauseGlobal = function () {
+  if (this._paused_global) {
+    this.log('warn', '事件总线已处于全局暂停状态');
+    return false;
+  }
+  this._paused_global = true;
+  this.log('info', '事件总线已全局暂停');
+  return true;
+};
+
+Eventer.prototype._pauseEvent = function (full_key) {
+  if (this._paused.has(full_key)) {
+    this.log('warn', `事件 '${full_key}' 已处于暂停状态`);
+    return false;
+  }
+  this._paused.add(full_key);
+  this.log('info', `事件 '${full_key}' 已暂停`);
+  return true;
+};
+
+Eventer.prototype._pauseNamespace = function (space) {
+  if (this._paused_space.has(space)) {
+    this.log('warn', `命名空间 '${space}' 已处于暂停状态`);
+    return false;
+  }
+  this._paused_space.add(space);
+  this.log('info', `命名空间 '${space}' 已暂停`);
+  return true;
+};
+
+/**
+ * 恢复事件执行
+ * @param {string} key 事件关键字或命名空间，支持space:key格式，为空表示恢复全局暂停
+ * @returns {boolean} 是否成功恢复
+ */
+Eventer.prototype.resume = function (key = '') {
+  if (!this.config.pause_enabled) {
+    this.log('warn', '暂停功能未启用');
+    return false;
+  }
+
+  if (!key) {
+    return this._resumeGlobal();
+  }
+
+  // 解析关键字
+  let parsed = this._parseKey(key);
+  let space = parsed.space;
+  let event_key = parsed.key;
+  let full_key = `${space}:${event_key}`;
+
+  if (key) {
+    return this._resumeEvent(full_key);
+  } else {
+    return this._resumeNamespace(space);
+  }
+};
+
+Eventer.prototype._resumeGlobal = function () {
+  if (!this._paused_global) {
+    this.log('warn', '事件总线未处于全局暂停状态');
+    return false;
+  }
+  this._paused_global = false;
+  this.log('info', '事件总线已恢复运行');
+  return true;
+};
+
+Eventer.prototype._resumeEvent = function (full_key) {
+  if (!this._paused.has(full_key)) {
+    this.log('warn', `事件 '${full_key}' 未处于暂停状态`);
+    return false;
+  }
+  this._paused.delete(full_key);
+  this.log('info', `事件 '${full_key}' 已恢复`);
+  return true;
+};
+
+Eventer.prototype._resumeNamespace = function (space) {
+  if (!this._paused_space.has(space)) {
+    this.log('warn', `命名空间 '${space}' 未处于暂停状态`);
+    return false;
+  }
+  this._paused_space.delete(space);
+  this.log('info', `命名空间 '${space}' 已恢复`);
+  return true;
+};
+
+/**
+ * 检查事件是否被暂停
+ * @param {string} key 事件关键字，支持space:key格式
+ * @returns {boolean} 是否被暂停
+ */
+Eventer.prototype.isPaused = function (key) {
+  if (!this.config.pause_enabled) {
+    return false;
+  }
+
+  // 全局暂停检查
+  if (this._paused_global) {
+    return true;
+  }
+
+  // 解析关键字
+  let parsed = this._parseKey(key);
+  let space = parsed.space;
+  let event_key = parsed.key;
+  let full_key = `${space}:${event_key}`;
+
+  // 命名空间暂停检查
+  if (this._paused_space.has(space)) {
+    return true;
+  }
+
+  // 单个事件暂停检查
+  if (this._paused.has(full_key)) {
+    return true;
+  }
+
+  return false;
+};
+
+/**
+ * 获取所有暂停的事件和命名空间
+ * @returns {object} 暂停状态信息
+ */
+Eventer.prototype.getPausedStatus = function () {
+  return {
+    global_paused: this._paused_global,
+    paused_events: Array.from(this._paused),
+    paused_spaces: Array.from(this._paused_space)
+  };
+};
+
+/**
+ * 清除所有暂停状态
+ * @returns {boolean} 是否成功清除
+ */
+Eventer.prototype.clearPaused = function () {
+  if (!this.config.pause_enabled) {
+    this.log('warn', '暂停功能未启用');
+    return false;
+  }
+
+  let cleared = false;
+
+  if (this._paused_global) {
+    this._paused_global = false;
+    cleared = true;
+  }
+
+  if (this._paused.size > 0) {
+    this._paused.clear();
+    cleared = true;
+  }
+
+  if (this._paused_space.size > 0) {
+    this._paused_space.clear();
+    cleared = true;
+  }
+
+  if (cleared) {
+    this.log('info', '所有暂停状态已清除');
+  }
+
+  return cleared;
+};
+
+let eventer = new Eventer();
+
+module.exports = {
+  Eventer,
+  eventer
+};