@decaf-ts/decoration 0.0.6 → 0.0.8

package/lib/esm/decoration/types.d.ts

@@ -1,95 +1,80 @@
 import { DecoratorData } from "./Decoration";
 /**
- * @description Interface for the final stage of the decoration builder pattern
- * @summary Represents the build stage of the decoration builder, providing the ability to apply
- * the configured decorator to a target. This is the final stage in the builder chain.
- *
+ * @description Interface for the final stage of the decoration builder pattern.
+ * @summary Represents the build stage of the decoration builder, providing the ability to apply the configured decorator to a target. This is the final stage in the builder chain.
  * @interface DecorationBuilderBuild
+ * @memberOf module:decoration
  */
 export interface DecorationBuilderBuild {
     /**
-     * @description Creates and returns the decorator function
-     * @summary Finalizes the builder process and returns a decorator function that can be applied to a class,
-     * property, or method.
-     *
-     * @returns {function} A decorator function that can be applied to a target
+     * @description Creates and returns the decorator function.
+     * @summary Finalises the builder process and returns a decorator function that can be applied to a class, property, or method.
+     * @param {any} target Target constructor or prototype receiving the decorator.
+     * @param {any} [propertyKey] Property key when decorating a class member.
+     * @param {TypedPropertyDescriptor<any>} [descriptor] Descriptor supplied for method or accessor decoration.
+     * @return {ClassDecorator|MethodDecorator|PropertyDecorator|ParameterDecorator} Decorator function that can be applied to a target.
      */
     apply(): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
 }
 /**
- * @description Interface for the extension stage of the decoration builder pattern
- * @summary Represents the extension stage of the decoration builder, providing the ability to add
- * additional decorators to the existing configuration.
- *
+ * @description Interface for the extension stage of the decoration builder pattern.
+ * @summary Represents the extension stage of the decoration builder, providing the ability to add additional decorators to the existing configuration.
  * @interface DecorationBuilderEnd
  * @memberOf module:decoration
  */
 export interface DecorationBuilderEnd {
     /**
-     * @description Adds additional decorators to the existing configuration
-     * @summary Extends the current decorator configuration with additional decorators.
-     * This is useful for adding behavior to existing decorators.
-     *
-     * @param {...(ClassDecorator|PropertyDecorator|MethodDecorator)} decorators - Additional decorators to add
-     * @returns {DecorationBuilderBuild} The build stage of the builder pattern
+     * @description Adds additional decorators to the existing configuration.
+     * @summary Extends the current decorator configuration with additional decorators, making it useful for augmenting previously defined behaviour.
+     * @param {...DecoratorData} decorators Additional decorators to add.
+     * @return {DecorationBuilderBuild} The build stage of the builder pattern.
      */
     extend(...decorators: DecoratorData[]): DecorationBuilderBuild;
 }
 /**
- * @description Interface for the middle stage of the decoration builder pattern
- * @summary Represents the middle stage of the decoration builder, extending the end stage
- * and providing the ability to define the primary decorators for the configuration.
- *
+ * @description Interface for the middle stage of the decoration builder pattern.
+ * @summary Represents the middle stage of the decoration builder, extending the end stage and providing the ability to define the primary decorators for the configuration.
  * @interface DecorationBuilderMid
  * @memberOf module:decoration
  */
 export interface DecorationBuilderMid extends DecorationBuilderEnd {
     /**
-     * @description Defines the primary decorators for the configuration
-     * @summary Sets the main decorators for the current context. This is typically
-     * called after specifying the key with the 'for' method.
+     * @description Defines the primary decorators for the configuration.
+     * @summary Sets the main decorators for the current context after specifying the key with the `for` method.
+     * @param {...DecoratorData} decorators Decorators to define for the current key and flavour.
+     * @return {DecorationBuilderEnd} Interface representing the remaining builder stages (also implements DecorationBuilderBuild).
      */
     define(...decorators: DecoratorData[]): DecorationBuilderEnd & DecorationBuilderBuild;
 }
 /**
- * @description Interface for the starting stage of the decoration builder pattern
- * @summary Represents the initial stage of the decoration builder, providing the entry point
- * for the builder pattern by specifying the key for the decorator.
- *
+ * @description Interface for the starting stage of the decoration builder pattern.
+ * @summary Represents the initial stage of the decoration builder, providing the entry point for the builder pattern by specifying the key for the decorator.
  * @interface DecorationBuilderStart
  * @memberOf module:decoration
  */
 export interface DecorationBuilderStart {
     /**
-     * @description Specifies the key for the decorator
-     * @summary Sets the identifier for the decorator, which is used to register and retrieve
-     * the decorator in the decoration registry.
-     *
-     * @param {string} id - The identifier for the decorator
-     * @return {DecorationBuilderMid} The middle stage of the builder pattern
+     * @description Specifies the key for the decorator.
+     * @summary Sets the identifier for the decorator, which is used to register and retrieve the decorator in the decoration registry.
+     * @param {string} id Identifier for the decorator.
+     * @return {DecorationBuilderMid} The middle stage of the builder pattern.
      */
     for(id: string): DecorationBuilderMid;
 }
 /**
- * @description Comprehensive interface for the complete decoration builder pattern
- * @summary A unified interface that combines all stages of the decoration builder pattern,
- * providing a complete API for creating, configuring, and applying decorators.
- * This interface is implemented by the Decoration class.
- *
+ * @description Comprehensive interface for the complete decoration builder pattern.
+ * @summary Unified interface that combines all stages of the decoration builder pattern, providing a complete API for creating, configuring, and applying decorators. This interface is implemented by the Decoration class.
  * @interface IDecorationBuilder
  * @memberOf module:decoration
  */
 export interface IDecorationBuilder extends DecorationBuilderStart, DecorationBuilderMid, DecorationBuilderEnd, DecorationBuilderBuild {
 }
 /**
- * @description Type definition for a function that resolves the flavour for a target
- * @summary Defines a function type that determines the appropriate flavour for a given target object.
- * This is used by the Decoration class to resolve which flavour of decorator to apply based on the target.
- *
- * @typedef {function(object): string} FlavourResolver
- *
- * @param {object} target - The target object to resolve the flavour for
- * @return {string} The resolved flavour identifier
+ * @description Type definition for a function that resolves the flavour for a target.
+ * @summary Defines a function type that determines the appropriate flavour for a given target object, enabling flavour-aware decorator selection.
+ * @param {object} target Target object to resolve the flavour for.
+ * @return {string} Resolved flavour identifier.
+ * @typeDef FlavourResolver
  * @memberOf module:decoration
  */
 export type FlavourResolver = (target: object) => string;

