assemblerjs 0.0.9

package/README.md

@@ -0,0 +1 @@
+# assembler.js

package/dist/index.d.ts

@@ -0,0 +1,194 @@
+/**
+ * An abstract class.
+ */
+declare interface Abstract<T> extends Function {
+    prototype: T;
+}
+
+export declare abstract class AbstractAssemblage {
+    [key: string]: any;
+    abstract onInit?(): void | Promise<void>;
+    abstract onDispose?(): void;
+}
+
+export declare abstract class AbstractAssembler {
+    abstract context: AssemblerContext;
+    abstract register<T>(injection: Injection<T>): void;
+    abstract has<T>(identifier: Identifier<T>): boolean;
+    abstract require<T>(identifier: Identifier<T>): T;
+}
+
+/**
+ * Generic `Array` items.
+ */
+declare type ArrayItems<T extends Array<any>> = T extends Array<infer TItems> ? TItems : never;
+
+/**
+ * Methods or keys that mutate an `Array`.
+ */
+declare type ArrayLengthMutationKeys = 'splice' | 'push' | 'pop' | 'shift' | 'unshift' | number;
+
+export declare const Assemblage: (definition?: AssemblageDefinition) => ClassDecorator;
+
+declare interface AssemblageDefinition {
+    singleton?: false;
+    inject?: Injection<unknown>[][];
+    tags?: string | string[];
+    controller?: true;
+    path?: string;
+    metadata?: Record<string, any>;
+}
+
+export declare class Assembler implements AbstractAssembler {
+    protected injectables: Map<Identifier<unknown>, Injectable<unknown>>;
+    readonly context: AssemblerContext;
+    static build(entry: Concrete<any>): Assembler;
+    private constructor();
+    /**
+     * Recursively register an `Injection` tuple and its inner injected dependencies.
+     *
+     * @param { Injection<T> } injection The injection tuple to register.
+     */
+    register<T>(injection: Injection<T>): Injectable<T>;
+    /**
+     * Check if `Assembler` has given identifier registered.
+     *
+     * @param { Identifier<T> } identifier An identifier (abstract or concrete class).
+     * @returns { boolean } `true` if dependency has been registered.
+     */
+    has<T>(identifier: Identifier<T>): boolean;
+    /**
+     * Get or instantiate an assemblage for given identifier.
+     *
+     * @param { Identifier<T> } identifier The identifier to get instance from.
+     * @returns { T } An instance of Concrete<T>.
+     */
+    require<T>(identifier: Identifier<T>): T;
+}
+
+declare class AssemblerContext {
+    /**
+     * User-defined data. Can be used to add properties to context after creation.
+     */
+    readonly userData: Record<string, any>;
+    register: AbstractAssembler['register'];
+    has: AbstractAssembler['has'];
+    require: AbstractAssembler['require'];
+    constructor(assembler: AbstractAssembler);
+    /**
+     * Add a value to user-defined data.
+     *
+     * @param { string } key The key to add.
+     * @param { any } value The value to add.
+     * @returns { this } This context.
+     */
+    set(key: string, value: any): this;
+    /**
+     * Get a value in user-defined data for given key.
+     *
+     * @param { string } key The key to get from user-defined data.
+     * @returns { any } The result.
+     */
+    get(key: string): any;
+}
+
+/**
+ * Injectable binds a concrete class to an abstract class as identifier without configuration.
+ */
+declare type BaseInjection<T> = Tuple<[Abstract<T>, Concrete<T>]>;
+
+/**
+ * A concrete (newable) class.
+ */
+declare interface Concrete<T> extends Function {
+    new (...args: any[]): T;
+}
+
+/**
+ * Injection binds a concrete class to itself as identifier
+ * and provides a configuration object that will be passed to context.
+ */
+declare type ConcreteConfiguredInjection<T> = Tuple<[
+Concrete<T>,
+Record<string, any>
+]>;
+
+/**
+ * Injectable binds a conrete class to itself as identifier.
+ */
+declare type ConcreteInjection<T> = Tuple<[Concrete<T>]>;
+
+export declare const Configuration: () => ParameterDecorator;
+
+/**
+ * Injectable binds a concrete class to an abstract class as identifier
+ * and provides a configuration object that will be passed to context.
+ */
+declare type ConfiguredInjection<T> = Tuple<[
+Abstract<T>,
+Concrete<T>,
+Record<string, any>
+]>;
+
+export declare const Context: () => ParameterDecorator;
+
+/**
+ * An identifier can be an abstract or a concrete class.
+ */
+declare type Identifier<T> = Concrete<T> | Abstract<T>;
+
+declare class Injectable<T> {
+    private context;
+    readonly identifier: Identifier<T>;
+    readonly concrete: Concrete<T>;
+    readonly configuration: Record<string, any>;
+    singleton: T | undefined;
+    static of<TNew>(injection: Injection<TNew>, context: AssemblerContext): Injectable<TNew>;
+    private constructor();
+    /**
+     * Instantiate the assemblage or get its singleton instance.
+     *
+     * @param { ...any[] } args The arguments to be passed to asssemblage's constructor.
+     * @returns { T } The assemblage instance.
+     */
+    build(): T;
+    /**
+     * Resolve dependencies passed as parameters in constructor.
+     *
+     * @returns { (Identifier<unknown> | any)[] } An array of parameters.
+     */
+    private resolveDependencies;
+    /**
+     * `true` if assemblage is a singleton.
+     *
+     * @todo Change assembler to avoid checking instance.
+     */
+    get isSingleton(): boolean;
+    /**
+     * Injectable assemblage's own injections defined in its decorator's definition.
+     */
+    get injections(): Injection<unknown>[];
+    /**
+     * Injectable assemblage's dependencies passed as 'constructor' parameters.
+     */
+    get dependencies(): (Identifier<unknown> | any)[];
+    get metadata(): Record<string, any>;
+}
+
+/**
+ * A generic injection tuple.
+ */
+declare type Injection<T> = BaseInjection<T> | ConfiguredInjection<T> | ConcreteInjection<T> | ConcreteConfiguredInjection<T>;
+
+export declare const Metadata: () => ParameterDecorator;
+
+/**
+ * An array of fixed length typed values.
+ *
+ * @see https://stackoverflow.com/a/59906630/1060921
+ */
+declare type Tuple<T extends any[]> = Pick<T, Exclude<keyof T, ArrayLengthMutationKeys>> & {
+    [Symbol.iterator]: () => IterableIterator<ArrayItems<T>>;
+};
+
+export { }

