@kaokei/di 3.0.8 → 4.0.0

package/dist/index.js

@@ -1,24 +1,22 @@
-var O = Object.defineProperty;
-var R = (e, t, n) => t in e ? O(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
-var r = (e, t, n) => R(e, typeof t != "symbol" ? t + "" : t, n);
+var L = Object.defineProperty;
+var j = (n, t, e) => t in n ? L(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e;
+var r = (n, t, e) => j(n, typeof t != "symbol" ? t + "" : t, e);
 const l = {
-  // 记录构造函数参数装饰器对应的数据的key
-  INJECTED_PARAMS: "injected:params",
-  // 记录实例属性装饰器对应的数据的key
+  // 记录实例属性装饰器对应的数据的键
   INJECTED_PROPS: "injected:props",
-  // Inject装饰器的key
+  // Inject 装饰器的键
   INJECT: "inject",
-  // Self装饰器的key
+  // Self 装饰器的键
   SELF: "self",
-  // SkipSelf装饰器的key
+  // SkipSelf 装饰器的键
   SKIP_SELF: "skipSelf",
-  // Optional装饰器的key
+  // Optional 装饰器的键
   OPTIONAL: "optional",
-  // PostConstruct装饰器的key
+  // PostConstruct 装饰器的键
   POST_CONSTRUCT: "postConstruct",
-  // PreDestroy装饰器的key
+  // PreDestroy 装饰器的键
   PRE_DESTROY: "preDestroy"
-}, p = {
+}, f = {
   DEFAULT: "default",
   INITING: "initing",
   ACTIVATED: "activated"
@@ -28,89 +26,99 @@ const l = {
   ConstantValue: "ConstantValue",
   DynamicValue: "DynamicValue"
 }, C = {
-  POST_CONSTRUCT: "Cannot apply @PostConstruct decorator multiple times in the same class.",
-  PRE_DESTROY: "Cannot apply @PreDestroy decorator multiple times in the same class.",
-  MISS_INJECT: "Expected a @Inject decorator to explicitly specify the token.",
-  MISS_CONTAINER: "@LazyInject decorator cannot find the corresponding container."
-}, D = Symbol(), S = /* @__PURE__ */ new WeakMap();
-function w(e) {
-  return typeof e == "function" && Object.getPrototypeOf(e) !== Function.prototype;
+  // 用于 decorator.ts 的 createMetaDecorator —— 重复装饰器检测
+  POST_CONSTRUCT: "Multiple @PostConstruct decorators are not allowed in a single class.",
+  PRE_DESTROY: "Multiple @PreDestroy decorators are not allowed in a single class.",
+  // 用于 token.ts 的 resolveToken —— 无效 token
+  INVALID_TOKEN: "@Inject or @LazyInject requires a valid token, but received null or undefined.",
+  // 用于 decorator.ts 的 defineLazyProperty —— 无效 token
+  LAZY_INJECT_INVALID_TOKEN: "@LazyInject requires a valid token, but received null or undefined."
+};
+function m(n, t) {
+  return Object.prototype.hasOwnProperty.call(n, t);
+}
+const D = Symbol("UNINITIALIZED"), A = /* @__PURE__ */ new WeakMap();
+function k(n) {
+  return typeof n == "function" && Object.getPrototypeOf(n) !== Function.prototype;
 }
-function b(e, t, n) {
-  const s = S.get(n) || {};
-  s[e] = t, S.set(n, s);
+function V(n, t, e) {
+  const i = A.get(e) || {};
+  i[n] = t, A.set(e, i);
 }
-function E(e, t) {
-  return (S.get(t) || {})[e];
+function P(n, t) {
+  return (A.get(t) || {})[n];
 }
-function y(e, t) {
-  const n = E(e, t);
-  if (!w(t))
-    return n;
-  const s = y(
-    e,
+function T(n, t) {
+  const e = P(n, t);
+  if (!k(t))
+    return e;
+  const i = T(
+    n,
     Object.getPrototypeOf(t)
   );
-  if (s || n)
+  if (i || e)
     return {
-      ...s || {},
-      ...n || {}
+      ...i || {},
+      ...e || {}
     };
 }
-class J {
+class G {
   constructor(t) {
-    r(this, "_", "");
+    // 仅类型层面存在，无运行时开销
     r(this, "name");
     this.name = t;
   }
 }
 class B {
   constructor(t) {
-    r(this, "callback");
-    this.callback = t;
+    r(this, "_callback");
+    this._callback = t;
   }
   resolve() {
-    return this.callback();
+    return this._callback();
   }
 }
-function A(e) {
-  if (!e)
-    throw new Error(C.MISS_INJECT);
-  return e instanceof B ? e.resolve() : e;
+function S(n) {
+  if (!n)
+    throw new Error(C.INVALID_TOKEN);
+  return n instanceof B ? n.resolve() : n;
 }
-class T extends Error {
-  constructor(t, n) {
-    super(), this.name = this.constructor.name, this.message = `${t}${n == null ? void 0 : n.name}`;
+class g extends Error {
+  constructor(e, i) {
+    const s = (i == null ? void 0 : i.name) || "<unknown token>";
+    super(`${e}${s}`);
+    r(this, "token");
+    this.name = this.constructor.name, this.token = i;
   }
 }
-class V extends T {
+class w extends g {
   constructor(t) {
     super("");
-    const n = [];
-    let s = t;
-    for (; s && s.token; )
-      n.push(s.token), s = s.parent;
-    const i = n.reverse().map((o) => o.name).join(" --> ");
-    this.message = `Circular dependency found: ${i}`;
+    const e = [];
+    let i = t;
+    for (; i && i.token; )
+      e.push(i.token), i = i.parent;
+    const s = e.reverse().map((a) => a.name || "<anonymous>").join(" --> ");
+    this.message = `Circular dependency found: ${s}`;
   }
 }
-class _ extends T {
+class H extends g {
   constructor(t) {
     super("Invalid binding: ", t);
   }
 }
-class H extends V {
+class M extends w {
   constructor(t) {
     super(t), this.name = "CircularDependencyError inside @PostConstruct";
   }
 }
-class j {
-  constructor(t, n) {
+const y = class y {
+  constructor(t, e) {
     r(this, "container");
     r(this, "context");
     r(this, "token");
     r(this, "type", d.Invalid);
-    r(this, "status", p.DEFAULT);
+    r(this, "status", f.DEFAULT);
     r(this, "classValue");
     r(this, "constantValue");
     r(this, "dynamicValue");
@@ -118,7 +126,7 @@ class j {
     r(this, "postConstructResult", D);
     r(this, "onActivationHandler");
     r(this, "onDeactivationHandler");
-    this.container = n, this.context = { container: this.container }, this.token = t;
+    this.container = e, this.context = { container: this.container }, this.token = t;
   }
   onActivation(t) {
     this.onActivationHandler = t;
@@ -127,8 +135,8 @@ class j {
     this.onDeactivationHandler = t;
   }
   activate(t) {
-    const n = this.onActivationHandler ? this.onActivationHandler(this.context, t) : t;
-    return this.container.activate(n, this.token);
+    const e = this.onActivationHandler ? this.onActivationHandler(this.context, t) : t;
+    return this.container.activate(e, this.token);
   }
   deactivate() {
     this.onDeactivationHandler && this.onDeactivationHandler(this.cache);
@@ -147,102 +155,125 @@ class j {
   }
   toService(t) {
     return this.toDynamicValue(
-      (n) => n.container.get(t, { parent: { token: this.token } })
+      (e) => e.container.get(t, { parent: { token: this.token } })
     );
   }
   get(t) {
-    if (p.INITING === this.status)
-      throw new V(t);
-    if (p.ACTIVATED === this.status)
+    if (f.INITING === this.status)
+      throw new w(t);
+    if (f.ACTIVATED === this.status)
       return this.cache;
-    if (d.Instance === this.type)
-      return this.resolveInstanceValue(t);
-    if (d.ConstantValue === this.type)
-      return this.resolveConstantValue();
-    if (d.DynamicValue === this.type)
-      return this.resolveDynamicValue();
-    throw new _(this.token);
-  }
-  getAwaitBindings(t, n) {
-    return n === !0 ? t : Array.isArray(n) ? t.filter((s) => n.includes(s.token)) : typeof n == "function" ? t.filter(n) : [];
-  }
-  postConstruct(t, n, s) {
+    const e = y._resolvers[this.type];
+    if (e)
+      return this[e](t);
+    throw new H(this.token);
+  }
+  _getAwaitBindings(t, e) {
+    return e === !0 ? t : Array.isArray(e) ? t.filter((i) => e.includes(i.token)) : typeof e == "function" ? t.filter(e) : [];
+  }
+  /**
+   * PostConstruct 生命周期处理
+   *
+   * postConstructResult 的三种状态：
+   * - UNINITIALIZED（Symbol）：PostConstruct 尚未执行，用于循环依赖检测
+   * - undefined：没有使用 @PostConstruct 装饰器，或 @PostConstruct() 无参数时同步执行完毕
+   * - Promise<void>：@PostConstruct(value) 有参数时，等待前置服务初始化后异步执行
+   *
+   * @PostConstruct() 无参数时：同步执行，不等待任何前置服务
+   * @PostConstruct(value) 有参数时：等待指定的前置服务初始化完成后再执行
+   *   - 如果前置服务初始化成功，执行当前服务的 PostConstruct 方法
+   *   - 如果前置服务初始化失败，rejected promise 自然传播，当前服务的 PostConstruct 不执行
+   */
+  _postConstruct(t, e) {
     if (d.Instance === this.type) {
-      const { key: i, value: o } = y(l.POST_CONSTRUCT, this.classValue) || {};
+      const { key: i, value: s } = T(l.POST_CONSTRUCT, this.classValue) || {};
       if (i)
-        if (o) {
-          const a = [...n, ...s].filter(
-            (u) => d.Instance === (u == null ? void 0 : u.type)
-          ), c = this.getAwaitBindings(a, o);
-          for (const u of c)
-            if (u && u.postConstructResult === D)
-              throw new H({
-                token: u.token,
+        if (s) {
+          const a = e.filter(
+            (c) => d.Instance === (c == null ? void 0 : c.type)
+          ), o = this._getAwaitBindings(a, s);
+          for (const c of o)
+            if (c && c.postConstructResult === D)
+              throw new M({
+                token: c.token,
                 parent: t
               });
-          const h = c.map((u) => u.postConstructResult);
-          this.postConstructResult = Promise.all(h).then(
-            () => this.execute(i)
+          const u = o.map((c) => c.postConstructResult);
+          this.postConstructResult = Promise.all(u).then(
+            () => this._execute(i)
           );
         } else
-          this.postConstructResult = this.execute(i);
+          this.postConstructResult = this._execute(i);
       else
         this.postConstructResult = void 0;
     }
   }
   preDestroy() {
     if (d.Instance === this.type) {
-      const { key: t } = y(l.PRE_DESTROY, this.classValue) || {};
-      t && this.execute(t);
+      const { key: t } = T(l.PRE_DESTROY, this.classValue) || {};
+      t && this._execute(t);
     }
-    I.map.delete(this.cache), this.container = null, this.context = null, this.classValue = null, this.constantValue = null, this.dynamicValue = null, this.cache = null, this.postConstructResult = D, this.onActivationHandler = void 0, this.onDeactivationHandler = void 0;
-  }
-  execute(t) {
-    const n = this.cache[t];
-    return n == null ? void 0 : n.call(this.cache);
-  }
-  resolveInstanceValue(t) {
-    this.status = p.INITING;
-    const n = this.classValue, [s, i] = this.getConstructorParameters(t), o = new n(...s);
-    this.cache = this.activate(o), this.status = p.ACTIVATED, I.map.set(this.cache, this.container);
-    const [a, c] = this.getInjectProperties(t);
-    return Object.assign(this.cache, a), this.postConstruct(t, i, c), this.cache;
-  }
-  resolveConstantValue() {
-    return this.status = p.INITING, this.cache = this.activate(this.constantValue), this.status = p.ACTIVATED, this.cache;
-  }
-  resolveDynamicValue() {
-    this.status = p.INITING;
-    const t = this.dynamicValue.call(this, this.context);
-    return this.cache = this.activate(t), this.status = p.ACTIVATED, this.cache;
-  }
-  getConstructorParameters(t) {
-    const n = E(l.INJECTED_PARAMS, this.classValue) || [], s = [], i = [];
-    for (let o = 0; o < n.length; o++) {
-      const a = n[o], { inject: c, ...h } = a;
-      h.parent = t;
-      const u = this.container.get(A(c), h);
-      s.push(u), i.push(h.binding);
+    I._instanceContainerMap.delete(this.cache), this.container = null, this.context = null, this.classValue = void 0, this.constantValue = void 0, this.dynamicValue = void 0, this.cache = void 0, this.postConstructResult = D, this.onActivationHandler = void 0, this.onDeactivationHandler = void 0;
+  }
+  _execute(t) {
+    const e = this.cache[t];
+    return e == null ? void 0 : e.call(this.cache);
+  }
+  _resolveInstanceValue(t) {
+    this.status = f.INITING;
+    const e = this._createInstance();
+    this.cache = this.activate(e), this.status = f.ACTIVATED, this._registerInstance();
+    const { properties: i, bindings: s } = this._getInjectProperties(t);
+    return this._injectProperties(i), this._postConstruct(t, s), this.cache;
+  }
+  // 创建类的实例
+  _createInstance() {
+    const t = this.classValue;
+    return new t();
+  }
+  // 注册实例与容器的映射关系
+  _registerInstance() {
+    I._instanceContainerMap.set(this.cache, this.container);
+  }
+  // 将解析后的属性注入到实例上
+  _injectProperties(t) {
+    Object.assign(this.cache, t);
+  }
+  _resolveConstantValue() {
+    return this.status = f.INITING, this.cache = this.activate(this.constantValue), this.status = f.ACTIVATED, this.cache;
+  }
+  _resolveDynamicValue() {
+    this.status = f.INITING;
+    const t = this.dynamicValue(this.context);
+    return this.cache = this.activate(t), this.status = f.ACTIVATED, this.cache;
+  }
+  _getInjectProperties(t) {
+    const e = T(l.INJECTED_PROPS, this.classValue) || {}, i = Object.keys(e), s = /* @__PURE__ */ Object.create(null), a = [];
+    for (let o = 0; o < i.length; o++) {
+      const u = i[o], c = e[u], { inject: p, ..._ } = c;
+      _.parent = t;
+      const h = this.container.get(
+        S(p),
+        _
+      );
+      h === void 0 && c.optional || (s[u] = h), a.push(_.binding);
     }
-    return [s, i];
-  }
-  getInjectProperties(t) {
-    const n = y(l.INJECTED_PROPS, this.classValue) || {}, s = Object.keys(n), i = /* @__PURE__ */ Object.create(null), o = [];
-    for (let a = 0; a < s.length; a++) {
-      const c = s[a], h = n[c], { inject: u, ...f } = h;
-      f.parent = t;
-      const g = this.container.get(A(u), f);
-      g === void 0 && h.optional || (i[c] = g), o.push(f.binding);
-    }
-    return [i, o];
+    return { properties: s, bindings: a };
   }
-}
-class k extends T {
+};
+// 类型到解析方法的静态映射表，用于替代 get 方法中的 if-else 链
+r(y, "_resolvers", {
+  [d.Instance]: "_resolveInstanceValue",
+  [d.ConstantValue]: "_resolveConstantValue",
+  [d.DynamicValue]: "_resolveDynamicValue"
+});
+let b = y;
+class x extends g {
   constructor(t) {
     super("No matching binding found for token: ", t);
   }
 }
-class x extends T {
+class F extends g {
   constructor(t) {
     super("Cannot bind token multiple times: ", t);
   }
@@ -251,29 +282,33 @@ const v = class v {
   constructor() {
     r(this, "parent");
     r(this, "children");
-    r(this, "bindings", /* @__PURE__ */ new Map());
-    r(this, "onActivationHandler");
-    r(this, "onDeactivationHandler");
+    r(this, "_bindings", /* @__PURE__ */ new Map());
+    r(this, "_onActivationHandler");
+    r(this, "_onDeactivationHandler");
+  }
+  // 查询实例所属的容器
+  static getContainerOf(t) {
+    return v._instanceContainerMap.get(t);
   }
   bind(t) {
-    if (this.bindings.has(t))
-      throw new x(t);
-    const n = this.buildBinding(t);
-    return this.bindings.set(t, n), n;
+    if (this._bindings.has(t))
+      throw new F(t);
+    const e = this._buildBinding(t);
+    return this._bindings.set(t, e), e;
   }
   unbind(t) {
-    if (this.bindings.has(t)) {
-      const n = this.getBinding(t);
-      this.deactivate(n), n.deactivate(), n.preDestroy(), this.bindings.delete(t);
+    if (this._bindings.has(t)) {
+      const e = this._getBinding(t);
+      this.deactivate(e), e.deactivate(), e.preDestroy(), this._bindings.delete(t);
     }
   }
   unbindAll() {
-    this.bindings.forEach((t) => {
-      this.unbind(t.token);
-    });
+    const t = Array.from(this._bindings.keys());
+    for (const e of t)
+      this.unbind(e);
   }
   isCurrentBound(t) {
-    return this.bindings.has(t);
+    return this._bindings.has(t);
   }
   isBound(t) {
     return this.isCurrentBound(t) || !!this.parent && this.parent.isBound(t);
@@ -283,124 +318,177 @@ const v = class v {
     return t.parent = this, this.children || (this.children = /* @__PURE__ */ new Set()), this.children.add(t), t;
   }
   destroy() {
-    var t, n, s;
-    this.unbindAll(), this.bindings.clear(), (n = (t = this.parent) == null ? void 0 : t.children) == null || n.delete(this), this.parent = void 0, (s = this.children) == null || s.clear(), this.children = void 0, this.onActivationHandler = void 0, this.onDeactivationHandler = void 0;
-  }
-  get(t, n = {}) {
-    const s = this.getBinding(t);
-    if (n.skipSelf) {
-      if (this.parent)
-        return n.skipSelf = !1, this.parent.get(t, n);
-    } else if (n.self || s) {
-      if (s)
-        return n.token = t, n.binding = s, s.get(n);
-    } else if (this.parent)
-      return this.parent.get(t, n);
-    return this.checkBindingNotFoundError(t, n);
+    var t, e;
+    if (this.children) {
+      const i = Array.from(this.children);
+      for (const s of i)
+        s.destroy();
+    }
+    this.unbindAll(), this._bindings.clear(), (e = (t = this.parent) == null ? void 0 : t.children) == null || e.delete(this), this.parent = void 0, this.children = void 0, this._onActivationHandler = void 0, this._onDeactivationHandler = void 0;
+  }
+  get(t, e = {}) {
+    return e.skipSelf ? this._resolveSkipSelf(t, e) : e.self ? this._resolveSelf(t, e) : this._resolveDefault(t, e);
+  }
+  // 处理 skipSelf 选项：跳过当前容器，委托父容器解析
+  _resolveSkipSelf(t, e) {
+    return this.parent ? (e.skipSelf = !1, this.parent.get(t, e)) : this._checkBindingNotFoundError(t, e);
+  }
+  // 处理 self 选项：仅在当前容器中查找
+  _resolveSelf(t, e) {
+    const i = this._getBinding(t);
+    return i ? (e.token = t, e.binding = i, i.get(e)) : this._checkBindingNotFoundError(t, e);
+  }
+  // 默认解析流程：当前容器 → 父容器 → 抛错
+  _resolveDefault(t, e) {
+    const i = this._getBinding(t);
+    return i ? (e.token = t, e.binding = i, i.get(e)) : this.parent ? this.parent.get(t, e) : this._checkBindingNotFoundError(t, e);
   }
   onActivation(t) {
-    this.onActivationHandler = t;
+    this._onActivationHandler = t;
   }
   onDeactivation(t) {
-    this.onDeactivationHandler = t;
+    this._onDeactivationHandler = t;
   }
-  activate(t, n) {
-    return this.onActivationHandler ? this.onActivationHandler({ container: this }, t, n) : t;
+  activate(t, e) {
+    return this._onActivationHandler ? this._onActivationHandler({ container: this }, t, e) : t;
   }
   deactivate(t) {
-    this.onDeactivationHandler && this.onDeactivationHandler(t.cache, t.token);
+    this._onDeactivationHandler && this._onDeactivationHandler(t.cache, t.token);
   }
-  buildBinding(t) {
-    return new j(t, this);
+  _buildBinding(t) {
+    return new b(t, this);
   }
-  getBinding(t) {
-    return this.bindings.get(t);
+  _getBinding(t) {
+    return this._bindings.get(t);
   }
-  checkBindingNotFoundError(t, n) {
-    if (!n.optional)
-      throw new k(t);
+  _checkBindingNotFoundError(t, e) {
+    if (!e.optional)
+      throw new x(t);
   }
 };
-r(v, "map", /* @__PURE__ */ new WeakMap());
+// 实例到容器的映射表，用于 @LazyInject 查找实例所属容器
+// 仅 Instance 类型的 binding 会注册映射（_registerInstance 仅在 _resolveInstanceValue 中调用）
+// toConstantValue 和 toDynamicValue 不会触发注册，原因：
+// 同一对象可能通过 toConstantValue 被绑定到多个容器，WeakMap 只能保留最后一次映射，
+// 会导致 @LazyInject 从错误的容器解析依赖。
+// 由于 Instance 类型每次都通过 new ClassName() 创建新实例，不存在同一实例被多个容器注册的覆盖风险
+r(v, "_instanceContainerMap", /* @__PURE__ */ new WeakMap());
 let I = v;
-function m(e, t) {
-  return function(n) {
-    return function(s, i, o) {
-      const a = typeof o == "number", c = a ? s : s.constructor, h = a ? o : i, u = a ? l.INJECTED_PARAMS : l.INJECTED_PROPS, f = a ? E(u, c) || [] : y(u, c) || {}, g = f[h] || {};
-      g[e] = n === void 0 ? t : n, f[h] = g, b(u, f, c);
+class z extends g {
+  constructor(t, e) {
+    super(
+      `@LazyInject(${t == null ? void 0 : t.name}) in class ${e.name} requires a registered container but none was found. Token: `,
+      t
+    );
+  }
+}
+function E(n, t) {
+  return function(e) {
+    return function(i, s) {
+      s.addInitializer(function() {
+        const a = this.constructor, o = s.name, u = P(l.INJECTED_PROPS, a) || {}, c = u[o] || {};
+        c[n] = e === void 0 ? t : e, u[o] = c, V(l.INJECTED_PROPS, u, a);
+      });
     };
   };
 }
-function N(e, t) {
-  return (n) => (s, i) => {
-    if (E(e, s.constructor))
+function R(n, t) {
+  return (e) => (i, s) => {
+    const a = s.name, o = s.metadata;
+    if (m(o, n))
       throw new Error(t);
-    b(
-      e,
-      { key: i, value: n },
-      s.constructor
-    );
+    o[n] = !0, s.addInitializer(function() {
+      const u = this.constructor;
+      V(n, { key: a, value: e }, u);
+    });
   };
 }
-const U = m(l.INJECT), G = m(l.SELF, !0), Y = m(l.SKIP_SELF, !0), z = m(l.OPTIONAL, !0), K = N(
+const K = E(l.INJECT), $ = E(l.SELF, !0), Z = E(l.SKIP_SELF, !0), q = E(l.OPTIONAL, !0), W = R(
   l.POST_CONSTRUCT,
   C.POST_CONSTRUCT
-), $ = N(
+), Q = R(
   l.PRE_DESTROY,
   C.PRE_DESTROY
 );
-function P(e, t, n, s) {
-  for (let i = e.length - 1; i >= 0; i--)
-    e[i](t, n, s);
-}
-function W(e, t, n) {
-  e = Array.isArray(e) ? e : [e], typeof n == "number" ? P(e, t, void 0, n) : typeof n == "string" && P(e, t.prototype, n);
-}
-function M(e, t, n, s) {
-  function i() {
-    const a = Symbol.for(t);
-    if (!this.hasOwnProperty(a)) {
-      const c = s || I.map.get(this), h = this.constructor;
-      if (!c)
-        throw new Error(`${C.MISS_CONTAINER} ${h.name}`);
-      this[a] = c.get(A(n), {
-        parent: { token: h }
-      });
-    }
-    return this[a];
-  }
-  function o(a) {
-    const c = Symbol.for(t);
-    this[c] = a;
-  }
-  Object.defineProperty(e, t, {
+function U(n, t, e, i) {
+  if (e == null)
+    throw new Error(C.LAZY_INJECT_INVALID_TOKEN);
+  const s = Symbol.for(t);
+  Object.defineProperty(n, t, {
     configurable: !0,
     enumerable: !0,
-    get: i,
-    set: o
+    get() {
+      if (!m(n, s)) {
+        const a = i || I.getContainerOf(n), o = n.constructor;
+        if (!a)
+          throw new z(S(e), o);
+        n[s] = a.get(S(e), {
+          parent: { token: o }
+        });
+      }
+      return n[s];
+    },
+    set(a) {
+      n[s] = a;
+    }
   });
 }
-function L(e, t) {
-  return function(n, s) {
-    M(n, s, e, t);
+function J(n, t) {
+  return function(e, i) {
+    const s = i.name;
+    i.addInitializer(function() {
+      U(this, s, n, t);
+    });
   };
 }
-function q(e) {
+function X(n) {
   return function(t) {
-    return L(t, e);
+    return J(t, n);
+  };
+}
+const N = Symbol("decorate.metadata");
+function tt(n, t, e) {
+  const i = Array.isArray(n) ? n : [n], s = t.prototype, a = typeof s[e] == "function", o = [];
+  m(t, N) || (t[N] = {});
+  const u = t[N], c = {
+    kind: a ? "method" : "field",
+    name: e,
+    static: !1,
+    private: !1,
+    addInitializer(h) {
+      o.push(h);
+    },
+    metadata: u
   };
+  let p = a ? s[e] : void 0;
+  for (let h = i.length - 1; h >= 0; h--) {
+    const O = i[h](p, c);
+    a && typeof O == "function" && (p = O);
+  }
+  a && p !== s[e] && (s[e] = p);
+  const _ = Object.create(s);
+  for (const h of o)
+    h.call(_);
 }
 export {
+  g as BaseError,
+  b as Binding,
+  x as BindingNotFoundError,
+  H as BindingNotValidError,
+  w as CircularDependencyError,
   I as Container,
-  U as Inject,
-  L as LazyInject,
+  z as ContainerNotFoundError,
+  F as DuplicateBindingError,
+  K as Inject,
+  J as LazyInject,
   B as LazyToken,
-  z as Optional,
-  K as PostConstruct,
-  $ as PreDestroy,
-  G as Self,
-  Y as SkipSelf,
-  J as Token,
-  q as createLazyInject,
-  W as decorate
+  q as Optional,
+  W as PostConstruct,
+  M as PostConstructError,
+  Q as PreDestroy,
+  $ as Self,
+  Z as SkipSelf,
+  G as Token,
+  X as createLazyInject,
+  tt as decorate
 };