package/lib/esm/decoration/types.js

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/decorators.d.ts

@@ -1,27 +1,74 @@
 /**
- * @description Assigns arbitrary metadata to a target using a string key
- * @summary Decorator factory that stores a key/value pair in the central Metadata store for the provided class or member.
- * @param {string} key The metadata key to associate with the target
- * @param {*} value The metadata value to store under the given key
- * @return A decorator that writes the metadata when applied
+ * @description Assigns arbitrary metadata to a target using a string key.
+ * @summary Decorator factory that stores a key/value pair in the central metadata store for the provided class or member.
+ * @param {string} key Metadata key to associate with the target.
+ * @param {any} value Metadata value to store under the given key.
+ * @return {ClassDecorator|MethodDecorator|PropertyDecorator|ParameterDecorator} Decorator that writes the metadata when applied.
  * @function metadata
  * @category Decorators
  */
-export declare function metadata(key: string, value: any): (model: any, prop?: any, descriptor?: PropertyDescriptor) => void;
+export declare function metadata(key: string, value: any): (model: any, prop?: any, descriptor?: PropertyDescriptor | number) => void;
 /**
- * @description Captures and stores a property's design type
- * @summary Decorator factory that reads the reflected design:type for a property and registers it in the Metadata store under the properties map.
- * @return A decorator that records the property's type metadata when applied
+ * @description Captures and stores a property's design type.
+ * @summary Decorator factory that reads the reflected `design:type` for a property and registers it in the metadata store under the properties map.
+ * @return {PropertyDecorator} Decorator that records the property's type metadata when applied.
  * @function prop
  * @category Property Decorators
  */
 export declare function prop(): (model: object, prop: any) => void;
-export declare function method(): (obj: any, prop: any, descriptor: any) => void;
 /**
- * @description Decorator factory that applies multiple decorators to a single target
- * @summary Creates a composite decorator that applies multiple decorators in sequence, correctly handling class, method, and property decorators.
- * @param {Array<ClassDecorator | MethodDecorator | PropertyDecorator>} decorators - Array of decorators to apply
- * @return {Function} A decorator function that applies all provided decorators to the target
+ * @description Captures a single parameter type for the decorated method.
+ * @summary Decorator factory that ensures the method metadata is initialised and stores the reflected parameter constructor at the provided index.
+ * @return {ParameterDecorator} Decorator that records the parameter type when applied.
+ * @function param
+ * @category Parameter Decorators
+ * @mermaid
+ * sequenceDiagram
+ *   participant U as User Code
+ *   participant P as param()
+ *   participant M as Metadata
+ *   U->>P: param()(target, key, index)
+ *   P->>U: method()(target, key, descriptor)
+ *   P->>M: params(constructor, key)
+ *   M-->>P: parameter constructors[]
+ *   P->>M: set(methods.key.index, constructor)
+ *   P-->>U: parameter recorded
+ */
+export declare function param(): (model: object, prop: string | symbol | undefined, index: number) => void;
+/**
+ * @description Extends a parameter decorator with additional metadata.
+ * @summary Applies the default `param()` decorator and augments the stored metadata with an arbitrary key/value pair.
+ * @param {string} key Metadata key to associate with the parameter.
+ * @param {any} value Metadata value persisted under the given key.
+ * @return {ParameterDecorator} Decorator that records both the parameter design type and additional metadata.
+ * @function paramMetadata
+ * @category Parameter Decorators
+ */
+export declare function paramMetadata(key: string, value: any): (target: any, prop: any, index: number) => void;
+/**
+ * @description Records method design-time metadata.
+ * @summary Decorator factory that captures a method's reflected parameter and return types, storing them under the appropriate metadata keys so they can be inspected at runtime.
+ * @return {MethodDecorator} Decorator that persists the method's signature information into the metadata store when applied.
+ * @function method
+ * @mermaid
+ * sequenceDiagram
+ *   participant U as User Code
+ *   participant F as method()
+ *   participant M as Metadata
+ *   U->>F: method()(target, key, descriptor)
+ *   F->>U: Reflect.getOwnMetadata(design:paramtypes)
+ *   F->>U: Reflect.getOwnMetadata(design:returntype)
+ *   F->>M: set(methods.key.design:paramtypes, params)
+ *   F->>M: set(methods.key.design:returntype, returnType)
+ *   F-->>U: decorated function
+ * @category Method Decorators
+ */
+export declare function method(): (obj: any, prop?: any, descriptor?: any) => void;
+/**
+ * @description Decorator factory that applies multiple decorators to a single target.
+ * @summary Creates a composite decorator that applies multiple decorators in sequence, correctly handling class, method, property, and parameter decorators.
+ * @param {Array<ClassDecorator|MethodDecorator|PropertyDecorator|ParameterDecorator>} decorators Collection of decorators to apply.
+ * @return {ClassDecorator|MethodDecorator|PropertyDecorator|ParameterDecorator} Decorator function that applies all provided decorators to the target.
  * @function apply
  * @mermaid
  * sequenceDiagram
@@ -36,22 +83,32 @@ export declare function method(): (obj: any, prop: any, descriptor: any) => void
  *   end
  * @category Decorators
  */
-export declare function apply(...decorators: Array<ClassDecorator | MethodDecorator | PropertyDecorator>): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
+export declare function apply(...decorators: Array<ClassDecorator | MethodDecorator | PropertyDecorator | ParameterDecorator>): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor | number) => void;
 /**
- * @description Creates a property metadata decorator
- * @summary Convenience factory that combines metadata(key, value) and prop() to both set an arbitrary metadata key and record the property's design type.
- * @param {string} key The metadata key to set for the property
- * @param {*} value The metadata value to associate with the key
- * @return A decorator that sets the metadata and captures the property's type
+ * @description Creates a property metadata decorator.
+ * @summary Convenience factory that combines `metadata(key, value)` and `prop()` to both set an arbitrary metadata key and record the property's design type.
+ * @param {string} key Metadata key to set for the property.
+ * @param {any} value Metadata value to associate with the key.
+ * @return {PropertyDecorator} Decorator that sets the metadata and captures the property's type.
  * @function propMetadata
  * @category Property Decorators
  */
