@decaf-ts/ui-decorators 0.5.9 → 0.5.11

package/lib/esm/model/model.d.ts

@@ -7,109 +7,215 @@ declare module "@decaf-ts/decorator-validation" {
         hasErrors(...exclusions: any[]): ModelErrorDefinition | undefined;
         hasErrors(previousVersion?: Model | any, ...exclusions: any[]): ModelErrorDefinition | undefined;
         /**
-         * @summary Compare object equality recursively
-         * @param {any} obj object to compare to
-         * @param {string} [exceptions] property names to be excluded from the comparison
+         * @description Compares this model with another object for equality
+         * @summary Compare object equality recursively, checking all properties
+         * @param {any} obj - Object to compare to
+         * @param {...string} exceptions - Property names to be excluded from the comparison
+         * @return {boolean} True if objects are equal, false otherwise
          */
         equals(obj: any, ...exceptions: string[]): boolean;
         /**
+         * @description Converts the model to a serialized string representation
          * @summary Returns the serialized model according to the currently defined {@link Serializer}
+         * @return {string} Serialized representation of the model
          */
         serialize(): string;
         /**
-         * @summary Override the implementation for js's 'toString()' which sucks...
+         * @description Provides a string representation of the model
+         * @summary Override the implementation for JavaScript's default toString() method
+         * @return {string} String representation of the model
          * @override
          */
         toString(): string;
         /**
-         * @summary Defines a default implementation for object hash. Relies on a very basic implementation based on Java's string hash;
+         * @description Generates a hash code for the model
+         * @summary Defines a default implementation for object hash based on Java's string hash algorithm
+         * @return {string} Hash code for the model
          */
         hash(): string;
         /**
-         * @summary Deserializes a Model
-         * @param {string} str
-         *
-         * @param args
+         * @description Converts a serialized string back to a model instance
+         * @summary Deserializes a Model from its string representation
+         * @param {string} str - The serialized string to deserialize
+         * @return {any} The deserialized model instance
          * @throws {Error} If it fails to parse the string, or if it fails to build the model
          */
         static deserialize(str: string): any;
         /**
-         * @summary Repopulates the Object properties with the ones from the new object
          * @description Iterates all common properties of obj (if existing) and self, and copies them onto self
-         *
-         * @param {T} self
-         * @param {T | Record<string, any>} [obj]
-         *
+         * @summary Repopulates the Object properties with the ones from the new object
+         * @template T - Type extending Model
+         * @param {T} self - The target model instance to update
+         * @param {T|Record<string, any>} [obj] - The source object to copy properties from
+         * @return {T} The updated model instance
          */
         static fromObject<T extends Model>(self: T, obj?: T | Record<string, any>): T;
         /**
-         * @summary Repopulates the instance with the ones from the new Model Object
-         * @description Iterates all common properties of obj (if existing) and self, and copies them onto self.
-         * Is aware of nested Model Objects and rebuilds them also.
-         * When List properties are decorated with {@link list}, they list items will also be rebuilt
-         *
-         * @param {T} self
-         * @param {T | Record<string, any>} [obj]
-         *
+         * @description Iterates all common properties of obj (if existing) and self, and copies them onto self. Is aware of nested Model Objects and rebuilds them also. When List properties are decorated with {@link list}, the list items will also be rebuilt
+         * @summary Repopulates the instance with properties from the new Model Object, handling nested models
+         * @template T - Type extending Model
+         * @param {T} self - The target model instance to update
+         * @param {T|Record<string, any>} [obj] - The source model or object to copy properties from
+         * @return {T} The updated model instance
          */
         static fromModel<T extends Model>(self: T, obj?: T | Record<string, any>): T;
         /**
-         * @summary Sets the Global {@link ModelBuilderFunction}
-         * @param {ModelBuilderFunction} [builder]
+         * @description Configures the global model builder function used for creating model instances
+         * @summary Sets the Global {@link ModelBuilderFunction} used for model construction
+         * @param {ModelBuilderFunction} [builder] - The builder function to set, or undefined to reset
+         * @return {void}
          */
         static setBuilder(builder?: ModelBuilderFunction): void;
         /**
-         * @summary Retrieves the current global {@link ModelBuilderFunction}
+         * @description Returns the currently configured global model builder function
+         * @summary Retrieves the current global {@link ModelBuilderFunction} used for model construction
+         * @return {ModelBuilderFunction|undefined} The current builder function or undefined if not set
          */
         static getBuilder(): ModelBuilderFunction | undefined;
         /**
-         * Returns the current {@link ModelRegistryManager}
-         *
-         * @return ModelRegistry, defaults to {@link ModelRegistryManager}
+         * @description Retrieves the current model registry instance
+         * @summary Returns the current {@link ModelRegistryManager} used for model registration
+         * @return {BuilderRegistry<any>} ModelRegistry instance, defaults to {@link ModelRegistryManager}
+         * @private
          */
         private static getRegistry;
         /**
-         * Returns the current actingModelRegistry
-         *
-         * @param {BuilderRegistry} modelRegistry the new implementation of Registry
+         * @description Sets the model registry to be used for model registration and retrieval
+         * @summary Configures the current model registry implementation
+         * @param {BuilderRegistry<any>} modelRegistry - The new implementation of Registry to use
+         * @return {void}
          */
         static setRegistry(modelRegistry: BuilderRegistry<any>): void;
         /**
-         * @summary register new Models
-         * @param {any} constructor
-         * @param {string} [name] when not defined, the name of the constructor will be used
-         *
+         * @description Registers a model constructor with the model registry
+         * @summary Registers new Models for later retrieval and instantiation
+         * @template T - Type extending Model
+         * @param {ModelConstructor<T>} constructor - The model constructor to register
+         * @param {string} [name] - Optional name for registration, defaults to constructor name
+         * @return {void}
          * @see ModelRegistry
          */
         static register<T extends Model>(constructor: ModelConstructor<T>, name?: string): void;
         /**
-         * @summary Gets a registered Model {@link ModelConstructor}
-         * @param {string} name
-         *
+         * @description Retrieves a previously registered model constructor by name
+         * @summary Gets a registered Model {@link ModelConstructor} from the registry
+         * @template T - Type extending Model
+         * @param {string} name - The name of the model to retrieve
+         * @return {ModelConstructor<T>|undefined} The model constructor or undefined if not found
          * @see ModelRegistry
          */
         static get<T extends Model>(name: string): ModelConstructor<T> | undefined;
         /**
-         * @param {Record<string, any>} obj
-         * @param {string} [clazz] when provided, it will attempt to find the matching constructor
-         *
-         * @throws Error If clazz is not found, or obj is not a {@link Model} meaning it has no {@link ModelKeys.ANCHOR} property
-         *
+         * @description Creates a new model instance from a plain object
+         * @summary Builds a model instance using the registered constructor
+         * @template T - Type extending Model
+         * @param {Record<string, any>} [obj] - The source object to build from
+         * @param {string} [clazz] - Optional class name to find the matching constructor
+         * @return {T} The built model instance
+         * @throws {Error} If clazz is not found, or obj is not a {@link Model} meaning it has no {@link ModelKeys.ANCHOR} property
          * @see ModelRegistry
          */
         static build<T extends Model>(obj?: Record<string, any>, clazz?: string): T;
+        /**
+         * @description Retrieves metadata associated with a model instance
+         * @summary Gets the metadata attached to a model
+         * @template V - Type extending Model
+         * @param {V} model - The model instance to get metadata from
+         * @return {any} The model's metadata
+         */
         static getMetadata<V extends Model>(model: V): any;
+        /**
+         * @description Retrieves all attribute names defined on a model
+         * @summary Gets the list of attributes for a model class or instance
+         * @template V - Type extending Model
+         * @param {(Constructor<V>|V)} model - The model constructor or instance
+         * @return {string[]} Array of attribute names
+         */
         static getAttributes<V extends Model>(model: Constructor<V> | V): string[];
-        static equals<V extends Model>(obj1: V, obj2: V, ...exceptions: any[]): boolean;
-        static hasErrors<V extends Model>(model: V, ...exceptions: any[]): ModelErrorDefinition | undefined;
-        static serialize<V extends Model>(model: V): any;
-        static hash<V extends Model>(model: V): any;
         /**
-         * @summary Builds the key to store as Metadata under Reflections
-         * @description concatenates {@link ModelKeys#REFLECT} with the provided key
-         * @param {string} str
+         * @description Compares two model instances for equality
+         * @summary Static method to check if two model instances are equal
+         * @template M - Type extending Model
+         * @param {M} obj1 - First model instance to compare
+         * @param {M} obj2 - Second model instance to compare
+         * @param {any[]} exceptions - Properties to exclude from comparison
+         * @return {boolean} True if models are equal, false otherwise
+         */
+        static equals<M extends Model>(obj1: M, obj2: M, ...exceptions: any[]): boolean;
+        /**
+         * @description Validates a model and checks for errors
+         * @summary Static method to validate a model instance
+         * @template M - Type extending Model
+         * @param {M} model - The model instance to validate
+         * @param {string[]} propsToIgnore - Properties to exclude from validation
+         * @return {ModelErrorDefinition|undefined} Error definition if validation fails, undefined otherwise
+         */
+        static hasErrors<M extends Model>(model: M, ...propsToIgnore: string[]): ModelErrorDefinition | undefined;
+        /**
+         * @description Serializes a model instance to a string
+         * @summary Static method to convert a model to its serialized form
+         * @template M - Type extending Model
+         * @param {M} model - The model instance to serialize
+         * @return {string} The serialized representation of the model
+         */
+        static serialize<M extends Model>(model: M): any;
+        /**
+         * @description Generates a hash code for a model instance
+         * @summary Static method to create a hash code for a model
+         * @template M - Type extending Model
+         * @param {M} model - The model instance to hash
+         * @return {string} The hash code for the model
+         */
+        static hash<M extends Model>(model: M): any;
+        /**
+         * @description Builds a metadata key for reflection
+         * @summary Concatenates the model reflection prefix with the provided key string
+         * @param {string} str - The key string to append to the reflection prefix
+         * @return {string} The complete metadata key
          */
         static key(str: string): string;
+        /**
+         * @description Determines if an object is a model instance or has model metadata
+         * @summary Checks whether a given object is either an instance of the Model class or
+         * has model metadata attached to it. This function is essential for serialization and
+         * deserialization processes, as it helps identify model objects that need special handling.
+         * It safely handles potential errors during metadata retrieval.
+         *
+         * @param {Record<string, any>} target - The object to check
+         * @return {boolean} True if the object is a model instance or has model metadata, false otherwise
+         *
+         * @example
+         * ```typescript
+         * // Check if an object is a model
+         * const user = new User({ name: "John" });
+         * const isUserModel = isModel(user); // true
+         *
+         * // Check a plain object
+         * const plainObject = { name: "John" };
+         * const isPlainObjectModel = isModel(plainObject); // false
+         * ```
+         */
+        static isModel(target: Record<string, any>): boolean;
+        /**
+         * @description Checks if a property of a model is itself a model or has a model type
+         * @summary Determines whether a specific property of a model instance is either a model instance
+         * or has a type that is registered as a model. This function is used for model serialization
+         * and deserialization to properly handle nested models.
+         * @template M extends {@link Model}
+         * @param {M} target - The model instance to check
+         * @param {string} attribute - The property name to check
+         * @return {boolean | string | undefined} Returns true if the property is a model instance,
+         * the model name if the property has a model type, or undefined if not a model
+         */
+        static isPropertyModel<M extends Model>(target: M, attribute: string): boolean | string | undefined;
+        /**
+         * @description Checks if a property of a model is itself a model or has a model type
+         * @summary Determines whether a specific property of a model instance is either a model instance
+         * or has a type that is registered as a model. This function is used for model serialization
+         * and deserialization to properly handle nested models.
+         * @template R the expected UI code according to each rendering engine
+         * @param {any[]} args - optional engine specific args
+         */
         render<R>(...args: any[]): R;
     }
 }