package/dist/index.js

@@ -0,0 +1,306 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+class AbstractAssemblage {
+}
+
+const ReflectCustomPrefix = '__';
+const ReflectCustomSuffix = '__';
+const ReflectParamTypes = 'design:paramtypes';
+const ReflectIsAssemblageFlag = `is_assemblage`;
+const ReflectIsSingletonFlag = `is_singleton`;
+const ReflectIsControllerFlag = `is_controller`;
+const ReflectContextParamIndex = `context_param_index`;
+const ReflectConfigurationParamIndex = `config_param_index`;
+const ReflectMetadataParamIndex = `metadata_param_index`;
+
+const defineCustomMetadata = (a, o, n)=>{
+    Reflect.defineMetadata(`${ReflectCustomPrefix}${a}${ReflectCustomSuffix}`, o, n);
+};
+const getCustomMetadata = (a, o)=>{
+    return Reflect.getMetadata(`${ReflectCustomPrefix}${a}${ReflectCustomSuffix}`, o);
+};
+const getOwnCustomMetadata = (a, o)=>{
+    return Reflect.getOwnMetadata(`${ReflectCustomPrefix}${a}${ReflectCustomSuffix}`, o);
+};
+
+const Assemblage = (n)=>{
+    const s = n || {};
+    return (n)=>{
+        defineCustomMetadata(ReflectIsAssemblageFlag, true, n);
+        defineCustomMetadata(ReflectIsSingletonFlag, true, n);
+        for(const e in s){
+            if (s.hasOwnProperty(e)) {
+                switch(e){
+                    case 'singleton':
+                        {
+                            if (s.singleton === false) {
+                                defineCustomMetadata(ReflectIsSingletonFlag, false, n);
+                            }
+                            break;
+                        }
+                    case 'controller':
+                        {
+                            if (s.controller === true) {
+                                if (typeof s.path !== 'string') {
+                                    throw new Error(`Controller assemblage '${n.name}' must define a path.`);
+                                }
+                                defineCustomMetadata(ReflectIsControllerFlag, true, n);
+                            }
+                            break;
+                        }
+                    default:
+                        {
+                            defineCustomMetadata(e, s[e], n);
+                        }
+                }
+            }
+        }
+        return n;
+    };
+};
+
+class AbstractAssembler {
+}
+
+const NoOp = (...e)=>{};
+const isClass = (e)=>{
+    return e && typeof e === 'function' && typeof e.constructor !== 'undefined';
+};
+const isObject = (e)=>typeof e === 'object' && !Array.isArray(e) && !isClass(e);
+const switchCase = (e, t)=>(o, ...s)=>e[o] ? e[o](...s) : t ? t(o, ...s) : NoOp();
+const pipe = (...e)=>(t)=>e.reduce((e, t)=>t(e), t);
+const conditionally = (e)=>(t)=>{
+        return e.if(t) ? e.then(t) : e.else ? e.else(t) : undefined;
+    };
+
+const i = (n)=>{
+    return {
+        identifier: n[0],
+        concrete: n[0],
+        configuration: {}
+    };
+};
+const c = (r)=>{
+    const i = ()=>isClass(r[0]) && isClass(r[1]);
+    const c = ()=>isClass(r[0]) && isObject(r[1]);
+    const u = ()=>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 u();
+};
+const u = (n)=>{
+    return {
+        identifier: n[0],
+        concrete: n[1],
+        configuration: n[2]
+    };
+};
+const resolveInjectionTuple = (n)=>switchCase({
+        1: ()=>i(n),
+        2: ()=>c(n),
+        3: ()=>u(n)
+    }, ()=>{
+        throw new Error(`Injection tuple must be of length 1, 2 or 3.`);
+    })(n.length);
+
+function t(t, e, n) {
+    if (e in t) {
+        Object.defineProperty(t, e, {
+            value: n,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        t[e] = n;
+    }
+    return t;
+}
+class Injectable {
+    static of(t, e) {
+        return new Injectable(t, e);
+    }
+    build() {
+        if (this.singleton) return this.singleton;
+        const t = this.resolveDependencies();
+        const e = new this.concrete(...t);
+        if (this.isSingleton) {
+            this.singleton = e;
+        }
+        return e;
+    }
+    resolveDependencies() {
+        const t = [];
+        const i = getOwnCustomMetadata(ReflectContextParamIndex, this.concrete) || [];
+        const s = getOwnCustomMetadata(ReflectConfigurationParamIndex, this.concrete) || [];
+        const h = getCustomMetadata(ReflectMetadataParamIndex, this.concrete) || [];
+        let u = 0;
+        for (const e of this.dependencies){
+            if (i.includes(u)) {
+                t.push(this.context);
+                u++;
+                continue;
+            }
+            if (s.includes(u)) {
+                t.push(this.configuration);
+                u++;
+                continue;
+            }
+            if (h.includes(u)) {
+                t.push(this.metadata);
+                u++;
+                continue;
+            }
+            t.push(this.context.require(e));
+            u++;
+        }
+        return t;
+    }
+    get isSingleton() {
+        return getOwnCustomMetadata(ReflectIsSingletonFlag, this.concrete) || false;
+    }
+    get injections() {
+        return getOwnCustomMetadata('inject', this.concrete) || [];
+    }
+    get dependencies() {
+        return Reflect.getMetadata(ReflectParamTypes, this.concrete) || [];
+    }
+    get metadata() {
+        return getCustomMetadata('metadata', this.concrete) || {};
+    }
+    constructor(e, n){
+        t(this, "context", undefined);
+        t(this, "identifier", undefined);
+        t(this, "concrete", undefined);
+        t(this, "configuration", undefined);
+        t(this, "singleton", undefined);
+        this.context = n;
+        const i = resolveInjectionTuple(e);
+        this.identifier = i.identifier;
+        this.concrete = i.concrete;
+        this.configuration = i.configuration;
+        for (const t of this.injections){
+            this.context.register(t);
+        }
+    }
+}
+
+function e$2(e, r, t) {
+    if (r in e) {
+        Object.defineProperty(e, r, {
+            value: t,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        e[r] = t;
+    }
+    return e;
+}
+class AssemblerContext {
+    set(e, r) {
+        if (this.userData[e]) {
+            throw new Error(`Key '${e}' is already defined in context's user data.`);
+        }
+        this.userData[e] = r;
+        return this;
+    }
+    get(e) {
+        return this.userData[e];
+    }
+    constructor(r){
+        e$2(this, "userData", {});
+        e$2(this, "register", undefined);
+        e$2(this, "has", undefined);
+        e$2(this, "require", undefined);
+        this.register = r.register.bind(r);
+        this.has = r.has.bind(r);
+        this.require = r.require.bind(r);
+    }
+}
+
+function e$1(e, t, i) {
+    if (t in e) {
+        Object.defineProperty(e, t, {
+            value: i,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        e[t] = i;
+    }
+    return e;
+}
+class Assembler {
+    static build(e) {
+        return new Assembler(e);
+    }
+    register(e) {
+        const t = Injectable.of(e, this.context);
+        if (this.has(t.identifier)) {
+            throw new Error(`An assemblage is already registered with identifier '${t.identifier.name}'.`);
+        }
+        this.injectables.set(t.identifier, t);
+        return t;
+    }
+    has(e) {
+        return this.injectables.has(e);
+    }
+    require(e) {
+        if (!this.injectables.has(e)) {
+            throw new Error(`Assemblage with identifier '${e.name}' has not been registered.`);
+        }
+        const t = this.injectables.get(e);
+        return t.build();
+    }
+    constructor(r){
+        e$1(this, "injectables", new Map());
+        e$1(this, "context", undefined);
+        this.context = new AssemblerContext(this);
+        defineCustomMetadata(ReflectIsSingletonFlag, true, r);
+        const s = this.register([
+            r
+        ]);
+        return s.build();
+    }
+}
+
+const m = (o)=>()=>{
+        return (t, n, m)=>{
+            const s = getOwnCustomMetadata(o, t) || [];
+            s.push(m);
+            defineCustomMetadata(o, s, t);
+        };
+    };
+const s = m(ReflectContextParamIndex);
+const e = m(ReflectConfigurationParamIndex);
+const a = m(ReflectMetadataParamIndex);
+
+exports.AbstractAssemblage = AbstractAssemblage;
+exports.AbstractAssembler = AbstractAssembler;
+exports.Assemblage = Assemblage;
+exports.Assembler = Assembler;
+exports.Configuration = e;
+exports.Context = s;
+exports.Metadata = a;

package/dist/index.mjs

@@ -0,0 +1,296 @@
+class AbstractAssemblage {
+}
+
+const ReflectCustomPrefix = '__';
+const ReflectCustomSuffix = '__';
+const ReflectParamTypes = 'design:paramtypes';
+const ReflectIsAssemblageFlag = `is_assemblage`;
+const ReflectIsSingletonFlag = `is_singleton`;
+const ReflectIsControllerFlag = `is_controller`;
+const ReflectContextParamIndex = `context_param_index`;
+const ReflectConfigurationParamIndex = `config_param_index`;
+const ReflectMetadataParamIndex = `metadata_param_index`;
+
+const defineCustomMetadata = (a, o, n)=>{
+    Reflect.defineMetadata(`${ReflectCustomPrefix}${a}${ReflectCustomSuffix}`, o, n);
+};
+const getCustomMetadata = (a, o)=>{
+    return Reflect.getMetadata(`${ReflectCustomPrefix}${a}${ReflectCustomSuffix}`, o);
+};
+const getOwnCustomMetadata = (a, o)=>{
+    return Reflect.getOwnMetadata(`${ReflectCustomPrefix}${a}${ReflectCustomSuffix}`, o);
+};
+
+const Assemblage = (n)=>{
+    const s = n || {};
+    return (n)=>{
+        defineCustomMetadata(ReflectIsAssemblageFlag, true, n);
+        defineCustomMetadata(ReflectIsSingletonFlag, true, n);
+        for(const e in s){
+            if (s.hasOwnProperty(e)) {
+                switch(e){
+                    case 'singleton':
+                        {
+                            if (s.singleton === false) {
+                                defineCustomMetadata(ReflectIsSingletonFlag, false, n);
+                            }
+                            break;
+                        }
+                    case 'controller':
+                        {
+                            if (s.controller === true) {
+                                if (typeof s.path !== 'string') {
+                                    throw new Error(`Controller assemblage '${n.name}' must define a path.`);
+                                }
+                                defineCustomMetadata(ReflectIsControllerFlag, true, n);
+                            }
+                            break;
+                        }
+                    default:
+                        {
+                            defineCustomMetadata(e, s[e], n);
+                        }
+                }
+            }
+        }
+        return n;
+    };
+};
+
+class AbstractAssembler {
+}
+
+const NoOp = (...e)=>{};
+const isClass = (e)=>{
+    return e && typeof e === 'function' && typeof e.constructor !== 'undefined';
+};
+const isObject = (e)=>typeof e === 'object' && !Array.isArray(e) && !isClass(e);
+const switchCase = (e, t)=>(o, ...s)=>e[o] ? e[o](...s) : t ? t(o, ...s) : NoOp();
+const pipe = (...e)=>(t)=>e.reduce((e, t)=>t(e), t);
+const conditionally = (e)=>(t)=>{
+        return e.if(t) ? e.then(t) : e.else ? e.else(t) : undefined;
+    };
+
+const i = (n)=>{
+    return {
+        identifier: n[0],
+        concrete: n[0],
+        configuration: {}
+    };
+};
+const c = (r)=>{
+    const i = ()=>isClass(r[0]) && isClass(r[1]);
+    const c = ()=>isClass(r[0]) && isObject(r[1]);
+    const u = ()=>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 u();
+};
+const u = (n)=>{
+    return {
+        identifier: n[0],
+        concrete: n[1],
+        configuration: n[2]
+    };
+};
+const resolveInjectionTuple = (n)=>switchCase({
+        1: ()=>i(n),
+        2: ()=>c(n),
+        3: ()=>u(n)
+    }, ()=>{
+        throw new Error(`Injection tuple must be of length 1, 2 or 3.`);
+    })(n.length);
+
+function t(t, e, n) {
+    if (e in t) {
+        Object.defineProperty(t, e, {
+            value: n,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        t[e] = n;
+    }
+    return t;
+}
+class Injectable {
+    static of(t, e) {
+        return new Injectable(t, e);
+    }
+    build() {
+        if (this.singleton) return this.singleton;
+        const t = this.resolveDependencies();
+        const e = new this.concrete(...t);
+        if (this.isSingleton) {
+            this.singleton = e;
+        }
+        return e;
+    }
+    resolveDependencies() {
+        const t = [];
+        const i = getOwnCustomMetadata(ReflectContextParamIndex, this.concrete) || [];
+        const s = getOwnCustomMetadata(ReflectConfigurationParamIndex, this.concrete) || [];
+        const h = getCustomMetadata(ReflectMetadataParamIndex, this.concrete) || [];
+        let u = 0;
+        for (const e of this.dependencies){
+            if (i.includes(u)) {
+                t.push(this.context);
+                u++;
+                continue;
+            }
+            if (s.includes(u)) {
+                t.push(this.configuration);
+                u++;
+                continue;
+            }
+            if (h.includes(u)) {
+                t.push(this.metadata);
+                u++;
+                continue;
+            }
+            t.push(this.context.require(e));
+            u++;
+        }
+        return t;
+    }
+    get isSingleton() {
+        return getOwnCustomMetadata(ReflectIsSingletonFlag, this.concrete) || false;
+    }
+    get injections() {
+        return getOwnCustomMetadata('inject', this.concrete) || [];
+    }
+    get dependencies() {
+        return Reflect.getMetadata(ReflectParamTypes, this.concrete) || [];
+    }
+    get metadata() {
+        return getCustomMetadata('metadata', this.concrete) || {};
+    }
+    constructor(e, n){
+        t(this, "context", undefined);
+        t(this, "identifier", undefined);
+        t(this, "concrete", undefined);
+        t(this, "configuration", undefined);
+        t(this, "singleton", undefined);
+        this.context = n;
+        const i = resolveInjectionTuple(e);
+        this.identifier = i.identifier;
+        this.concrete = i.concrete;
+        this.configuration = i.configuration;
+        for (const t of this.injections){
+            this.context.register(t);
+        }
+    }
+}
+
+function e$2(e, r, t) {
+    if (r in e) {
+        Object.defineProperty(e, r, {
+            value: t,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        e[r] = t;
+    }
+    return e;
+}
+class AssemblerContext {
+    set(e, r) {
+        if (this.userData[e]) {
+            throw new Error(`Key '${e}' is already defined in context's user data.`);
+        }
+        this.userData[e] = r;
+        return this;
+    }
+    get(e) {
+        return this.userData[e];
+    }
+    constructor(r){
+        e$2(this, "userData", {});
+        e$2(this, "register", undefined);
+        e$2(this, "has", undefined);
+        e$2(this, "require", undefined);
+        this.register = r.register.bind(r);
+        this.has = r.has.bind(r);
+        this.require = r.require.bind(r);
+    }
+}
+
+function e$1(e, t, i) {
+    if (t in e) {
+        Object.defineProperty(e, t, {
+            value: i,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        e[t] = i;
+    }
+    return e;
+}
+class Assembler {
+    static build(e) {
+        return new Assembler(e);
+    }
+    register(e) {
+        const t = Injectable.of(e, this.context);
+        if (this.has(t.identifier)) {
+            throw new Error(`An assemblage is already registered with identifier '${t.identifier.name}'.`);
+        }
+        this.injectables.set(t.identifier, t);
+        return t;
+    }
+    has(e) {
+        return this.injectables.has(e);
+    }
+    require(e) {
+        if (!this.injectables.has(e)) {
+            throw new Error(`Assemblage with identifier '${e.name}' has not been registered.`);
+        }
+        const t = this.injectables.get(e);
+        return t.build();
+    }
+    constructor(r){
+        e$1(this, "injectables", new Map());
+        e$1(this, "context", undefined);
+        this.context = new AssemblerContext(this);
+        defineCustomMetadata(ReflectIsSingletonFlag, true, r);
+        const s = this.register([
+            r
+        ]);
+        return s.build();
+    }
+}
+
+const m = (o)=>()=>{
+        return (t, n, m)=>{
+            const s = getOwnCustomMetadata(o, t) || [];
+            s.push(m);
+            defineCustomMetadata(o, s, t);
+        };
+    };
+const s = m(ReflectContextParamIndex);
+const e = m(ReflectConfigurationParamIndex);
+const a = m(ReflectMetadataParamIndex);
+
+export { AbstractAssemblage, AbstractAssembler, Assemblage, Assembler, e as Configuration, s as Context, a as Metadata };

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "assemblerjs",
+  "description": "A simple and zero-dependency DI package written in typescript.",
+  "version": "0.0.9",
+  "author": "Benoît LAHOZ <info@benoitlahoz.io>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/benoitlahoz/assemblerjs"
+  },
+  "bugs": {
+    "url": "https://github.com/benoitlahoz/assemblerjs/issues"
+  },
+  "homepage": "https://github.com/benoitlahoz/assemblerjs#README",
+  "devDependencies": {
+    "@swc/core": "^1.9.3",
+    "@types/node": "^22.5.5",
+    "@vitest/coverage-istanbul": "^2.1.1",
+    "assert": "^2.1.0",
+    "istanbul": "^0.4.5",
+    "istanbul-badges-readme": "^1.9.0",
+    "reflect-metadata": ">=0.2.2",
+    "rollup-plugin-swc": "^0.2.1",
+    "terser": "^5.34.1",
+    "vite": "6.0.2",
+    "vite-plugin-dts": "^4.4.0",
+    "vitest": "^2.1.1"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist/**/*",
+    "README.md"
+  ],
+  "keywords": [
+    "composition",
+    "decorators",
+    "dependency",
+    "di",
+    "injection",
+    "reflection",
+    "swc",
+    "typescript"
+  ],
+  "license": "MIT",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "vite build",
+    "coverage": "vitest run --coverage --passWithNoTests && istanbul-badges-readme",
+    "test": "vitest --coverage --passWithNoTests"
+  },
+  "types": "dist/index.d.ts"
+}