-export declare function propMetadata(key: string, value: any): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
+export declare function propMetadata(key: string, value: any): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor | number) => void;
+/**
+ * @description Creates a method metadata decorator.
+ * @summary Convenience factory that combines `metadata(key, value)` and `method()` to both set an arbitrary metadata key and record the method's design return and param types.
+ * @param {string} key Metadata key to set for the property.
+ * @param {any} value Metadata value to associate with the key.
+ * @return {PropertyDecorator} Decorator that sets the metadata and captures the property's type.
+ * @function methodMetadata
+ * @category Method Decorators
+ */
+export declare function methodMetadata(key: string, value: any): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor | number) => void;
 /**
- * @description Attaches a human-readable description to a class or member
- * @summary Decorator factory that stores a textual description in the Metadata store under the appropriate description key for a class or its property.
- * @param {string} desc The descriptive text to associate with the class or property
- * @return A decorator that records the description when applied
+ * @description Attaches a human-readable description to a class or member.
+ * @summary Decorator factory that stores a textual description in the metadata store under the appropriate description key for a class or its property.
+ * @param {string} desc Descriptive text to associate with the class or property.
+ * @return {ClassDecorator|MethodDecorator|PropertyDecorator} Decorator that records the description when applied.
  * @function description
  * @category Decorators
  */

package/lib/esm/decorators.js

@@ -1,11 +1,11 @@
 import { Metadata } from "./metadata/Metadata.js";
-import { DecorationKeys, ObjectKeySplitter } from "./constants.js";
+import { DecorationKeys } from "./constants.js";
 /**
- * @description Assigns arbitrary metadata to a target using a string key
- * @summary Decorator factory that stores a key/value pair in the central Metadata store for the provided class or member.
- * @param {string} key The metadata key to associate with the target
- * @param {*} value The metadata value to store under the given key
- * @return A decorator that writes the metadata when applied
+ * @description Assigns arbitrary metadata to a target using a string key.
+ * @summary Decorator factory that stores a key/value pair in the central metadata store for the provided class or member.
+ * @param {string} key Metadata key to associate with the target.
+ * @param {any} value Metadata value to store under the given key.
+ * @return {ClassDecorator|MethodDecorator|PropertyDecorator|ParameterDecorator} Decorator that writes the metadata when applied.
  * @function metadata
  * @category Decorators
  */
@@ -17,30 +17,93 @@ export function metadata(key, value) {
     };
 }
 /**
- * @description Captures and stores a property's design type
- * @summary Decorator factory that reads the reflected design:type for a property and registers it in the Metadata store under the properties map.
- * @return A decorator that records the property's type metadata when applied
+ * @description Captures and stores a property's design type.
+ * @summary Decorator factory that reads the reflected `design:type` for a property and registers it in the metadata store under the properties map.
+ * @return {PropertyDecorator} Decorator that records the property's type metadata when applied.
  * @function prop
  * @category Property Decorators
  */
 export function prop() {
     return function prop(model, prop) {
         const designType = Reflect.getOwnMetadata(DecorationKeys.DESIGN_TYPE, model, prop);
-        return metadata(`${DecorationKeys.PROPERTIES}.${prop}`, designType)(model, prop);
+        return metadata(Metadata.key(DecorationKeys.PROPERTIES, prop), designType)(model, prop);
     };
 }
+/**
+ * @description Captures a single parameter type for the decorated method.
+ * @summary Decorator factory that ensures the method metadata is initialised and stores the reflected parameter constructor at the provided index.
+ * @return {ParameterDecorator} Decorator that records the parameter type when applied.
+ * @function param
+ * @category Parameter Decorators
+ * @mermaid
+ * sequenceDiagram
+ *   participant U as User Code
+ *   participant P as param()
+ *   participant M as Metadata
+ *   U->>P: param()(target, key, index)
+ *   P->>U: method()(target, key, descriptor)
+ *   P->>M: params(constructor, key)
+ *   M-->>P: parameter constructors[]
+ *   P->>M: set(methods.key.index, constructor)
+ *   P-->>U: parameter recorded
+ */
+export function param() {
+    return function param(model, prop, index) {
+        if (!prop)
+            throw new Error(`The @param decorator can only be applied to methods`);
+        method()(model, prop, Object.getOwnPropertyDescriptor(model, prop));
+        const paramTpes = Metadata.params(model.constructor, prop);
+        if (!paramTpes)
+            throw new Error(`Missing parameter types for ${String(prop)}`);
+        if (index >= paramTpes.length)
+            throw new Error(`Parameter index ${index} out of range for ${String(prop)}`);
+        metadata(Metadata.key(DecorationKeys.METHODS, prop, index.toString()), paramTpes[index])(model, prop);
+    };
+}
+/**
+ * @description Extends a parameter decorator with additional metadata.
+ * @summary Applies the default `param()` decorator and augments the stored metadata with an arbitrary key/value pair.
+ * @param {string} key Metadata key to associate with the parameter.
+ * @param {any} value Metadata value persisted under the given key.
+ * @return {ParameterDecorator} Decorator that records both the parameter design type and additional metadata.
+ * @function paramMetadata
+ * @category Parameter Decorators
+ */
+export function paramMetadata(key, value) {
+    return function paramMetadata(target, prop, index) {
+        return apply(param(), metadata(Metadata.key(DecorationKeys.METHODS, prop, key), value))(target, prop, index);
+    };
+}
+/**
+ * @description Records method design-time metadata.
+ * @summary Decorator factory that captures a method's reflected parameter and return types, storing them under the appropriate metadata keys so they can be inspected at runtime.
+ * @return {MethodDecorator} Decorator that persists the method's signature information into the metadata store when applied.
+ * @function method
+ * @mermaid
+ * sequenceDiagram
+ *   participant U as User Code
+ *   participant F as method()
+ *   participant M as Metadata
+ *   U->>F: method()(target, key, descriptor)
+ *   F->>U: Reflect.getOwnMetadata(design:paramtypes)
+ *   F->>U: Reflect.getOwnMetadata(design:returntype)
+ *   F->>M: set(methods.key.design:paramtypes, params)
+ *   F->>M: set(methods.key.design:returntype, returnType)
+ *   F-->>U: decorated function
+ * @category Method Decorators
+ */
 export function method() {
     return function method(obj, prop, descriptor) {
         const designParams = Reflect.getOwnMetadata(DecorationKeys.DESIGN_PARAMS, obj, prop);
         const designReturn = Reflect.getOwnMetadata(DecorationKeys.DESIGN_RETURN, obj, prop);
-        return apply(metadata(`${DecorationKeys.METHODS}.${prop}.${DecorationKeys.DESIGN_PARAMS}`, designParams), metadata(`${DecorationKeys.METHODS}.${prop}.${DecorationKeys.DESIGN_RETURN}`, designReturn))(obj, prop, descriptor);
+        return apply(metadata(Metadata.key(DecorationKeys.METHODS, prop, DecorationKeys.DESIGN_PARAMS), designParams), metadata(Metadata.key(DecorationKeys.METHODS, prop, DecorationKeys.DESIGN_RETURN), designReturn))(obj, prop, descriptor);
     };
 }
 /**
- * @description Decorator factory that applies multiple decorators to a single target
- * @summary Creates a composite decorator that applies multiple decorators in sequence, correctly handling class, method, and property decorators.
- * @param {Array<ClassDecorator | MethodDecorator | PropertyDecorator>} decorators - Array of decorators to apply
- * @return {Function} A decorator function that applies all provided decorators to the target
+ * @description Decorator factory that applies multiple decorators to a single target.
+ * @summary Creates a composite decorator that applies multiple decorators in sequence, correctly handling class, method, property, and parameter decorators.
+ * @param {Array<ClassDecorator|MethodDecorator|PropertyDecorator|ParameterDecorator>} decorators Collection of decorators to apply.
+ * @return {ClassDecorator|MethodDecorator|PropertyDecorator|ParameterDecorator} Decorator function that applies all provided decorators to the target.
  * @function apply
  * @mermaid
  * sequenceDiagram
@@ -67,11 +130,11 @@ export function apply(...decorators) {
     };
 }
 /**
- * @description Creates a property metadata decorator
- * @summary Convenience factory that combines metadata(key, value) and prop() to both set an arbitrary metadata key and record the property's design type.
- * @param {string} key The metadata key to set for the property
- * @param {*} value The metadata value to associate with the key
- * @return A decorator that sets the metadata and captures the property's type
+ * @description Creates a property metadata decorator.
+ * @summary Convenience factory that combines `metadata(key, value)` and `prop()` to both set an arbitrary metadata key and record the property's design type.
+ * @param {string} key Metadata key to set for the property.
+ * @param {any} value Metadata value to associate with the key.
+ * @return {PropertyDecorator} Decorator that sets the metadata and captures the property's type.
  * @function propMetadata
  * @category Property Decorators
  */
