@orion-js/services 4.0.0-next.2 → 4.0.0-next.4

package/dist/index.cjs

@@ -1,8 +1,12 @@
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -15,858 +19,479 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  Container: () => import_typedi2.Container,
-  Inject: () => import_typedi2.Inject,
-  Service: () => import_typedi2.Service,
-  getInstance: () => getInstance
-});
-module.exports = __toCommonJS(index_exports);
-
-// node_modules/.pnpm/reflect-metadata@0.1.14/node_modules/reflect-metadata/Reflect.js
-var Reflect2;
-(function(Reflect3) {
-  (function(factory) {
-    var root = typeof global === "object" ? global : typeof self === "object" ? self : typeof this === "object" ? this : Function("return this;")();
-    var exporter = makeExporter(Reflect3);
-    if (typeof root.Reflect === "undefined") {
-      root.Reflect = Reflect3;
-    } else {
-      exporter = makeExporter(root.Reflect, exporter);
-    }
-    factory(exporter);
-    function makeExporter(target, previous) {
-      return function(key, value) {
-        if (typeof target[key] !== "function") {
-          Object.defineProperty(target, key, {
-            configurable: true,
-            writable: true,
-            value
-          });
-        }
-        if (previous) previous(key, value);
-      };
-    }
-    __name(makeExporter, "makeExporter");
-  })(function(exporter) {
-    var hasOwn = Object.prototype.hasOwnProperty;
-    var supportsSymbol = typeof Symbol === "function";
-    var toPrimitiveSymbol = supportsSymbol && typeof Symbol.toPrimitive !== "undefined" ? Symbol.toPrimitive : "@@toPrimitive";
-    var iteratorSymbol = supportsSymbol && typeof Symbol.iterator !== "undefined" ? Symbol.iterator : "@@iterator";
-    var supportsCreate = typeof Object.create === "function";
-    var supportsProto = {
-      __proto__: []
-    } instanceof Array;
-    var downLevel = !supportsCreate && !supportsProto;
-    var HashMap = {
-      // create an object in dictionary mode (a.k.a. "slow" mode in v8)
-      create: supportsCreate ? function() {
-        return MakeDictionary(/* @__PURE__ */ Object.create(null));
-      } : supportsProto ? function() {
-        return MakeDictionary({
-          __proto__: null
-        });
-      } : function() {
-        return MakeDictionary({});
-      },
-      has: downLevel ? function(map, key) {
-        return hasOwn.call(map, key);
-      } : function(map, key) {
-        return key in map;
-      },
-      get: downLevel ? function(map, key) {
-        return hasOwn.call(map, key) ? map[key] : void 0;
-      } : function(map, key) {
-        return map[key];
-      }
+// ../../node_modules/.pnpm/object-hash@2.2.0/node_modules/object-hash/index.js
+var require_object_hash = __commonJS({
+  "../../node_modules/.pnpm/object-hash@2.2.0/node_modules/object-hash/index.js"(exports2, module2) {
+    "use strict";
+    var crypto2 = require("crypto");
+    exports2 = module2.exports = objectHash;
+    function objectHash(object, options) {
+      options = applyDefaults(object, options);
+      return hash2(object, options);
+    }
+    exports2.sha1 = function(object) {
+      return objectHash(object);
     };
-    var functionPrototype = Object.getPrototypeOf(Function);
-    var usePolyfill = typeof process === "object" && process["env"] && process["env"]["REFLECT_METADATA_USE_MAP_POLYFILL"] === "true";
-    var _Map = !usePolyfill && typeof Map === "function" && typeof Map.prototype.entries === "function" ? Map : CreateMapPolyfill();
-    var _Set = !usePolyfill && typeof Set === "function" && typeof Set.prototype.entries === "function" ? Set : CreateSetPolyfill();
-    var _WeakMap = !usePolyfill && typeof WeakMap === "function" ? WeakMap : CreateWeakMapPolyfill();
-    var Metadata = new _WeakMap();
-    function decorate(decorators, target, propertyKey, attributes) {
-      if (!IsUndefined(propertyKey)) {
-        if (!IsArray(decorators)) throw new TypeError();
-        if (!IsObject(target)) throw new TypeError();
-        if (!IsObject(attributes) && !IsUndefined(attributes) && !IsNull(attributes)) throw new TypeError();
-        if (IsNull(attributes)) attributes = void 0;
-        propertyKey = ToPropertyKey(propertyKey);
-        return DecorateProperty(decorators, target, propertyKey, attributes);
-      } else {
-        if (!IsArray(decorators)) throw new TypeError();
-        if (!IsConstructor(target)) throw new TypeError();
-        return DecorateConstructor(decorators, target);
-      }
-    }
-    __name(decorate, "decorate");
-    exporter("decorate", decorate);
-    function metadata(metadataKey, metadataValue) {
-      function decorator(target, propertyKey) {
-        if (!IsObject(target)) throw new TypeError();
-        if (!IsUndefined(propertyKey) && !IsPropertyKey(propertyKey)) throw new TypeError();
-        OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
-      }
-      __name(decorator, "decorator");
-      return decorator;
-    }
-    __name(metadata, "metadata");
-    exporter("metadata", metadata);
-    function defineMetadata(metadataKey, metadataValue, target, propertyKey) {
-      if (!IsObject(target)) throw new TypeError();
-      if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
-      return OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
-    }
-    __name(defineMetadata, "defineMetadata");
-    exporter("defineMetadata", defineMetadata);
-    function hasMetadata(metadataKey, target, propertyKey) {
-      if (!IsObject(target)) throw new TypeError();
-      if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
-      return OrdinaryHasMetadata(metadataKey, target, propertyKey);
-    }
-    __name(hasMetadata, "hasMetadata");
-    exporter("hasMetadata", hasMetadata);
-    function hasOwnMetadata(metadataKey, target, propertyKey) {
-      if (!IsObject(target)) throw new TypeError();
-      if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
-      return OrdinaryHasOwnMetadata(metadataKey, target, propertyKey);
-    }
-    __name(hasOwnMetadata, "hasOwnMetadata");
-    exporter("hasOwnMetadata", hasOwnMetadata);
-    function getMetadata(metadataKey, target, propertyKey) {
-      if (!IsObject(target)) throw new TypeError();
-      if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
-      return OrdinaryGetMetadata(metadataKey, target, propertyKey);
-    }
-    __name(getMetadata, "getMetadata");
-    exporter("getMetadata", getMetadata);
-    function getOwnMetadata(metadataKey, target, propertyKey) {
-      if (!IsObject(target)) throw new TypeError();
-      if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
-      return OrdinaryGetOwnMetadata(metadataKey, target, propertyKey);
-    }
-    __name(getOwnMetadata, "getOwnMetadata");
-    exporter("getOwnMetadata", getOwnMetadata);
-    function getMetadataKeys(target, propertyKey) {
-      if (!IsObject(target)) throw new TypeError();
-      if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
-      return OrdinaryMetadataKeys(target, propertyKey);
-    }
-    __name(getMetadataKeys, "getMetadataKeys");
-    exporter("getMetadataKeys", getMetadataKeys);
-    function getOwnMetadataKeys(target, propertyKey) {
-      if (!IsObject(target)) throw new TypeError();
-      if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
-      return OrdinaryOwnMetadataKeys(target, propertyKey);
-    }
-    __name(getOwnMetadataKeys, "getOwnMetadataKeys");
-    exporter("getOwnMetadataKeys", getOwnMetadataKeys);
-    function deleteMetadata(metadataKey, target, propertyKey) {
-      if (!IsObject(target)) throw new TypeError();
-      if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
-      var metadataMap = GetOrCreateMetadataMap(
-        target,
-        propertyKey,
-        /*Create*/
-        false
-      );
-      if (IsUndefined(metadataMap)) return false;
-      if (!metadataMap.delete(metadataKey)) return false;
-      if (metadataMap.size > 0) return true;
-      var targetMetadata = Metadata.get(target);
-      targetMetadata.delete(propertyKey);
-      if (targetMetadata.size > 0) return true;
-      Metadata.delete(target);
-      return true;
-    }
-    __name(deleteMetadata, "deleteMetadata");
-    exporter("deleteMetadata", deleteMetadata);
-    function DecorateConstructor(decorators, target) {
-      for (var i = decorators.length - 1; i >= 0; --i) {
-        var decorator = decorators[i];
-        var decorated = decorator(target);
-        if (!IsUndefined(decorated) && !IsNull(decorated)) {
-          if (!IsConstructor(decorated)) throw new TypeError();
-          target = decorated;
-        }
+    exports2.keys = function(object) {
+      return objectHash(object, { excludeValues: true, algorithm: "sha1", encoding: "hex" });
+    };
+    exports2.MD5 = function(object) {
+      return objectHash(object, { algorithm: "md5", encoding: "hex" });
+    };
+    exports2.keysMD5 = function(object) {
+      return objectHash(object, { algorithm: "md5", encoding: "hex", excludeValues: true });
+    };
+    var hashes = crypto2.getHashes ? crypto2.getHashes().slice() : ["sha1", "md5"];
+    hashes.push("passthrough");
+    var encodings = ["buffer", "hex", "binary", "base64"];
+    function applyDefaults(object, sourceOptions) {
+      sourceOptions = sourceOptions || {};
+      var options = {};
+      options.algorithm = sourceOptions.algorithm || "sha1";
+      options.encoding = sourceOptions.encoding || "hex";
+      options.excludeValues = sourceOptions.excludeValues ? true : false;
+      options.algorithm = options.algorithm.toLowerCase();
+      options.encoding = options.encoding.toLowerCase();
+      options.ignoreUnknown = sourceOptions.ignoreUnknown !== true ? false : true;
+      options.respectType = sourceOptions.respectType === false ? false : true;
+      options.respectFunctionNames = sourceOptions.respectFunctionNames === false ? false : true;
+      options.respectFunctionProperties = sourceOptions.respectFunctionProperties === false ? false : true;
+      options.unorderedArrays = sourceOptions.unorderedArrays !== true ? false : true;
+      options.unorderedSets = sourceOptions.unorderedSets === false ? false : true;
+      options.unorderedObjects = sourceOptions.unorderedObjects === false ? false : true;
+      options.replacer = sourceOptions.replacer || void 0;
+      options.excludeKeys = sourceOptions.excludeKeys || void 0;
+      if (typeof object === "undefined") {
+        throw new Error("Object argument required.");
       }
-      return target;
-    }
-    __name(DecorateConstructor, "DecorateConstructor");
-    function DecorateProperty(decorators, target, propertyKey, descriptor) {
-      for (var i = decorators.length - 1; i >= 0; --i) {
-        var decorator = decorators[i];
-        var decorated = decorator(target, propertyKey, descriptor);
-        if (!IsUndefined(decorated) && !IsNull(decorated)) {
-          if (!IsObject(decorated)) throw new TypeError();
-          descriptor = decorated;
+      for (var i = 0; i < hashes.length; ++i) {
+        if (hashes[i].toLowerCase() === options.algorithm.toLowerCase()) {
+          options.algorithm = hashes[i];
         }
       }
-      return descriptor;
-    }
-    __name(DecorateProperty, "DecorateProperty");
-    function GetOrCreateMetadataMap(O, P, Create) {
-      var targetMetadata = Metadata.get(O);
-      if (IsUndefined(targetMetadata)) {
-        if (!Create) return void 0;
-        targetMetadata = new _Map();
-        Metadata.set(O, targetMetadata);
+      if (hashes.indexOf(options.algorithm) === -1) {
+        throw new Error('Algorithm "' + options.algorithm + '"  not supported. supported values: ' + hashes.join(", "));
       }
-      var metadataMap = targetMetadata.get(P);
-      if (IsUndefined(metadataMap)) {
-        if (!Create) return void 0;
-        metadataMap = new _Map();
-        targetMetadata.set(P, metadataMap);
+      if (encodings.indexOf(options.encoding) === -1 && options.algorithm !== "passthrough") {
+        throw new Error('Encoding "' + options.encoding + '"  not supported. supported values: ' + encodings.join(", "));
       }
-      return metadataMap;
+      return options;
     }
-    __name(GetOrCreateMetadataMap, "GetOrCreateMetadataMap");
-    function OrdinaryHasMetadata(MetadataKey, O, P) {
-      var hasOwn2 = OrdinaryHasOwnMetadata(MetadataKey, O, P);
-      if (hasOwn2) return true;
-      var parent = OrdinaryGetPrototypeOf(O);
-      if (!IsNull(parent)) return OrdinaryHasMetadata(MetadataKey, parent, P);
-      return false;
-    }
-    __name(OrdinaryHasMetadata, "OrdinaryHasMetadata");
-    function OrdinaryHasOwnMetadata(MetadataKey, O, P) {
-      var metadataMap = GetOrCreateMetadataMap(
-        O,
-        P,
-        /*Create*/
-        false
-      );
-      if (IsUndefined(metadataMap)) return false;
-      return ToBoolean(metadataMap.has(MetadataKey));
-    }
-    __name(OrdinaryHasOwnMetadata, "OrdinaryHasOwnMetadata");
-    function OrdinaryGetMetadata(MetadataKey, O, P) {
-      var hasOwn2 = OrdinaryHasOwnMetadata(MetadataKey, O, P);
-      if (hasOwn2) return OrdinaryGetOwnMetadata(MetadataKey, O, P);
-      var parent = OrdinaryGetPrototypeOf(O);
-      if (!IsNull(parent)) return OrdinaryGetMetadata(MetadataKey, parent, P);
-      return void 0;
-    }
-    __name(OrdinaryGetMetadata, "OrdinaryGetMetadata");
-    function OrdinaryGetOwnMetadata(MetadataKey, O, P) {
-      var metadataMap = GetOrCreateMetadataMap(
-        O,
-        P,
-        /*Create*/
-        false
-      );
-      if (IsUndefined(metadataMap)) return void 0;
-      return metadataMap.get(MetadataKey);
-    }
-    __name(OrdinaryGetOwnMetadata, "OrdinaryGetOwnMetadata");
-    function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) {
-      var metadataMap = GetOrCreateMetadataMap(
-        O,
-        P,
-        /*Create*/
-        true
-      );
-      metadataMap.set(MetadataKey, MetadataValue);
-    }
-    __name(OrdinaryDefineOwnMetadata, "OrdinaryDefineOwnMetadata");
-    function OrdinaryMetadataKeys(O, P) {
-      var ownKeys = OrdinaryOwnMetadataKeys(O, P);
-      var parent = OrdinaryGetPrototypeOf(O);
-      if (parent === null) return ownKeys;
-      var parentKeys = OrdinaryMetadataKeys(parent, P);
-      if (parentKeys.length <= 0) return ownKeys;
-      if (ownKeys.length <= 0) return parentKeys;
-      var set = new _Set();
-      var keys = [];
-      for (var _i = 0, ownKeys_1 = ownKeys; _i < ownKeys_1.length; _i++) {
-        var key = ownKeys_1[_i];
-        var hasKey = set.has(key);
-        if (!hasKey) {
-          set.add(key);
-          keys.push(key);
-        }
-      }
-      for (var _a = 0, parentKeys_1 = parentKeys; _a < parentKeys_1.length; _a++) {
-        var key = parentKeys_1[_a];
-        var hasKey = set.has(key);
-        if (!hasKey) {
-          set.add(key);
-          keys.push(key);
-        }
+    function isNativeFunction(f) {
+      if (typeof f !== "function") {
+        return false;
       }
-      return keys;
+      var exp = /^function\s+\w*\s*\(\s*\)\s*{\s+\[native code\]\s+}$/i;
+      return exp.exec(Function.prototype.toString.call(f)) != null;
     }
-    __name(OrdinaryMetadataKeys, "OrdinaryMetadataKeys");
-    function OrdinaryOwnMetadataKeys(O, P) {
-      var keys = [];
-      var metadataMap = GetOrCreateMetadataMap(
-        O,
-        P,
-        /*Create*/
-        false
-      );
-      if (IsUndefined(metadataMap)) return keys;
-      var keysObj = metadataMap.keys();
-      var iterator = GetIterator(keysObj);
-      var k = 0;
-      while (true) {
-        var next = IteratorStep(iterator);
-        if (!next) {
-          keys.length = k;
-          return keys;
-        }
-        var nextValue = IteratorValue(next);
-        try {
-          keys[k] = nextValue;
-        } catch (e) {
-          try {
-            IteratorClose(iterator);
-          } finally {
-            throw e;
-          }
-        }
-        k++;
+    function hash2(object, options) {
+      var hashingStream;
+      if (options.algorithm !== "passthrough") {
+        hashingStream = crypto2.createHash(options.algorithm);
+      } else {
+        hashingStream = new PassThrough();
       }
-    }
-    __name(OrdinaryOwnMetadataKeys, "OrdinaryOwnMetadataKeys");
-    function Type(x) {
-      if (x === null) return 1;
-      switch (typeof x) {
-        case "undefined":
-          return 0;
-        case "boolean":
-          return 2;
-        case "string":
-          return 3;
-        case "symbol":
-          return 4;
-        case "number":
-          return 5;
-        case "object":
-          return x === null ? 1 : 6;
-        default:
-          return 6;
+      if (typeof hashingStream.write === "undefined") {
+        hashingStream.write = hashingStream.update;
+        hashingStream.end = hashingStream.update;
       }
-    }
-    __name(Type, "Type");
-    function IsUndefined(x) {
-      return x === void 0;
-    }
-    __name(IsUndefined, "IsUndefined");
-    function IsNull(x) {
-      return x === null;
-    }
-    __name(IsNull, "IsNull");
-    function IsSymbol(x) {
-      return typeof x === "symbol";
-    }
-    __name(IsSymbol, "IsSymbol");
-    function IsObject(x) {
-      return typeof x === "object" ? x !== null : typeof x === "function";
-    }
-    __name(IsObject, "IsObject");
-    function ToPrimitive(input, PreferredType) {
-      switch (Type(input)) {
-        case 0:
-          return input;
-        case 1:
-          return input;
-        case 2:
-          return input;
-        case 3:
-          return input;
-        case 4:
-          return input;
-        case 5:
-          return input;
+      var hasher = typeHasher(options, hashingStream);
+      hasher.dispatch(object);
+      if (!hashingStream.update) {
+        hashingStream.end("");
       }
-      var hint = PreferredType === 3 ? "string" : PreferredType === 5 ? "number" : "default";
-      var exoticToPrim = GetMethod(input, toPrimitiveSymbol);
-      if (exoticToPrim !== void 0) {
-        var result = exoticToPrim.call(input, hint);
-        if (IsObject(result)) throw new TypeError();
-        return result;
+      if (hashingStream.digest) {
+        return hashingStream.digest(options.encoding === "buffer" ? void 0 : options.encoding);
       }
-      return OrdinaryToPrimitive(input, hint === "default" ? "number" : hint);
-    }
-    __name(ToPrimitive, "ToPrimitive");
-    function OrdinaryToPrimitive(O, hint) {
-      if (hint === "string") {
-        var toString_1 = O.toString;
-        if (IsCallable(toString_1)) {
-          var result = toString_1.call(O);
-          if (!IsObject(result)) return result;
-        }
-        var valueOf = O.valueOf;
-        if (IsCallable(valueOf)) {
-          var result = valueOf.call(O);
-          if (!IsObject(result)) return result;
-        }
-      } else {
-        var valueOf = O.valueOf;
-        if (IsCallable(valueOf)) {
-          var result = valueOf.call(O);
-          if (!IsObject(result)) return result;
-        }
-        var toString_2 = O.toString;
-        if (IsCallable(toString_2)) {
-          var result = toString_2.call(O);
-          if (!IsObject(result)) return result;
-        }
+      var buf = hashingStream.read();
+      if (options.encoding === "buffer") {
+        return buf;
       }
-      throw new TypeError();
+      return buf.toString(options.encoding);
     }
-    __name(OrdinaryToPrimitive, "OrdinaryToPrimitive");
-    function ToBoolean(argument) {
-      return !!argument;
-    }
-    __name(ToBoolean, "ToBoolean");
-    function ToString(argument) {
-      return "" + argument;
-    }
-    __name(ToString, "ToString");
-    function ToPropertyKey(argument) {
-      var key = ToPrimitive(
-        argument,
-        3
-        /* String */
-      );
-      if (IsSymbol(key)) return key;
-      return ToString(key);
-    }
-    __name(ToPropertyKey, "ToPropertyKey");
-    function IsArray(argument) {
-      return Array.isArray ? Array.isArray(argument) : argument instanceof Object ? argument instanceof Array : Object.prototype.toString.call(argument) === "[object Array]";
-    }
-    __name(IsArray, "IsArray");
-    function IsCallable(argument) {
-      return typeof argument === "function";
-    }
-    __name(IsCallable, "IsCallable");
-    function IsConstructor(argument) {
-      return typeof argument === "function";
-    }
-    __name(IsConstructor, "IsConstructor");
-    function IsPropertyKey(argument) {
-      switch (Type(argument)) {
-        case 3:
-          return true;
-        case 4:
-          return true;
-        default:
-          return false;
+    exports2.writeToStream = function(object, options, stream) {
+      if (typeof stream === "undefined") {
+        stream = options;
+        options = {};
       }
-    }
-    __name(IsPropertyKey, "IsPropertyKey");
-    function GetMethod(V, P) {
-      var func = V[P];
-      if (func === void 0 || func === null) return void 0;
-      if (!IsCallable(func)) throw new TypeError();
-      return func;
-    }
-    __name(GetMethod, "GetMethod");
-    function GetIterator(obj) {
-      var method = GetMethod(obj, iteratorSymbol);
-      if (!IsCallable(method)) throw new TypeError();
-      var iterator = method.call(obj);
-      if (!IsObject(iterator)) throw new TypeError();
-      return iterator;
-    }
-    __name(GetIterator, "GetIterator");
-    function IteratorValue(iterResult) {
-      return iterResult.value;
-    }
-    __name(IteratorValue, "IteratorValue");
-    function IteratorStep(iterator) {
-      var result = iterator.next();
-      return result.done ? false : result;
-    }
-    __name(IteratorStep, "IteratorStep");
-    function IteratorClose(iterator) {
-      var f = iterator["return"];
-      if (f) f.call(iterator);
-    }
-    __name(IteratorClose, "IteratorClose");
-    function OrdinaryGetPrototypeOf(O) {
-      var proto = Object.getPrototypeOf(O);
-      if (typeof O !== "function" || O === functionPrototype) return proto;
-      if (proto !== functionPrototype) return proto;
-      var prototype = O.prototype;
-      var prototypeProto = prototype && Object.getPrototypeOf(prototype);
-      if (prototypeProto == null || prototypeProto === Object.prototype) return proto;
-      var constructor = prototypeProto.constructor;
-      if (typeof constructor !== "function") return proto;
-      if (constructor === O) return proto;
-      return constructor;
-    }
-    __name(OrdinaryGetPrototypeOf, "OrdinaryGetPrototypeOf");
-    function CreateMapPolyfill() {
-      var cacheSentinel = {};
-      var arraySentinel = [];
-      var MapIterator = (
-        /** @class */
-        function() {
-          function MapIterator2(keys, values, selector) {
-            this._index = 0;
-            this._keys = keys;
-            this._values = values;
-            this._selector = selector;
+      options = applyDefaults(object, options);
+      return typeHasher(options, stream).dispatch(object);
+    };
+    function typeHasher(options, writeTo, context) {
+      context = context || [];
+      var write = function(str) {
+        if (writeTo.update) {
+          return writeTo.update(str, "utf8");
+        } else {
+          return writeTo.write(str, "utf8");
+        }
+      };
+      return {
+        dispatch: function(value) {
+          if (options.replacer) {
+            value = options.replacer(value);
           }
-          __name(MapIterator2, "MapIterator");
-          MapIterator2.prototype["@@iterator"] = function() {
-            return this;
-          };
-          MapIterator2.prototype[iteratorSymbol] = function() {
-            return this;
-          };
-          MapIterator2.prototype.next = function() {
-            var index = this._index;
-            if (index >= 0 && index < this._keys.length) {
-              var result = this._selector(this._keys[index], this._values[index]);
-              if (index + 1 >= this._keys.length) {
-                this._index = -1;
-                this._keys = arraySentinel;
-                this._values = arraySentinel;
-              } else {
-                this._index++;
-              }
-              return {
-                value: result,
-                done: false
-              };
-            }
-            return {
-              value: void 0,
-              done: true
-            };
-          };
-          MapIterator2.prototype.throw = function(error) {
-            if (this._index >= 0) {
-              this._index = -1;
-              this._keys = arraySentinel;
-              this._values = arraySentinel;
-            }
-            throw error;
-          };
-          MapIterator2.prototype.return = function(value) {
-            if (this._index >= 0) {
-              this._index = -1;
-              this._keys = arraySentinel;
-              this._values = arraySentinel;
-            }
-            return {
-              value,
-              done: true
-            };
-          };
-          return MapIterator2;
-        }()
-      );
-      return (
-        /** @class */
-        function() {
-          function Map1() {
-            this._keys = [];
-            this._values = [];
-            this._cacheKey = cacheSentinel;
-            this._cacheIndex = -2;
+          var type = typeof value;
+          if (value === null) {
+            type = "null";
           }
-          __name(Map1, "Map1");
-          Object.defineProperty(Map1.prototype, "size", {
-            get: /* @__PURE__ */ __name(function() {
-              return this._keys.length;
-            }, "get"),
-            enumerable: true,
-            configurable: true
-          });
-          Map1.prototype.has = function(key) {
-            return this._find(
-              key,
-              /*insert*/
-              false
-            ) >= 0;
-          };
-          Map1.prototype.get = function(key) {
-            var index = this._find(
-              key,
-              /*insert*/
-              false
-            );
-            return index >= 0 ? this._values[index] : void 0;
-          };
-          Map1.prototype.set = function(key, value) {
-            var index = this._find(
-              key,
-              /*insert*/
-              true
-            );
-            this._values[index] = value;
-            return this;
-          };
-          Map1.prototype.delete = function(key) {
-            var index = this._find(
-              key,
-              /*insert*/
-              false
-            );
-            if (index >= 0) {
-              var size = this._keys.length;
-              for (var i = index + 1; i < size; i++) {
-                this._keys[i - 1] = this._keys[i];
-                this._values[i - 1] = this._values[i];
-              }
-              this._keys.length--;
-              this._values.length--;
-              if (key === this._cacheKey) {
-                this._cacheKey = cacheSentinel;
-                this._cacheIndex = -2;
-              }
-              return true;
+          return this["_" + type](value);
+        },
+        _object: function(object) {
+          var pattern = /\[object (.*)\]/i;
+          var objString = Object.prototype.toString.call(object);
+          var objType = pattern.exec(objString);
+          if (!objType) {
+            objType = "unknown:[" + objString + "]";
+          } else {
+            objType = objType[1];
+          }
+          objType = objType.toLowerCase();
+          var objectNumber = null;
+          if ((objectNumber = context.indexOf(object)) >= 0) {
+            return this.dispatch("[CIRCULAR:" + objectNumber + "]");
+          } else {
+            context.push(object);
+          }
+          if (typeof Buffer !== "undefined" && Buffer.isBuffer && Buffer.isBuffer(object)) {
+            write("buffer:");
+            return write(object);
+          }
+          if (objType !== "object" && objType !== "function" && objType !== "asyncfunction") {
+            if (this["_" + objType]) {
+              this["_" + objType](object);
+            } else if (options.ignoreUnknown) {
+              return write("[" + objType + "]");
+            } else {
+              throw new Error('Unknown object type "' + objType + '"');
             }
-            return false;
-          };
-          Map1.prototype.clear = function() {
-            this._keys.length = 0;
-            this._values.length = 0;
-            this._cacheKey = cacheSentinel;
-            this._cacheIndex = -2;
-          };
-          Map1.prototype.keys = function() {
-            return new MapIterator(this._keys, this._values, getKey);
-          };
-          Map1.prototype.values = function() {
-            return new MapIterator(this._keys, this._values, getValue);
-          };
-          Map1.prototype.entries = function() {
-            return new MapIterator(this._keys, this._values, getEntry);
-          };
-          Map1.prototype["@@iterator"] = function() {
-            return this.entries();
-          };
-          Map1.prototype[iteratorSymbol] = function() {
-            return this.entries();
-          };
-          Map1.prototype._find = function(key, insert) {
-            if (this._cacheKey !== key) {
-              this._cacheIndex = this._keys.indexOf(this._cacheKey = key);
+          } else {
+            var keys = Object.keys(object);
+            if (options.unorderedObjects) {
+              keys = keys.sort();
             }
-            if (this._cacheIndex < 0 && insert) {
-              this._cacheIndex = this._keys.length;
-              this._keys.push(key);
-              this._values.push(void 0);
+            if (options.respectType !== false && !isNativeFunction(object)) {
+              keys.splice(0, 0, "prototype", "__proto__", "constructor");
             }
-            return this._cacheIndex;
-          };
-          return Map1;
-        }()
-      );
-      function getKey(key, _) {
-        return key;
-      }
-      __name(getKey, "getKey");
-      function getValue(_, value) {
-        return value;
-      }
-      __name(getValue, "getValue");
-      function getEntry(key, value) {
-        return [
-          key,
-          value
-        ];
-      }
-      __name(getEntry, "getEntry");
-    }
-    __name(CreateMapPolyfill, "CreateMapPolyfill");
-    function CreateSetPolyfill() {
-      return (
-        /** @class */
-        function() {
-          function Set1() {
-            this._map = new _Map();
+            if (options.excludeKeys) {
+              keys = keys.filter(function(key) {
+                return !options.excludeKeys(key);
+              });
+            }
+            write("object:" + keys.length + ":");
+            var self = this;
+            return keys.forEach(function(key) {
+              self.dispatch(key);
+              write(":");
+              if (!options.excludeValues) {
+                self.dispatch(object[key]);
+              }
+              write(",");
+            });
           }
-          __name(Set1, "Set1");
-          Object.defineProperty(Set1.prototype, "size", {
-            get: /* @__PURE__ */ __name(function() {
-              return this._map.size;
-            }, "get"),
-            enumerable: true,
-            configurable: true
-          });
-          Set1.prototype.has = function(value) {
-            return this._map.has(value);
-          };
-          Set1.prototype.add = function(value) {
-            return this._map.set(value, value), this;
-          };
-          Set1.prototype.delete = function(value) {
-            return this._map.delete(value);
-          };
-          Set1.prototype.clear = function() {
-            this._map.clear();
-          };
-          Set1.prototype.keys = function() {
-            return this._map.keys();
-          };
-          Set1.prototype.values = function() {
-            return this._map.values();
-          };
-          Set1.prototype.entries = function() {
-            return this._map.entries();
-          };
-          Set1.prototype["@@iterator"] = function() {
-            return this.keys();
-          };
-          Set1.prototype[iteratorSymbol] = function() {
-            return this.keys();
-          };
-          return Set1;
-        }()
-      );
-    }
-    __name(CreateSetPolyfill, "CreateSetPolyfill");
-    function CreateWeakMapPolyfill() {
-      var UUID_SIZE = 16;
-      var keys = HashMap.create();
-      var rootKey = CreateUniqueKey();
-      return (
-        /** @class */
-        function() {
-          function WeakMap1() {
-            this._key = CreateUniqueKey();
+        },
+        _array: function(arr, unordered) {
+          unordered = typeof unordered !== "undefined" ? unordered : options.unorderedArrays !== false;
+          var self = this;
+          write("array:" + arr.length + ":");
+          if (!unordered || arr.length <= 1) {
+            return arr.forEach(function(entry) {
+              return self.dispatch(entry);
+            });
           }
-          __name(WeakMap1, "WeakMap1");
-          WeakMap1.prototype.has = function(target) {
-            var table = GetOrCreateWeakMapTable(
-              target,
-              /*create*/
-              false
-            );
-            return table !== void 0 ? HashMap.has(table, this._key) : false;
-          };
-          WeakMap1.prototype.get = function(target) {
-            var table = GetOrCreateWeakMapTable(
-              target,
-              /*create*/
-              false
-            );
-            return table !== void 0 ? HashMap.get(table, this._key) : void 0;
-          };
-          WeakMap1.prototype.set = function(target, value) {
-            var table = GetOrCreateWeakMapTable(
-              target,
-              /*create*/
-              true
-            );
-            table[this._key] = value;
-            return this;
-          };
-          WeakMap1.prototype.delete = function(target) {
-            var table = GetOrCreateWeakMapTable(
-              target,
-              /*create*/
-              false
-            );
-            return table !== void 0 ? delete table[this._key] : false;
-          };
-          WeakMap1.prototype.clear = function() {
-            this._key = CreateUniqueKey();
-          };
-          return WeakMap1;
-        }()
-      );
-      function CreateUniqueKey() {
-        var key;
-        do
-          key = "@@WeakMap@@" + CreateUUID();
-        while (HashMap.has(keys, key));
-        keys[key] = true;
-        return key;
-      }
-      __name(CreateUniqueKey, "CreateUniqueKey");
-      function GetOrCreateWeakMapTable(target, create) {
-        if (!hasOwn.call(target, rootKey)) {
-          if (!create) return void 0;
-          Object.defineProperty(target, rootKey, {
-            value: HashMap.create()
+          var contextAdditions = [];
+          var entries = arr.map(function(entry) {
+            var strm = new PassThrough();
+            var localContext = context.slice();
+            var hasher = typeHasher(options, strm, localContext);
+            hasher.dispatch(entry);
+            contextAdditions = contextAdditions.concat(localContext.slice(context.length));
+            return strm.read().toString();
           });
+          context = context.concat(contextAdditions);
+          entries.sort();
+          return this._array(entries, false);
+        },
+        _date: function(date) {
+          return write("date:" + date.toJSON());
+        },
+        _symbol: function(sym) {
+          return write("symbol:" + sym.toString());
+        },
+        _error: function(err) {
+          return write("error:" + err.toString());
+        },
+        _boolean: function(bool) {
+          return write("bool:" + bool.toString());
+        },
+        _string: function(string) {
+          write("string:" + string.length + ":");
+          write(string.toString());
+        },
+        _function: function(fn) {
+          write("fn:");
+          if (isNativeFunction(fn)) {
+            this.dispatch("[native]");
+          } else {
+            this.dispatch(fn.toString());
+          }
+          if (options.respectFunctionNames !== false) {
+            this.dispatch("function-name:" + String(fn.name));
+          }
+          if (options.respectFunctionProperties) {
+            this._object(fn);
+          }
+        },
+        _number: function(number) {
+          return write("number:" + number.toString());
+        },
+        _xml: function(xml) {
+          return write("xml:" + xml.toString());
+        },
+        _null: function() {
+          return write("Null");
+        },
+        _undefined: function() {
+          return write("Undefined");
+        },
+        _regexp: function(regex) {
+          return write("regex:" + regex.toString());
+        },
+        _uint8array: function(arr) {
+          write("uint8array:");
+          return this.dispatch(Array.prototype.slice.call(arr));
+        },
+        _uint8clampedarray: function(arr) {
+          write("uint8clampedarray:");
+          return this.dispatch(Array.prototype.slice.call(arr));
+        },
+        _int8array: function(arr) {
+          write("uint8array:");
+          return this.dispatch(Array.prototype.slice.call(arr));
+        },
+        _uint16array: function(arr) {
+          write("uint16array:");
+          return this.dispatch(Array.prototype.slice.call(arr));
+        },
+        _int16array: function(arr) {
+          write("uint16array:");
+          return this.dispatch(Array.prototype.slice.call(arr));
+        },
+        _uint32array: function(arr) {
+          write("uint32array:");
+          return this.dispatch(Array.prototype.slice.call(arr));
+        },
+        _int32array: function(arr) {
+          write("uint32array:");
+          return this.dispatch(Array.prototype.slice.call(arr));
+        },
+        _float32array: function(arr) {
+          write("float32array:");
+          return this.dispatch(Array.prototype.slice.call(arr));
+        },
+        _float64array: function(arr) {
+          write("float64array:");
+          return this.dispatch(Array.prototype.slice.call(arr));
+        },
+        _arraybuffer: function(arr) {
+          write("arraybuffer:");
+          return this.dispatch(new Uint8Array(arr));
+        },
+        _url: function(url) {
+          return write("url:" + url.toString(), "utf8");
+        },
+        _map: function(map) {
+          write("map:");
+          var arr = Array.from(map);
+          return this._array(arr, options.unorderedSets !== false);
+        },
+        _set: function(set) {
+          write("set:");
+          var arr = Array.from(set);
+          return this._array(arr, options.unorderedSets !== false);
+        },
+        _file: function(file) {
+          write("file:");
+          return this.dispatch([file.name, file.size, file.type, file.lastModfied]);
+        },
+        _blob: function() {
+          if (options.ignoreUnknown) {
+            return write("[blob]");
+          }
+          throw Error('Hashing Blob objects is currently not supported\n(see https://github.com/puleos/object-hash/issues/26)\nUse "options.replacer" or "options.ignoreUnknown"\n');
+        },
+        _domwindow: function() {
+          return write("domwindow");
+        },
+        _bigint: function(number) {
+          return write("bigint:" + number.toString());
+        },
+        /* Node.js standard native objects */
+        _process: function() {
+          return write("process");
+        },
+        _timer: function() {
+          return write("timer");
+        },
+        _pipe: function() {
+          return write("pipe");
+        },
+        _tcp: function() {
+          return write("tcp");
+        },
+        _udp: function() {
+          return write("udp");
+        },
+        _tty: function() {
+          return write("tty");
+        },
+        _statwatcher: function() {
+          return write("statwatcher");
+        },
+        _securecontext: function() {
+          return write("securecontext");
+        },
+        _connection: function() {
+          return write("connection");
+        },
+        _zlib: function() {
+          return write("zlib");
+        },
+        _context: function() {
+          return write("context");
+        },
+        _nodescript: function() {
+          return write("nodescript");
+        },
+        _httpparser: function() {
+          return write("httpparser");
+        },
+        _dataview: function() {
+          return write("dataview");
+        },
+        _signal: function() {
+          return write("signal");
+        },
+        _fsevent: function() {
+          return write("fsevent");
+        },
+        _tlswrap: function() {
+          return write("tlswrap");
         }
-        return target[rootKey];
-      }
-      __name(GetOrCreateWeakMapTable, "GetOrCreateWeakMapTable");
-      function FillRandomBytes(buffer, size) {
-        for (var i = 0; i < size; ++i) buffer[i] = Math.random() * 255 | 0;
-        return buffer;
-      }
-      __name(FillRandomBytes, "FillRandomBytes");
-      function GenRandomBytes(size) {
-        if (typeof Uint8Array === "function") {
-          if (typeof crypto !== "undefined") return crypto.getRandomValues(new Uint8Array(size));
-          if (typeof msCrypto !== "undefined") return msCrypto.getRandomValues(new Uint8Array(size));
-          return FillRandomBytes(new Uint8Array(size), size);
-        }
-        return FillRandomBytes(new Array(size), size);
-      }
-      __name(GenRandomBytes, "GenRandomBytes");
-      function CreateUUID() {
-        var data = GenRandomBytes(UUID_SIZE);
-        data[6] = data[6] & 79 | 64;
-        data[8] = data[8] & 191 | 128;
-        var result = "";
-        for (var offset = 0; offset < UUID_SIZE; ++offset) {
-          var byte = data[offset];
-          if (offset === 4 || offset === 6 || offset === 8) result += "-";
-          if (byte < 16) result += "0";
-          result += byte.toString(16).toLowerCase();
-        }
-        return result;
-      }
-      __name(CreateUUID, "CreateUUID");
+      };
     }
-    __name(CreateWeakMapPolyfill, "CreateWeakMapPolyfill");
-    function MakeDictionary(obj) {
-      obj.__ = void 0;
-      delete obj.__;
-      return obj;
+    function PassThrough() {
+      return {
+        buf: "",
+        write: function(b) {
+          this.buf += b;
+        },
+        end: function(b) {
+          this.buf += b;
+        },
+        read: function() {
+          return this.buf;
+        }
+      };
     }
-    __name(MakeDictionary, "MakeDictionary");
-  });
-})(Reflect2 || (Reflect2 = {}));
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Inject: () => Inject,
+  Service: () => Service,
+  getInstance: () => getInstance
+});
+module.exports = __toCommonJS(index_exports);
+
+// ../helpers/dist/index.js
+var import_object_hash = __toESM(require_object_hash(), 1);
+var import_crypto = __toESM(require("crypto"), 1);
+var UNMISTAKABLE_CHARS = "23456789ABCDEFGHJKLMNPQRSTWXYZabcdefghjkmnopqrstuvwxyz";
+var hexString = function(digits) {
+  var numBytes = Math.ceil(digits / 2);
+  var bytes;
+  try {
+    bytes = import_crypto.default.randomBytes(numBytes);
+  } catch (e) {
+    bytes = import_crypto.default.pseudoRandomBytes(numBytes);
+  }
+  var result = bytes.toString("hex");
+  return result.substring(0, digits);
+};
+var fraction = function() {
+  var numerator = parseInt(hexString(8), 16);
+  return numerator * 23283064365386963e-26;
+};
+var choice = function(arrayOrString) {
+  var index = Math.floor(fraction() * arrayOrString.length);
+  if (typeof arrayOrString === "string") return arrayOrString.substr(index, 1);
+  else return arrayOrString[index];
+};
+var randomString = function(charsCount, alphabet) {
+  var digits = [];
+  for (var i = 0; i < charsCount; i++) {
+    digits[i] = choice(alphabet);
+  }
+  return digits.join("");
+};
+function generateId(charsCount, chars = UNMISTAKABLE_CHARS) {
+  if (!charsCount) {
+    charsCount = 17;
+  }
+  return randomString(charsCount, chars);
+}
 
-// src/typedi.ts
-var import_typedi = require("typedi");
-var import_typedi2 = require("typedi");
-function getInstance(service) {
-  return import_typedi.Container.get(service);
+// src/di.ts
+var instances = /* @__PURE__ */ new Map();
+var serviceMetadata = /* @__PURE__ */ new WeakMap();
+var injectionMetadata = /* @__PURE__ */ new WeakMap();
+function Service() {
+  return (_target, context) => {
+    serviceMetadata.set(context, {
+      id: generateId(12),
+      name: context.name
+    });
+  };
+}
+function Inject(getDependency) {
+  return (_, context) => {
+    context.addInitializer(function() {
+      const metadata = injectionMetadata.get(this) || {};
+      metadata[context.name] = getDependency;
+      injectionMetadata.set(this, metadata);
+    });
+  };
+}
+function getInstance(token) {
+  if (!instances.has(token)) {
+    const instance = new token();
+    instances.set(token, instance);
+    const injections = injectionMetadata.get(instance);
+    if (injections) {
+      for (const [propertyKey, getDependency] of Object.entries(injections)) {
+        instance[propertyKey] = getInstance(getDependency());
+      }
+    }
+  }
+  return instances.get(token);
 }
-__name(getInstance, "getInstance");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  Container,
   Inject,
   Service,
   getInstance
 });
-/*! Bundled license information:
-
-reflect-metadata/Reflect.js:
-  (*! *****************************************************************************
-  Copyright (C) Microsoft. All rights reserved.
-  Licensed under the Apache License, Version 2.0 (the "License"); you may not use
-  this file except in compliance with the License. You may obtain a copy of the
-  License at http://www.apache.org/licenses/LICENSE-2.0
-  
-  THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
-  WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
-  MERCHANTABLITY OR NON-INFRINGEMENT.
-  
-  See the Apache Version 2.0 License for specific language governing permissions
-  and limitations under the License.
-  ***************************************************************************** *)
-*/
 //# sourceMappingURL=index.cjs.map