package/lib/esm/model/model.js

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"model.js","sourceRoot":"","sources":["../../../src/model/model.ts"],"names":[],"mappings":"","sourcesContent":["import { ModelErrorDefinition } from \"@decaf-ts/decorator-validation\";\nimport {\n  BuilderRegistry,\n  Comparable,\n  Constructor,\n  Hashable,\n  ModelArg,\n  ModelBuilderFunction,\n  ModelConstructor,\n  Serializable,\n  Validatable,\n} from \"@decaf-ts/decorator-validation\";\nimport { Renderable } from \"./Renderable\";\n\ndeclare module \"@decaf-ts/decorator-validation\" {\n  // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n  // @ts-expect-error\n  declare abstract class Model\n    implements\n      Validatable,\n      Serializable,\n      Hashable,\n      Comparable<Model>,\n      Renderable\n  {\n    protected constructor(arg?: ModelArg<Model>);\n\n    hasErrors(...exclusions: any[]): ModelErrorDefinition | undefined;\n    hasErrors(\n      previousVersion?: Model | any,\n      ...exclusions: any[]\n    ): ModelErrorDefinition | undefined;\n\n    /**\n     * @description Compares this model with another object for equality\n     * @summary Compare object equality recursively, checking all properties\n     * @param {any} obj - Object to compare to\n     * @param {...string} exceptions - Property names to be excluded from the comparison\n     * @return {boolean} True if objects are equal, false otherwise\n     */\n    equals(obj: any, ...exceptions: string[]): boolean;\n\n    /**\n     * @description Converts the model to a serialized string representation\n     * @summary Returns the serialized model according to the currently defined {@link Serializer}\n     * @return {string} Serialized representation of the model\n     */\n    serialize(): string;\n\n    /**\n     * @description Provides a string representation of the model\n     * @summary Override the implementation for JavaScript's default toString() method\n     * @return {string} String representation of the model\n     * @override\n     */\n    toString(): string;\n\n    /**\n     * @description Generates a hash code for the model\n     * @summary Defines a default implementation for object hash based on Java's string hash algorithm\n     * @return {string} Hash code for the model\n     */\n    hash(): string;\n\n    /**\n     * @description Converts a serialized string back to a model instance\n     * @summary Deserializes a Model from its string representation\n     * @param {string} str - The serialized string to deserialize\n     * @return {any} The deserialized model instance\n     * @throws {Error} If it fails to parse the string, or if it fails to build the model\n     */\n    static deserialize(str: string): any;\n\n    /**\n     * @description Iterates all common properties of obj (if existing) and self, and copies them onto self\n     * @summary Repopulates the Object properties with the ones from the new object\n     * @template T - Type extending Model\n     * @param {T} self - The target model instance to update\n     * @param {T|Record<string, any>} [obj] - The source object to copy properties from\n     * @return {T} The updated model instance\n     */\n    static fromObject<T extends Model>(\n      self: T,\n      obj?: T | Record<string, any>\n    ): T;\n\n    /**\n     * @description Iterates all common properties of obj (if existing) and self, and copies them onto self. Is aware of nested Model Objects and rebuilds them also. When List properties are decorated with {@link list}, the list items will also be rebuilt\n     * @summary Repopulates the instance with properties from the new Model Object, handling nested models\n     * @template T - Type extending Model\n     * @param {T} self - The target model instance to update\n     * @param {T|Record<string, any>} [obj] - The source model or object to copy properties from\n     * @return {T} The updated model instance\n     */\n    static fromModel<T extends Model>(\n      self: T,\n      obj?: T | Record<string, any>\n    ): T;\n\n    /**\n     * @description Configures the global model builder function used for creating model instances\n     * @summary Sets the Global {@link ModelBuilderFunction} used for model construction\n     * @param {ModelBuilderFunction} [builder] - The builder function to set, or undefined to reset\n     * @return {void}\n     */\n    static setBuilder(builder?: ModelBuilderFunction): void;\n\n    /**\n     * @description Returns the currently configured global model builder function\n     * @summary Retrieves the current global {@link ModelBuilderFunction} used for model construction\n     * @return {ModelBuilderFunction|undefined} The current builder function or undefined if not set\n     */\n    static getBuilder(): ModelBuilderFunction | undefined;\n\n    /**\n     * @description Retrieves the current model registry instance\n     * @summary Returns the current {@link ModelRegistryManager} used for model registration\n     * @return {BuilderRegistry<any>} ModelRegistry instance, defaults to {@link ModelRegistryManager}\n     * @private\n     */\n    private static getRegistry;\n\n    /**\n     * @description Sets the model registry to be used for model registration and retrieval\n     * @summary Configures the current model registry implementation\n     * @param {BuilderRegistry<any>} modelRegistry - The new implementation of Registry to use\n     * @return {void}\n     */\n    static setRegistry(modelRegistry: BuilderRegistry<any>): void;\n\n    /**\n     * @description Registers a model constructor with the model registry\n     * @summary Registers new Models for later retrieval and instantiation\n     * @template T - Type extending Model\n     * @param {ModelConstructor<T>} constructor - The model constructor to register\n     * @param {string} [name] - Optional name for registration, defaults to constructor name\n     * @return {void}\n     * @see ModelRegistry\n     */\n    static register<T extends Model>(\n      constructor: ModelConstructor<T>,\n      name?: string\n    ): void;\n\n    /**\n     * @description Retrieves a previously registered model constructor by name\n     * @summary Gets a registered Model {@link ModelConstructor} from the registry\n     * @template T - Type extending Model\n     * @param {string} name - The name of the model to retrieve\n     * @return {ModelConstructor<T>|undefined} The model constructor or undefined if not found\n     * @see ModelRegistry\n     */\n    static get<T extends Model>(name: string): ModelConstructor<T> | undefined;\n\n    /**\n     * @description Creates a new model instance from a plain object\n     * @summary Builds a model instance using the registered constructor\n     * @template T - Type extending Model\n     * @param {Record<string, any>} [obj] - The source object to build from\n     * @param {string} [clazz] - Optional class name to find the matching constructor\n     * @return {T} The built model instance\n     * @throws {Error} If clazz is not found, or obj is not a {@link Model} meaning it has no {@link ModelKeys.ANCHOR} property\n     * @see ModelRegistry\n     */\n    static build<T extends Model>(obj?: Record<string, any>, clazz?: string): T;\n\n    /**\n     * @description Retrieves metadata associated with a model instance\n     * @summary Gets the metadata attached to a model\n     * @template V - Type extending Model\n     * @param {V} model - The model instance to get metadata from\n     * @return {any} The model's metadata\n     */\n    static getMetadata<V extends Model>(model: V): any;\n\n    /**\n     * @description Retrieves all attribute names defined on a model\n     * @summary Gets the list of attributes for a model class or instance\n     * @template V - Type extending Model\n     * @param {(Constructor<V>|V)} model - The model constructor or instance\n     * @return {string[]} Array of attribute names\n     */\n    static getAttributes<V extends Model>(model: Constructor<V> | V): string[];\n\n    /**\n     * @description Compares two model instances for equality\n     * @summary Static method to check if two model instances are equal\n     * @template M - Type extending Model\n     * @param {M} obj1 - First model instance to compare\n     * @param {M} obj2 - Second model instance to compare\n     * @param {any[]} exceptions - Properties to exclude from comparison\n     * @return {boolean} True if models are equal, false otherwise\n     */\n    static equals<M extends Model>(\n      obj1: M,\n      obj2: M,\n      ...exceptions: any[]\n    ): boolean;\n\n    /**\n     * @description Validates a model and checks for errors\n     * @summary Static method to validate a model instance\n     * @template M - Type extending Model\n     * @param {M} model - The model instance to validate\n     * @param {string[]} propsToIgnore - Properties to exclude from validation\n     * @return {ModelErrorDefinition|undefined} Error definition if validation fails, undefined otherwise\n     */\n    static hasErrors<M extends Model>(\n      model: M,\n      ...propsToIgnore: string[]\n    ): ModelErrorDefinition | undefined;\n\n    /**\n     * @description Serializes a model instance to a string\n     * @summary Static method to convert a model to its serialized form\n     * @template M - Type extending Model\n     * @param {M} model - The model instance to serialize\n     * @return {string} The serialized representation of the model\n     */\n    static serialize<M extends Model>(model: M): any;\n\n    /**\n     * @description Generates a hash code for a model instance\n     * @summary Static method to create a hash code for a model\n     * @template M - Type extending Model\n     * @param {M} model - The model instance to hash\n     * @return {string} The hash code for the model\n     */\n    static hash<M extends Model>(model: M): any;\n\n    /**\n     * @description Builds a metadata key for reflection\n     * @summary Concatenates the model reflection prefix with the provided key string\n     * @param {string} str - The key string to append to the reflection prefix\n     * @return {string} The complete metadata key\n     */\n    static key(str: string): string;\n\n    /**\n     * @description Determines if an object is a model instance or has model metadata\n     * @summary Checks whether a given object is either an instance of the Model class or\n     * has model metadata attached to it. This function is essential for serialization and\n     * deserialization processes, as it helps identify model objects that need special handling.\n     * It safely handles potential errors during metadata retrieval.\n     *\n     * @param {Record<string, any>} target - The object to check\n     * @return {boolean} True if the object is a model instance or has model metadata, false otherwise\n     *\n     * @example\n     * ```typescript\n     * // Check if an object is a model\n     * const user = new User({ name: \"John\" });\n     * const isUserModel = isModel(user); // true\n     *\n     * // Check a plain object\n     * const plainObject = { name: \"John\" };\n     * const isPlainObjectModel = isModel(plainObject); // false\n     * ```\n     */\n    static isModel(target: Record<string, any>): boolean;\n\n    /**\n     * @description Checks if a property of a model is itself a model or has a model type\n     * @summary Determines whether a specific property of a model instance is either a model instance\n     * or has a type that is registered as a model. This function is used for model serialization\n     * and deserialization to properly handle nested models.\n     * @template M extends {@link Model}\n     * @param {M} target - The model instance to check\n     * @param {string} attribute - The property name to check\n     * @return {boolean | string | undefined} Returns true if the property is a model instance,\n     * the model name if the property has a model type, or undefined if not a model\n     */\n    static isPropertyModel<M extends Model>(\n      target: M,\n      attribute: string\n    ): boolean | string | undefined;\n\n    /**\n     * @description Checks if a property of a model is itself a model or has a model type\n     * @summary Determines whether a specific property of a model instance is either a model instance\n     * or has a type that is registered as a model. This function is used for model serialization\n     * and deserialization to properly handle nested models.\n     * @template R the expected UI code according to each rendering engine\n     * @param {any[]} args - optional engine specific args\n     */\n    render<R>(...args: any[]): R;\n  }\n}\n"]}