@@ -79,10 +142,22 @@ export function propMetadata(key, value) {
     return apply(metadata(key, value), prop());
 }
 /**
- * @description Attaches a human-readable description to a class or member
- * @summary Decorator factory that stores a textual description in the Metadata store under the appropriate description key for a class or its property.
- * @param {string} desc The descriptive text to associate with the class or property
- * @return A decorator that records the description when applied
+ * @description Creates a method metadata decorator.
+ * @summary Convenience factory that combines `metadata(key, value)` and `method()` to both set an arbitrary metadata key and record the method's design return and param types.
+ * @param {string} key Metadata key to set for the property.
+ * @param {any} value Metadata value to associate with the key.
+ * @return {PropertyDecorator} Decorator that sets the metadata and captures the property's type.
+ * @function methodMetadata
+ * @category Method Decorators
+ */
+export function methodMetadata(key, value) {
+    return apply(metadata(key, value), method());
+}
+/**
+ * @description Attaches a human-readable description to a class or member.
+ * @summary Decorator factory that stores a textual description in the metadata store under the appropriate description key for a class or its property.
+ * @param {string} desc Descriptive text to associate with the class or property.
+ * @return {ClassDecorator|MethodDecorator|PropertyDecorator} Decorator that records the description when applied.
  * @function description
  * @category Decorators
  */
