@decaf-ts/decoration 0.0.2 → 0.0.4

package/dist/decoration.esm.cjs

@@ -27,10 +27,13 @@ const ObjectKeySplitter = ".";
  */
 var DecorationKeys;
 (function (DecorationKeys) {
+    DecorationKeys["LIBRARIES"] = "libraries";
     /** Storage key used on the constructor to mirror runtime metadata */
     DecorationKeys["REFLECT"] = "__decaf";
     /** Map of model property keys to their reflected design types */
     DecorationKeys["PROPERTIES"] = "properties";
+    /** Map of model method keys to their reflected design params and return types */
+    DecorationKeys["METHODS"] = "methods";
     /** Key under which the model's constructor is stored */
     DecorationKeys["CLASS"] = "class";
     /** Container of human-friendly descriptions per class and property */
@@ -61,6 +64,217 @@ const DefaultMetadata = {
     [DecorationKeys.PROPERTIES]: [],
 };
 
+/**
+ * @description Retrieves a nested value from an object given a path
+ * @summary Walks an object structure using a splitter-delimited path and returns the value at that location or undefined if any key is missing.
+ * @param {Record<string, any>} obj The object to traverse
+ * @param {string} path The path to the desired value (e.g., "a.b.c")
+ * @param {string} [splitter=ObjectKeySplitter] The delimiter used to split the path
+ * @return {*} The resolved value at the given path or undefined if not found
+ * @function getValueBySplitter
+ * @mermaid
+ * sequenceDiagram
+ *   participant C as Caller
+ *   participant F as getValueBySplitter
+ *   participant O as Object
+ *   C->>F: (obj, path, splitter)
+ *   F->>F: split path into keys
+ *   loop for each key
+ *     F->>O: access current[key]
+ *     alt missing or nullish
+ *       F-->>C: return undefined
+ *     end
+ *   end
+ *   F-->>C: return final value
+ * @memberOf module:decoration
+ */
+function getValueBySplitter(obj, path, splitter = ObjectKeySplitter) {
+    const keys = path.split(splitter);
+    let current = obj;
+    for (const key of keys) {
+        if (current === null ||
+            current === undefined ||
+            !Object.prototype.hasOwnProperty.call(current, key))
+            return undefined;
+        current = current[key];
+    }
+    return current;
+}
+/**
+ * @description Sets a nested value on an object given a path
+ * @summary Traverses or creates intermediate objects following a splitter-delimited path and assigns the provided value at the destination key.
+ * @param {Record<string, any>} obj The object to mutate
+ * @param {string} path The destination path (e.g., "a.b.c")
+ * @param {*} value The value to set at the destination
+ * @param {string} [splitter=ObjectKeySplitter] The delimiter used to split the path
+ * @return {void}
+ * @function setValueBySplitter
+ * @mermaid
+ * sequenceDiagram
+ *   participant C as Caller
+ *   participant F as setValueBySplitter
+ *   participant O as Object
+ *   C->>F: (obj, path, value, splitter)
+ *   F->>F: split path into keys
+ *   loop for each key
+ *     alt key missing
+ *       F->>O: create intermediate object
+ *     else key exists
+ *       F->>O: descend into existing object
+ *     end
+ *   end
+ *   F-->>C: void
+ * @memberOf module:decoration
+ */
+function setValueBySplitter(obj, path, value, splitter = ObjectKeySplitter) {
+    const keys = path.split(splitter).filter((k) => k.length > 0);
+    if (keys.length === 0)
+        return;
+    let current = obj;
+    for (let i = 0; i < keys.length - 1; i++) {
+        const key = keys[i];
+        if (current[key] === undefined ||
+            current[key] === null ||
+            typeof current[key] !== "object") {
+            current[key] = {};
+        }
+        current = current[key];
+    }
+    const lastKey = keys[keys.length - 1];
+    current[lastKey] = value;
+}
+/**
+ * @description Centralized runtime metadata store bound to constructors
+ * @summary Provides utilities to read and write structured metadata for classes and their members, with optional mirroring onto the constructor via a well-known symbol key. Supports nested key paths using a configurable splitter and offers both instance and static APIs.
+ * @template M The model type the metadata belongs to
+ * @template META Extends BasicMetadata<M> representing the metadata structure
+ * @class
+ * @example
+ * // Define and read metadata for a class
+ * class User { name!: string }
+ * Metadata.set(User, "description.class", "A user model");
+ * Metadata.set(User, "properties.name", String);
+ * const desc = Metadata.get(User, "description.class"); // "A user model"
+ * const type = Metadata.type(User, "name"); // String
+ * @mermaid
+ * sequenceDiagram
+ *   participant C as Constructor
+ *   participant S as Metadata (static)
+ *   C->>S: set(User, "properties.name", String)
+ *   C->>S: get(User, "properties.name")
+ *   S-->>C: String
+ */
+class Metadata {
+    /**
+     * @description In-memory storage of metadata by constructor symbol
+     * @summary Maps a Symbol derived from the constructor to its metadata object, enabling efficient lookup.
+     */
+    static { this._metadata = {}; }
+    /**
+     * @description Path delimiter for nested metadata keys
+     * @summary Used by get/set operations to navigate nested structures, defaults to ObjectKeySplitter.
+     */
+    static { this.splitter = ObjectKeySplitter; }
+    /**
+     * @description Symbol key used to mirror metadata on the constructor
+     * @summary When mirroring is enabled, the metadata object is defined on the constructor under this non-enumerable key.
+     */
+    static { this.baseKey = DecorationKeys.REFLECT; }
+    /**
+     * @description Controls whether metadata is mirrored onto the constructor
+     * @summary When true, the metadata object is defined on the constructor under the non-enumerable baseKey.
+     */
+    static { this.mirror = true; }
+    constructor() { }
+    /**
+     * @description Lists known property keys for a model
+     * @summary Reads the metadata entry and returns the names of properties that have recorded type information.
+     * @param {Constructor} model The target constructor
+     * @return {string[]|undefined} Array of property names or undefined if no metadata exists
+     */
+    static properties(model) {
+        const meta = this.get(model);
+        if (!meta)
+            return undefined;
+        return Object.keys(meta.properties);
+    }
+    /**
+     * @description Retrieves a human-readable description for a class or a property
+     * @summary Looks up the description stored under the metadata "description" map. If a property key is provided, returns the property's description; otherwise returns the class description.
+     * @template M
+     * @param {Constructor<M>} model The target constructor whose description is being retrieved
+     * @param {string} [prop] Optional property key for which to fetch the description
+     * @return {string|undefined} The description text if present, otherwise undefined
+     */
+    static description(model, prop) {
+        return this.get(model, [DecorationKeys.DESCRIPTION, prop ? prop : DecorationKeys.CLASS].join(ObjectKeySplitter));
+    }
+    /**
+     * @description Retrieves the recorded design type for a property
+     * @summary Reads the metadata entry under "properties.<prop>" to return the constructor recorded for the given property name.
+     * @param {Constructor} model The target constructor
+     * @param {string} prop The property name whose type should be returned
+     * @return {Constructor|undefined} The constructor reference of the property type or undefined if not available
+     */
+    static type(model, prop) {
+        return this.get(model, `${DecorationKeys.PROPERTIES}.${prop}`);
+    }
+    /**
+     * @description Retrieves metadata for a model or a specific key within it
+     * @summary When called with a constructor only, returns the entire metadata object associated with the model. When a key path is provided, returns the value stored at that nested key.
+     * @template M
+     * @template META
+     * @param {Constructor<M> | string} model The target constructor used to locate the metadata record
+     * @param {string} [key] Optional nested key path to fetch a specific value
+     * @return {META|*|undefined} The metadata object, the value at the key path, or undefined if nothing exists
+     */
+    static get(model, key) {
+        const symbol = Symbol.for(model.toString());
+        return this.innerGet(symbol, key);
+    }
+    static innerGet(symbol, key) {
+        if (!this._metadata[symbol])
+            return undefined;
+        if (!key)
+            return this._metadata[symbol];
+        return getValueBySplitter(this._metadata[symbol], key, this.splitter);
+    }
+    static innerSet(symbol, key, value) {
+        if (!this._metadata[symbol])
+            this._metadata[symbol] = {};
+        setValueBySplitter(this._metadata[symbol], key, value, this.splitter);
+    }
+    /**
+     * @description Writes a metadata value at a given nested key path
+     * @summary Ensures the metadata record exists for the constructor, mirrors it on the constructor when enabled, and sets the provided value on the nested key path using the configured splitter.
+     * @template M
+     * @param {Constructor<M> | string} model The target constructor to which the metadata belongs
+     * @param {string} key The nested key path at which to store the value
+     * @param {*} value The value to store in the metadata
+     * @return {void}
+     */
+    static set(model, key, value) {
+        const symbol = Symbol.for(model.toString());
+        this.innerSet(symbol, key, value);
+        if (Metadata.mirror &&
+            !Object.prototype.hasOwnProperty.call(model, this.baseKey)) {
+            Object.defineProperty(model, this.baseKey, {
+                enumerable: false,
+                configurable: false,
+                writable: false,
+                value: this._metadata[symbol],
+            });
+        }
+    }
+    static registerLibrary(library, version) {
+        const symbol = Symbol.for(DecorationKeys.LIBRARIES);
+        const lib = this.innerGet(symbol, library);
+        if (lib)
+            throw new Error(`Library already ${library} registered with version ${version}`);
+        this.innerSet(symbol, library, version);
+    }
+}
+
 /**
  * @description Default resolver that returns the current default flavour
  * @summary Resolves the flavour for a given target by always returning the library's DefaultFlavour value.
@@ -168,6 +382,9 @@ class Decoration {
      * @return Builder instance for finishing the chain
      */
     define(...decorators) {
+        if (decorators.find((d) => typeof d === "object") &&
+            decorators.length !== 1)
+            throw new Error(`When using an overridable decorator, only one is allowed`);
         return this.decorate(false, ...decorators);
     }
     /**
@@ -177,6 +394,9 @@ class Decoration {
      * @return {DecorationBuilderBuild} Builder instance for building the decorator
      */
     extend(...decorators) {
+        if (decorators.find((d) => typeof d === "object") &&
+            decorators.length !== 1)
+            throw new Error(`When extending using an overridable decorator, only one is allowed`);
         return this.decorate(true, ...decorators);
     }
     /**
@@ -210,15 +430,6 @@ class Decoration {
             const extras = cache[flavour]
                 ? cache[flavour].extras
                 : cache[DefaultFlavour].extras;
-            const extraArgs = [
-                ...(cache[DefaultFlavour].extras
-                    ? cache[DefaultFlavour].extras.values()
-                    : []),
-            ].reduce((accum, e, i) => {
-                if (e.args)
-                    accum[i] = e.args;
-                return accum;
-            }, {});
             if (cache &&
                 cache[flavour] &&
                 cache[flavour].decorators &&
@@ -239,15 +450,11 @@ class Decoration {
                 ...(decorators ? decorators.values() : []),
                 ...(extras ? extras.values() : []),
             ];
-            return toApply.reduce((_, d, i) => {
+            return toApply.reduce((_, d) => {
                 switch (typeof d) {
                     case "object": {
-                        const { decorator, args } = d;
-                        const argz = args || i < (decorators ? decorators.size : 0)
-                            ? decoratorArgs[i]
-                            : extraArgs[i - (decorators ? decorators.size : 0)] ||
-                                (decorators ? decoratorArgs[i - decorators.size] : []);
-                        return decorator(...(argz || []))(target, propertyKey, descriptor);
+                        const { decorator } = d;
+                        return decorator(...(Object.values(decoratorArgs)[0] || []))(target, propertyKey, descriptor);
                     }
                     case "function":
                         return d(target, propertyKey, descriptor);
@@ -326,203 +533,6 @@ class Decoration {
     }
 }
 
-/**
- * @description Retrieves a nested value from an object given a path
- * @summary Walks an object structure using a splitter-delimited path and returns the value at that location or undefined if any key is missing.
- * @param {Record<string, any>} obj The object to traverse
- * @param {string} path The path to the desired value (e.g., "a.b.c")
- * @param {string} [splitter=ObjectKeySplitter] The delimiter used to split the path
- * @return {*} The resolved value at the given path or undefined if not found
- * @function getValueBySplitter
- * @mermaid
- * sequenceDiagram
- *   participant C as Caller
- *   participant F as getValueBySplitter
- *   participant O as Object
- *   C->>F: (obj, path, splitter)
- *   F->>F: split path into keys
- *   loop for each key
- *     F->>O: access current[key]
- *     alt missing or nullish
- *       F-->>C: return undefined
- *     end
- *   end
- *   F-->>C: return final value
- * @memberOf module:decoration
- */
-function getValueBySplitter(obj, path, splitter = ObjectKeySplitter) {
-    const keys = path.split(splitter);
-    let current = obj;
-    for (const key of keys) {
-        if (current === null ||
-            current === undefined ||
-            !Object.prototype.hasOwnProperty.call(current, key))
-            return undefined;
-        current = current[key];
-    }
-    return current;
-}
-/**
- * @description Sets a nested value on an object given a path
- * @summary Traverses or creates intermediate objects following a splitter-delimited path and assigns the provided value at the destination key.
- * @param {Record<string, any>} obj The object to mutate
- * @param {string} path The destination path (e.g., "a.b.c")
- * @param {*} value The value to set at the destination
- * @param {string} [splitter=ObjectKeySplitter] The delimiter used to split the path
- * @return {void}
- * @function setValueBySplitter
- * @mermaid
- * sequenceDiagram
- *   participant C as Caller
- *   participant F as setValueBySplitter
- *   participant O as Object
- *   C->>F: (obj, path, value, splitter)
- *   F->>F: split path into keys
- *   loop for each key
- *     alt key missing
- *       F->>O: create intermediate object
- *     else key exists
- *       F->>O: descend into existing object
- *     end
- *   end
- *   F-->>C: void
- * @memberOf module:decoration
- */
-function setValueBySplitter(obj, path, value, splitter = ObjectKeySplitter) {
-    const keys = path.split(splitter).filter((k) => k.length > 0);
-    if (keys.length === 0)
-        return;
-    let current = obj;
-    for (let i = 0; i < keys.length - 1; i++) {
-        const key = keys[i];
-        if (current[key] === undefined ||
-            current[key] === null ||
-            typeof current[key] !== "object") {
-            current[key] = {};
-        }
-        current = current[key];
-    }
-    const lastKey = keys[keys.length - 1];
-    current[lastKey] = value;
-}
-/**
- * @description Centralized runtime metadata store bound to constructors
- * @summary Provides utilities to read and write structured metadata for classes and their members, with optional mirroring onto the constructor via a well-known symbol key. Supports nested key paths using a configurable splitter and offers both instance and static APIs.
- * @template M The model type the metadata belongs to
- * @template META Extends BasicMetadata<M> representing the metadata structure
- * @class
- * @example
- * // Define and read metadata for a class
- * class User { name!: string }
- * Metadata.set(User, "description.class", "A user model");
- * Metadata.set(User, "properties.name", String);
- * const desc = Metadata.get(User, "description.class"); // "A user model"
- * const type = Metadata.type(User, "name"); // String
- * @mermaid
- * sequenceDiagram
- *   participant C as Constructor
- *   participant S as Metadata (static)
- *   C->>S: set(User, "properties.name", String)
- *   C->>S: get(User, "properties.name")
- *   S-->>C: String
- */
-class Metadata {
-    /**
-     * @description In-memory storage of metadata by constructor symbol
-     * @summary Maps a Symbol derived from the constructor to its metadata object, enabling efficient lookup.
-     */
-    static { this._metadata = {}; }
-    /**
-     * @description Path delimiter for nested metadata keys
-     * @summary Used by get/set operations to navigate nested structures, defaults to ObjectKeySplitter.
-     */
-    static { this.splitter = ObjectKeySplitter; }
-    /**
-     * @description Symbol key used to mirror metadata on the constructor
-     * @summary When mirroring is enabled, the metadata object is defined on the constructor under this non-enumerable key.
-     */
-    static { this.baseKey = DecorationKeys.REFLECT; }
-    /**
-     * @description Controls whether metadata is mirrored onto the constructor
-     * @summary When true, the metadata object is defined on the constructor under the non-enumerable baseKey.
-     */
-    static { this.mirror = true; }
-    constructor() { }
-    /**
-     * @description Lists known property keys for a model
-     * @summary Reads the metadata entry and returns the names of properties that have recorded type information.
-     * @param {Constructor} model The target constructor
-     * @return {string[]|undefined} Array of property names or undefined if no metadata exists
-     */
-    static properties(model) {
-        const meta = this.get(model);
-        if (!meta)
-            return undefined;
-        return Object.keys(meta.properties);
-    }
-    /**
-     * @description Retrieves a human-readable description for a class or a property
-     * @summary Looks up the description stored under the metadata "description" map. If a property key is provided, returns the property's description; otherwise returns the class description.
-     * @template M
-     * @param {Constructor<M>} model The target constructor whose description is being retrieved
-     * @param {string} [prop] Optional property key for which to fetch the description
-     * @return {string|undefined} The description text if present, otherwise undefined
-     */
-    static description(model, prop) {
-        return this.get(model, [DecorationKeys.DESCRIPTION, prop ? prop : DecorationKeys.CLASS].join(ObjectKeySplitter));
-    }
-    /**
-     * @description Retrieves the recorded design type for a property
-     * @summary Reads the metadata entry under "properties.<prop>" to return the constructor recorded for the given property name.
-     * @param {Constructor} model The target constructor
-     * @param {string} prop The property name whose type should be returned
-     * @return {Constructor|undefined} The constructor reference of the property type or undefined if not available
-     */
-    static type(model, prop) {
-        return this.get(model, `${DecorationKeys.PROPERTIES}.${prop}`);
-    }
-    /**
-     * @description Retrieves metadata for a model or a specific key within it
-     * @summary When called with a constructor only, returns the entire metadata object associated with the model. When a key path is provided, returns the value stored at that nested key.
-     * @template M
-     * @template META
-     * @param {Constructor<M>} model The target constructor used to locate the metadata record
-     * @param {string} [key] Optional nested key path to fetch a specific value
-     * @return {META|*|undefined} The metadata object, the value at the key path, or undefined if nothing exists
-     */
-    static get(model, key) {
-        const symbol = Symbol.for(model.toString());
-        if (!this._metadata[symbol])
-            return undefined;
-        if (!key)
-            return this._metadata[symbol];
-        return getValueBySplitter(this._metadata[symbol], key, this.splitter);
-    }
-    /**
-     * @description Writes a metadata value at a given nested key path
-     * @summary Ensures the metadata record exists for the constructor, mirrors it on the constructor when enabled, and sets the provided value on the nested key path using the configured splitter.
-     * @param {Constructor} model The target constructor to which the metadata belongs
-     * @param {string} key The nested key path at which to store the value
-     * @param {*} value The value to store in the metadata
-     * @return {void}
-     */
-    static set(model, key, value) {
-        const symbol = Symbol.for(model.toString());
-        if (!this._metadata[symbol])
-            this._metadata[symbol] = {};
-        if (Metadata.mirror &&
-            !Object.prototype.hasOwnProperty.call(model, this.baseKey)) {
-            Object.defineProperty(model, this.baseKey, {
-                enumerable: false,
-                configurable: false,
-                writable: false,
-                value: this._metadata[symbol],
-            });
-        }
-        setValueBySplitter(this._metadata[symbol], key, value, this.splitter);
-    }
-}
-
 /**
  * @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.
@@ -552,6 +562,13 @@ function prop() {
         return metadata(`${DecorationKeys.PROPERTIES}.${prop}`, designType)(model, prop);
     };
 }
+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);
+    };
+}
 /**
  * @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.
@@ -627,7 +644,8 @@ function description(desc) {
  * @const VERSION
  * @memberOf module:decoration
  */
-const VERSION = "0.0.2";
+const VERSION = "0.0.4";
+Metadata.registerLibrary("@decaf-ts/decoration", VERSION);
 
-export { Decoration, DecorationKeys, DefaultFlavour, DefaultMetadata, Metadata, ObjectKeySplitter, VERSION, apply, description, metadata, prop, propMetadata };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"decoration.esm.cjs","sources":["../src/constants.ts","../src/decoration/Decoration.ts","../src/metadata/Metadata.ts","../src/decorators.ts","../src/index.ts"],"sourcesContent":["import { BasicMetadata } from \"./metadata/types\";\n\n/**\n * @description Default flavour identifier for the decorator system\n * @summary Defines the default flavour used by the Decoration class when no specific flavour is provided.\n * This constant is used throughout the library as the fallback flavour for decorators.\n * @const DefaultFlavour\n * @memberOf module:decoration\n */\nexport const DefaultFlavour = \"decaf\";\n\n/**\n * @description Character used to split nested metadata keys\n * @summary The delimiter used by the metadata store to traverse nested object paths when reading/writing values.\n * @const ObjectKeySplitter\n * @memberOf module:decoration\n */\nexport const ObjectKeySplitter = \".\";\n\n/**\n * @description Enum containing metadata keys used for reflection in the model system\n * @summary Defines the various Model keys used for reflection and metadata storage.\n * These keys are used throughout the library to store and retrieve metadata about models,\n * their properties, and their behavior.\n * @readonly\n * @enum {string}\n * @readonly\n * @memberOf module:decoration\n */\nexport enum DecorationKeys {\n  /** Storage key used on the constructor to mirror runtime metadata */\n  REFLECT = `__${DefaultFlavour}`,\n  /** Map of model property keys to their reflected design types */\n  PROPERTIES = \"properties\",\n  /** Key under which the model's constructor is stored */\n  CLASS = \"class\",\n  /** Container of human-friendly descriptions per class and property */\n  DESCRIPTION = \"description\",\n  /** Reflect metadata key for design time type of a property */\n  DESIGN_TYPE = \"design:type\",\n  /** Reflect metadata key for constructor parameter types */\n  DESIGN_PARAMS = \"design:paramtypes\",\n  /** Reflect metadata key for method return type */\n  DESIGN_RETURN = \"design:returntype\",\n}\n\n/**\n * @description Typedef for the default metadata object shape\n * @summary Describes the minimal structure persisted for a model before any metadata is recorded.\n * @template M\n * @typedef {object} DefaultMetadataType<M>\n * @property {Record<string, Constructor | undefined>} properties - Mapping of property names to their design types\n * @memberOf module:decoration\n */\n\n/**\n * @description Default metadata instance\n * @summary Concrete default metadata object used when initializing metadata for a model\n * @type {DefaultMetadataType<any>}\n * @const DefaultMetadata\n * @memberOf module:decoration\n */\nexport const DefaultMetadata: BasicMetadata<any> = {\n  [DecorationKeys.PROPERTIES]: [],\n} as unknown as BasicMetadata<any>;\n","import {\n  DecorationBuilderBuild,\n  DecorationBuilderEnd,\n  DecorationBuilderMid,\n  DecorationBuilderStart,\n  FlavourResolver,\n  IDecorationBuilder,\n} from \"./types\";\nimport { DefaultFlavour } from \"../constants\";\n\n/**\n * @description Default resolver that returns the current default flavour\n * @summary Resolves the flavour for a given target by always returning the library's DefaultFlavour value.\n * @param {object} target The target object being decorated\n * @return {string} The resolved flavour identifier\n * @function defaultFlavourResolver\n * @memberOf module:decoration\n */\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nfunction defaultFlavourResolver(target: object) {\n  return DefaultFlavour;\n}\n\n/**\n * @description Union type covering supported decorator kinds\n * @summary Represents any of the standard TypeScript decorator signatures (class, property, or method), enabling flexible registration and application within the Decoration system.\n * @template T\n * @typeDef DecoratorTypes\n * @memberOf module:decoration\n */\nexport type DecoratorTypes =\n  | ClassDecorator\n  | PropertyDecorator\n  | MethodDecorator;\n\n/**\n * @description Type definition for a decorator factory function\n * @summary Represents a function that accepts arbitrary arguments and returns a concrete decorator function to be applied to a target.\n * @template A\n * @typeDef DecoratorFactory\n * @memberOf module:decoration\n */\nexport type DecoratorFactory = (...args: any[]) => DecoratorTypes;\n\n/**\n * @description Argument bundle for a decorator factory\n * @summary Object form used to defer decorator creation, carrying both the factory function and its argument list to be invoked later during application.\n * @typeDef DecoratorFactoryArgs\n * @property {DecoratorFactory} decorator The factory function that produces a decorator when invoked\n * @property {any[]} [args] Optional list of arguments to pass to the decorator factory\n * @memberOf module:decoration\n */\nexport type DecoratorFactoryArgs = {\n  decorator: DecoratorFactory;\n  args?: any[];\n};\n\n/**\n * @description Union that represents either a ready-to-apply decorator or a factory with arguments\n * @summary Allows registering decorators in two forms: as direct decorator functions or as deferred factories paired with their argument lists for later instantiation.\n * @typeDef DecoratorData\n * @memberOf module:decoration\n */\nexport type DecoratorData = DecoratorTypes | DecoratorFactoryArgs;\n/**\n * @description A decorator management class that handles flavoured decorators\n * @summary The Decoration class provides a builder pattern for creating and managing decorators with different flavours.\n * It supports registering, extending, and applying decorators with context-aware flavour resolution.\n * The class implements a fluent interface for defining, extending, and applying decorators with different flavours,\n * allowing for framework-specific decorator implementations while maintaining a consistent API.\n * @template T Type of the decorator (ClassDecorator | PropertyDecorator | MethodDecorator)\n * @param {string} [flavour] Optional flavour parameter for the decorator context\n * @class\n * @example\n * ```typescript\n * // Create a new decoration for 'component' with default flavour\n * const componentDecorator = new Decoration()\n *   .for('component')\n *   .define(customComponentDecorator);\n *\n * // Create a flavoured decoration\n * const vueComponent = new Decoration('vue')\n *   .for('component')\n *   .define(vueComponentDecorator);\n *\n * // Apply the decoration\n * @componentDecorator\n * class MyComponent {}\n * ```\n * @mermaid\n * sequenceDiagram\n *   participant C as Client\n *   participant D as Decoration\n *   participant R as FlavourResolver\n *   participant F as DecoratorFactory\n *\n *   C->>D: new Decoration(flavour)\n *   C->>D: for(key)\n *   C->>D: define(decorators)\n *   D->>D: register(key, flavour, decorators)\n *   D->>F: decoratorFactory(key, flavour)\n *   F->>R: resolve(target)\n *   R-->>F: resolved flavour\n *   F->>F: apply decorators\n *   F-->>C: decorated target\n */\nexport class Decoration implements IDecorationBuilder {\n  /**\n   * @description Static map of registered decorators\n   * @summary Stores all registered decorators organized by key and flavour\n   */\n  private static decorators: Record<\n    string,\n    Record<\n      string,\n      {\n        decorators?: Set<DecoratorData>;\n        extras?: Set<DecoratorData>;\n      }\n    >\n  > = {};\n\n  /**\n   * @description Function to resolve flavour from a target\n   * @summary Resolver function that determines the appropriate flavour for a given target\n   */\n  private static flavourResolver: FlavourResolver = defaultFlavourResolver;\n\n  /**\n   * @description Set of decorators for the current context\n   */\n  private decorators?: Set<DecoratorData>;\n\n  /**\n   * @description Set of additional decorators\n   */\n  private extras?: Set<DecoratorData>;\n\n  /**\n   * @description Current decorator key\n   */\n  private key?: string;\n\n  constructor(private flavour: string = DefaultFlavour) {}\n\n  /**\n   * @description Sets the key for the decoration builder\n   * @summary Initializes a new decoration chain with the specified key\n   * @param {string} key The identifier for the decorator\n   * @return {DecorationBuilderMid} Builder instance for method chaining\n   */\n  for(key: string): DecorationBuilderMid {\n    this.key = key;\n    return this;\n  }\n\n  /**\n   * @description Adds decorators to the current context\n   * @summary Internal method to add decorators with addon support\n   * @param {boolean} [addon=false] Whether the decorators are addons\n   * @param decorators Array of decorators\n   * @return {this} Current instance for chaining\n   */\n  private decorate(\n    addon: boolean = false,\n    ...decorators: DecoratorData[]\n  ): this {\n    if (!this.key)\n      throw new Error(\"key must be provided before decorators can be added\");\n    if (\n      (!decorators || !decorators.length) &&\n      !addon &&\n      this.flavour !== DefaultFlavour\n    )\n      throw new Error(\n        \"Must provide overrides or addons to override or extend decaf's decorators\"\n      );\n    if (this.flavour === DefaultFlavour && addon)\n      throw new Error(\"Default flavour cannot be extended\");\n\n    this[addon ? \"extras\" : \"decorators\"] = new Set([\n      ...(this[addon ? \"extras\" : \"decorators\"] || new Set()).values(),\n      ...decorators,\n    ]);\n\n    return this;\n  }\n\n  /**\n   * @description Defines the base decorators\n   * @summary Sets the primary decorators for the current context\n   * @param decorators Decorators to define\n   * @return Builder instance for finishing the chain\n   */\n  define(\n    ...decorators: DecoratorData[]\n  ): DecorationBuilderEnd & DecorationBuilderBuild {\n    return this.decorate(false, ...decorators);\n  }\n\n  /**\n   * @description Extends existing decorators\n   * @summary Adds additional decorators to the current context\n   * @param decorators Additional decorators\n   * @return {DecorationBuilderBuild} Builder instance for building the decorator\n   */\n  extend(...decorators: DecoratorData[]): DecorationBuilderBuild {\n    return this.decorate(true, ...decorators);\n  }\n\n  /**\n   * @description Factory that creates a context-aware decorator for a key/flavour\n   * @summary Produces a decorator function bound to the provided key and flavour. The resulting decorator resolves the actual\n   * decorators to apply at invocation time based on the target's resolved flavour and the registered base and extra decorators.\n   * @param {string} key The decoration key used to look up registered decorators\n   * @param {string} [f=DefaultFlavour] Optional explicit flavour to bind the factory to\n   * @return {function(object, any, TypedPropertyDescriptor<any>): any} A decorator function that applies the resolved decorators\n   * @mermaid\n   * sequenceDiagram\n   *   participant U as User Code\n   *   participant B as Decoration (builder)\n   *   participant F as decoratorFactory(key, f)\n   *   participant R as flavourResolver\n   *   participant A as Applied Decorators\n   *   U->>B: define()/extend() and apply()\n   *   B->>F: create context decorator\n   *   F->>R: resolve(target)\n   *   R-->>F: flavour\n   *   F->>A: collect base + extras\n   *   loop each decorator\n   *     A->>U: invoke decorator(target, key?, desc?)\n   *   end\n   */\n  protected decoratorFactory(key: string, f: string = DefaultFlavour) {\n    function contextDecorator(\n      target: object,\n      propertyKey?: any,\n      descriptor?: TypedPropertyDescriptor<any>\n    ) {\n      const flavour = Decoration.flavourResolver(target);\n      const cache = Decoration.decorators[key];\n      let decorators;\n      const extras = cache[flavour]\n        ? cache[flavour].extras\n        : cache[DefaultFlavour].extras;\n      const extraArgs = [\n        ...((cache[DefaultFlavour] as any).extras\n          ? (cache[DefaultFlavour] as any).extras.values()\n          : []),\n      ].reduce((accum: Record<number, any>, e, i) => {\n        if (e.args) accum[i] = e.args;\n        return accum;\n      }, {});\n\n      if (\n        cache &&\n        cache[flavour] &&\n        cache[flavour].decorators &&\n        cache[flavour].decorators.size\n      ) {\n        decorators = cache[flavour].decorators;\n      } else {\n        decorators = cache[DefaultFlavour].decorators;\n      }\n\n      const decoratorArgs = [\n        ...(cache[DefaultFlavour] as any).decorators.values(),\n      ].reduce((accum: Record<number, any>, e, i) => {\n        if (e.args) accum[i] = e.args;\n        return accum;\n      }, {});\n\n      const toApply = [\n        ...(decorators ? decorators.values() : []),\n        ...(extras ? extras.values() : []),\n      ];\n\n      return toApply.reduce(\n        (_, d, i) => {\n          switch (typeof d) {\n            case \"object\": {\n              const { decorator, args } = d as DecoratorFactoryArgs;\n              const argz =\n                args || i < (decorators ? decorators.size : 0)\n                  ? decoratorArgs[i]\n                  : extraArgs[i - (decorators ? decorators.size : 0)] ||\n                    (decorators ? decoratorArgs[i - decorators.size] : []);\n\n              return (decorator(...(argz || [])) as any)(\n                target,\n                propertyKey,\n                descriptor\n              );\n            }\n            case \"function\":\n              return (d as any)(target, propertyKey, descriptor);\n            default:\n              throw new Error(`Unexpected decorator type: ${typeof d}`);\n          }\n        },\n        { target, propertyKey, descriptor }\n      );\n    }\n    Object.defineProperty(contextDecorator, \"name\", {\n      value: [f, key].join(\"_decorator_for_\"),\n      writable: false,\n    });\n    return contextDecorator;\n  }\n\n  /**\n   * @description Creates the final decorator function\n   * @summary Builds and returns the decorator factory function\n   * @return {function(any, any?, TypedPropertyDescriptor?): any} The generated decorator function\n   */\n  apply(): (\n    target: any,\n    propertyKey?: any,\n    descriptor?: TypedPropertyDescriptor<any>\n  ) => any {\n    if (!this.key)\n      throw new Error(\"No key provided for the decoration builder\");\n    Decoration.register(\n      this.key,\n      this.flavour,\n      this.decorators || new Set(),\n      this.extras\n    );\n    return this.decoratorFactory(this.key, this.flavour);\n  }\n\n  /**\n   * @description Registers decorators for a specific key and flavour\n   * @summary Internal method to store decorators in the static registry\n   * @param {string} key Decorator key\n   * @param {string} flavour Decorator flavour\n   * @param [decorators] Primary decorators\n   * @param [extras] Additional decorators\n   */\n  private static register(\n    key: string,\n    flavour: string,\n    decorators?: Set<DecoratorData>,\n    extras?: Set<DecoratorData>\n  ) {\n    if (!key) {\n      throw new Error(\"No key provided for the decoration builder\");\n    }\n    if (!decorators)\n      throw new Error(\"No decorators provided for the decoration builder\");\n    if (!flavour)\n      throw new Error(\"No flavour provided for the decoration builder\");\n\n    if (!Decoration.decorators[key]) Decoration.decorators[key] = {};\n    if (!Decoration.decorators[key][flavour])\n      Decoration.decorators[key][flavour] = {};\n    if (decorators) Decoration.decorators[key][flavour].decorators = decorators;\n    if (extras) Decoration.decorators[key][flavour].extras = extras;\n  }\n\n  /**\n   * @description Sets the global flavour resolver\n   * @summary Configures the function used to determine decorator flavours\n   * @param {FlavourResolver} resolver Function to resolve flavours\n   */\n  static setFlavourResolver(resolver: FlavourResolver) {\n    Decoration.flavourResolver = resolver;\n  }\n\n  /**\n   * @description Convenience static entry to start a decoration builder\n   * @summary Creates a new Decoration instance and initiates the builder chain with the provided key.\n   * @param {string} key The decoration key to configure\n   * @return {DecorationBuilderMid} A builder instance for chaining definitions\n   */\n  static for(key: string): DecorationBuilderMid {\n    return new Decoration().for(key);\n  }\n\n  /**\n   * @description Starts a builder for a specific flavour\n   * @summary Convenience method to begin a Decoration builder chain bound to the given flavour identifier, allowing registration of flavour-specific decorators.\n   * @param {string} flavour The flavour name to bind to the builder\n   * @return {DecorationBuilderStart} A builder start interface to continue configuration\n   */\n  static flavouredAs(flavour: string): DecorationBuilderStart {\n    return new Decoration(flavour);\n  }\n}\n","import { BasicMetadata, Constructor } from \"./types\";\nimport { DecorationKeys, ObjectKeySplitter } from \"../constants\";\nimport \"reflect-metadata\";\n\n/**\n * @description Retrieves a nested value from an object given a path\n * @summary Walks an object structure using a splitter-delimited path and returns the value at that location or undefined if any key is missing.\n * @param {Record<string, any>} obj The object to traverse\n * @param {string} path The path to the desired value (e.g., \"a.b.c\")\n * @param {string} [splitter=ObjectKeySplitter] The delimiter used to split the path\n * @return {*} The resolved value at the given path or undefined if not found\n * @function getValueBySplitter\n * @mermaid\n * sequenceDiagram\n *   participant C as Caller\n *   participant F as getValueBySplitter\n *   participant O as Object\n *   C->>F: (obj, path, splitter)\n *   F->>F: split path into keys\n *   loop for each key\n *     F->>O: access current[key]\n *     alt missing or nullish\n *       F-->>C: return undefined\n *     end\n *   end\n *   F-->>C: return final value\n * @memberOf module:decoration\n */\nfunction getValueBySplitter(\n  obj: Record<string, any>,\n  path: string,\n  splitter: string = ObjectKeySplitter\n): any {\n  const keys = path.split(splitter);\n  let current = obj;\n\n  for (const key of keys) {\n    if (\n      current === null ||\n      current === undefined ||\n      !Object.prototype.hasOwnProperty.call(current, key)\n    )\n      return undefined;\n    current = current[key];\n  }\n\n  return current;\n}\n\n/**\n * @description Sets a nested value on an object given a path\n * @summary Traverses or creates intermediate objects following a splitter-delimited path and assigns the provided value at the destination key.\n * @param {Record<string, any>} obj The object to mutate\n * @param {string} path The destination path (e.g., \"a.b.c\")\n * @param {*} value The value to set at the destination\n * @param {string} [splitter=ObjectKeySplitter] The delimiter used to split the path\n * @return {void}\n * @function setValueBySplitter\n * @mermaid\n * sequenceDiagram\n *   participant C as Caller\n *   participant F as setValueBySplitter\n *   participant O as Object\n *   C->>F: (obj, path, value, splitter)\n *   F->>F: split path into keys\n *   loop for each key\n *     alt key missing\n *       F->>O: create intermediate object\n *     else key exists\n *       F->>O: descend into existing object\n *     end\n *   end\n *   F-->>C: void\n * @memberOf module:decoration\n */\nfunction setValueBySplitter(\n  obj: Record<string, any>,\n  path: string,\n  value: any,\n  splitter = ObjectKeySplitter\n): void {\n  const keys = path.split(splitter).filter((k) => k.length > 0);\n  if (keys.length === 0) return;\n\n  let current: Record<any, any> = obj;\n\n  for (let i = 0; i < keys.length - 1; i++) {\n    const key = keys[i];\n    if (\n      current[key] === undefined ||\n      current[key] === null ||\n      typeof current[key] !== \"object\"\n    ) {\n      current[key] = {};\n    }\n    current = current[key];\n  }\n\n  const lastKey = keys[keys.length - 1];\n  current[lastKey] = value;\n}\n\n/**\n * @description Centralized runtime metadata store bound to constructors\n * @summary Provides utilities to read and write structured metadata for classes and their members, with optional mirroring onto the constructor via a well-known symbol key. Supports nested key paths using a configurable splitter and offers both instance and static APIs.\n * @template M The model type the metadata belongs to\n * @template META Extends BasicMetadata<M> representing the metadata structure\n * @class\n * @example\n * // Define and read metadata for a class\n * class User { name!: string }\n * Metadata.set(User, \"description.class\", \"A user model\");\n * Metadata.set(User, \"properties.name\", String);\n * const desc = Metadata.get(User, \"description.class\"); // \"A user model\"\n * const type = Metadata.type(User, \"name\"); // String\n * @mermaid\n * sequenceDiagram\n *   participant C as Constructor\n *   participant S as Metadata (static)\n *   C->>S: set(User, \"properties.name\", String)\n *   C->>S: get(User, \"properties.name\")\n *   S-->>C: String\n */\nexport class Metadata {\n  /**\n   * @description In-memory storage of metadata by constructor symbol\n   * @summary Maps a Symbol derived from the constructor to its metadata object, enabling efficient lookup.\n   */\n  private static _metadata: Record<symbol, any> = {};\n\n  /**\n   * @description Path delimiter for nested metadata keys\n   * @summary Used by get/set operations to navigate nested structures, defaults to ObjectKeySplitter.\n   */\n  static splitter = ObjectKeySplitter;\n  /**\n   * @description Symbol key used to mirror metadata on the constructor\n   * @summary When mirroring is enabled, the metadata object is defined on the constructor under this non-enumerable key.\n   */\n  static baseKey = DecorationKeys.REFLECT;\n  /**\n   * @description Controls whether metadata is mirrored onto the constructor\n   * @summary When true, the metadata object is defined on the constructor under the non-enumerable baseKey.\n   */\n  static mirror: boolean = true;\n\n  private constructor() {}\n\n  /**\n   * @description Lists known property keys for a model\n   * @summary Reads the metadata entry and returns the names of properties that have recorded type information.\n   * @param {Constructor} model The target constructor\n   * @return {string[]|undefined} Array of property names or undefined if no metadata exists\n   */\n  static properties(model: Constructor): string[] | undefined {\n    const meta = this.get(model);\n    if (!meta) return undefined;\n    return Object.keys(meta.properties);\n  }\n\n  /**\n   * @description Retrieves a human-readable description for a class or a property\n   * @summary Looks up the description stored under the metadata \"description\" map. If a property key is provided, returns the property's description; otherwise returns the class description.\n   * @template M\n   * @param {Constructor<M>} model The target constructor whose description is being retrieved\n   * @param {string} [prop] Optional property key for which to fetch the description\n   * @return {string|undefined} The description text if present, otherwise undefined\n   */\n  static description<M>(model: Constructor<M>, prop?: keyof M) {\n    return this.get(\n      model,\n      [DecorationKeys.DESCRIPTION, prop ? prop : DecorationKeys.CLASS].join(\n        ObjectKeySplitter\n      )\n    );\n  }\n\n  /**\n   * @description Retrieves the recorded design type for a property\n   * @summary Reads the metadata entry under \"properties.<prop>\" to return the constructor recorded for the given property name.\n   * @param {Constructor} model The target constructor\n   * @param {string} prop The property name whose type should be returned\n   * @return {Constructor|undefined} The constructor reference of the property type or undefined if not available\n   */\n  static type(model: Constructor, prop: string) {\n    return this.get(model, `${DecorationKeys.PROPERTIES}.${prop}`);\n  }\n\n  /**\n   * @description Retrieves metadata for a model or a specific key within it\n   * @summary When called with a constructor only, returns the entire metadata object associated with the model. When a key path is provided, returns the value stored at that nested key.\n   * @template M\n   * @template META\n   * @param {Constructor<M>} model The target constructor used to locate the metadata record\n   * @return {META|undefined} The metadata object, the value at the key path, or undefined if nothing exists\n   */\n  static get<M, META extends BasicMetadata<M> = BasicMetadata<M>>(\n    model: Constructor<M>\n  ): META | undefined;\n  /**\n   * @description Retrieves metadata for a model or a specific key within it\n   * @summary When called with a constructor only, returns the entire metadata object associated with the model. When a key path is provided, returns the value stored at that nested key.\n   * @template M\n   * @template META\n   * @param {Constructor<M>} model The target constructor used to locate the metadata record\n   * @param {string} key nested key path to fetch a specific value\n   * @return {META|*|undefined} The metadata object, the value at the key path, or undefined if nothing exists\n   */\n  static get(model: Constructor, key: string): any;\n  /**\n   * @description Retrieves metadata for a model or a specific key within it\n   * @summary When called with a constructor only, returns the entire metadata object associated with the model. When a key path is provided, returns the value stored at that nested key.\n   * @template M\n   * @template META\n   * @param {Constructor<M>} model The target constructor used to locate the metadata record\n   * @param {string} [key] Optional nested key path to fetch a specific value\n   * @return {META|*|undefined} The metadata object, the value at the key path, or undefined if nothing exists\n   */\n  static get(model: Constructor, key?: string) {\n    const symbol = Symbol.for(model.toString());\n    if (!this._metadata[symbol]) return undefined;\n    if (!key) return this._metadata[symbol];\n    return getValueBySplitter(this._metadata[symbol], key, this.splitter);\n  }\n\n  /**\n   * @description Writes a metadata value at a given nested key path\n   * @summary Ensures the metadata record exists for the constructor, mirrors it on the constructor when enabled, and sets the provided value on the nested key path using the configured splitter.\n   * @param {Constructor} model The target constructor to which the metadata belongs\n   * @param {string} key The nested key path at which to store the value\n   * @param {*} value The value to store in the metadata\n   * @return {void}\n   */\n  static set(model: Constructor, key: string, value: any) {\n    const symbol = Symbol.for(model.toString());\n    if (!this._metadata[symbol]) this._metadata[symbol] = {} as any;\n    if (\n      Metadata.mirror &&\n      !Object.prototype.hasOwnProperty.call(model, this.baseKey)\n    ) {\n      Object.defineProperty(model, this.baseKey, {\n        enumerable: false,\n        configurable: false,\n        writable: false,\n        value: this._metadata[symbol],\n      });\n    }\n    setValueBySplitter(this._metadata[symbol], key, value, this.splitter);\n  }\n}\n","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\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","/**\n * @description Root entry point for the decoration module\n * @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:\n * - Core builder: {@link Decoration}\n * - Decorator utilities: {@link module:decoration | decorators in ./decorators}\n * - Metadata utilities: {@link Metadata}\n * - Constants and enums: {@link DecorationKeys}, {@link DefaultFlavour}\n *\n * @module decoration\n */\n\nexport * from \"./decoration\";\nexport * from \"./metadata\";\nexport * from \"./constants\";\nexport * from \"./decorators\";\n\n/**\n * @description Current version of the reflection package\n * @summary Stores the semantic version number of the package\n * @const VERSION\n * @memberOf module:decoration\n */\nexport const VERSION = \"##VERSION##\";\n"],"names":[],"mappings":"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"}
+export { Decoration, DecorationKeys, DefaultFlavour, DefaultMetadata, Metadata, ObjectKeySplitter, VERSION, apply, description, getValueBySplitter, metadata, method, prop, propMetadata, setValueBySplitter };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"decoration.esm.cjs","sources":["../src/constants.ts","../src/metadata/Metadata.ts","../src/decoration/Decoration.ts","../src/decorators.ts","../src/index.ts"],"sourcesContent":["import { BasicMetadata } from \"./metadata/types\";\n\n/**\n * @description Default flavour identifier for the decorator system\n * @summary Defines the default flavour used by the Decoration class when no specific flavour is provided.\n * This constant is used throughout the library as the fallback flavour for decorators.\n * @const DefaultFlavour\n * @memberOf module:decoration\n */\nexport const DefaultFlavour = \"decaf\";\n\n/**\n * @description Character used to split nested metadata keys\n * @summary The delimiter used by the metadata store to traverse nested object paths when reading/writing values.\n * @const ObjectKeySplitter\n * @memberOf module:decoration\n */\nexport const ObjectKeySplitter = \".\";\n\n/**\n * @description Enum containing metadata keys used for reflection in the model system\n * @summary Defines the various Model keys used for reflection and metadata storage.\n * These keys are used throughout the library to store and retrieve metadata about models,\n * their properties, and their behavior.\n * @readonly\n * @enum {string}\n * @readonly\n * @memberOf module:decoration\n */\nexport enum DecorationKeys {\n  LIBRARIES = \"libraries\",\n  /** Storage key used on the constructor to mirror runtime metadata */\n  REFLECT = `__${DefaultFlavour}`,\n  /** Map of model property keys to their reflected design types */\n  PROPERTIES = \"properties\",\n  /** Map of model method keys to their reflected design params and return types */\n  METHODS = \"methods\",\n  /** Key under which the model's constructor is stored */\n  CLASS = \"class\",\n  /** Container of human-friendly descriptions per class and property */\n  DESCRIPTION = \"description\",\n  /** Reflect metadata key for design time type of a property */\n  DESIGN_TYPE = \"design:type\",\n  /** Reflect metadata key for constructor parameter types */\n  DESIGN_PARAMS = \"design:paramtypes\",\n  /** Reflect metadata key for method return type */\n  DESIGN_RETURN = \"design:returntype\",\n}\n\n/**\n * @description Typedef for the default metadata object shape\n * @summary Describes the minimal structure persisted for a model before any metadata is recorded.\n * @template M\n * @typedef {object} DefaultMetadataType<M>\n * @property {Record<string, Constructor | undefined>} properties - Mapping of property names to their design types\n * @memberOf module:decoration\n */\n\n/**\n * @description Default metadata instance\n * @summary Concrete default metadata object used when initializing metadata for a model\n * @type {DefaultMetadataType<any>}\n * @const DefaultMetadata\n * @memberOf module:decoration\n */\nexport const DefaultMetadata: BasicMetadata<any> = {\n  [DecorationKeys.PROPERTIES]: [],\n} as unknown as BasicMetadata<any>;\n","import { BasicMetadata, Constructor } from \"./types\";\nimport { DecorationKeys, ObjectKeySplitter } from \"../constants\";\nimport \"reflect-metadata\";\n\n/**\n * @description Retrieves a nested value from an object given a path\n * @summary Walks an object structure using a splitter-delimited path and returns the value at that location or undefined if any key is missing.\n * @param {Record<string, any>} obj The object to traverse\n * @param {string} path The path to the desired value (e.g., \"a.b.c\")\n * @param {string} [splitter=ObjectKeySplitter] The delimiter used to split the path\n * @return {*} The resolved value at the given path or undefined if not found\n * @function getValueBySplitter\n * @mermaid\n * sequenceDiagram\n *   participant C as Caller\n *   participant F as getValueBySplitter\n *   participant O as Object\n *   C->>F: (obj, path, splitter)\n *   F->>F: split path into keys\n *   loop for each key\n *     F->>O: access current[key]\n *     alt missing or nullish\n *       F-->>C: return undefined\n *     end\n *   end\n *   F-->>C: return final value\n * @memberOf module:decoration\n */\nexport function getValueBySplitter(\n  obj: Record<string, any>,\n  path: string,\n  splitter: string = ObjectKeySplitter\n): any {\n  const keys = path.split(splitter);\n  let current = obj;\n\n  for (const key of keys) {\n    if (\n      current === null ||\n      current === undefined ||\n      !Object.prototype.hasOwnProperty.call(current, key)\n    )\n      return undefined;\n    current = current[key];\n  }\n\n  return current;\n}\n\n/**\n * @description Sets a nested value on an object given a path\n * @summary Traverses or creates intermediate objects following a splitter-delimited path and assigns the provided value at the destination key.\n * @param {Record<string, any>} obj The object to mutate\n * @param {string} path The destination path (e.g., \"a.b.c\")\n * @param {*} value The value to set at the destination\n * @param {string} [splitter=ObjectKeySplitter] The delimiter used to split the path\n * @return {void}\n * @function setValueBySplitter\n * @mermaid\n * sequenceDiagram\n *   participant C as Caller\n *   participant F as setValueBySplitter\n *   participant O as Object\n *   C->>F: (obj, path, value, splitter)\n *   F->>F: split path into keys\n *   loop for each key\n *     alt key missing\n *       F->>O: create intermediate object\n *     else key exists\n *       F->>O: descend into existing object\n *     end\n *   end\n *   F-->>C: void\n * @memberOf module:decoration\n */\nexport function setValueBySplitter(\n  obj: Record<string, any>,\n  path: string,\n  value: any,\n  splitter = ObjectKeySplitter\n): void {\n  const keys = path.split(splitter).filter((k) => k.length > 0);\n  if (keys.length === 0) return;\n\n  let current: Record<any, any> = obj;\n\n  for (let i = 0; i < keys.length - 1; i++) {\n    const key = keys[i];\n    if (\n      current[key] === undefined ||\n      current[key] === null ||\n      typeof current[key] !== \"object\"\n    ) {\n      current[key] = {};\n    }\n    current = current[key];\n  }\n\n  const lastKey = keys[keys.length - 1];\n  current[lastKey] = value;\n}\n\n/**\n * @description Centralized runtime metadata store bound to constructors\n * @summary Provides utilities to read and write structured metadata for classes and their members, with optional mirroring onto the constructor via a well-known symbol key. Supports nested key paths using a configurable splitter and offers both instance and static APIs.\n * @template M The model type the metadata belongs to\n * @template META Extends BasicMetadata<M> representing the metadata structure\n * @class\n * @example\n * // Define and read metadata for a class\n * class User { name!: string }\n * Metadata.set(User, \"description.class\", \"A user model\");\n * Metadata.set(User, \"properties.name\", String);\n * const desc = Metadata.get(User, \"description.class\"); // \"A user model\"\n * const type = Metadata.type(User, \"name\"); // String\n * @mermaid\n * sequenceDiagram\n *   participant C as Constructor\n *   participant S as Metadata (static)\n *   C->>S: set(User, \"properties.name\", String)\n *   C->>S: get(User, \"properties.name\")\n *   S-->>C: String\n */\nexport class Metadata {\n  /**\n   * @description In-memory storage of metadata by constructor symbol\n   * @summary Maps a Symbol derived from the constructor to its metadata object, enabling efficient lookup.\n   */\n  private static _metadata: Record<symbol, any> = {};\n\n  /**\n   * @description Path delimiter for nested metadata keys\n   * @summary Used by get/set operations to navigate nested structures, defaults to ObjectKeySplitter.\n   */\n  static splitter = ObjectKeySplitter;\n  /**\n   * @description Symbol key used to mirror metadata on the constructor\n   * @summary When mirroring is enabled, the metadata object is defined on the constructor under this non-enumerable key.\n   */\n  static baseKey = DecorationKeys.REFLECT;\n  /**\n   * @description Controls whether metadata is mirrored onto the constructor\n   * @summary When true, the metadata object is defined on the constructor under the non-enumerable baseKey.\n   */\n  static mirror: boolean = true;\n\n  private constructor() {}\n\n  /**\n   * @description Lists known property keys for a model\n   * @summary Reads the metadata entry and returns the names of properties that have recorded type information.\n   * @param {Constructor} model The target constructor\n   * @return {string[]|undefined} Array of property names or undefined if no metadata exists\n   */\n  static properties(model: Constructor): string[] | undefined {\n    const meta = this.get(model);\n    if (!meta) return undefined;\n    return Object.keys(meta.properties);\n  }\n\n  /**\n   * @description Retrieves a human-readable description for a class or a property\n   * @summary Looks up the description stored under the metadata \"description\" map. If a property key is provided, returns the property's description; otherwise returns the class description.\n   * @template M\n   * @param {Constructor<M>} model The target constructor whose description is being retrieved\n   * @param {string} [prop] Optional property key for which to fetch the description\n   * @return {string|undefined} The description text if present, otherwise undefined\n   */\n  static description<M>(\n    model: Constructor<M>,\n    prop?: keyof M\n  ): string | undefined {\n    return this.get(\n      model,\n      [DecorationKeys.DESCRIPTION, prop ? prop : DecorationKeys.CLASS].join(\n        ObjectKeySplitter\n      )\n    );\n  }\n\n  /**\n   * @description Retrieves the recorded design type for a property\n   * @summary Reads the metadata entry under \"properties.<prop>\" to return the constructor recorded for the given property name.\n   * @param {Constructor} model The target constructor\n   * @param {string} prop The property name whose type should be returned\n   * @return {Constructor|undefined} The constructor reference of the property type or undefined if not available\n   */\n  static type(model: Constructor, prop: string) {\n    return this.get(model, `${DecorationKeys.PROPERTIES}.${prop}`);\n  }\n\n  /**\n   * @description Retrieves metadata for a model or a specific key within it\n   * @summary When called with a constructor only, returns the entire metadata object associated with the model. When a key path is provided, returns the value stored at that nested key.\n   * @template M\n   * @template META\n   * @param {Constructor<M>} model The target constructor used to locate the metadata record\n   * @return {META|undefined} The metadata object, the value at the key path, or undefined if nothing exists\n   */\n  static get<M, META extends BasicMetadata<M> = BasicMetadata<M>>(\n    model: Constructor<M>\n  ): META | undefined;\n  /**\n   * @description Retrieves metadata for a model or a specific key within it\n   * @summary When called with a constructor only, returns the entire metadata object associated with the model. When a key path is provided, returns the value stored at that nested key.\n   * @template M\n   * @template META\n   * @param {Constructor<M>} model The target constructor used to locate the metadata record\n   * @param {string} key nested key path to fetch a specific value\n   * @return {META|*|undefined} The metadata object, the value at the key path, or undefined if nothing exists\n   */\n  static get(model: Constructor, key: string): any;\n  /**\n   * @description Retrieves metadata for a model or a specific key within it\n   * @summary When called with a constructor only, returns the entire metadata object associated with the model. When a key path is provided, returns the value stored at that nested key.\n   * @template M\n   * @template META\n   * @param {Constructor<M> | string} model The target constructor used to locate the metadata record\n   * @param {string} [key] Optional nested key path to fetch a specific value\n   * @return {META|*|undefined} The metadata object, the value at the key path, or undefined if nothing exists\n   */\n  static get(model: Constructor, key?: string) {\n    const symbol = Symbol.for(model.toString());\n    return this.innerGet(symbol, key);\n  }\n\n  private static innerGet(symbol: symbol, key?: string) {\n    if (!this._metadata[symbol]) return undefined;\n    if (!key) return this._metadata[symbol];\n    return getValueBySplitter(this._metadata[symbol], key, this.splitter);\n  }\n\n  private static innerSet(symbol: symbol, key: string, value: any) {\n    if (!this._metadata[symbol]) this._metadata[symbol] = {} as any;\n    setValueBySplitter(this._metadata[symbol], key, value, this.splitter);\n  }\n\n  /**\n   * @description Writes a metadata value at a given nested key path\n   * @summary Ensures the metadata record exists for the constructor, mirrors it on the constructor when enabled, and sets the provided value on the nested key path using the configured splitter.\n   * @template M\n   * @param {Constructor<M> | string} model The target constructor to which the metadata belongs\n   * @param {string} key The nested key path at which to store the value\n   * @param {*} value The value to store in the metadata\n   * @return {void}\n   */\n  static set(model: Constructor | string, key: string, value: any) {\n    const symbol = Symbol.for(model.toString());\n    this.innerSet(symbol, key, value);\n    if (\n      Metadata.mirror &&\n      !Object.prototype.hasOwnProperty.call(model, this.baseKey)\n    ) {\n      Object.defineProperty(model, this.baseKey, {\n        enumerable: false,\n        configurable: false,\n        writable: false,\n        value: this._metadata[symbol],\n      });\n    }\n  }\n\n  static registerLibrary(library: string, version: string) {\n    const symbol = Symbol.for(DecorationKeys.LIBRARIES);\n    const lib = this.innerGet(symbol, library);\n    if (lib)\n      throw new Error(\n        `Library already ${library} registered with version ${version}`\n      );\n    this.innerSet(symbol, library, version);\n  }\n}\n","import {\n  DecorationBuilderBuild,\n  DecorationBuilderEnd,\n  DecorationBuilderMid,\n  DecorationBuilderStart,\n  FlavourResolver,\n  IDecorationBuilder,\n} from \"./types\";\nimport { DefaultFlavour } from \"../constants\";\n\n/**\n * @description Default resolver that returns the current default flavour\n * @summary Resolves the flavour for a given target by always returning the library's DefaultFlavour value.\n * @param {object} target The target object being decorated\n * @return {string} The resolved flavour identifier\n * @function defaultFlavourResolver\n * @memberOf module:decoration\n */\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nfunction defaultFlavourResolver(target: object) {\n  return DefaultFlavour;\n}\n\n/**\n * @description Union type covering supported decorator kinds\n * @summary Represents any of the standard TypeScript decorator signatures (class, property, or method), enabling flexible registration and application within the Decoration system.\n * @template T\n * @typeDef DecoratorTypes\n * @memberOf module:decoration\n */\nexport type DecoratorTypes =\n  | ClassDecorator\n  | PropertyDecorator\n  | MethodDecorator;\n\n/**\n * @description Type definition for a decorator factory function\n * @summary Represents a function that accepts arbitrary arguments and returns a concrete decorator function to be applied to a target.\n * @template A\n * @typeDef DecoratorFactory\n * @memberOf module:decoration\n */\nexport type DecoratorFactory = (...args: any[]) => DecoratorTypes;\n\n/**\n * @description Argument bundle for a decorator factory\n * @summary Object form used to defer decorator creation, carrying both the factory function and its argument list to be invoked later during application.\n * @typeDef DecoratorFactoryArgs\n * @property {DecoratorFactory} decorator The factory function that produces a decorator when invoked\n * @property {any[]} args list of arguments to pass to the decorator factory\n * @memberOf module:decoration\n */\nexport type DecoratorFactoryArgs = {\n  decorator: DecoratorFactory;\n  args: any[];\n};\n\n/**\n * @description Union that represents either a ready-to-apply decorator or a factory with arguments\n * @summary Allows registering decorators in two forms: as direct decorator functions or as deferred factories paired with their argument lists for later instantiation.\n * @typeDef DecoratorData\n * @memberOf module:decoration\n */\nexport type DecoratorData = DecoratorTypes | DecoratorFactoryArgs;\n/**\n * @description A decorator management class that handles flavoured decorators\n * @summary The Decoration class provides a builder pattern for creating and managing decorators with different flavours.\n * It supports registering, extending, and applying decorators with context-aware flavour resolution.\n * The class implements a fluent interface for defining, extending, and applying decorators with different flavours,\n * allowing for framework-specific decorator implementations while maintaining a consistent API.\n * @template T Type of the decorator (ClassDecorator | PropertyDecorator | MethodDecorator)\n * @param {string} [flavour] Optional flavour parameter for the decorator context\n * @class\n * @example\n * ```typescript\n * // Create a new decoration for 'component' with default flavour\n * const componentDecorator = new Decoration()\n *   .for('component')\n *   .define(customComponentDecorator);\n *\n * // Create a flavoured decoration\n * const vueComponent = new Decoration('vue')\n *   .for('component')\n *   .define(vueComponentDecorator);\n *\n * // Apply the decoration\n * @componentDecorator\n * class MyComponent {}\n * ```\n * @mermaid\n * sequenceDiagram\n *   participant C as Client\n *   participant D as Decoration\n *   participant R as FlavourResolver\n *   participant F as DecoratorFactory\n *\n *   C->>D: new Decoration(flavour)\n *   C->>D: for(key)\n *   C->>D: define(decorators)\n *   D->>D: register(key, flavour, decorators)\n *   D->>F: decoratorFactory(key, flavour)\n *   F->>R: resolve(target)\n *   R-->>F: resolved flavour\n *   F->>F: apply decorators\n *   F-->>C: decorated target\n */\nexport class Decoration implements IDecorationBuilder {\n  /**\n   * @description Static map of registered decorators\n   * @summary Stores all registered decorators organized by key and flavour\n   */\n  private static decorators: Record<\n    string,\n    Record<\n      string,\n      {\n        decorators?: Set<DecoratorData>;\n        extras?: Set<DecoratorData>;\n      }\n    >\n  > = {};\n\n  /**\n   * @description Function to resolve flavour from a target\n   * @summary Resolver function that determines the appropriate flavour for a given target\n   */\n  private static flavourResolver: FlavourResolver = defaultFlavourResolver;\n\n  /**\n   * @description Set of decorators for the current context\n   */\n  private decorators?: Set<DecoratorData>;\n\n  /**\n   * @description Set of additional decorators\n   */\n  private extras?: Set<DecoratorData>;\n\n  /**\n   * @description Current decorator key\n   */\n  private key?: string;\n\n  constructor(private flavour: string = DefaultFlavour) {}\n\n  /**\n   * @description Sets the key for the decoration builder\n   * @summary Initializes a new decoration chain with the specified key\n   * @param {string} key The identifier for the decorator\n   * @return {DecorationBuilderMid} Builder instance for method chaining\n   */\n  for(key: string): DecorationBuilderMid {\n    this.key = key;\n    return this;\n  }\n\n  /**\n   * @description Adds decorators to the current context\n   * @summary Internal method to add decorators with addon support\n   * @param {boolean} [addon=false] Whether the decorators are addons\n   * @param decorators Array of decorators\n   * @return {this} Current instance for chaining\n   */\n  private decorate(\n    addon: boolean = false,\n    ...decorators: DecoratorData[]\n  ): this {\n    if (!this.key)\n      throw new Error(\"key must be provided before decorators can be added\");\n    if (\n      (!decorators || !decorators.length) &&\n      !addon &&\n      this.flavour !== DefaultFlavour\n    )\n      throw new Error(\n        \"Must provide overrides or addons to override or extend decaf's decorators\"\n      );\n    if (this.flavour === DefaultFlavour && addon)\n      throw new Error(\"Default flavour cannot be extended\");\n\n    this[addon ? \"extras\" : \"decorators\"] = new Set([\n      ...(this[addon ? \"extras\" : \"decorators\"] || new Set()).values(),\n      ...decorators,\n    ]);\n\n    return this;\n  }\n\n  /**\n   * @description Defines the base decorators\n   * @summary Sets the primary decorators for the current context\n   * @param decorators Decorators to define\n   * @return Builder instance for finishing the chain\n   */\n  define(\n    ...decorators: DecoratorData[]\n  ): DecorationBuilderEnd & DecorationBuilderBuild {\n    if (\n      decorators.find((d) => typeof d === \"object\") &&\n      decorators.length !== 1\n    )\n      throw new Error(\n        `When using an overridable decorator, only one is allowed`\n      );\n    return this.decorate(false, ...decorators);\n  }\n\n  /**\n   * @description Extends existing decorators\n   * @summary Adds additional decorators to the current context\n   * @param decorators Additional decorators\n   * @return {DecorationBuilderBuild} Builder instance for building the decorator\n   */\n  extend(...decorators: DecoratorData[]): DecorationBuilderBuild {\n    if (\n      decorators.find((d) => typeof d === \"object\") &&\n      decorators.length !== 1\n    )\n      throw new Error(\n        `When extending using an overridable decorator, only one is allowed`\n      );\n    return this.decorate(true, ...decorators);\n  }\n\n  /**\n   * @description Factory that creates a context-aware decorator for a key/flavour\n   * @summary Produces a decorator function bound to the provided key and flavour. The resulting decorator resolves the actual\n   * decorators to apply at invocation time based on the target's resolved flavour and the registered base and extra decorators.\n   * @param {string} key The decoration key used to look up registered decorators\n   * @param {string} [f=DefaultFlavour] Optional explicit flavour to bind the factory to\n   * @return {function(object, any, TypedPropertyDescriptor<any>): any} A decorator function that applies the resolved decorators\n   * @mermaid\n   * sequenceDiagram\n   *   participant U as User Code\n   *   participant B as Decoration (builder)\n   *   participant F as decoratorFactory(key, f)\n   *   participant R as flavourResolver\n   *   participant A as Applied Decorators\n   *   U->>B: define()/extend() and apply()\n   *   B->>F: create context decorator\n   *   F->>R: resolve(target)\n   *   R-->>F: flavour\n   *   F->>A: collect base + extras\n   *   loop each decorator\n   *     A->>U: invoke decorator(target, key?, desc?)\n   *   end\n   */\n  protected decoratorFactory(key: string, f: string = DefaultFlavour) {\n    function contextDecorator(\n      target: object,\n      propertyKey?: any,\n      descriptor?: TypedPropertyDescriptor<any>\n    ) {\n      const flavour = Decoration.flavourResolver(target);\n      const cache = Decoration.decorators[key];\n      let decorators;\n      const extras = cache[flavour]\n        ? cache[flavour].extras\n        : cache[DefaultFlavour].extras;\n\n      if (\n        cache &&\n        cache[flavour] &&\n        cache[flavour].decorators &&\n        cache[flavour].decorators.size\n      ) {\n        decorators = cache[flavour].decorators;\n      } else {\n        decorators = cache[DefaultFlavour].decorators;\n      }\n\n      const decoratorArgs = [\n        ...(cache[DefaultFlavour] as any).decorators.values(),\n      ].reduce((accum: Record<number, any>, e, i) => {\n        if (e.args) accum[i] = e.args;\n        return accum;\n      }, {});\n\n      const toApply = [\n        ...(decorators ? decorators.values() : []),\n        ...(extras ? extras.values() : []),\n      ];\n\n      return toApply.reduce(\n        (_, d) => {\n          switch (typeof d) {\n            case \"object\": {\n              const { decorator } = d as DecoratorFactoryArgs;\n\n              return (\n                decorator(...(Object.values(decoratorArgs)[0] || [])) as any\n              )(target, propertyKey, descriptor);\n            }\n            case \"function\":\n              return (d as any)(target, propertyKey, descriptor);\n            default:\n              throw new Error(`Unexpected decorator type: ${typeof d}`);\n          }\n        },\n        { target, propertyKey, descriptor }\n      );\n    }\n    Object.defineProperty(contextDecorator, \"name\", {\n      value: [f, key].join(\"_decorator_for_\"),\n      writable: false,\n    });\n    return contextDecorator;\n  }\n\n  /**\n   * @description Creates the final decorator function\n   * @summary Builds and returns the decorator factory function\n   * @return {function(any, any?, TypedPropertyDescriptor?): any} The generated decorator function\n   */\n  apply(): (\n    target: any,\n    propertyKey?: any,\n    descriptor?: TypedPropertyDescriptor<any>\n  ) => any {\n    if (!this.key)\n      throw new Error(\"No key provided for the decoration builder\");\n    Decoration.register(\n      this.key,\n      this.flavour,\n      this.decorators || new Set(),\n      this.extras\n    );\n    return this.decoratorFactory(this.key, this.flavour);\n  }\n\n  /**\n   * @description Registers decorators for a specific key and flavour\n   * @summary Internal method to store decorators in the static registry\n   * @param {string} key Decorator key\n   * @param {string} flavour Decorator flavour\n   * @param [decorators] Primary decorators\n   * @param [extras] Additional decorators\n   */\n  private static register(\n    key: string,\n    flavour: string,\n    decorators?: Set<DecoratorData>,\n    extras?: Set<DecoratorData>\n  ) {\n    if (!key) {\n      throw new Error(\"No key provided for the decoration builder\");\n    }\n    if (!decorators)\n      throw new Error(\"No decorators provided for the decoration builder\");\n    if (!flavour)\n      throw new Error(\"No flavour provided for the decoration builder\");\n\n    if (!Decoration.decorators[key]) Decoration.decorators[key] = {};\n    if (!Decoration.decorators[key][flavour])\n      Decoration.decorators[key][flavour] = {};\n    if (decorators) Decoration.decorators[key][flavour].decorators = decorators;\n    if (extras) Decoration.decorators[key][flavour].extras = extras;\n  }\n\n  /**\n   * @description Sets the global flavour resolver\n   * @summary Configures the function used to determine decorator flavours\n   * @param {FlavourResolver} resolver Function to resolve flavours\n   */\n  static setFlavourResolver(resolver: FlavourResolver) {\n    Decoration.flavourResolver = resolver;\n  }\n\n  /**\n   * @description Convenience static entry to start a decoration builder\n   * @summary Creates a new Decoration instance and initiates the builder chain with the provided key.\n   * @param {string} key The decoration key to configure\n   * @return {DecorationBuilderMid} A builder instance for chaining definitions\n   */\n  static for(key: string): DecorationBuilderMid {\n    return new Decoration().for(key);\n  }\n\n  /**\n   * @description Starts a builder for a specific flavour\n   * @summary Convenience method to begin a Decoration builder chain bound to the given flavour identifier, allowing registration of flavour-specific decorators.\n   * @param {string} flavour The flavour name to bind to the builder\n   * @return {DecorationBuilderStart} A builder start interface to continue configuration\n   */\n  static flavouredAs(flavour: string): DecorationBuilderStart {\n    return new Decoration(flavour);\n  }\n}\n","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","/**\n * @description Root entry point for the decoration module\n * @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:\n * - Core builder: {@link Decoration}\n * - Decorator utilities: {@link module:decoration | decorators in ./decorators}\n * - Metadata utilities: {@link Metadata}\n * - Constants and enums: {@link DecorationKeys}, {@link DefaultFlavour}\n *\n * @module decoration\n */\n\nimport { Metadata } from \"./metadata/index\";\n\nexport * from \"./decoration\";\nexport * from \"./metadata\";\nexport * from \"./constants\";\nexport * from \"./decorators\";\n\n/**\n * @description Current version of the reflection package\n * @summary Stores the semantic version number of the package\n * @const VERSION\n * @memberOf module:decoration\n */\nexport const VERSION = \"##VERSION##\";\n\nMetadata.registerLibrary(\"@decaf-ts/decoration\", VERSION);\n"],"names":[],"mappings":";;AAEA;;;;;;AAMG;AACI,MAAM,cAAc,GAAG;AAE9B;;;;;AAKG;AACI,MAAM,iBAAiB,GAAG;AAEjC;;;;;;;;;AASG;IACS;AAAZ,CAAA,UAAY,cAAc,EAAA;AACxB,IAAA,cAAA,CAAA,WAAA,CAAA,GAAA,WAAuB;;AAEvB,IAAA,cAAA,CAAA,SAAA,CAAA,GAAA,SAA+B;;AAE/B,IAAA,cAAA,CAAA,YAAA,CAAA,GAAA,YAAyB;;AAEzB,IAAA,cAAA,CAAA,SAAA,CAAA,GAAA,SAAmB;;AAEnB,IAAA,cAAA,CAAA,OAAA,CAAA,GAAA,OAAe;;AAEf,IAAA,cAAA,CAAA,aAAA,CAAA,GAAA,aAA2B;;AAE3B,IAAA,cAAA,CAAA,aAAA,CAAA,GAAA,aAA2B;;AAE3B,IAAA,cAAA,CAAA,eAAA,CAAA,GAAA,mBAAmC;;AAEnC,IAAA,cAAA,CAAA,eAAA,CAAA,GAAA,mBAAmC;AACrC,CAAC,EAlBW,cAAc,KAAd,cAAc,GAkBzB,EAAA,CAAA,CAAA;AAED;;;;;;;AAOG;AAEH;;;;;;AAMG;AACU,MAAA,eAAe,GAAuB;AACjD,IAAA,CAAC,cAAc,CAAC,UAAU,GAAG,EAAE;;;AC9DjC;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AACG,SAAU,kBAAkB,CAChC,GAAwB,EACxB,IAAY,EACZ,WAAmB,iBAAiB,EAAA;IAEpC,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC;IACjC,IAAI,OAAO,GAAG,GAAG;AAEjB,IAAA,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE;QACtB,IACE,OAAO,KAAK,IAAI;AAChB,YAAA,OAAO,KAAK,SAAS;YACrB,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,CAAC;AAEnD,YAAA,OAAO,SAAS;AAClB,QAAA,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC;;AAGxB,IAAA,OAAO,OAAO;AAChB;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;AACG,SAAU,kBAAkB,CAChC,GAAwB,EACxB,IAAY,EACZ,KAAU,EACV,QAAQ,GAAG,iBAAiB,EAAA;IAE5B,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC;AAC7D,IAAA,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;QAAE;IAEvB,IAAI,OAAO,GAAqB,GAAG;AAEnC,IAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE;AACxC,QAAA,MAAM,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC;AACnB,QAAA,IACE,OAAO,CAAC,GAAG,CAAC,KAAK,SAAS;AAC1B,YAAA,OAAO,CAAC,GAAG,CAAC,KAAK,IAAI;AACrB,YAAA,OAAO,OAAO,CAAC,GAAG,CAAC,KAAK,QAAQ,EAChC;AACA,YAAA,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE;;AAEnB,QAAA,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC;;IAGxB,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;AACrC,IAAA,OAAO,CAAC,OAAO,CAAC,GAAG,KAAK;AAC1B;AAEA;;;;;;;;;;;;;;;;;;;;AAoBG;MACU,QAAQ,CAAA;AACnB;;;AAGG;aACY,IAAS,CAAA,SAAA,GAAwB,EAAE,CAAC;AAEnD;;;AAGG;aACI,IAAQ,CAAA,QAAA,GAAG,iBAAiB,CAAC;AACpC;;;AAGG;AACI,IAAA,SAAA,IAAA,CAAA,OAAO,GAAG,cAAc,CAAC,OAAO,CAAC;AACxC;;;AAGG;aACI,IAAM,CAAA,MAAA,GAAY,IAAI,CAAC;AAE9B,IAAA,WAAA,GAAA;AAEA;;;;;AAKG;IACH,OAAO,UAAU,CAAC,KAAkB,EAAA;QAClC,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC;AAC5B,QAAA,IAAI,CAAC,IAAI;AAAE,YAAA,OAAO,SAAS;QAC3B,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC;;AAGrC;;;;;;;AAOG;AACH,IAAA,OAAO,WAAW,CAChB,KAAqB,EACrB,IAAc,EAAA;AAEd,QAAA,OAAO,IAAI,CAAC,GAAG,CACb,KAAK,EACL,CAAC,cAAc,CAAC,WAAW,EAAE,IAAI,GAAG,IAAI,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC,IAAI,CACnE,iBAAiB,CAClB,CACF;;AAGH;;;;;;AAMG;AACH,IAAA,OAAO,IAAI,CAAC,KAAkB,EAAE,IAAY,EAAA;AAC1C,QAAA,OAAO,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,CAAA,EAAG,cAAc,CAAC,UAAU,CAAA,CAAA,EAAI,IAAI,CAAA,CAAE,CAAC;;AAwBhE;;;;;;;;AAQG;AACH,IAAA,OAAO,GAAG,CAAC,KAAkB,EAAE,GAAY,EAAA;QACzC,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;QAC3C,OAAO,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC;;AAG3B,IAAA,OAAO,QAAQ,CAAC,MAAc,EAAE,GAAY,EAAA;AAClD,QAAA,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;AAAE,YAAA,OAAO,SAAS;AAC7C,QAAA,IAAI,CAAC,GAAG;AAAE,YAAA,OAAO,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;AACvC,QAAA,OAAO,kBAAkB,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,GAAG,EAAE,IAAI,CAAC,QAAQ,CAAC;;AAG/D,IAAA,OAAO,QAAQ,CAAC,MAAc,EAAE,GAAW,EAAE,KAAU,EAAA;AAC7D,QAAA,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;AAAE,YAAA,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,EAAS;AAC/D,QAAA,kBAAkB,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,CAAC,QAAQ,CAAC;;AAGvE;;;;;;;;AAQG;AACH,IAAA,OAAO,GAAG,CAAC,KAA2B,EAAE,GAAW,EAAE,KAAU,EAAA;QAC7D,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;QAC3C,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,GAAG,EAAE,KAAK,CAAC;QACjC,IACE,QAAQ,CAAC,MAAM;AACf,YAAA,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,EAC1D;YACA,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,IAAI,CAAC,OAAO,EAAE;AACzC,gBAAA,UAAU,EAAE,KAAK;AACjB,gBAAA,YAAY,EAAE,KAAK;AACnB,gBAAA,QAAQ,EAAE,KAAK;AACf,gBAAA,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;AAC9B,aAAA,CAAC;;;AAIN,IAAA,OAAO,eAAe,CAAC,OAAe,EAAE,OAAe,EAAA;QACrD,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,cAAc,CAAC,SAAS,CAAC;QACnD,MAAM,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;AAC1C,QAAA,IAAI,GAAG;YACL,MAAM,IAAI,KAAK,CACb,CAAA,gBAAA,EAAmB,OAAO,CAA4B,yBAAA,EAAA,OAAO,CAAE,CAAA,CAChE;QACH,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC;;;;ACnQ3C;;;;;;;AAOG;AACH;AACA,SAAS,sBAAsB,CAAC,MAAc,EAAA;AAC5C,IAAA,OAAO,cAAc;AACvB;AA2CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCG;MACU,UAAU,CAAA;AACrB;;;AAGG;aACY,IAAU,CAAA,UAAA,GASrB,EAAE,CAAC;AAEP;;;AAGG;aACY,IAAe,CAAA,eAAA,GAAoB,sBAAsB,CAAC;AAiBzE,IAAA,WAAA,CAAoB,UAAkB,cAAc,EAAA;QAAhC,IAAO,CAAA,OAAA,GAAP,OAAO;;AAE3B;;;;;AAKG;AACH,IAAA,GAAG,CAAC,GAAW,EAAA;AACb,QAAA,IAAI,CAAC,GAAG,GAAG,GAAG;AACd,QAAA,OAAO,IAAI;;AAGb;;;;;;AAMG;AACK,IAAA,QAAQ,CACd,KAAA,GAAiB,KAAK,EACtB,GAAG,UAA2B,EAAA;QAE9B,IAAI,CAAC,IAAI,CAAC,GAAG;AACX,YAAA,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC;QACxE,IACE,CAAC,CAAC,UAAU,IAAI,CAAC,UAAU,CAAC,MAAM;AAClC,YAAA,CAAC,KAAK;YACN,IAAI,CAAC,OAAO,KAAK,cAAc;AAE/B,YAAA,MAAM,IAAI,KAAK,CACb,2EAA2E,CAC5E;AACH,QAAA,IAAI,IAAI,CAAC,OAAO,KAAK,cAAc,IAAI,KAAK;AAC1C,YAAA,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC;AAEvD,QAAA,IAAI,CAAC,KAAK,GAAG,QAAQ,GAAG,YAAY,CAAC,GAAG,IAAI,GAAG,CAAC;YAC9C,GAAG,CAAC,IAAI,CAAC,KAAK,GAAG,QAAQ,GAAG,YAAY,CAAC,IAAI,IAAI,GAAG,EAAE,EAAE,MAAM,EAAE;AAChE,YAAA,GAAG,UAAU;AACd,SAAA,CAAC;AAEF,QAAA,OAAO,IAAI;;AAGb;;;;;AAKG;IACH,MAAM,CACJ,GAAG,UAA2B,EAAA;AAE9B,QAAA,IACE,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,KAAK,QAAQ,CAAC;YAC7C,UAAU,CAAC,MAAM,KAAK,CAAC;AAEvB,YAAA,MAAM,IAAI,KAAK,CACb,CAAA,wDAAA,CAA0D,CAC3D;QACH,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,GAAG,UAAU,CAAC;;AAG5C;;;;;AAKG;IACH,MAAM,CAAC,GAAG,UAA2B,EAAA;AACnC,QAAA,IACE,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,KAAK,QAAQ,CAAC;YAC7C,UAAU,CAAC,MAAM,KAAK,CAAC;AAEvB,YAAA,MAAM,IAAI,KAAK,CACb,CAAA,kEAAA,CAAoE,CACrE;QACH,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,GAAG,UAAU,CAAC;;AAG3C;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACO,IAAA,gBAAgB,CAAC,GAAW,EAAE,CAAA,GAAY,cAAc,EAAA;AAChE,QAAA,SAAS,gBAAgB,CACvB,MAAc,EACd,WAAiB,EACjB,UAAyC,EAAA;YAEzC,MAAM,OAAO,GAAG,UAAU,CAAC,eAAe,CAAC,MAAM,CAAC;YAClD,MAAM,KAAK,GAAG,UAAU,CAAC,UAAU,CAAC,GAAG,CAAC;AACxC,YAAA,IAAI,UAAU;AACd,YAAA,MAAM,MAAM,GAAG,KAAK,CAAC,OAAO;AAC1B,kBAAE,KAAK,CAAC,OAAO,CAAC,CAAC;AACjB,kBAAE,KAAK,CAAC,cAAc,CAAC,CAAC,MAAM;AAEhC,YAAA,IACE,KAAK;gBACL,KAAK,CAAC,OAAO,CAAC;AACd,gBAAA,KAAK,CAAC,OAAO,CAAC,CAAC,UAAU;gBACzB,KAAK,CAAC,OAAO,CAAC,CAAC,UAAU,CAAC,IAAI,EAC9B;AACA,gBAAA,UAAU,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC,UAAU;;iBACjC;AACL,gBAAA,UAAU,GAAG,KAAK,CAAC,cAAc,CAAC,CAAC,UAAU;;AAG/C,YAAA,MAAM,aAAa,GAAG;gBACpB,GAAI,KAAK,CAAC,cAAc,CAAS,CAAC,UAAU,CAAC,MAAM,EAAE;aACtD,CAAC,MAAM,CAAC,CAAC,KAA0B,EAAE,CAAC,EAAE,CAAC,KAAI;gBAC5C,IAAI,CAAC,CAAC,IAAI;AAAE,oBAAA,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI;AAC7B,gBAAA,OAAO,KAAK;aACb,EAAE,EAAE,CAAC;AAEN,YAAA,MAAM,OAAO,GAAG;AACd,gBAAA,IAAI,UAAU,GAAG,UAAU,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC;AAC1C,gBAAA,IAAI,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC;aACnC;YAED,OAAO,OAAO,CAAC,MAAM,CACnB,CAAC,CAAC,EAAE,CAAC,KAAI;gBACP,QAAQ,OAAO,CAAC;oBACd,KAAK,QAAQ,EAAE;AACb,wBAAA,MAAM,EAAE,SAAS,EAAE,GAAG,CAAyB;wBAE/C,OACE,SAAS,CAAC,IAAI,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CACrD,CAAC,MAAM,EAAE,WAAW,EAAE,UAAU,CAAC;;AAEpC,oBAAA,KAAK,UAAU;wBACb,OAAQ,CAAS,CAAC,MAAM,EAAE,WAAW,EAAE,UAAU,CAAC;AACpD,oBAAA;wBACE,MAAM,IAAI,KAAK,CAAC,CAAA,2BAAA,EAA8B,OAAO,CAAC,CAAA,CAAE,CAAC;;aAE9D,EACD,EAAE,MAAM,EAAE,WAAW,EAAE,UAAU,EAAE,CACpC;;AAEH,QAAA,MAAM,CAAC,cAAc,CAAC,gBAAgB,EAAE,MAAM,EAAE;YAC9C,KAAK,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC;AACvC,YAAA,QAAQ,EAAE,KAAK;AAChB,SAAA,CAAC;AACF,QAAA,OAAO,gBAAgB;;AAGzB;;;;AAIG;IACH,KAAK,GAAA;QAKH,IAAI,CAAC,IAAI,CAAC,GAAG;AACX,YAAA,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC;QAC/D,UAAU,CAAC,QAAQ,CACjB,IAAI,CAAC,GAAG,EACR,IAAI,CAAC,OAAO,EACZ,IAAI,CAAC,UAAU,IAAI,IAAI,GAAG,EAAE,EAC5B,IAAI,CAAC,MAAM,CACZ;AACD,QAAA,OAAO,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC;;AAGtD;;;;;;;AAOG;IACK,OAAO,QAAQ,CACrB,GAAW,EACX,OAAe,EACf,UAA+B,EAC/B,MAA2B,EAAA;QAE3B,IAAI,CAAC,GAAG,EAAE;AACR,YAAA,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC;;AAE/D,QAAA,IAAI,CAAC,UAAU;AACb,YAAA,MAAM,IAAI,KAAK,CAAC,mDAAmD,CAAC;AACtE,QAAA,IAAI,CAAC,OAAO;AACV,YAAA,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC;AAEnE,QAAA,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,GAAG,CAAC;AAAE,YAAA,UAAU,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,EAAE;QAChE,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC;YACtC,UAAU,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE;AAC1C,QAAA,IAAI,UAAU;AAAE,YAAA,UAAU,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,UAAU,GAAG,UAAU;AAC3E,QAAA,IAAI,MAAM;AAAE,YAAA,UAAU,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,MAAM,GAAG,MAAM;;AAGjE;;;;AAIG;IACH,OAAO,kBAAkB,CAAC,QAAyB,EAAA;AACjD,QAAA,UAAU,CAAC,eAAe,GAAG,QAAQ;;AAGvC;;;;;AAKG;IACH,OAAO,GAAG,CAAC,GAAW,EAAA;QACpB,OAAO,IAAI,UAAU,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC;;AAGlC;;;;;AAKG;IACH,OAAO,WAAW,CAAC,OAAe,EAAA;AAChC,QAAA,OAAO,IAAI,UAAU,CAAC,OAAO,CAAC;;;;AC9XlC;;;;;;;;AAQG;AACa,SAAA,QAAQ,CAAC,GAAW,EAAE,KAAU,EAAA;AAC9C,IAAA,OAAO,SAAS,QAAQ,CACtB,KAAU,EAEV,IAAU;;IAEV,UAA+B,EAAA;AAE/B,QAAA,QAAQ,CAAC,GAAG,CAAC,IAAI,GAAG,KAAK,CAAC,WAAW,GAAG,KAAK,EAAE,GAAG,EAAE,KAAK,CAAC;AAC5D,KAAC;AACH;AAEA;;;;;;AAMG;SACa,IAAI,GAAA;AAClB,IAAA,OAAO,SAAS,IAAI,CAAC,KAAa,EAAE,IAAS,EAAA;AAC3C,QAAA,MAAM,UAAU,GAAG,OAAO,CAAC,cAAc,CACvC,cAAc,CAAC,WAAW,EAC1B,KAAK,EACL,IAAI,CACL;AACD,QAAA,OAAO,QAAQ,CAAC,CAAA,EAAG,cAAc,CAAC,UAAU,CAAI,CAAA,EAAA,IAAI,CAAE,CAAA,EAAE,UAAU,CAAC,CACjE,KAAK,EACL,IAAI,CACL;AACH,KAAC;AACH;SAEgB,MAAM,GAAA;AACpB,IAAA,OAAO,SAAS,MAAM,CAAC,GAAQ,EAAE,IAAS,EAAE,UAAe,EAAA;AACzD,QAAA,MAAM,YAAY,GAAG,OAAO,CAAC,cAAc,CACzC,cAAc,CAAC,aAAa,EAC5B,GAAG,EACH,IAAI,CACL;AACD,QAAA,MAAM,YAAY,GAAG,OAAO,CAAC,cAAc,CACzC,cAAc,CAAC,aAAa,EAC5B,GAAG,EACH,IAAI,CACL;AACD,QAAA,OAAO,KAAK,CACV,QAAQ,CACN,CAAG,EAAA,cAAc,CAAC,OAAO,CAAA,CAAA,EAAI,IAAI,CAAI,CAAA,EAAA,cAAc,CAAC,aAAa,CAAA,CAAE,EACnE,YAAY,CACb,EACD,QAAQ,CACN,GAAG,cAAc,CAAC,OAAO,CAAI,CAAA,EAAA,IAAI,IAAI,cAAc,CAAC,aAAa,CAAE,CAAA,EACnE,YAAY,CACb,CACF,CAAC,GAAG,EAAE,IAAI,EAAE,UAAU,CAAC;AAC1B,KAAC;AACH;AAEA;;;;;;;;;;;;;;;;;;AAkBG;AACa,SAAA,KAAK,CACnB,GAAG,UAAuE,EAAA;AAE1E,IAAA,OAAO,CACL,MAAc,EACd,WAAuC,EACvC,UAA+B,KAC7B;AACF,QAAA,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE;AAClC,YAAA,IAAI,MAAM,YAAY,QAAQ,IAAI,CAAC,UAAU,EAAE;gBAC5C,SAA4B,CAAC,MAAM,CAAC;gBACrC;;AAED,YAAA,SAAiD,CAChD,MAAM,EACN,WAA8B,EAC9B,UAA8C,CAC/C;;AAEL,KAAC;AACH;AAEA;;;;;;;;AAQG;AACa,SAAA,YAAY,CAAC,GAAW,EAAE,KAAU,EAAA;AAClD,IAAA,OAAO,KAAK,CAAC,QAAQ,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,IAAI,EAAE,CAAC;AAC5C;AAEA;;;;;;;AAOG;AACG,SAAU,WAAW,CAAC,IAAY,EAAA;AACtC,IAAA,OAAO,SAAS,WAAW,CAAC,QAAa,EAAE,IAAS,EAAE,UAAgB,EAAA;AACpE,QAAA,OAAO,QAAQ,CACb;AACE,YAAA,cAAc,CAAC,WAAW;AAC1B,YAAA,IAAI,GAAG,IAAI,CAAC,QAAQ,EAAE,GAAG,cAAc,CAAC,KAAK;AAC9C,SAAA,CAAC,IAAI,CAAC,iBAAiB,CAAC,EACzB,IAAI,CACL,CAAC,QAAQ,EAAE,IAAI,EAAE,UAAU,CAAC;AAC/B,KAAC;AACH;;AC9IA;;;;;;;;;AASG;AASH;;;;;AAKG;AACI,MAAM,OAAO,GAAG;AAEvB,QAAQ,CAAC,eAAe,CAAC,sBAAsB,EAAE,OAAO,CAAC;;;;"}