assemblerjs 0.3.25 → 0.4.0

package/dist/index.mjs

@@ -1,3 +1,19 @@
+class AbstractAssemblage {
+    static onRegister(s) {}
+}
+
+const ReflectParamTypes = 'design:paramtypes';
+const ReflectPrefix = '__';
+const ReflectSuffix = '__';
+var ReflectFlags = /*#__PURE__*/ function(e) {
+    e["IsAssemblage"] = "is_assemblage";
+    return e;
+}({});
+var ReflectValue = /*#__PURE__*/ function(e) {
+    e["AssemblageDefinition"] = "assemblage:definition.value";
+    return e;
+}({});
+
 const NoOp = (...e)=>{};
 const isOfType = (...e)=>(t)=>{
         if (!e.includes(typeof t)) return undefined;
@@ -48,7 +64,7 @@ const forIn = (e)=>(t)=>{
             t(r(o));
         }
     };
-const e$6 = (e, t)=>{
+const e$5 = (e, t)=>{
     return [
         ...Object.getOwnPropertyNames(t.prototype),
         ...Object.getOwnPropertyNames(Object.getPrototypeOf(e)),
@@ -60,7 +76,7 @@ const proxifyIterable = (t, r)=>{
         get: function(o, n) {
             if (n === Symbol.iterator) {
                 return o[Symbol.iterator].bind(o);
-            } else if (!e$6(t, r).includes(n)) {
+            } else if (!e$5(t, r).includes(n)) {
                 return o.collection[n];
             }
             return o[n];
@@ -85,7 +101,310 @@ const clearInstance = (e, t)=>{
     }
 };
 
-function e$5(e, t, n) {
+const defineCustomMetadata = (t, o, n)=>{
+    Reflect.defineMetadata(`${ReflectPrefix}${t}${ReflectSuffix}`, o, n);
+};
+const getOwnCustomMetadata = (t, o)=>{
+    return Reflect.getOwnMetadata(`${ReflectPrefix}${t}${ReflectSuffix}`, o);
+};
+const getParamTypes = (e)=>{
+    return Reflect.getMetadata(ReflectParamTypes, e) || [];
+};
+
+const isAssemblage = (m)=>{
+    return getOwnCustomMetadata(ReflectFlags.IsAssemblage, m) || false;
+};
+
+const n = {
+    singleton: {
+        test: (r)=>typeof r === 'boolean' || typeof r === 'undefined',
+        throw: ()=>{
+            throw new Error(`'singleton' property must be of type 'boolean' or 'undefined'.`);
+        },
+        transform: (r)=>typeof r === 'undefined' ? true : false
+    },
+    events: {
+        test: (r)=>typeof r === 'undefined' || Array.isArray(r) && r.every((r)=>typeof r === 'string'),
+        throw: ()=>{
+            throw new Error(`'events' property must be an array of strings or 'undefined'.`);
+        },
+        transform: (r)=>r
+    },
+    inject: {
+        test: (r)=>typeof r === 'undefined' || Array.isArray(r) && r.every((r)=>Array.isArray(r) && r.length >= 1 && r.length <= 3),
+        throw: ()=>{
+            throw new Error(`'inject' property must be an array of tuples of length 1, 2 or 3.`);
+        },
+        transform: (r)=>r
+    },
+    use: {
+        test: (r)=>typeof r === 'undefined' || Array.isArray(r) && r.every((r)=>Array.isArray(r) && r.length == 2),
+        throw: ()=>{
+            throw new Error(`'use' property must be an array of tuples of length 2.`);
+        },
+        transform: (r)=>r
+    },
+    tags: {
+        test: (r)=>typeof r === 'undefined' || typeof r === 'string' || Array.isArray(r) && r.every((r)=>typeof r === 'string'),
+        throw: ()=>{
+            throw new Error(`'tags' property must be a string or an array of strings.`);
+        },
+        transform: (r)=>typeof r === 'string' ? [
+                r
+            ] : r
+    },
+    metadata: {
+        test: (r)=>(typeof r === 'object' || typeof r === 'undefined') && !Array.isArray(r),
+        throw: ()=>{
+            throw new Error(`'metadata' property must be of type 'object' or 'undefined'.`);
+        },
+        transform: (r)=>r
+    }
+};
+const validateDefinition = (r)=>{
+    const t = {
+        ...r
+    };
+    for(const r in t){
+        if (!Object.keys(n).includes(r)) {
+            throw new Error(`Property '${r}' is not a valid assemblage definition property.`);
+        }
+        const e = n[r].test;
+        const o = n[r].throw;
+        const s = n[r].transform;
+        if (!e(t[r])) {
+            o();
+        }
+        t[r] = s(t[r]);
+    }
+    return t;
+};
+const getDefinition = (t)=>{
+    if (!isAssemblage(t)) {
+        throw new Error(`Class '${t.name}' is not an assemblage.`);
+    }
+    return getOwnCustomMetadata(ReflectValue.AssemblageDefinition, t);
+};
+const getDefinitionValue = (r, t)=>{
+    const e = getDefinition(t);
+    return e[r];
+};
+const setDefinitionValue = (e, o, n)=>{
+    const s = getDefinition(n);
+    s[e] = o;
+    const i = validateDefinition(s);
+    defineCustomMetadata(ReflectValue.AssemblageDefinition, i, n);
+    return i;
+};
+
+const i$1 = (n)=>{
+    return {
+        identifier: n[0],
+        concrete: n[0],
+        configuration: {}
+    };
+};
+const c$2 = (r)=>{
+    const i = ()=>isClass(r[0]) && isClass(r[1]);
+    const c = ()=>isClass(r[0]) && isObject(r[1]);
+    const f = ()=>pipe(conditionally({
+            if: ()=>i(),
+            then: ()=>{
+                return {
+                    identifier: r[0],
+                    concrete: r[1],
+                    configuration: {}
+                };
+            }
+        }), conditionally({
+            if: ()=>c(),
+            then: ()=>{
+                return {
+                    identifier: r[0],
+                    concrete: r[0],
+                    configuration: r[1]
+                };
+            },
+            else: (n)=>n
+        }))();
+    return f();
+};
+const f = (n)=>{
+    return {
+        identifier: n[0],
+        concrete: n[1],
+        configuration: n[2]
+    };
+};
+const resolveInjectionTuple = (n)=>switchCase({
+        1: ()=>i$1(n),
+        2: ()=>c$2(n),
+        3: ()=>f(n)
+    }, ()=>{
+        throw new Error(`Injection tuple must be of length 1, 2 or 3.`);
+    })(n.length);
+
+const resolveInstanceInjectionTuple = (e)=>{
+    return {
+        identifier: e[0],
+        concrete: e[0],
+        instance: e[1],
+        configuration: {}
+    };
+};
+
+const Assemblage = (m)=>{
+    const n = m ? validateDefinition(m) : {};
+    return (t)=>{
+        defineCustomMetadata(ReflectFlags.IsAssemblage, true, t);
+        defineCustomMetadata(ReflectValue.AssemblageDefinition, n, t);
+        return t;
+    };
+};
+
+const Await = (t, e = 25)=>{
+    return (n, s, a)=>{
+        const i = a.value;
+        a.value = async function() {
+            return new Promise((n)=>{
+                if (this[t]) {
+                    i.apply(this);
+                    n();
+                } else {
+                    const s = setInterval(()=>{
+                        if (this[t]) {
+                            clearInterval(s);
+                            i.apply(this);
+                            n();
+                        }
+                    }, e);
+                }
+            });
+        };
+    };
+};
+
+var ReflectParamValue = /*#__PURE__*/ function(e) {
+    e["UseIdentifier"] = "assemblage:use.param.value";
+    return e;
+}({});
+var ReflectParamIndex = /*#__PURE__*/ function(e) {
+    e["Context"] = "assembler:context.param.index";
+    e["Dispose"] = "assembler:dispose.param.index";
+    e["Definition"] = "assemblage:definition.param.index";
+    e["Configuration"] = "assemblage:configuration.param.index";
+    e["Use"] = "assemblage:use.param.index";
+    return e;
+}({});
+
+const i = (t)=>()=>{
+        return (i, s, r)=>{
+            const c = getOwnCustomMetadata(t, i) || [];
+            c.push(r);
+            defineCustomMetadata(t, c, i);
+        };
+    };
+const s$1 = i(ReflectParamIndex.Context);
+const r$1 = i(ReflectParamIndex.Configuration);
+const c$1 = i(ReflectParamIndex.Definition);
+const e$4 = i(ReflectParamIndex.Dispose);
+
+const Use = (n)=>{
+    return (r, i, m)=>{
+        const c = getOwnCustomMetadata(ReflectParamIndex.Use, r) || [];
+        c.push(m);
+        defineCustomMetadata(ReflectParamIndex.Use, c, r);
+        const U = getOwnCustomMetadata(ReflectParamValue.UseIdentifier, r) || {};
+        U[m] = n;
+        defineCustomMetadata(ReflectParamValue.UseIdentifier, U, r);
+    };
+};
+
+const o = (o)=>{
+    return getOwnCustomMetadata(ReflectParamIndex.Context, o) || [];
+};
+const r = (o)=>{
+    return getOwnCustomMetadata(ReflectParamIndex.Configuration, o) || [];
+};
+const e$3 = (o)=>{
+    return getOwnCustomMetadata(ReflectParamIndex.Definition, o) || [];
+};
+const s = (o)=>{
+    return getOwnCustomMetadata(ReflectParamIndex.Dispose, o) || [];
+};
+const c = (o)=>{
+    return getOwnCustomMetadata(ReflectParamIndex.Use, o) || [];
+};
+const getDecoratedParametersIndexes = (t)=>{
+    const n = o(t);
+    const i = e$3(t);
+    const a = r(t);
+    const u = s(t);
+    const m = c(t);
+    return {
+        context: n,
+        definition: i,
+        configuration: a,
+        dispose: u,
+        use: m
+    };
+};
+
+const resolveParameters = (i)=>{
+    const c = [];
+    const s = getParamTypes(i.concrete);
+    const u = getDecoratedParametersIndexes(i.concrete);
+    let r = 0;
+    for (const n of s){
+        if (u.context.includes(r)) {
+            c.push(i.publicContext);
+            r++;
+            continue;
+        }
+        if (u.configuration.includes(r)) {
+            c.push(i.configuration);
+            r++;
+            continue;
+        }
+        if (u.definition.includes(r)) {
+            c.push(i.definition);
+            r++;
+            continue;
+        }
+        if (u.dispose.includes(r)) {
+            c.push(i.privateContext.dispose);
+            r++;
+            continue;
+        }
+        if (u.use.includes(r)) {
+            const n = getOwnCustomMetadata(ReflectParamValue.UseIdentifier, i.concrete);
+            const t = n[r];
+            c.push(i.privateContext.require(t));
+            r++;
+            continue;
+        }
+        c.push(i.privateContext.require(n));
+        r++;
+    }
+    return c;
+};
+const resolveDependencies = (e)=>{
+    const o = [];
+    const i = getParamTypes(e);
+    const c = getDecoratedParametersIndexes(e);
+    let s = 0;
+    for (const e of i){
+        if (c.context.includes(s) || c.configuration.includes(s) || c.definition.includes(s) || c.dispose.includes(s) || c.use.includes(s)) {
+            s++;
+            continue;
+        }
+        o.push(e);
+        s++;
+    }
+    return o;
+};
+
+function e$2(e, t, n) {
     if (t in e) {
         Object.defineProperty(e, t, {
             value: n,
@@ -98,14 +417,14 @@ function e$5(e, t, n) {
     }
     return e;
 }
-let h$1 = Symbol.iterator;
+let h = Symbol.iterator;
 class ListenerCollection {
     dispose() {
         clearInstance(this, ListenerCollection);
     }
     add(...e) {
-        const n = (e)=>this.collection[e.channel].push(e.listener);
-        const c = conditionally({
+        const t = (e)=>this.collection[e.channel].push(e.listener);
+        const l = conditionally({
             if: ()=>e.length === 2,
             then: ()=>{
                 return {
@@ -121,35 +440,35 @@ class ListenerCollection {
                 };
             }
         });
-        const o = conditionally({
+        const i = conditionally({
             if: (e)=>!isDefined(this.collection[e.channel]),
             then: (e)=>{
                 this.collection[e.channel] = [];
-                n(e);
+                t(e);
             },
             else: (e)=>{
-                n(e);
+                t(e);
             }
         });
-        pipe(c, o)();
+        pipe(l, i)();
         return this;
     }
-    remove(e, n) {
-        const c = (t)=>this.collection[e].splice(t, 1);
-        const o = conditionally({
+    remove(e, t) {
+        const l = (t)=>this.collection[e].splice(t, 1);
+        const i = conditionally({
             if: ()=>this.collection[e] && this.collection[e].length === 0,
             then: ()=>delete this.collection[e]
         });
-        const s = conditionally({
-            if: ()=>isDefined(n),
-            then: ()=>c(this.collection[e].indexOf(n)),
+        const o = conditionally({
+            if: ()=>isDefined(t),
+            then: ()=>l(this.collection[e].indexOf(t)),
             else: ()=>delete this.collection[e]
         });
         const r = conditionally({
             if: (e)=>this.has(e),
             then: (e)=>this.collection[e]
         });
-        pipe(r, s, o)();
+        pipe(r, o, i)();
         return this;
     }
     has(...e) {
@@ -183,7 +502,7 @@ class ListenerCollection {
     get length() {
         return Object.values(this.collection).flat().length;
     }
-    [h$1]() {
+    [h]() {
         let e = -1;
         const t = this.collection ? Object.keys(this.collection) : [];
         return {
@@ -194,13 +513,16 @@ class ListenerCollection {
         };
     }
     constructor(){
-        e$5(this, "collection", {});
+        e$2(this, "collection", {});
         const t = proxifyIterable(this, ListenerCollection);
         return t;
     }
 }
 
-function e$4(e, n, s) {
+class AbstractEventManager {
+}
+
+function e$1(e, n, s) {
     if (n in e) {
         Object.defineProperty(e, n, {
             value: s,
@@ -302,237 +624,15 @@ class EventManager {
         return onlyAlphanumeric(e, '*');
     }
     constructor(...n){
-        e$4(this, "listeners", new ListenerCollection());
-        e$4(this, "onceListeners", new ListenerCollection());
-        e$4(this, "channels", new Set([
+        e$1(this, "listeners", new ListenerCollection());
+        e$1(this, "onceListeners", new ListenerCollection());
+        e$1(this, "channels", new Set([
             '*'
         ]));
         this.addChannels(...n);
     }
 }
 
-const ReflectParamTypes = 'design:paramtypes';
-const ReflectPrefix = '__';
-const ReflectSuffix = '__';
-const ReflectIsAssemblageFlag = `is_assemblage`;
-const ReflectDefinition = 'assemblage_definition';
-const ReflectContextParamIndex = `context_param_index`;
-const ReflectConfigurationParamIndex = `config_param_index`;
-const ReflectDefinitionParamIndex = `definition_param_index`;
-const ReflectDisposeParamIndex = `dispose_param_index`;
-const ReflectUseParamIndex = `use_param_index`;
-const ReflectUseToken = 'use_token';
-
-const defineCustomMetadata = (t, o, n)=>{
-    Reflect.defineMetadata(`${ReflectPrefix}${t}${ReflectSuffix}`, o, n);
-};
-const getOwnCustomMetadata = (t, o)=>{
-    return Reflect.getOwnMetadata(`${ReflectPrefix}${t}${ReflectSuffix}`, o);
-};
-const getParamTypes = (e)=>{
-    return Reflect.getMetadata(ReflectParamTypes, e) || [];
-};
-
-const e$3 = {
-    singleton: {
-        test: (r)=>typeof r === 'boolean' || typeof r === 'undefined',
-        throw: ()=>{
-            throw new Error(`'singleton' property must be of type 'boolean' or 'undefined'.`);
-        },
-        transform: (r)=>typeof r === 'undefined' ? true : false
-    },
-    events: {
-        test: (r)=>typeof r === 'undefined' || Array.isArray(r) && r.every((r)=>typeof r === 'string'),
-        throw: ()=>{
-            throw new Error(`'events' property must be an array of strings or 'undefined'.`);
-        },
-        transform: (r)=>r
-    },
-    inject: {
-        test: (r)=>typeof r === 'undefined' || Array.isArray(r) && r.every((r)=>Array.isArray(r) && r.length >= 1 && r.length <= 3),
-        throw: ()=>{
-            throw new Error(`'inject' property must be an array of tuples of length 1, 2 or 3.`);
-        },
-        transform: (r)=>r
-    },
-    use: {
-        test: (r)=>typeof r === 'undefined' || Array.isArray(r) && r.every((r)=>Array.isArray(r) && r.length == 2),
-        throw: ()=>{
-            throw new Error(`'use' property must be an array of tuples of length 2.`);
-        },
-        transform: (r)=>r
-    },
-    tags: {
-        test: (r)=>typeof r === 'undefined' || typeof r === 'string' || Array.isArray(r) && r.every((r)=>typeof r === 'string'),
-        throw: ()=>{
-            throw new Error(`'tags' property must be a string or an array of strings.`);
-        },
-        transform: (r)=>typeof r === 'string' ? [
-                r
-            ] : r
-    },
-    metadata: {
-        test: (r)=>(typeof r === 'object' || typeof r === 'undefined') && !Array.isArray(r),
-        throw: ()=>{
-            throw new Error(`'metadata' property must be of type 'object' or 'undefined'.`);
-        },
-        transform: (r)=>r
-    }
-};
-const validateDefinition = (r)=>{
-    const t = {
-        ...r
-    };
-    for(const r in t){
-        if (!Object.keys(e$3).includes(r)) {
-            throw new Error(`Property '${r}' is not a valid assemblage definition property.`);
-        }
-        const o = e$3[r].test;
-        const n = e$3[r].throw;
-        const s = e$3[r].transform;
-        if (!o(t[r])) {
-            n();
-        }
-        t[r] = s(t[r]);
-    }
-    return t;
-};
-const getDefinition = (e)=>{
-    return getOwnCustomMetadata(ReflectDefinition, e);
-};
-const getDefinitionValue = (r, t)=>{
-    const e = getDefinition(t);
-    return e[r];
-};
-const setDefinitionValue = (r, t, e)=>{
-    const o = getDefinition(e);
-    o[r] = t;
-    const n = validateDefinition(o);
-    return n;
-};
-
-function e$2(e, t, r, o) {
-    var s = arguments.length, n = s < 3 ? t : o === null ? o = Object.getOwnPropertyDescriptor(t, r) : o, l;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") n = Reflect.decorate(e, t, r, o);
-    else for(var c = e.length - 1; c >= 0; c--)if (l = e[c]) n = (s < 3 ? l(n) : s > 3 ? l(t, r, n) : l(t, r)) || n;
-    return s > 3 && n && Object.defineProperty(t, r, n), n;
-}
-const Assemblage = (e)=>{
-    const r = e ? validateDefinition(e) : {};
-    return (e)=>{
-        defineCustomMetadata(ReflectIsAssemblageFlag, true, e);
-        defineCustomMetadata(ReflectDefinition, r, e);
-        return e;
-    };
-};
-const isAssemblage = (e)=>{
-    return getOwnCustomMetadata(ReflectIsAssemblageFlag, e) || false;
-};
-class NoOpAssemblage {
-}
-NoOpAssemblage = e$2([
-    Assemblage()
-], NoOpAssemblage);
-
-const callHook = (o, r, t)=>{
-    return new Promise((i)=>{
-        const e = o[r];
-        if (e) {
-            if (isAsync(e)) {
-                e.bind(o)(t).then(()=>{
-                    i();
-                });
-                return;
-            }
-            i(e.bind(o)(t));
-        }
-    });
-};
-
-const getContextIndex = (e)=>{
-    return getOwnCustomMetadata(ReflectContextParamIndex, e) || [];
-};
-const getConfigurationIndex = (t)=>{
-    return getOwnCustomMetadata(ReflectConfigurationParamIndex, t) || [];
-};
-const getDefinitionIndex = (e)=>{
-    return getOwnCustomMetadata(ReflectDefinitionParamIndex, e) || [];
-};
-const getDisposeIndex = (e)=>{
-    return getOwnCustomMetadata(ReflectDisposeParamIndex, e) || [];
-};
-const getUseIndex = (e)=>{
-    return getOwnCustomMetadata(ReflectUseParamIndex, e) || [];
-};
-const getDecoratedParametersIndexes = (e)=>{
-    const t = getContextIndex(e);
-    const n = getDefinitionIndex(e);
-    const o = getConfigurationIndex(e);
-    const r = getDisposeIndex(e);
-    const s = getUseIndex(e);
-    return {
-        context: t,
-        definition: n,
-        configuration: o,
-        dispose: r,
-        use: s
-    };
-};
-
-const resolveParameters = (i)=>{
-    const s = [];
-    const c = getParamTypes(i.concrete);
-    const r = getDecoratedParametersIndexes(i.concrete);
-    let u = 0;
-    for (const e of c){
-        if (r.context.includes(u)) {
-            s.push(i.publicContext);
-            u++;
-            continue;
-        }
-        if (r.configuration.includes(u)) {
-            s.push(i.configuration);
-            u++;
-            continue;
-        }
-        if (r.definition.includes(u)) {
-            s.push(i.definition);
-            u++;
-            continue;
-        }
-        if (r.dispose.includes(u)) {
-            s.push(i.privateContext.dispose);
-            u++;
-            continue;
-        }
-        if (r.use.includes(u)) {
-            const e = getOwnCustomMetadata(ReflectUseToken, i.concrete);
-            const o = e[u];
-            s.push(i.privateContext.require(o));
-            u++;
-            continue;
-        }
-        s.push(i.privateContext.require(e));
-        u++;
-    }
-    return s;
-};
-const resolveDependencies = (n)=>{
-    const t = [];
-    const i = getParamTypes(n);
-    const s = getDecoratedParametersIndexes(n);
-    let c = 0;
-    for (const e of i){
-        if (s.context.includes(c) || s.configuration.includes(c) || s.definition.includes(c) || s.dispose.includes(c) || s.use.includes(c)) {
-            c++;
-            continue;
-        }
-        t.push(e);
-        c++;
-    }
-    return t;
-};
-
 const registerEvents = (t, n)=>{
     const o = t.concrete.prototype instanceof EventManager;
     if (o) {
@@ -561,22 +661,22 @@ const unregisterEvents = (t, n)=>{
     }
 };
 
-function e$1(e, t, n) {
-    if (t in e) {
-        Object.defineProperty(e, t, {
+function t(t, e, n) {
+    if (e in t) {
+        Object.defineProperty(t, e, {
             value: n,
             enumerable: true,
             configurable: true,
             writable: true
         });
     } else {
-        e[t] = n;
+        t[e] = n;
     }
-    return e;
+    return t;
 }
 class Injectable {
-    static of(e, t, n) {
-        return new Injectable(e, t, n);
+    static of(t, e, n) {
+        return new Injectable(t, e, n);
     }
     dispose() {
         if (this.singletonInstance) {
@@ -588,16 +688,16 @@ class Injectable {
     }
     build() {
         if (this.singletonInstance) return this.singletonInstance;
-        const e = resolveParameters(this);
-        const t = new this.concrete(...e);
-        registerEvents(this, t);
+        const t = resolveParameters(this);
+        const e = new this.concrete(...t);
+        registerEvents(this, e);
         if (this.isSingleton) {
-            this.singletonInstance = t;
-            this.privateContext.prepareInit(t);
+            this.singletonInstance = e;
+            this.privateContext.prepareInitHook(e);
             return this.singletonInstance;
         }
-        callHook(t, 'onInit', this.publicContext);
-        return t;
+        callHook(e, 'onInit', this.publicContext);
+        return e;
     }
     get dependencies() {
         return this.dependenciesIds;
@@ -623,93 +723,53 @@ class Injectable {
     get events() {
         return getDefinitionValue('events', this.concrete) || [];
     }
-    constructor(t, s, o){
-        e$1(this, "privateContext", undefined);
-        e$1(this, "publicContext", undefined);
-        e$1(this, "identifier", undefined);
-        e$1(this, "concrete", undefined);
-        e$1(this, "configuration", undefined);
-        e$1(this, "dependenciesIds", undefined);
-        e$1(this, "singletonInstance", undefined);
+    constructor(e, s, o){
+        t(this, "privateContext", undefined);
+        t(this, "publicContext", undefined);
+        t(this, "identifier", undefined);
+        t(this, "concrete", undefined);
+        t(this, "configuration", undefined);
+        t(this, "dependenciesIds", undefined);
+        t(this, "singletonInstance", undefined);
         this.privateContext = s;
         this.publicContext = o;
         this.dependenciesIds = [];
-        this.identifier = t.identifier;
-        this.concrete = t.concrete;
-        this.configuration = t.configuration;
+        this.identifier = e.identifier;
+        this.concrete = e.concrete;
+        this.configuration = e.configuration;
         if (!isAssemblage(this.concrete)) {
             throw new Error(`Class '${this.concrete.name}' is not an Assemblage.`);
         }
         const r = forOf(this.injections);
-        r((e)=>this.privateContext.register(e));
-        const h = forOf(this.objects);
-        h((e)=>{
-            if (typeof e[0] === 'string' || typeof e[0] === 'symbol') {
-                this.privateContext.use(e[0], e[1]);
+        const c = forOf(this.objects);
+        r((t)=>this.privateContext.register(t));
+        c((t)=>{
+            if (typeof t[0] === 'string' || typeof t[0] === 'symbol') {
+                this.privateContext.use(t[0], t[1]);
             } else {
-                this.privateContext.register(e, true);
+                this.privateContext.register(t, true);
             }
         });
         this.dependenciesIds = resolveDependencies(this.concrete);
-        if (t.instance) {
-            this.singletonInstance = t.instance;
+        if (e.instance) {
+            this.singletonInstance = e.instance;
         }
     }
 }
 
-const i = (n)=>{
-    return {
-        identifier: n[0],
-        concrete: n[0],
-        configuration: {}
-    };
-};
-const c = (o)=>{
-    const i = ()=>isClass(o[0]) && isClass(o[1]);
-    const c = ()=>isClass(o[0]) && isObject(o[1]);
-    const u = ()=>pipe(conditionally({
-            if: ()=>i(),
-            then: ()=>{
-                return {
-                    identifier: o[0],
-                    concrete: o[1],
-                    configuration: {}
-                };
+const callHook = (n, r, t)=>{
+    return new Promise((e)=>{
+        const i = n[r];
+        if (i) {
+            if (isAsync(i)) {
+                i.bind(n)(t).then(()=>{
+                    e();
+                });
+                return;
             }
-        }), conditionally({
-            if: ()=>c(),
-            then: ()=>{
-                return {
-                    identifier: o[0],
-                    concrete: o[0],
-                    configuration: o[1]
-                };
-            },
-            else: (n)=>n
-        }))();
-    return u();
-};
-const u$1 = (n)=>{
-    return {
-        identifier: n[0],
-        concrete: n[1],
-        configuration: n[2]
-    };
-};
-const resolveInjectionTuple = (n)=>switchCase({
-        1: ()=>i(n),
-        2: ()=>c(n),
-        3: ()=>u$1(n)
-    }, ()=>{
-        throw new Error(`Injection tuple must be of length 1, 2 or 3.`);
-    })(n.length);
-const resolveInstanceInjectionTuple = (n)=>{
-    return {
-        identifier: n[0],
-        concrete: n[0],
-        instance: n[1],
-        configuration: {}
-    };
+            e(i.bind(n)(t));
+        }
+    });
 };
 
 function e(e, t, i) {
@@ -729,18 +789,18 @@ class Assembler extends EventManager {
     static build(e) {
         const t = new Assembler();
         setDefinitionValue('singleton', true, e);
-        const i = t.register([
+        const s = t.register([
             e
         ]);
-        const s = t.require(i.identifier);
-        const o = t.initCache.indexOf(s);
-        t.initCache.splice(o, 1);
+        const n = t.require(s.identifier);
+        const r = t.initCache.indexOf(n);
+        t.initCache.splice(r, 1);
         for (const e of t.initCache){
             callHook(e, 'onInit', t.publicContext);
         }
-        callHook(s, 'onInit', t.publicContext);
+        callHook(n, 'onInit', t.publicContext);
         t.initCache.length = 0;
-        return s;
+        return n;
     }
     dispose() {
         for (const [e, t] of this.injectables){
@@ -753,10 +813,10 @@ class Assembler extends EventManager {
         if (this.has(i.identifier)) {
             throw new Error(`An assemblage is already registered with identifier '${i.identifier.name}'.`);
         }
-        const r = Injectable.of(i, this.privateContext, this.publicContext);
-        this.injectables.set(r.identifier, r);
-        callHook(r.concrete, 'onRegister', this.publicContext);
-        return r;
+        const o = Injectable.of(i, this.privateContext, this.publicContext);
+        this.injectables.set(o.identifier, o);
+        callHook(o.concrete, 'onRegister', this.publicContext);
+        return o;
     }
     use(e, t) {
         if (this.has(e)) {
@@ -765,7 +825,7 @@ class Assembler extends EventManager {
         this.objects.set(e, t);
         return t;
     }
-    prepareInit(e) {
+    prepareInitHook(e) {
         this.initCache.push(e);
         return this.initCache;
     }
@@ -822,7 +882,7 @@ class Assembler extends EventManager {
             ...this.publicContext,
             register: this.register.bind(this),
             use: this.use.bind(this),
-            prepareInit: this.prepareInit.bind(this),
+            prepareInitHook: this.prepareInitHook.bind(this),
             emit: this.emit.bind(this),
             addChannels: this.addChannels.bind(this),
             removeChannels: this.removeChannels.bind(this),
@@ -831,58 +891,7 @@ class Assembler extends EventManager {
     }
 }
 
-const p = (o)=>()=>{
-        return (t, n, s)=>{
-            const e = getOwnCustomMetadata(o, t) || [];
-            e.push(s);
-            defineCustomMetadata(o, e, t);
-        };
-    };
-const f = p(ReflectContextParamIndex);
-const u = p(ReflectConfigurationParamIndex);
-const m = p(ReflectDefinitionParamIndex);
-const h = p(ReflectDisposeParamIndex);
-const l = (o)=>{
-    return (t, n, s)=>{
-        const p = getOwnCustomMetadata(ReflectUseParamIndex, t) || [];
-        p.push(s);
-        defineCustomMetadata(ReflectUseParamIndex, p, t);
-        const f = getOwnCustomMetadata(ReflectUseToken, t) || {};
-        f[s] = o;
-        defineCustomMetadata(ReflectUseToken, f, t);
-    };
-};
-
-const Await = (t, e = 25)=>{
-    return (n, s, a)=>{
-        const i = a.value;
-        a.value = async function() {
-            return new Promise((n)=>{
-                if (this[t]) {
-                    i.apply(this);
-                    n();
-                } else {
-                    const s = setInterval(()=>{
-                        if (this[t]) {
-                            clearInterval(s);
-                            i.apply(this);
-                            n();
-                        }
-                    }, e);
-                }
-            });
-        };
-    };
-};
-
-class AbstractAssemblage {
-    static onRegister(s) {}
-}
-
-class AbstractEventManager {
-}
-
 class AbstractAssembler extends AbstractEventManager {
 }
 
-export { AbstractAssemblage, AbstractAssembler, AbstractEventManager, Assemblage, Assembler, Await, u as Configuration, f as Context, m as Definition, h as Dispose, EventManager, l as Use };
+export { AbstractAssemblage, AbstractAssembler, AbstractEventManager, Assemblage, Assembler, Await, r$1 as Configuration, s$1 as Context, c$1 as Definition, e$4 as Dispose, EventManager, ReflectParamIndex, ReflectParamValue, Use, getDecoratedParametersIndexes };