@@ -91,7 +166,7 @@ export function description(desc) {
         return metadata([
             DecorationKeys.DESCRIPTION,
             prop ? prop.toString() : DecorationKeys.CLASS,
-        ].join(ObjectKeySplitter), desc)(original, prop, descriptor);
+        ].join(Metadata.splitter), desc)(original, prop, descriptor);
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../../src/decorators.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,+BAA4B;AAC/C,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,uBAAoB;AAEhE;;;;;;;;GAQG;AACH,MAAM,UAAU,QAAQ,CAAC,GAAW,EAAE,KAAU;IAC9C,OAAO,SAAS,QAAQ,CACtB,KAAU,EAEV,IAAU;IACV,6DAA6D;IAC7D,UAA+B;QAE/B,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,KAAK,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;IAC7D,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,IAAI;IAClB,OAAO,SAAS,IAAI,CAAC,KAAa,EAAE,IAAS;QAC3C,MAAM,UAAU,GAAG,OAAO,CAAC,cAAc,CACvC,cAAc,CAAC,WAAW,EAC1B,KAAK,EACL,IAAI,CACL,CAAC;QACF,OAAO,QAAQ,CAAC,GAAG,cAAc,CAAC,UAAU,IAAI,IAAI,EAAE,EAAE,UAAU,CAAC,CACjE,KAAK,EACL,IAAI,CACL,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,MAAM;IACpB,OAAO,SAAS,MAAM,CAAC,GAAQ,EAAE,IAAS,EAAE,UAAe;QACzD,MAAM,YAAY,GAAG,OAAO,CAAC,cAAc,CACzC,cAAc,CAAC,aAAa,EAC5B,GAAG,EACH,IAAI,CACL,CAAC;QACF,MAAM,YAAY,GAAG,OAAO,CAAC,cAAc,CACzC,cAAc,CAAC,aAAa,EAC5B,GAAG,EACH,IAAI,CACL,CAAC;QACF,OAAO,KAAK,CACV,QAAQ,CACN,GAAG,cAAc,CAAC,OAAO,IAAI,IAAI,IAAI,cAAc,CAAC,aAAa,EAAE,EACnE,YAAY,CACb,EACD,QAAQ,CACN,GAAG,cAAc,CAAC,OAAO,IAAI,IAAI,IAAI,cAAc,CAAC,aAAa,EAAE,EACnE,YAAY,CACb,CACF,CAAC,GAAG,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC;IAC3B,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,KAAK,CACnB,GAAG,UAAuE;IAE1E,OAAO,CACL,MAAc,EACd,WAAuC,EACvC,UAA+B,EAC/B,EAAE;QACF,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;YACnC,IAAI,MAAM,YAAY,QAAQ,IAAI,CAAC,UAAU,EAAE,CAAC;gBAC7C,SAA4B,CAAC,MAAM,CAAC,CAAC;gBACtC,SAAS;YACX,CAAC;YACA,SAAiD,CAChD,MAAM,EACN,WAA8B,EAC9B,UAA8C,CAC/C,CAAC;QACJ,CAAC;IACH,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,YAAY,CAAC,GAAW,EAAE,KAAU;IAClD,OAAO,KAAK,CAAC,QAAQ,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC;AAC7C,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,WAAW,CAAC,IAAY;IACtC,OAAO,SAAS,WAAW,CAAC,QAAa,EAAE,IAAU,EAAE,UAAgB;QACrE,OAAO,QAAQ,CACb;YACE,cAAc,CAAC,WAAW;YAC1B,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,cAAc,CAAC,KAAK;SAC9C,CAAC,IAAI,CAAC,iBAAiB,CAAC,EACzB,IAAI,CACL,CAAC,QAAQ,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC;IAChC,CAAC,CAAC;AACJ,CAAC","sourcesContent":["import { Metadata } from \"./metadata/Metadata\";\nimport { DecorationKeys, ObjectKeySplitter } from \"./constants\";\n\n/**\n * @description Assigns arbitrary metadata to a target using a string key\n * @summary Decorator factory that stores a key/value pair in the central Metadata store for the provided class or member.\n * @param {string} key The metadata key to associate with the target\n * @param {*} value The metadata value to store under the given key\n * @return A decorator that writes the metadata when applied\n * @function metadata\n * @category Decorators\n */\nexport function metadata(key: string, value: any) {\n  return function metadata(\n    model: any,\n\n    prop?: any,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    descriptor?: PropertyDescriptor\n  ) {\n    Metadata.set(prop ? model.constructor : model, key, value);\n  };\n}\n\n/**\n * @description Captures and stores a property's design type\n * @summary Decorator factory that reads the reflected design:type for a property and registers it in the Metadata store under the properties map.\n * @return A decorator that records the property's type metadata when applied\n * @function prop\n * @category Property Decorators\n */\nexport function prop() {\n  return function prop(model: object, prop: any) {\n    const designType = Reflect.getOwnMetadata(\n      DecorationKeys.DESIGN_TYPE,\n      model,\n      prop\n    );\n    return metadata(`${DecorationKeys.PROPERTIES}.${prop}`, designType)(\n      model,\n      prop\n    );\n  };\n}\n\nexport function method() {\n  return function method(obj: any, prop: any, descriptor: any) {\n    const designParams = Reflect.getOwnMetadata(\n      DecorationKeys.DESIGN_PARAMS,\n      obj,\n      prop\n    );\n    const designReturn = Reflect.getOwnMetadata(\n      DecorationKeys.DESIGN_RETURN,\n      obj,\n      prop\n    );\n    return apply(\n      metadata(\n        `${DecorationKeys.METHODS}.${prop}.${DecorationKeys.DESIGN_PARAMS}`,\n        designParams\n      ),\n      metadata(\n        `${DecorationKeys.METHODS}.${prop}.${DecorationKeys.DESIGN_RETURN}`,\n        designReturn\n      )\n    )(obj, prop, descriptor);\n  };\n}\n\n/**\n * @description Decorator factory that applies multiple decorators to a single target\n * @summary Creates a composite decorator that applies multiple decorators in sequence, correctly handling class, method, and property decorators.\n * @param {Array<ClassDecorator | MethodDecorator | PropertyDecorator>} decorators - Array of decorators to apply\n * @return {Function} A decorator function that applies all provided decorators to the target\n * @function apply\n * @mermaid\n * sequenceDiagram\n *   participant U as User Code\n *   participant A as apply(...decorators)\n *   participant D as Decorator\n *   U->>A: get decorator(...decorators)\n *   A->>U: returns (target, key?, desc?) => void\n *   U->>A: invoke on target\n *   loop for each decorator\n *     A->>D: invoke appropriate decorator type\n *   end\n * @category Decorators\n */\nexport function apply(\n  ...decorators: Array<ClassDecorator | MethodDecorator | PropertyDecorator>\n) {\n  return (\n    target: object,\n    propertyKey?: string | symbol | unknown,\n    descriptor?: PropertyDescriptor\n  ) => {\n    for (const decorator of decorators) {\n      if (target instanceof Function && !descriptor) {\n        (decorator as ClassDecorator)(target);\n        continue;\n      }\n      (decorator as MethodDecorator | PropertyDecorator)(\n        target,\n        propertyKey as string | symbol,\n        descriptor as TypedPropertyDescriptor<unknown>\n      );\n    }\n  };\n}\n\n/**\n * @description Creates a property metadata decorator\n * @summary Convenience factory that combines metadata(key, value) and prop() to both set an arbitrary metadata key and record the property's design type.\n * @param {string} key The metadata key to set for the property\n * @param {*} value The metadata value to associate with the key\n * @return A decorator that sets the metadata and captures the property's type\n * @function propMetadata\n * @category Property Decorators\n */\nexport function propMetadata(key: string, value: any) {\n  return apply(metadata(key, value), prop());\n}\n\n/**\n * @description Attaches a human-readable description to a class or member\n * @summary Decorator factory that stores a textual description in the Metadata store under the appropriate description key for a class or its property.\n * @param {string} desc The descriptive text to associate with the class or property\n * @return A decorator that records the description when applied\n * @function description\n * @category Decorators\n */\nexport function description(desc: string) {\n  return function description(original: any, prop?: any, descriptor?: any) {\n    return metadata(\n      [\n        DecorationKeys.DESCRIPTION,\n        prop ? prop.toString() : DecorationKeys.CLASS,\n      ].join(ObjectKeySplitter),\n      desc\n    )(original, prop, descriptor);\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../../src/decorators.ts"],"names":[],"mappings":"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","sourcesContent":["import { Metadata } from \"./metadata/Metadata\";\nimport { DecorationKeys } from \"./constants\";\n\n/**\n * @description Assigns arbitrary metadata to a target using a string key.\n * @summary Decorator factory that stores a key/value pair in the central metadata store for the provided class or member.\n * @param {string} key Metadata key to associate with the target.\n * @param {any} value Metadata value to store under the given key.\n * @return {ClassDecorator|MethodDecorator|PropertyDecorator|ParameterDecorator} Decorator that writes the metadata when applied.\n * @function metadata\n * @category Decorators\n */\nexport function metadata(key: string, value: any) {\n  return function metadata(\n    model: any,\n\n    prop?: any,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    descriptor?: PropertyDescriptor | number\n  ) {\n    Metadata.set(prop ? model.constructor : model, key, value);\n  };\n}\n\n/**\n * @description Captures and stores a property's design type.\n * @summary Decorator factory that reads the reflected `design:type` for a property and registers it in the metadata store under the properties map.\n * @return {PropertyDecorator} Decorator that records the property's type metadata when applied.\n * @function prop\n * @category Property Decorators\n */\nexport function prop() {\n  return function prop(model: object, prop: any) {\n    const designType = Reflect.getOwnMetadata(\n      DecorationKeys.DESIGN_TYPE,\n      model,\n      prop\n    );\n    return metadata(Metadata.key(DecorationKeys.PROPERTIES, prop), designType)(\n      model,\n      prop\n    );\n  };\n}\n\n/**\n * @description Captures a single parameter type for the decorated method.\n * @summary Decorator factory that ensures the method metadata is initialised and stores the reflected parameter constructor at the provided index.\n * @return {ParameterDecorator} Decorator that records the parameter type when applied.\n * @function param\n * @category Parameter Decorators\n * @mermaid\n * sequenceDiagram\n *   participant U as User Code\n *   participant P as param()\n *   participant M as Metadata\n *   U->>P: param()(target, key, index)\n *   P->>U: method()(target, key, descriptor)\n *   P->>M: params(constructor, key)\n *   M-->>P: parameter constructors[]\n *   P->>M: set(methods.key.index, constructor)\n *   P-->>U: parameter recorded\n */\nexport function param() {\n  return function param(\n    model: object,\n    prop: string | symbol | undefined,\n    index: number\n  ) {\n    if (!prop)\n      throw new Error(`The @param decorator can only be applied to methods`);\n    method()(model, prop, Object.getOwnPropertyDescriptor(model, prop));\n    const paramTpes = Metadata.params(model.constructor as any, prop as string);\n    if (!paramTpes)\n      throw new Error(`Missing parameter types for ${String(prop)}`);\n    if (index >= paramTpes.length)\n      throw new Error(\n        `Parameter index ${index} out of range for ${String(prop)}`\n      );\n    metadata(\n      Metadata.key(DecorationKeys.METHODS, prop as string, index.toString()),\n      paramTpes[index]\n    )(model, prop);\n  };\n}\n\n/**\n * @description Extends a parameter decorator with additional metadata.\n * @summary Applies the default `param()` decorator and augments the stored metadata with an arbitrary key/value pair.\n * @param {string} key Metadata key to associate with the parameter.\n * @param {any} value Metadata value persisted under the given key.\n * @return {ParameterDecorator} Decorator that records both the parameter design type and additional metadata.\n * @function paramMetadata\n * @category Parameter Decorators\n */\nexport function paramMetadata(key: string, value: any) {\n  return function paramMetadata(target: any, prop: any, index: number) {\n    return apply(\n      param(),\n      metadata(Metadata.key(DecorationKeys.METHODS, prop, key), value)\n    )(target, prop, index);\n  };\n}\n\n/**\n * @description Records method design-time metadata.\n * @summary Decorator factory that captures a method's reflected parameter and return types, storing them under the appropriate metadata keys so they can be inspected at runtime.\n * @return {MethodDecorator} Decorator that persists the method's signature information into the metadata store when applied.\n * @function method\n * @mermaid\n * sequenceDiagram\n *   participant U as User Code\n *   participant F as method()\n *   participant M as Metadata\n *   U->>F: method()(target, key, descriptor)\n *   F->>U: Reflect.getOwnMetadata(design:paramtypes)\n *   F->>U: Reflect.getOwnMetadata(design:returntype)\n *   F->>M: set(methods.key.design:paramtypes, params)\n *   F->>M: set(methods.key.design:returntype, returnType)\n *   F-->>U: decorated function\n * @category Method Decorators\n */\nexport function method() {\n  return function method(obj: any, prop?: any, descriptor?: any) {\n    const designParams = Reflect.getOwnMetadata(\n      DecorationKeys.DESIGN_PARAMS,\n      obj,\n      prop\n    );\n    const designReturn = Reflect.getOwnMetadata(\n      DecorationKeys.DESIGN_RETURN,\n      obj,\n      prop\n    );\n    return apply(\n      metadata(\n        Metadata.key(\n          DecorationKeys.METHODS,\n          prop,\n          DecorationKeys.DESIGN_PARAMS\n        ),\n        designParams\n      ),\n      metadata(\n        Metadata.key(\n          DecorationKeys.METHODS,\n          prop,\n          DecorationKeys.DESIGN_RETURN\n        ),\n        designReturn\n      )\n    )(obj, prop, descriptor);\n  };\n}\n\n/**\n * @description Decorator factory that applies multiple decorators to a single target.\n * @summary Creates a composite decorator that applies multiple decorators in sequence, correctly handling class, method, property, and parameter decorators.\n * @param {Array<ClassDecorator|MethodDecorator|PropertyDecorator|ParameterDecorator>} decorators Collection of decorators to apply.\n * @return {ClassDecorator|MethodDecorator|PropertyDecorator|ParameterDecorator} Decorator function that applies all provided decorators to the target.\n * @function apply\n * @mermaid\n * sequenceDiagram\n *   participant U as User Code\n *   participant A as apply(...decorators)\n *   participant D as Decorator\n *   U->>A: get decorator(...decorators)\n *   A->>U: returns (target, key?, desc?) => void\n *   U->>A: invoke on target\n *   loop for each decorator\n *     A->>D: invoke appropriate decorator type\n *   end\n * @category Decorators\n */\nexport function apply(\n  ...decorators: Array<\n    ClassDecorator | MethodDecorator | PropertyDecorator | ParameterDecorator\n  >\n) {\n  return (\n    target: object,\n    propertyKey?: string | symbol | unknown,\n    descriptor?: PropertyDescriptor | number\n  ) => {\n    for (const decorator of decorators) {\n      if (target instanceof Function && !descriptor) {\n        (decorator as ClassDecorator)(target);\n        continue;\n      }\n      (decorator as MethodDecorator | PropertyDecorator)(\n        target,\n        propertyKey as string | symbol,\n        descriptor as TypedPropertyDescriptor<unknown>\n      );\n    }\n  };\n}\n\n/**\n * @description Creates a property metadata decorator.\n * @summary Convenience factory that combines `metadata(key, value)` and `prop()` to both set an arbitrary metadata key and record the property's design type.\n * @param {string} key Metadata key to set for the property.\n * @param {any} value Metadata value to associate with the key.\n * @return {PropertyDecorator} Decorator that sets the metadata and captures the property's type.\n * @function propMetadata\n * @category Property Decorators\n */\nexport function propMetadata(key: string, value: any) {\n  return apply(metadata(key, value), prop());\n}\n\n/**\n * @description Creates a method metadata decorator.\n * @summary Convenience factory that combines `metadata(key, value)` and `method()` to both set an arbitrary metadata key and record the method's design return and param types.\n * @param {string} key Metadata key to set for the property.\n * @param {any} value Metadata value to associate with the key.\n * @return {PropertyDecorator} Decorator that sets the metadata and captures the property's type.\n * @function methodMetadata\n * @category Method Decorators\n */\nexport function methodMetadata(key: string, value: any) {\n  return apply(metadata(key, value), method());\n}\n\n/**\n * @description Attaches a human-readable description to a class or member.\n * @summary Decorator factory that stores a textual description in the metadata store under the appropriate description key for a class or its property.\n * @param {string} desc Descriptive text to associate with the class or property.\n * @return {ClassDecorator|MethodDecorator|PropertyDecorator} Decorator that records the description when applied.\n * @function description\n * @category Decorators\n */\nexport function description(desc: string) {\n  return function description(original: any, prop?: any, descriptor?: any) {\n    return metadata(\n      [\n        DecorationKeys.DESCRIPTION,\n        prop ? prop.toString() : DecorationKeys.CLASS,\n      ].join(Metadata.splitter),\n      desc\n    )(original, prop, descriptor);\n  };\n}\n"]}