package/lib/esm/model/overrides.d.ts

@@ -1 +1,9 @@
+/**
+ * @description Module that extends the Model prototype with rendering capabilities
+ * @summary Adds the render method to all Model instances from decorator-validation
+ * This module implements the Renderable interface for the Model class by adding a render method
+ * to its prototype. This allows any Model instance to be rendered using the RenderingEngine.
+ * @module model/overrides
+ * @memberOf module:ui-decorators/model
+ */
 export {};

package/lib/esm/model/overrides.js

@@ -1,6 +1,24 @@
+/**
+ * @description Module that extends the Model prototype with rendering capabilities
+ * @summary Adds the render method to all Model instances from decorator-validation
+ * This module implements the Renderable interface for the Model class by adding a render method
+ * to its prototype. This allows any Model instance to be rendered using the RenderingEngine.
+ * @module model/overrides
+ * @memberOf module:ui-decorators/model
+ */
 import { Model } from "@decaf-ts/decorator-validation";
 import { RenderingEngine } from "../ui/Rendering";
+/**
+ * @description Renders the model using the appropriate rendering engine
+ * @summary Delegates rendering to the RenderingEngine based on model metadata
+ * This method implements the render method from the Renderable interface for all Model instances.
+ * It uses the RenderingEngine to determine how to render the model based on its metadata.
+ *
+ * @template M Type of the model being rendered
+ * @param {any[]} args Additional arguments to pass to the rendering engine
+ * @return {any} The rendered output in the format determined by the rendering engine
+ */
 Model.prototype.render = function (...args) {
     return RenderingEngine.render(this, ...args);
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3ZlcnJpZGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL21vZGVsL292ZXJyaWRlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsS0FBSyxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDdkQsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBRWxELEtBQUssQ0FBQyxTQUFTLENBQUMsTUFBTSxHQUFHLFVBQW9DLEdBQUcsSUFBVztJQUN6RSxPQUFPLGVBQWUsQ0FBQyxNQUFNLENBQUMsSUFBSSxFQUFFLEdBQUcsSUFBSSxDQUFDLENBQUM7QUFDL0MsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTW9kZWwgfSBmcm9tIFwiQGRlY2FmLXRzL2RlY29yYXRvci12YWxpZGF0aW9uXCI7XG5pbXBvcnQgeyBSZW5kZXJpbmdFbmdpbmUgfSBmcm9tIFwiLi4vdWkvUmVuZGVyaW5nXCI7XG5cbk1vZGVsLnByb3RvdHlwZS5yZW5kZXIgPSBmdW5jdGlvbiA8TSBleHRlbmRzIE1vZGVsPih0aGlzOiBNLCAuLi5hcmdzOiBhbnlbXSkge1xuICByZXR1cm4gUmVuZGVyaW5nRW5naW5lLnJlbmRlcih0aGlzLCAuLi5hcmdzKTtcbn07XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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