plugin-tls 2.0.1 → 3.1.0

package/dist/index.js

@@ -1,243 +1,398 @@
-import { deepmergeInto as M, deepmerge as w } from "deepmerge-ts";
-import { WebDestroyable as V, createDestroyableSubClass as H } from "@gby/destroyable";
-function l(n, ...t) {
+import { Destroyable as M, DestroyableEventEmitter as N, DestroyableEventTarget as H, createDestroyableSubClass as V } from "@gby/destroyable";
+import { serialCallFuns as g } from "com-tools";
+import { deepmergeInto as P, deepmerge as w } from "deepmerge-ts";
+function d(s, ...t) {
   for (const e of t) {
-    const i = Object.getOwnPropertyDescriptors(e);
-    Object.defineProperties(n, i);
+    const n = Object.getOwnPropertyDescriptors(e);
+    Object.defineProperties(s, n);
   }
-  return n;
+  return s;
 }
-function A(n, t) {
+function B(s, t) {
   return t;
 }
-function k() {
+function K() {
   return function(t, e) {
     return e;
   };
 }
-function z(n, t) {
-  return l(n, t), t;
+function R(s, t) {
+  return d(s, t), t;
 }
-function C(n) {
+function W(s) {
   return function(e) {
-    return l(n, e), e;
+    return d(s, e), e;
   };
 }
-function a(n, t) {
-  return l(n, t), n;
+function c(s, t) {
+  return d(s, t), s;
 }
-function $(n) {
+function G(s) {
   return function(e) {
-    return l(n, e), n;
+    return d(s, e), s;
   };
 }
-function S(n, t) {
+const k = ["onCreate", "onInit", "onDestroy"];
+function T(s) {
+  const t = { ...s };
+  for (const e of k)
+    typeof t[e] == "function" && delete t[e];
   return t;
 }
-function O(n, t) {
-  l(n.prototype, t);
-  const e = t._constructor;
-  typeof e == "function" && (n._constructors ?? (n._constructors = [])).push(e);
-  const i = t._destroy;
-  return typeof i == "function" && (n._destroys ?? (n._destroys = [])).push(i), t;
-}
-function q(n) {
-  return function(e) {
-    return O(n, e), e;
-  };
-}
-function T(n, t) {
-  return O(n, t), n;
-}
-function B(n) {
-  return function(e) {
-    return O(n, e), n;
-  };
-}
-function m(n, t, e) {
-  for (const i of n)
-    i.apply(t, e);
-}
-function K(n) {
-  return {
-    constructed: function(t, e) {
-      m(n._constructors ?? [], t, e);
-    },
-    initialized: function(t, e) {
-      m(n._inits ?? [], t, e);
-    },
-    destroyed: function(t, e) {
-      m(n._destroys ?? [], t, e);
-    }
-  };
-}
-function R(n, t) {
+function J(s, t) {
   return t;
 }
-function y(n, t) {
-  O(n, t);
-  const e = t._init;
-  return typeof e == "function" && (n._inits ?? (n._inits = [])).push(e), t;
-}
-function G(n) {
-  return function(e) {
-    return y(n, e), e;
-  };
-}
-function J(n, t) {
-  return y(n, t), n;
+function I(s) {
+  return s && typeof s.onUse == "function";
 }
-function L(n) {
-  return function(e) {
-    return y(n, e), n;
-  };
-}
-class g {
+class L extends M {
   /**
    * 插件的宿主
    */
   host;
   /**
-   * 插件与插件选项的映射
+   * 所有注册的插件
    */
-  pluginOptsMap = /* @__PURE__ */ new Map();
-  /**
-   * 注册的插件
-   */
-  plugins = [];
+  plugins = /* @__PURE__ */ new Map();
   /**
    * @param host - 插件的宿主
    */
   constructor(t) {
-    t && (this.host = t);
+    super(), t && (this.host = t);
+  }
+  destroyThis() {
+    return this.plugins.clear(), this.host = null, super.destroyThis();
   }
   /**
    * 使用插件、注册插件
    * @param plugin - 插件
-   * @param options - 传递给插件的选项
+   * @param args - 传递给插件的选项
    */
   use(t, ...e) {
-    const { pluginOptsMap: i, plugins: s, host: o } = this;
-    if (!s.includes(t))
-      return s.push(t), i.set(t, e[0]), t.used(o, e[0]);
+    const { plugins: n } = this;
+    if (n.has(t)) return n.get(t);
+    const i = t.onUse(this.host, ...e);
+    return n.set(t, i), i;
+  }
+  /**
+   * 插件宿主实例的注册插件的方法
+   *
+   * @remarks
+   * 会调用每个插件的 {@link IPlugin.use } 方法
+   * @param hostInst - 插件宿主的新实例
+   */
+  instUse(t, e, ...n) {
+    const { plugins: i } = this;
+    if (i.has(e)) return i.get(e);
+    const o = this.use(e, ...n);
+    return e.onCreate?.(t), o;
   }
   /**
    * 插件宿主创建实例时调用
    *
    * @remarks
-   * 会调用每个插件的 {@link IPlugin.created} 方法
+   * 会调用每个插件的 {@link IPlugin.onCreate} 方法
+   * 如果插件的 created 方法返回 Promise，则会等待 Promise  resolve
    * @param hostInst - 插件宿主的新实例
    */
-  created(t) {
-    const { plugins: e, pluginOptsMap: i } = this;
-    for (const s of e) {
-      const o = i.get(s);
-      s.created?.(t, o);
-    }
+  onCreate(t, ...e) {
+    const n = [];
+    for (const [i] of this.plugins)
+      i.onCreate && n.push(i.onCreate.bind(i));
+    return g(n, void 0, [t, ...e]);
+  }
+  /**
+   * 插件宿主创建实例时调用
+   *
+   * @remarks
+   * 会调用每个插件的 {@link IPlugin.onCreate } 方法
+   * @param hostInst - 插件宿主的新实例
+   * @param args - 初始化宿主实例时的参数
+   */
+  onInit(t, ...e) {
+    const n = [];
+    for (const [i] of this.plugins)
+      i.onInit && n.push(i.onInit.bind(i));
+    return g(n, void 0, [t, ...e]);
   }
   /**
    * 插件宿主被销毁时调用
    *
    * @remarks
-   * 会调用每个插件的 {@link IPlugin.destroyed} 方法
+   * 会调用每个插件的 {@link IPlugin.onDestroy} 方法
    * @param hostInst - 被销毁的插件实例
    */
-  destroyed(t) {
-    const { plugins: e, pluginOptsMap: i } = this;
-    for (const s of e) {
-      const o = i.get(s);
-      s.destroyed?.(t, o);
-    }
+  onDestroy(t) {
+    const e = [];
+    for (const [n] of this.plugins)
+      n.onDestroy && e.push(n.onDestroy.bind(n));
+    return e.reverse(), g(e, void 0, [t]);
+  }
+}
+class Q extends M {
+  /**
+   * 插件的宿主
+   */
+  host;
+  /**
+   * 所有注册的插件
+   */
+  plugins = /* @__PURE__ */ new Set();
+  /**
+   * @param host - 插件的宿主
+   */
+  constructor(t) {
+    super(), t && (this.host = t);
+  }
+  destroyThis() {
+    return this.plugins.clear(), this.host = null, super.destroyThis();
+  }
+  /**
+   * 使用插件、注册插件
+   * @param plugin - 插件
+   * @param args - 传递给插件的选项
+   */
+  use(t) {
+    const { plugins: e } = this;
+    return e.has(t) ? !1 : (d(this.host.prototype, T(t)), e.add(t), !0);
   }
   /**
    * 插件宿主实例的注册插件的方法
    *
    * @remarks
-   * 会调用每个插件的 {@link IPlugin.use | IPlugin.created()} 方法
+   * 会调用每个插件的 {@link IExtend.use } 方法
+   * @param hostInst - 插件宿主的新实例
+   */
+  instUse(t, e, ...n) {
+    const { plugins: i } = this;
+    return i.has(e) ? !1 : (this.use(e), e.onCreate?.call(t, t, ...n), !0);
+  }
+  /**
+   * 插件宿主创建实例时调用
+   *
+   * @remarks
+   * 会调用每个插件的 {@link IExtend.onCreate} 方法
+   * 如果插件的 created 方法返回 Promise，则会等待 Promise  resolve
+   * @param hostInst - 插件宿主的新实例
+   */
+  onCreate(t, ...e) {
+    const n = [];
+    for (const i of this.plugins)
+      i.onCreate && n.push(i.onCreate);
+    return g(n, t, [t, ...e]);
+  }
+  /**
+   * 插件宿主创建实例时调用
+   *
+   * @remarks
+   * 会调用每个插件的 {@link IExtend.onCreate } 方法
    * @param hostInst - 插件宿主的新实例
+   * @param args - 初始化宿主实例时的参数
    */
-  instUse(t, e, ...i) {
-    if (!this.pluginOptsMap.has(e))
-      return this.use(e, ...i), e.created?.(t, ...i);
+  onInit(t, ...e) {
+    const n = [];
+    for (const i of this.plugins)
+      i.onInit && n.push(i.onInit);
+    return g(n, t, [t, ...e]);
+  }
+  /**
+   * 插件宿主被销毁时调用
+   *
+   * @remarks
+   * 会调用每个插件的 {@link IExtend.onDestroy} 方法
+   * @param hostInst - 被销毁的插件实例
+   */
+  onDestroy(t) {
+    const e = [];
+    for (const n of this.plugins)
+      n.onDestroy && e.push(n.onDestroy);
+    return e.reverse(), g(e, t, [t]);
   }
 }
-class Q extends g {
+const O = /* @__PURE__ */ Symbol("extend");
+class p extends M {
+  /**
+   * 插件的宿主
+   */
+  host;
+  /**
+   * 所有注册的插件
+   */
+  plugins = /* @__PURE__ */ new Map();
+  /**
+   * @param host - 插件的宿主
+   */
+  constructor(t) {
+    super(), t && (this.host = t);
+  }
+  destroyThis() {
+    return this.plugins.clear(), this.host = null, super.destroyThis();
+  }
+  /**
+   * 判断一个对象是否是插件
+   * @param target 
+   * @returns 
+   */
+  isPlugin(t) {
+    const { plugins: e } = this;
+    return e.has(t) ? e.get(t) !== O : I(t);
+  }
+  /**
+   * 使用插件、注册插件
+   * @param ext - 插件
+   * @param args - 传递给插件的选项
+   */
+  useExtend(t) {
+    const { plugins: e } = this;
+    return e.has(t) ? !1 : (d(this.host.prototype, T(t)), e.set(t, O), !0);
+  }
+  /**
+   * 插件宿主实例的注册插件的方法
+   *
+   * @remarks
+   * 会调用每个插件的 {@link IExtend.use } 方法
+   * @param hostInst - 插件宿主的新实例
+   */
+  instUseExtend(t, e, ...n) {
+    const { plugins: i } = this;
+    return i.has(e) ? !1 : (this.useExtend(e), e.onCreate?.call(t, t, ...n), !0);
+  }
+  /**
+   * 使用插件、注册插件
+   * @param plugin - 插件
+   * @param args - 传递给插件的选项
+   */
+  usePlugin(t, ...e) {
+    const { plugins: n } = this;
+    if (n.has(t)) return n.get(t);
+    const i = t.onUse(this.host, ...e);
+    return n.set(t, i), i;
+  }
+  /**
+   * 插件宿主实例的注册插件的方法
+   *
+   * @remarks
+   * 会调用每个插件的 {@link IPlugin.use } 方法
+   * @param hostInst - 插件宿主的新实例
+   */
+  instUsePlugin(t, e, ...n) {
+    const { plugins: i } = this;
+    if (i.has(e)) return i.get(e);
+    const o = this.usePlugin(e, ...n);
+    return e.onCreate?.(t), o;
+  }
   /**
    * 插件宿主创建实例时调用
    *
    * @remarks
-   * 会调用每个插件的 {@link IPlugin.created | IPlugin.created()} 方法
+   * 会调用每个插件的 {@link IPlugin.onCreate} 方法
+   * 如果插件的 created 方法返回 Promise，则会等待 Promise  resolve
    * @param hostInst - 插件宿主的新实例
    */
-  inited(t) {
-    const { plugins: e, pluginOptsMap: i } = this;
-    for (const s of e) {
-      const o = i.get(s);
-      s.inited?.(t, o);
-    }
+  onCreate(t, ...e) {
+    const n = [];
+    for (const [i, o] of this.plugins)
+      if (i.onCreate) {
+        const r = o === O ? i.onCreate : i.onCreate.bind(i);
+        n.push(r);
+      }
+    return g(n, t, [t, ...e]);
+  }
+  /**
+   * 插件宿主创建实例时调用
+   *
+   * @remarks
+   * 会调用每个插件的 {@link IPlugin.onCreate } 方法
+   * @param hostInst - 插件宿主的新实例
+   * @param args - 初始化宿主实例时的参数
+   */
+  onInit(t, ...e) {
+    const n = [];
+    for (const [i, o] of this.plugins)
+      if (i.onInit) {
+        const r = o === O ? i.onInit : i.onInit.bind(i);
+        n.push(r);
+      }
+    return g(n, t, [t, ...e]);
+  }
+  /**
+   * 插件宿主被销毁时调用
+   *
+   * @remarks
+   * 会调用每个插件的 {@link IPlugin.onDestroy} 方法
+   * @param hostInst - 被销毁的插件实例
+   */
+  onDestroy(t) {
+    const e = [];
+    for (const [n, i] of this.plugins)
+      if (n.onDestroy) {
+        const o = i === O ? n.onDestroy : n.onDestroy.bind(n);
+        e.push(o);
+      }
+    return e.reverse(), g(e, t, [t]);
   }
 }
-function X(n, t) {
-  const e = t ?? "defaultOptions", i = `_${e}`;
+function X(s, t) {
+  const e = t ?? "defaultOptions", n = `_${e}`;
   return function(o) {
-    const r = a(o, {
+    const r = c(o, {
       /**
        * 全局级别的默认选项
        */
       get [e]() {
-        return n;
+        return s;
       }
     });
-    T(r, {
+    c(r.prototype, {
       /**
       * 实例级的默认选项
       */
       get [e]() {
-        return this[i] || (this[i] = structuredClone(r.defaultOptions));
+        return this[n] || (this[n] = structuredClone(r.defaultOptions));
       }
     });
   };
 }
-function Y(n, t, e) {
-  const i = `_${t}`;
-  return T(n, {
+function Y(s, t, e) {
+  const n = `_${t}`;
+  return c(s.prototype, {
     /**
     * 实例级的默认选项
     */
     get [t]() {
-      return this[i] || (this[i] = structuredClone(n[t]));
+      return this[n] || (this[n] = structuredClone(s[t]));
     }
   }), e;
 }
-function F(n) {
-  const t = n.split(".");
+function b(s) {
+  const t = s.split(".");
   return t[0] === "" && t.shift(), t;
 }
-function x(n, t) {
+function y(s, t) {
   for (const e of t)
-    if (n = n[e], n == null) return;
-  return n;
+    if (s = s[e], s == null) return;
+  return s;
 }
-function Z(n, t) {
-  return x(n, F(t));
+function Z(s, t) {
+  return y(s, b(t));
 }
-function b(n, t, e) {
-  const i = t.pop(), s = t.length;
+function E(s, t, e) {
+  const n = t.pop(), i = t.length;
   let o = 0;
-  for (; o < s; ) {
-    const r = n[t[o]];
+  for (; o < i; ) {
+    const r = s[t[o]];
     if (r == null) break;
-    n = r, o++;
+    s = r, o++;
   }
   t = t.slice(o);
   for (const r of t)
-    n = n[r] = {};
-  return n[i] = e, n;
+    s = s[r] = {};
+  return s[n] = e, s;
 }
-function tt(n, t, e) {
-  return b(n, F(t), e);
+function tt(s, t, e) {
+  return E(s, b(t), e);
 }
-const _ = {
+const x = {
   UndefinedAndNull: function(t) {
     return t == null;
   },
@@ -263,13 +418,13 @@ class v {
    */
   fullOption = new Proxy(this, {
     // @ts-ignore
-    get: function(t, e, i) {
-      const s = t.plainFullOption[e];
-      return t.freezeMember ? Object.freeze(s) : s;
+    get: function(t, e, n) {
+      const i = t.plainFullOption[e];
+      return t.freezeMember ? Object.freeze(i) : i;
     },
     // @ts-ignore
-    set: function(t, e, i, s) {
-      return t.setMember(e, i, !1), !0;
+    set: function(t, e, n, i) {
+      return t.setMember(e, n, !1), !0;
     },
     // @ts-ignore
     has: function(t, e) {
@@ -288,8 +443,8 @@ class v {
       return t.setMember(e, void 0), !0;
     },
     // @ts-ignore
-    defineProperty: function(t, e, i) {
-      return Object.defineProperty(t.option, e, i), !0;
+    defineProperty: function(t, e, n) {
+      return Object.defineProperty(t.option, e, n), !0;
     }
   });
   /**
@@ -300,8 +455,8 @@ class v {
    * @param deep - 是否要进行深度合并 
    */
   setOption(t, e) {
-    const i = e ? M(this.option, t) : Object.assign(this.option, t);
-    return this.updateFullOption(), i;
+    const n = e ? P(this.option, t) : Object.assign(this.option, t);
+    return this.updateFullOption(), n;
   }
   /**
    * 未定义值的类型
@@ -310,13 +465,13 @@ class v {
     return this._undefinedValue;
   }
   set undefinedValue(t) {
-    this._undefinedValue = t, this.isUndefined = _[t] || _.UndefinedAndNull;
+    this._undefinedValue = t, this.isUndefined = x[t] || x.UndefinedAndNull;
   }
   _undefinedValue = "UndefinedAndNull";
   /**
    * 未定义值的判断函数
    */
-  isUndefined = _.UndefinedAndNull;
+  isUndefined = x.UndefinedAndNull;
   /**
    * 获取选项成员
    * @param key 
@@ -331,13 +486,13 @@ class v {
    * @param value 
    * @param deep - 是否要进行深度合并 
    */
-  setMember(t, e, i) {
-    const s = this.option;
+  setMember(t, e, n) {
+    const i = this.option;
     if (e === void 0)
-      delete s[t];
+      delete i[t];
     else {
-      const o = s[t];
-      i && o && typeof o == "object" ? M(o, e) : s[t] = e;
+      const o = i[t];
+      n && o && typeof o == "object" ? P(o, e) : i[t] = e;
     }
     this.updateFullOption();
   }
@@ -347,7 +502,7 @@ class v {
    * @returns 
    */
   getValue(t) {
-    return x(this.option, t);
+    return y(this.option, t);
   }
   /**
    * 设置属性路径对应的值
@@ -356,13 +511,13 @@ class v {
    * @param deep - 是否要进行深度合并 
    * @returns 
    */
-  setValue(t, e, i) {
-    const s = this.option;
+  setValue(t, e, n) {
+    const i = this.option;
     let o;
-    i && (o = x(s, t)) && typeof o == "object" ? M(o, e) : b(this.option, t, e), this.updateFullOption();
+    n && (o = y(i, t)) && typeof o == "object" ? P(o, e) : E(this.option, t, e), this.updateFullOption();
   }
 }
-class p extends v {
+class u extends v {
   constructor(t, e) {
     super(), t && (this.option = t), e && (this.extends = e);
   }
@@ -388,10 +543,10 @@ class p extends v {
   get plainFullOption() {
     let t = this._plainFullOption;
     if (t) return t;
-    const { extends: e, option: i } = this;
-    if (t = i, e) {
-      const s = e.plainFullOption;
-      t = w(s, i);
+    const { extends: e, option: n } = this;
+    if (t = n, e) {
+      const i = e.plainFullOption;
+      t = w(i, n);
     }
     return this._plainFullOption = t;
   }
@@ -410,9 +565,9 @@ class p extends v {
   getMember(t) {
     const e = this.option[t];
     if (!this.isUndefined(e)) return e;
-    const i = this.extends;
-    if (i)
-      return i.getMember(t);
+    const n = this.extends;
+    if (n)
+      return n.getMember(t);
   }
   /**
    * 获取属性路径对应的值
@@ -422,20 +577,20 @@ class p extends v {
   getValue(t) {
     const e = super.getValue(t);
     if (!this.isUndefined(e)) return e;
-    const i = this.extends;
-    if (i)
-      return i.getValue(t);
+    const n = this.extends;
+    if (n)
+      return n.getValue(t);
   }
 }
-function et(n, t) {
-  const { name: e } = t, i = `_${e}`;
+function et(s, t) {
+  const { name: e } = t, n = `_${e}`;
   return {
     get: function() {
-      return this[i] || (this[i] = new p(void 0, this.constructor[e]));
+      return this[n] || (this[n] = new u(void 0, this.constructor[e]));
     }
   };
 }
-class E extends v {
+class S extends v {
   constructor(t, e) {
     super(), e && this.setModeOption(t, e), this.mode = t;
   }
@@ -524,18 +679,18 @@ class E extends v {
    * @param deep - 是否要进行深度合并 
    * @param extend - 继承哪个模式
    */
-  setModeOption(t, e, i, s) {
-    const { modes: o } = this, r = o[t] || (o[t] = new p());
-    if (r.setOption(e, i), s) {
-      const u = o[s];
-      u && (r.extends = u);
+  setModeOption(t, e, n, i) {
+    const { modes: o } = this, r = o[t] || (o[t] = new u());
+    if (r.setOption(e, n), i) {
+      const l = o[i];
+      l && (r.extends = l);
     }
     return this.updateFullOption(), r;
   }
 }
-class c extends E {
-  constructor(t, e, i) {
-    super(t, e), i && (this.extends = i);
+class a extends S {
+  constructor(t, e, n) {
+    super(t, e), n && (this.extends = n);
   }
   /**
    * 继承的选项
@@ -555,22 +710,22 @@ class c extends E {
    * @returns 
    */
   getFullModeOption(t) {
-    const { modes: e, extends: i } = this, s = e[t]?.plainFullOption;
-    if (i) {
-      const o = i.getFullModeOption(t);
-      return s ? w(o, s) : o;
+    const { modes: e, extends: n } = this, i = e[t]?.plainFullOption;
+    if (n) {
+      const o = n.getFullModeOption(t);
+      return i ? w(o, i) : o;
     }
-    return s;
+    return i;
   }
   /**
    * 获取所有的模式名字
    * @returns 
    */
   getModeNames() {
-    const { modes: t, extends: e } = this, i = Object.keys(t);
-    if (!e) return i;
-    const s = e.getModeNames();
-    return [.../* @__PURE__ */ new Set([...i, ...s])];
+    const { modes: t, extends: e } = this, n = Object.keys(t);
+    if (!e) return n;
+    const i = e.getModeNames();
+    return [.../* @__PURE__ */ new Set([...n, ...i])];
   }
   /**
    * 在整个层级上判断是否有某个模式
@@ -605,9 +760,9 @@ class c extends E {
   getMember(t) {
     const e = this.optionManager.getMember(t);
     if (!this.isUndefined(e)) return e;
-    const i = this.extends;
-    if (i)
-      return i.getMember(t);
+    const n = this.extends;
+    if (n)
+      return n.getMember(t);
   }
   /**
    * 获取属性路径对应的值
@@ -617,28 +772,32 @@ class c extends E {
   getValue(t) {
     const e = this.optionManager.getValue(t);
     if (!this.isUndefined(e)) return e;
-    const i = this.extends;
-    if (i)
-      return i.getValue(t);
+    const n = this.extends;
+    if (n)
+      return n.getValue(t);
   }
 }
-function nt(n, t) {
-  const { name: e } = t, i = `_${e}`;
+function nt(s, t) {
+  const { name: e } = t, n = `_${e}`;
   return {
     get: function() {
-      return this[i] || (this[i] = new c(this.constructor[e].mode, void 0, this.constructor[e]));
+      return this[n] || (this[n] = new a(this.constructor[e].mode, void 0, this.constructor[e]));
     }
   };
 }
-class N extends V {
+class F extends M {
+  /**
+   * 是否使用独立的插件管理器
+   * @defaultValue false
+   */
+  static isolatedPluginManager = !1;
   /**
    * 插件管理器
    */
   static get pluginManager() {
-    let t = this._pluginManager;
-    return t || (t = this._pluginManager = new g(this)), t;
+    return this.isolatedPluginManager && !this.hasOwnProperty("_pluginManager") && (this._pluginManager = new p(this)), this._pluginManager;
   }
-  static _pluginManager;
+  static _pluginManager = new p(this);
   /**
    * 插件管理器 {@link PluginHost.pluginManager}
    */
@@ -646,100 +805,316 @@ class N extends V {
     return this.constructor.pluginManager;
   }
   /**
-   * {@inheritDoc PluginManager.use}
+   * {@inheritDoc PluginExtendManager.usePlugin}
+   */
+  static usePlugin(t, ...e) {
+    return this.pluginManager.usePlugin(t, ...e);
+  }
+  /**
+   * {@inheritDoc PluginExtendManager.useExtend}
    */
-  static use(t, ...e) {
-    return this.pluginManager.use(t, ...e);
+  static useExtend(t) {
+    return this.pluginManager.useExtend(t);
   }
   /**
    * 需要在子类中调用
    * 
-   * 之所以没写在该类中的函数中，是因为 `this.pluginManager.created(this)` 通常会在构建函数执行的最后时才调用；
-   * 如果像下面写在该类的构建函数中，然后子类通过 `super()` 来调用，这样就会导致 `this.pluginManager.created(this)` 不是在最后的执行；
+   * 之所以没写在该类中的函数中，是因为 `this.pluginManager.onCreate(this,...args)` 通常会在构建函数执行的最后时才调用；
+   * 如果像下面写在该类的构建函数中，然后子类通过 `super()` 来调用，这样就会导致 `this.pluginManager.onCreate(this,...args)` 不是在最后的执行； 
    */
-  // constructor() {
-  //   this.pluginManager.created(this);
+  // constructor(...args:any) {
+  //   super();
+  //   // @ts-ignore
+  //   this.pluginManager.onCreate(this,...args);
   // }
   /**
    * 实例的注册插件的方法
    * @param plugin
-   * @param options
+   * @param args
    * @returns
    */
-  use(t, ...e) {
-    return this.pluginManager.instUse(this, t, ...e);
+  usePlugin(t, ...e) {
+    return this.pluginManager.instUsePlugin(this, t, ...e);
+  }
+  /**
+   * {@inheritDoc PluginExtendManager.useExtend}
+   */
+  useExtend(t, ...e) {
+    return this.pluginManager.instUseExtend(this, t, ...e);
+  }
+  /**
+   * 初始化实例
+   * @remarks
+   * 会调用 {@link PluginExtendManager.onInit}
+   * @param args 
+   */
+  init(...t) {
+    return this.pluginManager.onInit(this, ...t);
   }
   /**
    * 销毁实例
    * @returns 
    */
   destroyThis() {
-    return this.pluginManager.destroyed(this), super.destroyThis();
+    const t = this.pluginManager.onDestroy(this);
+    return t instanceof Promise ? t.finally(() => super.destroyThis()) : super.destroyThis();
   }
 }
-function U(n) {
-  const t = H(n);
+class U extends N {
+  /**
+   * 是否使用独立的插件管理器
+   * @defaultValue false
+   */
+  static isolatedPluginManager = !1;
+  /**
+   * 插件管理器
+   */
+  static get pluginManager() {
+    return this.isolatedPluginManager && !this.hasOwnProperty("_pluginManager") && (this._pluginManager = new p(this)), this._pluginManager;
+  }
+  static _pluginManager = new p(this);
+  /**
+   * 插件管理器 {@link PluginHost.pluginManager}
+   */
+  get pluginManager() {
+    return this.constructor.pluginManager;
+  }
+  /**
+   * {@inheritDoc PluginExtendManager.usePlugin}
+   */
+  static usePlugin(t, ...e) {
+    return this.pluginManager.usePlugin(t, ...e);
+  }
+  /**
+   * {@inheritDoc PluginExtendManager.useExtend}
+   */
+  static useExtend(t) {
+    return this.pluginManager.useExtend(t);
+  }
+  /**
+   * 需要在子类中调用
+   * 
+   * 之所以没写在该类中的函数中，是因为 `this.pluginManager.onCreate(this,...args)` 通常会在构建函数执行的最后时才调用；
+   * 如果像下面写在该类的构建函数中，然后子类通过 `super()` 来调用，这样就会导致 `this.pluginManager.onCreate(this,...args)` 不是在最后的执行； 
+   */
+  // constructor(...args:any) {
+  //   super();
+  //   // @ts-ignore
+  //   this.pluginManager.onCreate(this,...args);
+  // }
+  /**
+   * 实例的注册插件的方法
+   * @param plugin
+   * @param args
+   * @returns
+   */
+  usePlugin(t, ...e) {
+    return this.pluginManager.instUsePlugin(this, t, ...e);
+  }
+  /**
+   * {@inheritDoc PluginExtendManager.useExtend}
+   */
+  useExtend(t, ...e) {
+    return this.pluginManager.instUseExtend(this, t, ...e);
+  }
+  /**
+   * 初始化实例
+   * @remarks
+   * 会调用 {@link PluginExtendManager.onInit}
+   * @param args 
+   */
+  init(...t) {
+    return this.pluginManager.onInit(this, ...t);
+  }
+  /**
+   * 销毁实例
+   * @returns 
+   */
+  destroyThis() {
+    const t = this.pluginManager.onDestroy(this);
+    return t instanceof Promise ? t.finally(() => super.destroyThis()) : super.destroyThis();
+  }
+}
+class D extends H {
+  /**
+   * 是否使用独立的插件管理器
+   * @defaultValue false
+   */
+  static isolatedPluginManager = !1;
+  /**
+   * 插件管理器
+   */
+  static get pluginManager() {
+    return this.isolatedPluginManager && !this.hasOwnProperty("_pluginManager") && (this._pluginManager = new p(this)), this._pluginManager;
+  }
+  static _pluginManager = new p(this);
+  /**
+   * 插件管理器 {@link PluginHost.pluginManager}
+   */
+  get pluginManager() {
+    return this.constructor.pluginManager;
+  }
+  /**
+   * {@inheritDoc PluginExtendManager.usePlugin}
+   */
+  static usePlugin(t, ...e) {
+    return this.pluginManager.usePlugin(t, ...e);
+  }
+  /**
+   * {@inheritDoc PluginExtendManager.useExtend}
+   */
+  static useExtend(t) {
+    return this.pluginManager.useExtend(t);
+  }
+  /**
+   * 需要在子类中调用
+   * 
+   * 之所以没写在该类中的函数中，是因为 `this.pluginManager.onCreate(this,...args)` 通常会在构建函数执行的最后时才调用；
+   * 如果像下面写在该类的构建函数中，然后子类通过 `super()` 来调用，这样就会导致 `this.pluginManager.onCreate(this,...args)` 不是在最后的执行； 
+   */
+  // constructor(...args:any) {
+  //   super();
+  //   // @ts-ignore
+  //   this.pluginManager.onCreate(this,...args);
+  // }
+  /**
+   * 实例的注册插件的方法
+   * @param plugin
+   * @param args
+   * @returns
+   */
+  usePlugin(t, ...e) {
+    return this.pluginManager.instUsePlugin(this, t, ...e);
+  }
+  /**
+   * {@inheritDoc PluginExtendManager.useExtend}
+   */
+  useExtend(t, ...e) {
+    return this.pluginManager.instUseExtend(this, t, ...e);
+  }
+  /**
+   * 初始化实例
+   * @remarks
+   * 会调用 {@link PluginExtendManager.onInit}
+   * @param args 
+   */
+  init(...t) {
+    return this.pluginManager.onInit(this, ...t);
+  }
+  /**
+   * 销毁实例
+   * @returns 
+   */
+  destroyThis() {
+    const t = this.pluginManager.onDestroy(this);
+    return t instanceof Promise ? t.finally(() => super.destroyThis()) : super.destroyThis();
+  }
+}
+function C(s) {
+  const t = V(s);
   return class extends t {
     /**
-     * PluginHost 的插件管理器
+     * 是否使用独立的插件管理器
+     * @defaultValue false
+     */
+    static isolatedPluginManager = !1;
+    /**
+     * 插件管理器
      */
     static get pluginManager() {
-      let i = this._pluginManager;
-      return i || (i = this._pluginManager = new g(this)), i;
+      return this.isolatedPluginManager && !this.hasOwnProperty("_pluginManager") && (this._pluginManager = new p(this)), this._pluginManager;
     }
-    static _pluginManager;
+    static _pluginManager = new p(this);
     /**
-     *  插件管理器 {@link CEarth.pluginManager}
+     * 插件管理器 {@link PluginHostSub.pluginManager}
      */
     get pluginManager() {
       return this.constructor.pluginManager;
     }
     /**
-     * {@inheritDoc PluginManager.use}
+     * {@inheritDoc PluginExtendManager.usePlugin}
+     */
+    static usePlugin(n, ...i) {
+      return this.pluginManager.usePlugin(n, ...i);
+    }
+    /**
+     * {@inheritDoc PluginExtendManager.useExtend}
      */
-    static use(i, ...s) {
-      return this.pluginManager.use(i, ...s);
+    static useExtend(n) {
+      return this.pluginManager.useExtend(n);
     }
+    /**
+     * 需要在子类中调用
+     * 
+     * 之所以没写在该类中的函数中，是因为 `this.pluginManager.onCreate(this)` 通常会在构建函数执行的最后时才调用；
+     * 如果像下面写在该类的构建函数中，然后子类通过 `super()` 来调用，这样就会导致 `this.pluginManager.onCreate(this)` 不是在最后的执行；
+     */
     // constructor() {
-    //   this.pluginManager.created(this as HostInst<PHOST>);
+    //   super();
+    //   this.pluginManager.onCreate(this);
     // }
-    /**
     /**
      * 实例的注册插件的方法
      * @param plugin
-     * @param options
+     * @param args
      * @returns
      */
-    use(i, ...s) {
-      return this.pluginManager.instUse(this, i, ...s);
+    usePlugin(n, ...i) {
+      return this.pluginManager.instUsePlugin(this, n, ...i);
+    }
+    /**
+     * {@inheritDoc PluginExtendManager.useExtend}
+     */
+    useExtend(n, ...i) {
+      return this.pluginManager.instUseExtend(this, n, ...i);
+    }
+    /**
+     * 初始化实例
+     * @remarks
+     * 会调用 {@link PluginExtendManager.onInit}
+     * @param args 
+     */
+    init(...n) {
+      return this.pluginManager.onInit(this, ...n);
     }
     /**
      * 销毁实例
      * @returns 
      */
     destroyThis() {
-      return this.pluginManager.destroyed(this), super.destroyThis();
+      const n = this.pluginManager.onDestroy(this);
+      return n instanceof Promise ? n.finally(() => super.destroyThis()) : super.destroyThis();
     }
   };
 }
-function D(n) {
-  const t = a(n, {
+function j(s) {
+  const t = c(s, {
+    /**
+     * 是否使用独立的插件管理器
+     * @defaultValue false
+     */
+    isolatedPluginManager: !1,
     /**
      * PluginHost 的插件管理器
      */
     get pluginManager() {
-      let e = this._pluginManager;
-      return e || (e = this._pluginManager = new g(this)), e;
+      return (!this._pluginManager || this.isolatedPluginManager && !this.hasOwnProperty("_pluginManager")) && (this._pluginManager = new p(this)), this._pluginManager;
     },
     // _pluginManager: PluginManager<HOST,Plugin>;
     /**
-     * {@inheritDoc PluginManager.use}
+     * {@inheritDoc PluginExtendManager.usePlugin}
      */
-    use(e, i) {
-      return this.pluginManager.use(e, i);
+    usePlugin(e, ...n) {
+      return this.pluginManager.usePlugin(e, ...n);
+    },
+    /**
+     * {@inheritDoc PluginExtendManager.useExtend}
+     */
+    useExtend(e) {
+      return this.pluginManager.useExtend(e);
     }
   });
-  return a(t.prototype, {
+  return c(t.prototype, {
     /**
      *  插件管理器
      */
@@ -752,132 +1127,242 @@ function D(n) {
      * @param options
      * @returns
      */
-    use(e, i) {
-      return this.pluginManager.instUse(this, e, i);
+    usePlugin(e, ...n) {
+      return this.pluginManager.instUsePlugin(this, e, ...n);
+    },
+    /**
+     * {@inheritDoc PluginExtendManager.useExtend}
+     */
+    useExtend(e, ...n) {
+      return this.pluginManager.instUseExtend(this, e, ...n);
+    },
+    /**
+     * 初始化实例
+     * @param args 
+     */
+    async init(...e) {
+      return super.init && await super.init(...e), this.pluginManager.onInit(this, ...e);
     },
     /**
      * 销毁实例
      * @returns 
      */
-    destroy() {
-      return this.pluginManager.destroyed(this);
+    async destroy() {
+      if (await this.pluginManager.onDestroy(this), super.destroy) return super.destroy();
     }
-  }), n;
+  }), s;
 }
-function st(n) {
-  const t = D(n);
-  return new Proxy(n, {
-    construct: function(e, i, s) {
-      const o = new e(...i);
-      return t.pluginManager.created(this), o;
+function it(s) {
+  const t = j(s);
+  return new Proxy(t, {
+    construct: function(e, n, i) {
+      const o = new e(...n);
+      return t.pluginManager.onCreate(this, ...n), o;
     }
   });
 }
-function rt(n) {
-  return class extends n {
+function rt(s) {
+  return class extends s {
+    /**
+     * 是否使用独立的插件管理器
+     * @defaultValue false
+     */
+    static isolatedPluginManager = !1;
     /**
      * 插件管理器
      */
     static get pluginManager() {
-      let e = this._pluginManager;
-      return e || (e = this._pluginManager = new g(this)), e;
+      return this.isolatedPluginManager && !this.hasOwnProperty("_pluginManager") && (this._pluginManager = new p(this)), this._pluginManager;
     }
-    static _pluginManager;
+    static _pluginManager = new p(this);
     /**
-     * 插件管理器 {@link PluginHost.pluginManager}
+     * 插件管理器 {@link PluginHostExtends.pluginManager}
      */
     get pluginManager() {
       return this.constructor.pluginManager;
     }
     /**
-     * {@inheritDoc PluginManager.use}
+     * {@inheritDoc PluginExtendManager.usePlugin}
      */
-    static use(e, ...i) {
-      return this.pluginManager.use(e, ...i);
+    static usePlugin(e, ...n) {
+      return this.pluginManager.usePlugin(e, ...n);
+    }
+    /**
+     * {@inheritDoc PluginExtendManager.useExtend}
+     */
+    static useExtend(e) {
+      return this.pluginManager.useExtend(e);
     }
     constructor(...e) {
-      super(...e), this.pluginManager.created(this);
+      super(...e), this.pluginManager.onCreate(this, ...e);
     }
     /**
      * 实例的注册插件的方法
      * @param plugin
-     * @param options
+     * @param args
      * @returns
      */
-    use(e, ...i) {
-      return this.pluginManager.instUse(this, e, ...i);
+    usePlugin(e, ...n) {
+      return this.pluginManager.instUsePlugin(this, e, ...n);
+    }
+    /**
+     * {@inheritDoc PluginExtendManager.useExtend}
+     */
+    useExtend(e, ...n) {
+      return this.pluginManager.instUseExtend(this, e, ...n);
+    }
+    /**
+     * 初始化实例
+     * @remarks
+     * 会调用 {@link PluginExtendManager.onInit}
+     * @param args 
+     */
+    init(...e) {
+      if (super.init) {
+        const n = super.init(...e);
+        if (n instanceof Promise)
+          return n.then(() => this.pluginManager.onInit(this, ...e));
+      }
+      return this.pluginManager.onInit(this, ...e);
     }
     /**
      * 销毁实例
      * @returns 
      */
     destroy() {
-      return this.pluginManager.destroyed(this);
+      const e = this.pluginManager.onDestroy(this);
+      return super.destroy ? e instanceof Promise ? e.finally(() => super.destroy()) : super.destroy() : e;
     }
   };
 }
-class ut extends N {
+class ut extends F {
+  /**
+   * 全局级别的默认选项
+   */
+  static defaultOptions = new u();
+  /**
+   * 实例级的默认选项
+   */
+  get defaultOptions() {
+    return this._defaultOptions || (this._defaultOptions = new u(void 0, this.constructor.defaultOptions));
+  }
+  _defaultOptions;
+  constructor(t) {
+    super(), this.defaultOptions.option = t;
+  }
+}
+class at extends U {
   /**
    * 全局级别的默认选项
    */
-  static defaultOptions = new p();
+  static defaultOptions = new u();
   /**
    * 实例级的默认选项
    */
   get defaultOptions() {
-    return this._defaultOptions || (this._defaultOptions = new p(void 0, this.constructor.defaultOptions));
+    return this._defaultOptions || (this._defaultOptions = new u(void 0, this.constructor.defaultOptions));
   }
   _defaultOptions;
   constructor(t) {
     super(), this.defaultOptions.option = t;
   }
 }
-function at(n) {
-  const t = U(n);
+class lt extends D {
+  /**
+   * 全局级别的默认选项
+   */
+  static defaultOptions = new u();
+  /**
+   * 实例级的默认选项
+   */
+  get defaultOptions() {
+    return this._defaultOptions || (this._defaultOptions = new u(void 0, this.constructor.defaultOptions));
+  }
+  _defaultOptions;
+  constructor(t) {
+    super(), this.defaultOptions.option = t;
+  }
+}
+function dt(s) {
+  const t = C(s);
   return class extends t {
     /**
      * 全局级别的默认选项
      */
-    static defaultOptions = new p();
+    static defaultOptions = new u();
     /**
      * 实例级的默认选项
      */
     get defaultOptions() {
-      return this._defaultOptions || (this._defaultOptions = new p(void 0, this.constructor.defaultOptions));
+      return this._defaultOptions || (this._defaultOptions = new u(void 0, this.constructor.defaultOptions));
     }
     _defaultOptions;
-    constructor(i) {
-      super(), this.defaultOptions.option = i;
+    constructor(n) {
+      super(), this.defaultOptions.option = n;
     }
   };
 }
-function ct(n, t) {
-  const e = a(n, {
-    /**
-     * 全局级别的默认选项
-     */
-    defaultOptions: new p(t)
-  });
-  return a(e.prototype, {
-    /**
-     * 实例级的默认选项
-     */
-    get defaultOptions() {
-      return this._defaultOptions || (this._defaultOptions = new p(void 0, this.constructor.defaultOptions));
-    }
-  }), n;
-}
 const h = "common";
-class dt extends N {
+class gt extends F {
+  /**
+   * 全局级别的默认选项
+   */
+  static modeOptions = new a(h);
+  /**
+   * 实例级的默认选项
+   */
+  get modeOptions() {
+    return this._modeOptions || (this._modeOptions = new a(h, void 0, this.constructor.modeOptions));
+  }
+  _modeOptions;
+  get mode() {
+    return this.modeOptions.mode;
+  }
+  set mode(t) {
+    this.modeOptions.mode = t;
+  }
+  get options() {
+    return this.modeOptions.plainFullOption;
+  }
+  constructor(t) {
+    super(), this.modeOptions.setOption(t);
+  }
+}
+class ct extends U {
+  /**
+   * 全局级别的默认选项
+   */
+  static modeOptions = new a(h);
+  /**
+   * 实例级的默认选项
+   */
+  get modeOptions() {
+    return this._modeOptions || (this._modeOptions = new a(h, void 0, this.constructor.modeOptions));
+  }
+  _modeOptions;
+  get mode() {
+    return this.modeOptions.mode;
+  }
+  set mode(t) {
+    this.modeOptions.mode = t;
+  }
+  get options() {
+    return this.modeOptions.plainFullOption;
+  }
+  constructor(t) {
+    super(), this.modeOptions.setOption(t);
+  }
+}
+class ht extends D {
   /**
    * 全局级别的默认选项
    */
-  static modeOptions = new c(h);
+  static modeOptions = new a(h);
   /**
    * 实例级的默认选项
    */
   get modeOptions() {
-    return this._modeOptions || (this._modeOptions = new c(h, void 0, this.constructor.modeOptions));
+    return this._modeOptions || (this._modeOptions = new a(h, void 0, this.constructor.modeOptions));
   }
   _modeOptions;
   get mode() {
@@ -893,146 +1378,216 @@ class dt extends N {
     super(), this.modeOptions.setOption(t);
   }
 }
-function gt(n) {
-  const t = U(n);
+function Ot(s) {
+  const t = C(s);
   return class extends t {
     /**
      * 全局级别的默认选项
      */
-    static modeOptions = new c(h);
+    static modeOptions = new a(h);
     /**
      * 实例级的默认选项
      */
     get modeOptions() {
-      return this._modeOptions || (this._modeOptions = new c(h, void 0, this.constructor.modeOptions));
+      return this._modeOptions || (this._modeOptions = new a(h, void 0, this.constructor.modeOptions));
     }
     _modeOptions;
     get mode() {
       return this.modeOptions.mode;
     }
-    set mode(i) {
-      this.modeOptions.mode = i;
+    set mode(n) {
+      this.modeOptions.mode = n;
     }
     get options() {
       return this.modeOptions.plainFullOption;
     }
-    constructor(i) {
-      super(), this.modeOptions.setOption(i);
+    constructor(n) {
+      super(), this.modeOptions.setOption(n);
     }
   };
 }
-function ft(n, t, e) {
-  const i = a(n, {
+function mt(s, t, e) {
+  const n = c(s, {
     /**
      * 全局级别的默认选项
      */
-    modeOptions: new c(t, e)
+    modeOptions: new a(t, e)
   });
-  return a(i.prototype, {
+  return c(n.prototype, {
     /**
      * 实例级的默认选项
      */
     get modeOptions() {
-      return this._modeOptions || (this._modeOptions = new c(t, void 0, this.constructor.modeOptions));
+      return this._modeOptions || (this._modeOptions = new a(t, void 0, this.constructor.modeOptions));
     },
     get mode() {
       return this.modeOptions.mode;
     },
-    set mode(s) {
-      this.modeOptions.mode = s;
+    set mode(i) {
+      this.modeOptions.mode = i;
     },
     get options() {
       return this.modeOptions.fullOption;
     }
-  }), n;
+  }), s;
 }
-function P(n, t) {
-  const e = [{ target: n, props: t }];
-  let i;
-  for (; i = e.shift(); ) {
-    const { target: s, props: o } = i;
-    for (const [r, u] of Object.entries(o)) {
-      if (u != null && typeof u == "object" && (!u.constructor || u.constructor === Object)) {
-        e.push({ target: s[r], props: u });
+const Mt = {
+  onUse(s, t, e) {
+    const n = t ?? h;
+    d(s, {
+      modeOptions: new a(
+        n,
+        void 0,
+        e
+      )
+    }), d(s.prototype, {
+      get modeOptions() {
+        const i = this, o = s;
+        return i._modeOptions || (i._modeOptions = new a(
+          o.modeOptions.mode,
+          void 0,
+          o.modeOptions
+        ));
+      },
+      get mode() {
+        return this.modeOptions.mode;
+      },
+      set mode(i) {
+        const o = this;
+        o.modeOptions.mode = i;
+      },
+      get options() {
+        return this.modeOptions.plainFullOption;
+      }
+    });
+  },
+  onCreate(s, t) {
+    s.modeOptions.setOption(t);
+  }
+}, Pt = {
+  onUse(s, t, e) {
+    d(s, {
+      /**
+       * 全局级别的默认选项
+       */
+      defaultOptions: new u(t, e)
+    }), d(s.prototype, {
+      /**
+       * 实例级的默认选项
+       */
+      get defaultOptions() {
+        return this._defaultOptions || (this._defaultOptions = new u(void 0, s.defaultOptions));
+      }
+    });
+  },
+  onCreate(s, t) {
+    s.defaultOptions.option = t;
+  }
+};
+function xt(s, t) {
+  const e = c(s, {
+    /**
+     * 全局级别的默认选项
+     */
+    defaultOptions: new u(t)
+  });
+  return c(e.prototype, {
+    /**
+     * 实例级的默认选项
+     */
+    get defaultOptions() {
+      return this._defaultOptions || (this._defaultOptions = new u(void 0, this.constructor.defaultOptions));
+    }
+  }), s;
+}
+function _(s, t) {
+  const e = [{ target: s, props: t }];
+  let n;
+  for (; n = e.shift(); ) {
+    const { target: i, props: o } = n;
+    for (const [r, l] of Object.entries(o)) {
+      if (l != null && typeof l == "object" && (!l.constructor || l.constructor === Object)) {
+        e.push({ target: i[r], props: l });
         continue;
       }
-      s[r] = u;
+      i[r] = l;
     }
   }
-  return n;
+  return s;
 }
-function j(n, t) {
-  const e = {}, i = [{ target: n, props: t, targetProps: e }];
-  let s;
-  for (; s = i.shift(); ) {
-    const { target: o, props: r, targetProps: u } = s;
-    for (const [f, d] of Object.entries(r)) {
-      if (d != null && typeof d == "object" && (!d.constructor || d.constructor === Object)) {
-        i.push({ target: o[f], props: d, targetProps: u[f] = {} });
+function A(s, t) {
+  const e = {}, n = [{ target: s, props: t, targetProps: e }];
+  let i;
+  for (; i = n.shift(); ) {
+    const { target: o, props: r, targetProps: l } = i;
+    for (const [m, f] of Object.entries(r)) {
+      if (f != null && typeof f == "object" && (!f.constructor || f.constructor === Object)) {
+        n.push({ target: o[m], props: f, targetProps: l[m] = {} });
         continue;
       }
-      u[f] = o[f];
+      l[m] = o[m];
     }
   }
   return e;
 }
-function ht(n, t) {
-  const e = j(n, t);
-  function i() {
-    P(n, t);
+function yt(s, t) {
+  const e = A(s, t);
+  function n() {
+    _(s, t);
   }
-  function s() {
-    P(n, e);
+  function i() {
+    _(s, e);
   }
-  return { set: i, unset: s };
+  return { set: n, unset: i };
 }
 export {
-  E as ModeOptions,
-  N as PluginHost,
-  g as PluginManager,
-  Q as PluginManagerWithInit,
-  c as TierModeOptions,
-  dt as TierModeOptionsPluginHost,
-  p as TierOptions,
+  Q as ExtendManager,
+  S as ModeOptions,
+  p as PluginExtendManager,
+  F as PluginHost,
+  U as PluginHostEventEmitter,
+  D as PluginHostEventTarget,
+  L as PluginManager,
+  a as TierModeOptions,
+  gt as TierModeOptionsPluginHost,
+  ct as TierModeOptionsPluginHostEventEmitter,
+  ht as TierModeOptionsPluginHostEventTarget,
+  u as TierOptions,
   ut as TierOptionsPluginHost,
+  at as TierOptionsPluginHostEventEmitter,
+  lt as TierOptionsPluginHostEventTarget,
   X as addDefaultOptions,
   Y as addInstOptions,
-  m as allFunctionApply,
-  D as becomePluginHost,
+  j as becomePluginHost,
   rt as becomePluginHost_Extends,
-  st as becomePluginHost_Proxy,
-  ft as becomeTierModeOptionsHost,
-  ct as becomeTierOptionsHost,
+  it as becomePluginHost_Proxy,
+  mt as becomeTierModeOptionsHost,
+  xt as becomeTierOptionsHost,
   h as commonModeName,
-  K as createCallerOfPrivateMemberOfExtend,
-  k as createDefineMixin,
-  B as createExtendTarget,
-  L as createExtendTargetWithInit,
-  $ as createMixinTarget,
-  U as createPluginHost,
-  ht as createPropertySetter,
-  q as createTargetExtend,
-  G as createTargetExtendWithInit,
-  C as createTargetMixin,
-  gt as createTierModeOptionsPluginHost,
-  at as createTierOptionsPluginHost,
-  S as defineExtend,
-  R as defineExtendWithInit,
-  A as defineMixin,
-  T as extendTarget,
-  J as extendTargetWithInit,
-  x as getPropertyValue,
+  K as createDefineMixin,
+  G as createMixinTarget,
+  C as createPluginHost,
+  yt as createPropertySetter,
+  W as createTargetMixin,
+  Ot as createTierModeOptionsPluginHost,
+  dt as createTierOptionsPluginHost,
+  J as defineExtend,
+  B as defineMixin,
+  O as extendMark,
+  y as getPropertyValue,
   Z as getPropertyValueByPath,
-  j as getTargetProperties,
-  P as mergeProperties,
-  l as mixin,
-  a as mixinTarget,
-  F as parsePropertyPath,
-  b as setPropertyValue,
+  A as getTargetProperties,
+  I as isPlugin,
+  _ as mergeProperties,
+  d as mixin,
+  c as mixinTarget,
+  b as parsePropertyPath,
+  T as pickHostExtendMembers,
+  E as setPropertyValue,
   tt as setPropertyValueByPath,
-  O as targetExtend,
-  y as targetExtendWithInit,
-  z as targetMixin,
+  R as targetMixin,
   nt as tierModeOptionsDecorator,
-  et as tierOptionsDecorator
+  Mt as tierModeOptionsPlugin,
+  et as tierOptionsDecorator,
+  Pt as tierOptionsPlugin
 };