package/lib/esm/index.d.ts

@@ -1,11 +1,10 @@
 /**
- * @description Root entry point for the decoration module
- * @summary Aggregates and re-exports the public API of the decoration library, including core classes like {@link Decoration}, utility decorators, metadata helpers, and constants. This module is the primary import surface for consumers and exposes:
+ * @description Root entry point for the decoration module.
+ * @summary Aggregates and re-exports the public API of the decoration library, including {@link Decoration}, decorator utilities from {@link module:decoration|./decorators}, {@link Metadata}, and shared constants such as {@link DecorationKeys} and {@link DefaultFlavour}. This is the primary import surface for consumers and exposes:
  * - Core builder: {@link Decoration}
- * - Decorator utilities: {@link module:decoration | decorators in ./decorators}
+ * - Decorator utilities: {@link module:decoration|decorators in ./decorators}
  * - Metadata utilities: {@link Metadata}
  * - Constants and enums: {@link DecorationKeys}, {@link DefaultFlavour}
- *
  * @module decoration
  */
 export * from "./decoration";
@@ -18,4 +17,4 @@ export * from "./decorators";
  * @const VERSION
  * @memberOf module:decoration
  */
-export declare const VERSION = "0.0.6";
+export declare const VERSION = "0.0.8";

package/lib/esm/index.js

