@sarafapp/ant-design 1.0.8 → 1.0.10

package/dist/node_modules/tslib/tslib.es6.es.js

@@ -0,0 +1,155 @@
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+var y = function(r, u) {
+  return y = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(e, i) {
+    e.__proto__ = i;
+  } || function(e, i) {
+    for (var a in i) i.hasOwnProperty(a) && (e[a] = i[a]);
+  }, y(r, u);
+};
+function _(r, u) {
+  y(r, u);
+  function e() {
+    this.constructor = r;
+  }
+  r.prototype = u === null ? Object.create(u) : (e.prototype = u.prototype, new e());
+}
+function b(r, u, e, i) {
+  function a(t) {
+    return t instanceof e ? t : new e(function(o) {
+      o(t);
+    });
+  }
+  return new (e || (e = Promise))(function(t, o) {
+    function c(l) {
+      try {
+        n(i.next(l));
+      } catch (s) {
+        o(s);
+      }
+    }
+    function f(l) {
+      try {
+        n(i.throw(l));
+      } catch (s) {
+        o(s);
+      }
+    }
+    function n(l) {
+      l.done ? t(l.value) : a(l.value).then(c, f);
+    }
+    n((i = i.apply(r, [])).next());
+  });
+}
+function d(r, u) {
+  var e = { label: 0, sent: function() {
+    if (t[0] & 1) throw t[1];
+    return t[1];
+  }, trys: [], ops: [] }, i, a, t, o;
+  return o = { next: c(0), throw: c(1), return: c(2) }, typeof Symbol == "function" && (o[Symbol.iterator] = function() {
+    return this;
+  }), o;
+  function c(n) {
+    return function(l) {
+      return f([n, l]);
+    };
+  }
+  function f(n) {
+    if (i) throw new TypeError("Generator is already executing.");
+    for (; e; ) try {
+      if (i = 1, a && (t = n[0] & 2 ? a.return : n[0] ? a.throw || ((t = a.return) && t.call(a), 0) : a.next) && !(t = t.call(a, n[1])).done) return t;
+      switch (a = 0, t && (n = [n[0] & 2, t.value]), n[0]) {
+        case 0:
+        case 1:
+          t = n;
+          break;
+        case 4:
+          return e.label++, { value: n[1], done: !1 };
+        case 5:
+          e.label++, a = n[1], n = [0];
+          continue;
+        case 7:
+          n = e.ops.pop(), e.trys.pop();
+          continue;
+        default:
+          if (t = e.trys, !(t = t.length > 0 && t[t.length - 1]) && (n[0] === 6 || n[0] === 2)) {
+            e = 0;
+            continue;
+          }
+          if (n[0] === 3 && (!t || n[1] > t[0] && n[1] < t[3])) {
+            e.label = n[1];
+            break;
+          }
+          if (n[0] === 6 && e.label < t[1]) {
+            e.label = t[1], t = n;
+            break;
+          }
+          if (t && e.label < t[2]) {
+            e.label = t[2], e.ops.push(n);
+            break;
+          }
+          t[2] && e.ops.pop(), e.trys.pop();
+          continue;
+      }
+      n = u.call(r, e);
+    } catch (l) {
+      n = [6, l], a = 0;
+    } finally {
+      i = t = 0;
+    }
+    if (n[0] & 5) throw n[1];
+    return { value: n[0] ? n[1] : void 0, done: !0 };
+  }
+}
+function w(r) {
+  var u = typeof Symbol == "function" && Symbol.iterator, e = u && r[u], i = 0;
+  if (e) return e.call(r);
+  if (r && typeof r.length == "number") return {
+    next: function() {
+      return r && i >= r.length && (r = void 0), { value: r && r[i++], done: !r };
+    }
+  };
+  throw new TypeError(u ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function h(r, u) {
+  var e = typeof Symbol == "function" && r[Symbol.iterator];
+  if (!e) return r;
+  var i = e.call(r), a, t = [], o;
+  try {
+    for (; (u === void 0 || u-- > 0) && !(a = i.next()).done; ) t.push(a.value);
+  } catch (c) {
+    o = { error: c };
+  } finally {
+    try {
+      a && !a.done && (e = i.return) && e.call(i);
+    } finally {
+      if (o) throw o.error;
+    }
+  }
+  return t;
+}
+function v() {
+  for (var r = [], u = 0; u < arguments.length; u++)
+    r = r.concat(h(arguments[u]));
+  return r;
+}
+export {
+  b as __awaiter,
+  _ as __extends,
+  d as __generator,
+  h as __read,
+  v as __spread,
+  w as __values
+};

package/dist/node_modules/tsyringe/dist/esm5/dependency-container.es.js

@@ -0,0 +1,256 @@
+import { __spread as c, __values as h, __read as w, __awaiter as A, __generator as C } from "../../../tslib/tslib.es6.es.js";
+import { isClassProvider as S } from "./providers/class-provider.es.js";
+import { isFactoryProvider as R } from "./providers/factory-provider.es.js";
+import { isNormalToken as a, isConstructorToken as D, isTokenDescriptor as P, isTransformDescriptor as m } from "./providers/injection-token.es.js";
+import { isTokenProvider as y } from "./providers/token-provider.es.js";
+import { isValueProvider as g } from "./providers/value-provider.es.js";
+import { isProvider as I } from "./providers/provider.es.js";
+import N from "./registry.es.js";
+import p from "./types/lifecycle.es.js";
+import d from "./resolution-context.es.js";
+import { formatErrorCtor as T } from "./error-helpers.es.js";
+import { DelayedConstructor as E } from "./lazy-helpers.es.js";
+import { isDisposable as _ } from "./types/disposable.es.js";
+import q from "./interceptors.es.js";
+var V = /* @__PURE__ */ new Map(), b = function() {
+  function u(e) {
+    this.parent = e, this._registry = new N(), this.interceptors = new q(), this.disposed = !1, this.disposables = /* @__PURE__ */ new Set();
+  }
+  return u.prototype.register = function(e, r, s) {
+    s === void 0 && (s = { lifecycle: p.Transient }), this.ensureNotDisposed();
+    var t;
+    if (I(r) ? t = r : t = { useClass: r }, y(t))
+      for (var i = [e], o = t; o != null; ) {
+        var l = o.useToken;
+        if (i.includes(l))
+          throw new Error("Token registration cycle detected! " + c(i, [l]).join(" -> "));
+        i.push(l);
+        var n = this._registry.get(l);
+        n && y(n.provider) ? o = n.provider : o = null;
+      }
+    if ((s.lifecycle === p.Singleton || s.lifecycle == p.ContainerScoped || s.lifecycle == p.ResolutionScoped) && (g(t) || R(t)))
+      throw new Error('Cannot use lifecycle "' + p[s.lifecycle] + '" with ValueProviders or FactoryProviders');
+    return this._registry.set(e, { provider: t, options: s }), this;
+  }, u.prototype.registerType = function(e, r) {
+    return this.ensureNotDisposed(), a(r) ? this.register(e, {
+      useToken: r
+    }) : this.register(e, {
+      useClass: r
+    });
+  }, u.prototype.registerInstance = function(e, r) {
+    return this.ensureNotDisposed(), this.register(e, {
+      useValue: r
+    });
+  }, u.prototype.registerSingleton = function(e, r) {
+    if (this.ensureNotDisposed(), a(e)) {
+      if (a(r))
+        return this.register(e, {
+          useToken: r
+        }, { lifecycle: p.Singleton });
+      if (r)
+        return this.register(e, {
+          useClass: r
+        }, { lifecycle: p.Singleton });
+      throw new Error('Cannot register a type name as a singleton without a "to" token');
+    }
+    var s = e;
+    return r && !a(r) && (s = r), this.register(e, {
+      useClass: s
+    }, { lifecycle: p.Singleton });
+  }, u.prototype.resolve = function(e, r, s) {
+    r === void 0 && (r = new d()), s === void 0 && (s = !1), this.ensureNotDisposed();
+    var t = this.getRegistration(e);
+    if (!t && a(e)) {
+      if (s)
+        return;
+      throw new Error('Attempted to resolve unregistered dependency token: "' + e.toString() + '"');
+    }
+    if (this.executePreResolutionInterceptor(e, "Single"), t) {
+      var i = this.resolveRegistration(t, r);
+      return this.executePostResolutionInterceptor(e, i, "Single"), i;
+    }
+    if (D(e)) {
+      var i = this.construct(e, r);
+      return this.executePostResolutionInterceptor(e, i, "Single"), i;
+    }
+    throw new Error("Attempted to construct an undefined constructor. Could mean a circular dependency problem. Try using `delay` function.");
+  }, u.prototype.executePreResolutionInterceptor = function(e, r) {
+    var s, t;
+    if (this.interceptors.preResolution.has(e)) {
+      var i = [];
+      try {
+        for (var o = h(this.interceptors.preResolution.getAll(e)), l = o.next(); !l.done; l = o.next()) {
+          var n = l.value;
+          n.options.frequency != "Once" && i.push(n), n.callback(e, r);
+        }
+      } catch (f) {
+        s = { error: f };
+      } finally {
+        try {
+          l && !l.done && (t = o.return) && t.call(o);
+        } finally {
+          if (s) throw s.error;
+        }
+      }
+      this.interceptors.preResolution.setAll(e, i);
+    }
+  }, u.prototype.executePostResolutionInterceptor = function(e, r, s) {
+    var t, i;
+    if (this.interceptors.postResolution.has(e)) {
+      var o = [];
+      try {
+        for (var l = h(this.interceptors.postResolution.getAll(e)), n = l.next(); !n.done; n = l.next()) {
+          var f = n.value;
+          f.options.frequency != "Once" && o.push(f), f.callback(e, r, s);
+        }
+      } catch (v) {
+        t = { error: v };
+      } finally {
+        try {
+          n && !n.done && (i = l.return) && i.call(l);
+        } finally {
+          if (t) throw t.error;
+        }
+      }
+      this.interceptors.postResolution.setAll(e, o);
+    }
+  }, u.prototype.resolveRegistration = function(e, r) {
+    if (this.ensureNotDisposed(), e.options.lifecycle === p.ResolutionScoped && r.scopedResolutions.has(e))
+      return r.scopedResolutions.get(e);
+    var s = e.options.lifecycle === p.Singleton, t = e.options.lifecycle === p.ContainerScoped, i = s || t, o;
+    return g(e.provider) ? o = e.provider.useValue : y(e.provider) ? o = i ? e.instance || (e.instance = this.resolve(e.provider.useToken, r)) : this.resolve(e.provider.useToken, r) : S(e.provider) ? o = i ? e.instance || (e.instance = this.construct(e.provider.useClass, r)) : this.construct(e.provider.useClass, r) : R(e.provider) ? o = e.provider.useFactory(this) : o = this.construct(e.provider, r), e.options.lifecycle === p.ResolutionScoped && r.scopedResolutions.set(e, o), o;
+  }, u.prototype.resolveAll = function(e, r, s) {
+    var t = this;
+    r === void 0 && (r = new d()), s === void 0 && (s = !1), this.ensureNotDisposed();
+    var i = this.getAllRegistrations(e);
+    if (!i && a(e)) {
+      if (s)
+        return [];
+      throw new Error('Attempted to resolve unregistered dependency token: "' + e.toString() + '"');
+    }
+    if (this.executePreResolutionInterceptor(e, "All"), i) {
+      var o = i.map(function(n) {
+        return t.resolveRegistration(n, r);
+      });
+      return this.executePostResolutionInterceptor(e, o, "All"), o;
+    }
+    var l = [this.construct(e, r)];
+    return this.executePostResolutionInterceptor(e, l, "All"), l;
+  }, u.prototype.isRegistered = function(e, r) {
+    return r === void 0 && (r = !1), this.ensureNotDisposed(), this._registry.has(e) || r && (this.parent || !1) && this.parent.isRegistered(e, !0);
+  }, u.prototype.reset = function() {
+    this.ensureNotDisposed(), this._registry.clear(), this.interceptors.preResolution.clear(), this.interceptors.postResolution.clear();
+  }, u.prototype.clearInstances = function() {
+    var e, r;
+    this.ensureNotDisposed();
+    try {
+      for (var s = h(this._registry.entries()), t = s.next(); !t.done; t = s.next()) {
+        var i = w(t.value, 2), o = i[0], l = i[1];
+        this._registry.setAll(o, l.filter(function(n) {
+          return !g(n.provider);
+        }).map(function(n) {
+          return n.instance = void 0, n;
+        }));
+      }
+    } catch (n) {
+      e = { error: n };
+    } finally {
+      try {
+        t && !t.done && (r = s.return) && r.call(s);
+      } finally {
+        if (e) throw e.error;
+      }
+    }
+  }, u.prototype.createChildContainer = function() {
+    var e, r;
+    this.ensureNotDisposed();
+    var s = new u(this);
+    try {
+      for (var t = h(this._registry.entries()), i = t.next(); !i.done; i = t.next()) {
+        var o = w(i.value, 2), l = o[0], n = o[1];
+        n.some(function(f) {
+          var v = f.options;
+          return v.lifecycle === p.ContainerScoped;
+        }) && s._registry.setAll(l, n.map(function(f) {
+          return f.options.lifecycle === p.ContainerScoped ? {
+            provider: f.provider,
+            options: f.options
+          } : f;
+        }));
+      }
+    } catch (f) {
+      e = { error: f };
+    } finally {
+      try {
+        i && !i.done && (r = t.return) && r.call(t);
+      } finally {
+        if (e) throw e.error;
+      }
+    }
+    return s;
+  }, u.prototype.beforeResolution = function(e, r, s) {
+    s === void 0 && (s = { frequency: "Always" }), this.interceptors.preResolution.set(e, {
+      callback: r,
+      options: s
+    });
+  }, u.prototype.afterResolution = function(e, r, s) {
+    s === void 0 && (s = { frequency: "Always" }), this.interceptors.postResolution.set(e, {
+      callback: r,
+      options: s
+    });
+  }, u.prototype.dispose = function() {
+    return A(this, void 0, void 0, function() {
+      var e;
+      return C(this, function(r) {
+        switch (r.label) {
+          case 0:
+            return this.disposed = !0, e = [], this.disposables.forEach(function(s) {
+              var t = s.dispose();
+              t && e.push(t);
+            }), [4, Promise.all(e)];
+          case 1:
+            return r.sent(), [2];
+        }
+      });
+    });
+  }, u.prototype.getRegistration = function(e) {
+    return this.isRegistered(e) ? this._registry.get(e) : this.parent ? this.parent.getRegistration(e) : null;
+  }, u.prototype.getAllRegistrations = function(e) {
+    return this.isRegistered(e) ? this._registry.getAll(e) : this.parent ? this.parent.getAllRegistrations(e) : null;
+  }, u.prototype.construct = function(e, r) {
+    var s = this;
+    if (e instanceof E)
+      return e.createProxy(function(i) {
+        return s.resolve(i, r);
+      });
+    var t = function() {
+      var i = V.get(e);
+      if (!i || i.length === 0) {
+        if (e.length === 0)
+          return new e();
+        throw new Error('TypeInfo not known for "' + e.name + '"');
+      }
+      var o = i.map(s.resolveParams(r, e));
+      return new (e.bind.apply(e, c([void 0], o)))();
+    }();
+    return _(t) && this.disposables.add(t), t;
+  }, u.prototype.resolveParams = function(e, r) {
+    var s = this;
+    return function(t, i) {
+      var o, l, n;
+      try {
+        return P(t) ? m(t) ? t.multiple ? (o = s.resolve(t.transform)).transform.apply(o, c([s.resolveAll(t.token, new d(), t.isOptional)], t.transformArgs)) : (l = s.resolve(t.transform)).transform.apply(l, c([s.resolve(t.token, e, t.isOptional)], t.transformArgs)) : t.multiple ? s.resolveAll(t.token, new d(), t.isOptional) : s.resolve(t.token, e, t.isOptional) : m(t) ? (n = s.resolve(t.transform, e)).transform.apply(n, c([s.resolve(t.token, e)], t.transformArgs)) : s.resolve(t, e);
+      } catch (f) {
+        throw new Error(T(r, i, f));
+      }
+    };
+  }, u.prototype.ensureNotDisposed = function() {
+    if (this.disposed)
+      throw new Error("This container has been disposed, you cannot interact with a disposed container");
+  }, u;
+}(), W = new b();
+export {
+  W as default,
+  W as instance,
+  V as typeInfo
+};

package/dist/node_modules/tsyringe/dist/esm5/error-helpers.es.js

@@ -0,0 +1,21 @@
+import { __read as s, __spread as u } from "../../../tslib/tslib.es6.es.js";
+function c(r, n) {
+  if (r === null)
+    return "at position #" + n;
+  var o = r.split(",")[n].trim();
+  return '"' + o + '" at position #' + n;
+}
+function p(r, n, o) {
+  return o === void 0 && (o = "    "), u([r], n.message.split(`
+`).map(function(t) {
+    return o + t;
+  })).join(`
+`);
+}
+function f(r, n, o) {
+  var t = s(r.toString().match(/constructor\(([\w, ]+)\)/) || [], 2), e = t[1], a = e === void 0 ? null : e, i = c(a, n);
+  return p("Cannot inject the dependency " + i + ' of "' + r.name + '" constructor. Reason:', o);
+}
+export {
+  f as formatErrorCtor
+};

package/dist/node_modules/tsyringe/dist/esm5/index.es.js

@@ -0,0 +1,9 @@
+import { default as o } from "./types/lifecycle.es.js";
+import { instance as f } from "./dependency-container.es.js";
+import "./lazy-helpers.es.js";
+if (typeof Reflect > "u" || !Reflect.getMetadata)
+  throw new Error(`tsyringe requires a reflect polyfill. Please add 'import "reflect-metadata"' to the top of your entry point.`);
+export {
+  o as Lifecycle,
+  f as container
+};

package/dist/node_modules/tsyringe/dist/esm5/interceptors.es.js

@@ -0,0 +1,25 @@
+import { __extends as e } from "../../../tslib/tslib.es6.es.js";
+import o from "./registry-base.es.js";
+var r = function(t) {
+  e(n, t);
+  function n() {
+    return t !== null && t.apply(this, arguments) || this;
+  }
+  return n;
+}(o), s = function(t) {
+  e(n, t);
+  function n() {
+    return t !== null && t.apply(this, arguments) || this;
+  }
+  return n;
+}(o), l = /* @__PURE__ */ function() {
+  function t() {
+    this.preResolution = new r(), this.postResolution = new s();
+  }
+  return t;
+}();
+export {
+  s as PostResolutionInterceptors,
+  r as PreResolutionInterceptors,
+  l as default
+};

package/dist/node_modules/tsyringe/dist/esm5/lazy-helpers.es.js

@@ -0,0 +1,38 @@
+import { __spread as p } from "../../../tslib/tslib.es6.es.js";
+var f = function() {
+  function n(e) {
+    this.wrap = e, this.reflectMethods = [
+      "get",
+      "getPrototypeOf",
+      "setPrototypeOf",
+      "getOwnPropertyDescriptor",
+      "defineProperty",
+      "has",
+      "set",
+      "deleteProperty",
+      "apply",
+      "construct",
+      "ownKeys"
+    ];
+  }
+  return n.prototype.createProxy = function(e) {
+    var a = this, s = {}, o = !1, t, r = function() {
+      return o || (t = e(a.wrap()), o = !0), t;
+    };
+    return new Proxy(s, this.createHandler(r));
+  }, n.prototype.createHandler = function(e) {
+    var a = {}, s = function(o) {
+      a[o] = function() {
+        for (var t = [], r = 0; r < arguments.length; r++)
+          t[r] = arguments[r];
+        t[0] = e();
+        var c = Reflect[o];
+        return c.apply(void 0, p(t));
+      };
+    };
+    return this.reflectMethods.forEach(s), a;
+  }, n;
+}();
+export {
+  f as DelayedConstructor
+};

package/dist/node_modules/tsyringe/dist/esm5/providers/class-provider.es.js

@@ -0,0 +1,6 @@
+function r(s) {
+  return !!s.useClass;
+}
+export {
+  r as isClassProvider
+};

package/dist/node_modules/tsyringe/dist/esm5/providers/factory-provider.es.js

@@ -0,0 +1,6 @@
+function o(r) {
+  return !!r.useFactory;
+}
+export {
+  o as isFactoryProvider
+};

package/dist/node_modules/tsyringe/dist/esm5/providers/injection-token.es.js

@@ -0,0 +1,19 @@
+import { DelayedConstructor as o } from "../lazy-helpers.es.js";
+function e(n) {
+  return typeof n == "string" || typeof n == "symbol";
+}
+function r(n) {
+  return typeof n == "object" && "token" in n && "multiple" in n;
+}
+function i(n) {
+  return typeof n == "object" && "token" in n && "transform" in n;
+}
+function f(n) {
+  return typeof n == "function" || n instanceof o;
+}
+export {
+  f as isConstructorToken,
+  e as isNormalToken,
+  r as isTokenDescriptor,
+  i as isTransformDescriptor
+};

package/dist/node_modules/tsyringe/dist/esm5/providers/provider.es.js

@@ -0,0 +1,10 @@
+import { isClassProvider as o } from "./class-provider.es.js";
+import { isValueProvider as i } from "./value-provider.es.js";
+import { isTokenProvider as m } from "./token-provider.es.js";
+import { isFactoryProvider as t } from "./factory-provider.es.js";
+function n(r) {
+  return o(r) || i(r) || m(r) || t(r);
+}
+export {
+  n as isProvider
+};

package/dist/node_modules/tsyringe/dist/esm5/providers/token-provider.es.js

@@ -0,0 +1,6 @@
+function n(e) {
+  return !!e.useToken;
+}
+export {
+  n as isTokenProvider
+};

package/dist/node_modules/tsyringe/dist/esm5/providers/value-provider.es.js

@@ -0,0 +1,6 @@
+function u(e) {
+  return e.useValue != null;
+}
+export {
+  u as isValueProvider
+};

package/dist/node_modules/tsyringe/dist/esm5/registry-base.es.js

@@ -0,0 +1,27 @@
+var s = function() {
+  function e() {
+    this._registryMap = /* @__PURE__ */ new Map();
+  }
+  return e.prototype.entries = function() {
+    return this._registryMap.entries();
+  }, e.prototype.getAll = function(t) {
+    return this.ensure(t), this._registryMap.get(t);
+  }, e.prototype.get = function(t) {
+    this.ensure(t);
+    var r = this._registryMap.get(t);
+    return r[r.length - 1] || null;
+  }, e.prototype.set = function(t, r) {
+    this.ensure(t), this._registryMap.get(t).push(r);
+  }, e.prototype.setAll = function(t, r) {
+    this._registryMap.set(t, r);
+  }, e.prototype.has = function(t) {
+    return this.ensure(t), this._registryMap.get(t).length > 0;
+  }, e.prototype.clear = function() {
+    this._registryMap.clear();
+  }, e.prototype.ensure = function(t) {
+    this._registryMap.has(t) || this._registryMap.set(t, []);
+  }, e;
+}();
+export {
+  s as default
+};

package/dist/node_modules/tsyringe/dist/esm5/registry.es.js

@@ -0,0 +1,12 @@
+import { __extends as e } from "../../../tslib/tslib.es6.es.js";
+import i from "./registry-base.es.js";
+var s = function(t) {
+  e(r, t);
+  function r() {
+    return t !== null && t.apply(this, arguments) || this;
+  }
+  return r;
+}(i);
+export {
+  s as default
+};

package/dist/node_modules/tsyringe/dist/esm5/resolution-context.es.js

@@ -0,0 +1,9 @@
+var o = /* @__PURE__ */ function() {
+  function t() {
+    this.scopedResolutions = /* @__PURE__ */ new Map();
+  }
+  return t;
+}();
+export {
+  o as default
+};

package/dist/node_modules/tsyringe/dist/esm5/types/disposable.es.js

@@ -0,0 +1,9 @@
+function i(e) {
+  if (typeof e.dispose != "function")
+    return !1;
+  var s = e.dispose;
+  return !(s.length > 0);
+}
+export {
+  i as isDisposable
+};

package/dist/node_modules/tsyringe/dist/esm5/types/lifecycle.es.js

@@ -0,0 +1,8 @@
+var o;
+(function(n) {
+  n[n.Transient = 0] = "Transient", n[n.Singleton = 1] = "Singleton", n[n.ResolutionScoped = 2] = "ResolutionScoped", n[n.ContainerScoped = 3] = "ContainerScoped";
+})(o || (o = {}));
+const t = o;
+export {
+  t as default
+};