@@ -1,11 +1,10 @@
 /**
- * @description Root entry point for the decoration module
- * @summary Aggregates and re-exports the public API of the decoration library, including core classes like {@link Decoration}, utility decorators, metadata helpers, and constants. This module is the primary import surface for consumers and exposes:
+ * @description Root entry point for the decoration module.
+ * @summary Aggregates and re-exports the public API of the decoration library, including {@link Decoration}, decorator utilities from {@link module:decoration|./decorators}, {@link Metadata}, and shared constants such as {@link DecorationKeys} and {@link DefaultFlavour}. This is the primary import surface for consumers and exposes:
  * - Core builder: {@link Decoration}
- * - Decorator utilities: {@link module:decoration | decorators in ./decorators}
+ * - Decorator utilities: {@link module:decoration|decorators in ./decorators}
  * - Metadata utilities: {@link Metadata}
  * - Constants and enums: {@link DecorationKeys}, {@link DefaultFlavour}
- *
  * @module decoration
  */
 import { Metadata } from "./metadata/index.js";
@@ -19,6 +18,6 @@ export * from "./decorators.js";
  * @const VERSION
  * @memberOf module:decoration
  */
-export const VERSION = "0.0.6";
+export const VERSION = "0.0.8";
 Metadata.registerLibrary("@decaf-ts/decoration", VERSION);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7OztHQVNHO0FBRUgsT0FBTyxFQUFFLFFBQVEsRUFBRSw0QkFBeUI7QUFFNUMsc0NBQTZCO0FBQzdCLG9DQUEyQjtBQUMzQiwrQkFBNEI7QUFDNUIsZ0NBQTZCO0FBRTdCOzs7OztHQUtHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sT0FBTyxHQUFHLGFBQWEsQ0FBQztBQUVyQyxRQUFRLENBQUMsZUFBZSxDQUFDLHNCQUFzQixFQUFFLE9BQU8sQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAZGVzY3JpcHRpb24gUm9vdCBlbnRyeSBwb2ludCBmb3IgdGhlIGRlY29yYXRpb24gbW9kdWxlXG4gKiBAc3VtbWFyeSBBZ2dyZWdhdGVzIGFuZCByZS1leHBvcnRzIHRoZSBwdWJsaWMgQVBJIG9mIHRoZSBkZWNvcmF0aW9uIGxpYnJhcnksIGluY2x1ZGluZyBjb3JlIGNsYXNzZXMgbGlrZSB7QGxpbmsgRGVjb3JhdGlvbn0sIHV0aWxpdHkgZGVjb3JhdG9ycywgbWV0YWRhdGEgaGVscGVycywgYW5kIGNvbnN0YW50cy4gVGhpcyBtb2R1bGUgaXMgdGhlIHByaW1hcnkgaW1wb3J0IHN1cmZhY2UgZm9yIGNvbnN1bWVycyBhbmQgZXhwb3NlczpcbiAqIC0gQ29yZSBidWlsZGVyOiB7QGxpbmsgRGVjb3JhdGlvbn1cbiAqIC0gRGVjb3JhdG9yIHV0aWxpdGllczoge0BsaW5rIG1vZHVsZTpkZWNvcmF0aW9uIHwgZGVjb3JhdG9ycyBpbiAuL2RlY29yYXRvcnN9XG4gKiAtIE1ldGFkYXRhIHV0aWxpdGllczoge0BsaW5rIE1ldGFkYXRhfVxuICogLSBDb25zdGFudHMgYW5kIGVudW1zOiB7QGxpbmsgRGVjb3JhdGlvbktleXN9LCB7QGxpbmsgRGVmYXVsdEZsYXZvdXJ9XG4gKlxuICogQG1vZHVsZSBkZWNvcmF0aW9uXG4gKi9cblxuaW1wb3J0IHsgTWV0YWRhdGEgfSBmcm9tIFwiLi9tZXRhZGF0YS9pbmRleFwiO1xuXG5leHBvcnQgKiBmcm9tIFwiLi9kZWNvcmF0aW9uXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9tZXRhZGF0YVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vY29uc3RhbnRzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kZWNvcmF0b3JzXCI7XG5cbi8qKlxuICogQGRlc2NyaXB0aW9uIEN1cnJlbnQgdmVyc2lvbiBvZiB0aGUgcmVmbGVjdGlvbiBwYWNrYWdlXG4gKiBAc3VtbWFyeSBTdG9yZXMgdGhlIHNlbWFudGljIHZlcnNpb24gbnVtYmVyIG9mIHRoZSBwYWNrYWdlXG4gKiBAY29uc3QgVkVSU0lPTlxuICogQG1lbWJlck9mIG1vZHVsZTpkZWNvcmF0aW9uXG4gKi9cbmV4cG9ydCBjb25zdCBWRVJTSU9OID0gXCIjI1ZFUlNJT04jI1wiO1xuXG5NZXRhZGF0YS5yZWdpc3RlckxpYnJhcnkoXCJAZGVjYWYtdHMvZGVjb3JhdGlvblwiLCBWRVJTSU9OKTtcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7O0dBUUc7QUFFSCxPQUFPLEVBQUUsUUFBUSxFQUFFLDRCQUF5QjtBQUU1QyxzQ0FBNkI7QUFDN0Isb0NBQTJCO0FBQzNCLCtCQUE0QjtBQUM1QixnQ0FBNkI7QUFFN0I7Ozs7O0dBS0c7QUFDSCxNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsYUFBYSxDQUFDO0FBRXJDLFFBQVEsQ0FBQyxlQUFlLENBQUMsc0JBQXNCLEVBQUUsT0FBTyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBkZXNjcmlwdGlvbiBSb290IGVudHJ5IHBvaW50IGZvciB0aGUgZGVjb3JhdGlvbiBtb2R1bGUuXG4gKiBAc3VtbWFyeSBBZ2dyZWdhdGVzIGFuZCByZS1leHBvcnRzIHRoZSBwdWJsaWMgQVBJIG9mIHRoZSBkZWNvcmF0aW9uIGxpYnJhcnksIGluY2x1ZGluZyB7QGxpbmsgRGVjb3JhdGlvbn0sIGRlY29yYXRvciB1dGlsaXRpZXMgZnJvbSB7QGxpbmsgbW9kdWxlOmRlY29yYXRpb258Li9kZWNvcmF0b3JzfSwge0BsaW5rIE1ldGFkYXRhfSwgYW5kIHNoYXJlZCBjb25zdGFudHMgc3VjaCBhcyB7QGxpbmsgRGVjb3JhdGlvbktleXN9IGFuZCB7QGxpbmsgRGVmYXVsdEZsYXZvdXJ9LiBUaGlzIGlzIHRoZSBwcmltYXJ5IGltcG9ydCBzdXJmYWNlIGZvciBjb25zdW1lcnMgYW5kIGV4cG9zZXM6XG4gKiAtIENvcmUgYnVpbGRlcjoge0BsaW5rIERlY29yYXRpb259XG4gKiAtIERlY29yYXRvciB1dGlsaXRpZXM6IHtAbGluayBtb2R1bGU6ZGVjb3JhdGlvbnxkZWNvcmF0b3JzIGluIC4vZGVjb3JhdG9yc31cbiAqIC0gTWV0YWRhdGEgdXRpbGl0aWVzOiB7QGxpbmsgTWV0YWRhdGF9XG4gKiAtIENvbnN0YW50cyBhbmQgZW51bXM6IHtAbGluayBEZWNvcmF0aW9uS2V5c30sIHtAbGluayBEZWZhdWx0Rmxhdm91cn1cbiAqIEBtb2R1bGUgZGVjb3JhdGlvblxuICovXG5cbmltcG9ydCB7IE1ldGFkYXRhIH0gZnJvbSBcIi4vbWV0YWRhdGEvaW5kZXhcIjtcblxuZXhwb3J0ICogZnJvbSBcIi4vZGVjb3JhdGlvblwiO1xuZXhwb3J0ICogZnJvbSBcIi4vbWV0YWRhdGFcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2NvbnN0YW50c1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vZGVjb3JhdG9yc1wiO1xuXG4vKipcbiAqIEBkZXNjcmlwdGlvbiBDdXJyZW50IHZlcnNpb24gb2YgdGhlIHJlZmxlY3Rpb24gcGFja2FnZVxuICogQHN1bW1hcnkgU3RvcmVzIHRoZSBzZW1hbnRpYyB2ZXJzaW9uIG51bWJlciBvZiB0aGUgcGFja2FnZVxuICogQGNvbnN0IFZFUlNJT05cbiAqIEBtZW1iZXJPZiBtb2R1bGU6ZGVjb3JhdGlvblxuICovXG5leHBvcnQgY29uc3QgVkVSU0lPTiA9IFwiIyNWRVJTSU9OIyNcIjtcblxuTWV0YWRhdGEucmVnaXN0ZXJMaWJyYXJ5KFwiQGRlY2FmLXRzL2RlY29yYXRpb25cIiwgVkVSU0lPTik7XG4iXX0=