@decaf-ts/decorator-validation 1.0.7 → 1.0.11

package/lib/reflection/utils.cjs

@@ -0,0 +1,251 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllPropertyDecorators = void 0;
+exports.getPropertyDecorators = getPropertyDecorators;
+exports.getTypeFromDecorator = getTypeFromDecorator;
+exports.getAllProperties = getAllProperties;
+exports.getClassDecorators = getClassDecorators;
+exports.checkType = checkType;
+exports.checkTypes = checkTypes;
+exports.evaluateDesignTypes = evaluateDesignTypes;
+exports.isModel = isModel;
+const constants_1 = require("../utils/constants/index.cjs");
+const strings_1 = require("../utils/strings/index.cjs");
+const equality_1 = require("../utils/equality/index.cjs");
+require("reflect-metadata");
+/**
+ * @summary Util function to retrieve the decorators for the provided Property
+ *
+ * @param {string} annotationPrefix
+ * @param {any} target
+ * @param {string | symbol} propertyName
+ * @param {boolean} [ignoreType] defaults to false. decides if the {@link ModelKeys.TYPE} is ignored or not
+ * @param {boolean} [recursive] defaults to true. decides if it should climb the prototypal tree searching for more decorators on that property
+ * @param {DecoratorMetadata[]} [accumulator] used when recursive is true, to cache decorators while it climbs the prototypal tree
+ *
+ * @function getPropertyDecorators
+ * @memberOf module:decorator-validation.Reflection
+ * @category Reflection
+ */
+function getPropertyDecorators(annotationPrefix, target, propertyName, ignoreType = false, recursive = true, accumulator) {
+    const getPropertyDecoratorsForModel = function (annotationPrefix, target, propertyName, ignoreType = false, accumulator) {
+        // get info about keys that used in current property
+        const keys = Reflect.getMetadataKeys(target, propertyName);
+        const decorators = keys
+            // filter your custom decorators
+            .filter((key) => {
+            if (ignoreType)
+                return key.toString().startsWith(annotationPrefix);
+            return (key === constants_1.ModelKeys.TYPE || key.toString().startsWith(annotationPrefix));
+        })
+            .reduce((values, key) => {
+            // get metadata value.
+            const currValues = {
+                key: key !== constants_1.ModelKeys.TYPE
+                    ? key.substring(annotationPrefix.length)
+                    : key,
+                props: Reflect.getMetadata(key, target, propertyName),
+            };
+            return values.concat(currValues);
+        }, accumulator || []);
+        return {
+            prop: propertyName.toString(),
+            decorators: decorators,
+        };
+    };
+    const result = getPropertyDecoratorsForModel(annotationPrefix, target, propertyName, ignoreType, accumulator);
+    const trim = function (items) {
+        const cache = {};
+        return items.filter((item) => {
+            if (item.key in cache) {
+                if (!(0, equality_1.isEqual)(item.props, cache[item.key]))
+                    console.log((0, strings_1.sf)("Found a similar decorator for the {0} property of a {1} model but with different attributes. The original one will be kept", item.key, target.constructor.name));
+                return false;
+            }
+            cache[item.key.toString()] = item.props;
+            return true;
+        });
+    };
+    if (!recursive || Object.getPrototypeOf(target) === Object.prototype) {
+        return {
+            prop: result.prop,
+            decorators: trim(result.decorators),
+        };
+    }
+    // We choose to ignore type here, because in inheritance the expected type is from the lowest child class
+    return getPropertyDecorators(annotationPrefix, Object.getPrototypeOf(target.constructor), propertyName, true, recursive, result.decorators);
+}
+/**
+ * @summary gets the prop type from the decorator
+ * @param {any} model
+ * @param {string | symbol} propKey
+ * @return {string | undefined}
+ *
+ * @function geTypeFromDecorators
+ *
+ * @memberOf module:decorator-validation.Reflection
+ */
+function getTypeFromDecorator(model, propKey) {
+    const decorators = getPropertyDecorators(constants_1.ModelKeys.REFLECT, model, propKey, false);
+    if (!decorators || !decorators.decorators)
+        return;
+    // TODO handle @type decorators. for now we stick with design:type
+    const typeDecorator = decorators.decorators.shift();
+    const name = typeDecorator.props ? typeDecorator.props.name : undefined;
+    return name !== "Function" ? name : undefined;
+}
+/**
+ * @summary Retrieves the decorators for an object's properties prefixed by {@param prefixes}
+ *
+ * @param {T} model
+ * @param {string[]} prefixes
+ *
+ * @function getAllPropertyDecorators
+ *
+ * @memberOf module:db-decorators.Reflection
+ */
+const getAllPropertyDecorators = function (model, ...prefixes) {
+    if (!prefixes || !prefixes.length)
+        return;
+    const pushOrCreate = function (accum, key, decorators) {
+        if (!decorators || !decorators.length)
+            return;
+        if (!accum[key])
+            accum[key] = [];
+        accum[key].push(...decorators);
+    };
+    return Object.getOwnPropertyNames(model).reduce((accum, propKey) => {
+        prefixes.forEach((p, index) => {
+            const decorators = getPropertyDecorators(p, model, propKey, index !== 0);
+            if (!accum)
+                accum = {};
+            pushOrCreate(accum, propKey, decorators.decorators);
+        });
+        return accum;
+    }, undefined);
+};
+exports.getAllPropertyDecorators = getAllPropertyDecorators;
+/**
+ * @summary Retrieves all properties of an object
+ * @description
+ *  - and of all its prototypes if {@param climbTree} until it reaches {@param stopAt} (or ends the prototype chain)
+ *
+ * @param obj
+ * @param {boolean} [climbTree] default to true
+ * @param {string} [stopAt] defaults to 'Object'
+ *
+ * @function getAllProperties
+ *
+ * @memberOf module:decorator-validation.Model
+ */
+function getAllProperties(obj, climbTree = true, stopAt = "Object") {
+    const allProps = [];
+    let curr = obj;
+    const keepAtIt = function () {
+        if (!climbTree)
+            return;
+        const prototype = Object.getPrototypeOf(curr);
+        if (!prototype || prototype.constructor.name === stopAt)
+            return;
+        curr = prototype;
+        return curr;
+    };
+    do {
+        const props = Object.getOwnPropertyNames(curr);
+        props.forEach(function (prop) {
+            if (allProps.indexOf(prop) === -1)
+                allProps.push(prop);
+        });
+    } while (keepAtIt());
+    return allProps;
+}
+/**
+ * @summary Util function to retrieve the Class decorators
+ *
+ * @function getClassDecorators
+ * @memberOf module:decorator-validation.Reflection
+ * @category Reflection
+ */
+function getClassDecorators(annotationPrefix, target) {
+    const keys = Reflect.getOwnMetadataKeys(target.constructor);
+    return keys
+        .filter((key) => key.toString().startsWith(annotationPrefix))
+        .reduce((values, key) => {
+        // get metadata value
+        const currValues = {
+            key: key.substring(annotationPrefix.length),
+            props: Reflect.getMetadata(key, target.constructor),
+        };
+        return values.concat(currValues);
+    }, []);
+}
+/**
+ * @summary Util function to check a type according to a typeName
+ *
+ * @param {any} value
+ * @param {string} acceptedType
+ * @return {boolean} true for a match, false otherwise
+ *
+ * @function checkType
+ * @memberOf module:decorator-validation.Validation
+ * @category Validation
+ */
+function checkType(value, acceptedType) {
+    if (typeof value === acceptedType)
+        return true;
+    return (value.constructor &&
+        value.constructor.name.toLowerCase() === acceptedType.toLowerCase());
+}
+/**
+ * @summary Util function to check a type according multiple possibilities
+ * @param {any} value
+ * @param {string[]} acceptedTypes
+ * @return {boolean} true if any is a match, false otherwise
+ *
+ * @function checkTypes
+ * @memberOf module:decorator-validation.Validation
+ * @category Validation
+ */
+function checkTypes(value, acceptedTypes) {
+    return !acceptedTypes.every((t) => !checkType(value, t));
+}
+/**
+ * @summary The model type
+ *
+ * @param {any} value
+ * @param {string | string[] | {name: string}} types
+ *
+ * @function evaluateDesignTypes
+ * @memberOf module:decorator-validation.Validation
+ * @category Validation
+ */
+function evaluateDesignTypes(value, types) {
+    switch (typeof types) {
+        case "string":
+            return checkType(value, types);
+        case "object":
+            if (Array.isArray(types))
+                return checkTypes(value, types);
+            return true;
+        case "function":
+            if (types.name && types.name !== "Object")
+                return checkType(value, types.name);
+            return true;
+        default:
+            return true;
+    }
+}
+/**
+ * @summary For Serialization/deserialization purposes.
+ * @description Reads the {@link ModelKeys.ANCHOR} property of a {@link Model} to discover the class to instantiate
+ *
+ * @function isModel
+ * @memberOf module:decorator-validation.Validation
+ * @category Validation
+ */
+function isModel(target) {
+    return (!!target[constants_1.ModelKeys.ANCHOR] ||
+        !!getClassDecorators(constants_1.ModelKeys.REFLECT, target).find((dec) => dec.key === constants_1.ModelKeys.MODEL && dec.props && dec.props.class));
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/reflection/utils.ts"],"names":[],"mappings":"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","file":"reflection/utils.js","sourcesContent":["import { Model } from \"../model/Model\";\nimport { ModelKeys } from \"../utils/constants\";\nimport { sf } from \"../utils/strings\";\nimport { isEqual } from \"../utils/equality\";\nimport \"reflect-metadata\";\nimport { DecoratorMetadata } from \"../validation\";\n\n/**\n * @summary Util function to retrieve the decorators for the provided Property\n *\n * @param {string} annotationPrefix\n * @param {any} target\n * @param {string | symbol} propertyName\n * @param {boolean} [ignoreType] defaults to false. decides if the {@link ModelKeys.TYPE} is ignored or not\n * @param {boolean} [recursive] defaults to true. decides if it should climb the prototypal tree searching for more decorators on that property\n * @param {DecoratorMetadata[]} [accumulator] used when recursive is true, to cache decorators while it climbs the prototypal tree\n *\n * @function getPropertyDecorators\n * @memberOf module:decorator-validation.Reflection\n * @category Reflection\n */\nexport function getPropertyDecorators(\n  annotationPrefix: string,\n  target: any,\n  propertyName: string | symbol,\n  ignoreType: boolean = false,\n  recursive = true,\n  accumulator?: DecoratorMetadata[],\n): { prop: string; decorators: DecoratorMetadata[] } {\n  const getPropertyDecoratorsForModel = function (\n    annotationPrefix: string,\n    target: any,\n    propertyName: string | symbol,\n    ignoreType: boolean = false,\n    accumulator?: DecoratorMetadata[],\n  ): { prop: string; decorators: DecoratorMetadata[] } {\n    // get info about keys that used in current property\n    const keys: any[] = Reflect.getMetadataKeys(target, propertyName);\n    const decorators: DecoratorMetadata[] = keys\n      // filter your custom decorators\n      .filter((key) => {\n        if (ignoreType) return key.toString().startsWith(annotationPrefix);\n        return (\n          key === ModelKeys.TYPE || key.toString().startsWith(annotationPrefix)\n        );\n      })\n      .reduce((values, key) => {\n        // get metadata value.\n        const currValues = {\n          key:\n            key !== ModelKeys.TYPE\n              ? key.substring(annotationPrefix.length)\n              : key,\n          props: Reflect.getMetadata(key, target, propertyName),\n        };\n        return values.concat(currValues);\n      }, accumulator || []);\n\n    return {\n      prop: propertyName.toString(),\n      decorators: decorators,\n    };\n  };\n\n  const result: { prop: string; decorators: DecoratorMetadata[] } =\n    getPropertyDecoratorsForModel(\n      annotationPrefix,\n      target,\n      propertyName,\n      ignoreType,\n      accumulator,\n    );\n\n  const trim = function (items: DecoratorMetadata[]) {\n    const cache: Record<string, DecoratorMetadata> = {};\n    return items.filter((item: DecoratorMetadata) => {\n      if (item.key in cache) {\n        if (!isEqual(item.props, cache[item.key]))\n          console.log(\n            sf(\n              \"Found a similar decorator for the {0} property of a {1} model but with different attributes. The original one will be kept\",\n              item.key,\n              target.constructor.name,\n            ),\n          );\n        return false;\n      }\n\n      cache[item.key.toString()] = item.props as DecoratorMetadata;\n      return true;\n    });\n  };\n\n  if (!recursive || Object.getPrototypeOf(target) === Object.prototype) {\n    return {\n      prop: result.prop,\n      decorators: trim(result.decorators),\n    };\n  }\n\n  // We choose to ignore type here, because in inheritance the expected type is from the lowest child class\n  return getPropertyDecorators(\n    annotationPrefix,\n    Object.getPrototypeOf(target.constructor),\n    propertyName,\n    true,\n    recursive,\n    result.decorators,\n  );\n}\n\n/**\n * @summary gets the prop type from the decorator\n * @param {any} model\n * @param {string | symbol} propKey\n * @return {string | undefined}\n *\n * @function geTypeFromDecorators\n *\n * @memberOf module:decorator-validation.Reflection\n */\nexport function getTypeFromDecorator(\n  model: any,\n  propKey: string | symbol,\n): string | undefined {\n  const decorators: { prop: string | symbol; decorators: any[] } =\n    getPropertyDecorators(ModelKeys.REFLECT, model, propKey, false);\n  if (!decorators || !decorators.decorators) return;\n\n  // TODO handle @type decorators. for now we stick with design:type\n  const typeDecorator = decorators.decorators.shift();\n  const name = typeDecorator.props ? typeDecorator.props.name : undefined;\n  return name !== \"Function\" ? name : undefined;\n}\n\n/**\n * @summary Retrieves the decorators for an object's properties prefixed by {@param prefixes}\n *\n * @param {T} model\n * @param {string[]} prefixes\n *\n * @function getAllPropertyDecorators\n *\n * @memberOf module:db-decorators.Reflection\n */\nexport const getAllPropertyDecorators = function <T extends Model>(\n  model: T,\n  ...prefixes: string[]\n): Record<string, any> | undefined {\n  if (!prefixes || !prefixes.length) return;\n\n  const pushOrCreate = function (\n    accum: Record<string, Record<string, any>>,\n    key: string,\n    decorators: any[],\n  ) {\n    if (!decorators || !decorators.length) return;\n    if (!accum[key]) accum[key] = [];\n    accum[key].push(...decorators);\n  };\n\n  return Object.getOwnPropertyNames(model).reduce(\n    (accum: Record<string, any> | undefined, propKey) => {\n      prefixes.forEach((p, index) => {\n        const decorators: { prop: string | symbol; decorators: any[] } =\n          getPropertyDecorators(p, model, propKey, index !== 0);\n        if (!accum) accum = {};\n        pushOrCreate(accum, propKey, decorators.decorators);\n      });\n      return accum;\n    },\n    undefined,\n  );\n};\n\n/**\n * @summary Retrieves all properties of an object\n * @description\n *  - and of all its prototypes if {@param climbTree} until it reaches {@param stopAt} (or ends the prototype chain)\n *\n * @param obj\n * @param {boolean} [climbTree] default to true\n * @param {string} [stopAt] defaults to 'Object'\n *\n * @function getAllProperties\n *\n * @memberOf module:decorator-validation.Model\n */\nexport function getAllProperties(\n  obj: Record<any, any>,\n  climbTree = true,\n  stopAt = \"Object\",\n) {\n  const allProps: string[] = [];\n  let curr: Record<any, any> = obj;\n\n  const keepAtIt = function () {\n    if (!climbTree) return;\n    const prototype = Object.getPrototypeOf(curr);\n    if (!prototype || prototype.constructor.name === stopAt) return;\n    curr = prototype;\n    return curr;\n  };\n\n  do {\n    const props = Object.getOwnPropertyNames(curr);\n    props.forEach(function (prop) {\n      if (allProps.indexOf(prop) === -1) allProps.push(prop);\n    });\n  } while (keepAtIt());\n  return allProps;\n}\n\n/**\n * @summary Util function to retrieve the Class decorators\n *\n * @function getClassDecorators\n * @memberOf module:decorator-validation.Reflection\n * @category Reflection\n */\nexport function getClassDecorators(\n  annotationPrefix: string,\n  target: any,\n): { key: string; props: any }[] {\n  const keys: any[] = Reflect.getOwnMetadataKeys(target.constructor);\n\n  return keys\n    .filter((key) => key.toString().startsWith(annotationPrefix))\n    .reduce((values, key) => {\n      // get metadata value\n      const currValues = {\n        key: key.substring(annotationPrefix.length),\n        props: Reflect.getMetadata(key, target.constructor),\n      };\n      return values.concat(currValues);\n    }, []);\n}\n\n/**\n * @summary Util function to check a type according to a typeName\n *\n * @param {any} value\n * @param {string} acceptedType\n * @return {boolean} true for a match, false otherwise\n *\n * @function checkType\n * @memberOf module:decorator-validation.Validation\n * @category Validation\n */\nexport function checkType(value: any, acceptedType: string) {\n  if (typeof value === acceptedType) return true;\n  return (\n    value.constructor &&\n    value.constructor.name.toLowerCase() === acceptedType.toLowerCase()\n  );\n}\n\n/**\n * @summary Util function to check a type according multiple possibilities\n * @param {any} value\n * @param {string[]} acceptedTypes\n * @return {boolean} true if any is a match, false otherwise\n *\n * @function checkTypes\n * @memberOf module:decorator-validation.Validation\n * @category Validation\n */\nexport function checkTypes(value: any, acceptedTypes: string[]) {\n  return !acceptedTypes.every((t) => !checkType(value, t));\n}\n\n/**\n * @summary The model type\n *\n * @param {any} value\n * @param {string | string[] | {name: string}} types\n *\n * @function evaluateDesignTypes\n * @memberOf module:decorator-validation.Validation\n * @category Validation\n */\nexport function evaluateDesignTypes(\n  value: any,\n  types: string | string[] | { name: string },\n) {\n  switch (typeof types) {\n    case \"string\":\n      return checkType(value, types);\n    case \"object\":\n      if (Array.isArray(types)) return checkTypes(value, types);\n      return true;\n    case \"function\":\n      if (types.name && types.name !== \"Object\")\n        return checkType(value, types.name);\n      return true;\n    default:\n      return true;\n  }\n}\n\n/**\n * @summary For Serialization/deserialization purposes.\n * @description Reads the {@link ModelKeys.ANCHOR} property of a {@link Model} to discover the class to instantiate\n *\n * @function isModel\n * @memberOf module:decorator-validation.Validation\n * @category Validation\n */\nexport function isModel(target: Record<string, any>) {\n  return (\n    !!target[ModelKeys.ANCHOR] ||\n    !!getClassDecorators(ModelKeys.REFLECT, target).find(\n      (dec) => dec.key === ModelKeys.MODEL && dec.props && dec.props.class,\n    )\n  );\n}\n"]}

package/lib/{utils/general.d.ts → reflection/utils.d.ts}

@@ -1,6 +1,6 @@
+import { Model } from "../model/Model";
 import "reflect-metadata";
 import { DecoratorMetadata } from "../validation";
-import { Model } from "../model";
 /**
  * @summary Util function to retrieve the decorators for the provided Property
  *
@@ -55,83 +55,6 @@ export declare const getAllPropertyDecorators: <T extends Model>(model: T, ...pr
  * @memberOf module:decorator-validation.Model
  */
 export declare function getAllProperties(obj: Record<any, any>, climbTree?: boolean, stopAt?: string): string[];
-/**
- * @summary Util function to provide string format functionality similar to C#'s string.format
- *
- * @param {string} string
- * @param {string} args replacements made by order of appearance (replacement0 wil replace {0} and so on)
- * @return {string} formatted string
- *
- * @function stringFormat
- * @memberOf module:decorator-validation.Utils.Format
- * @category Format
- */
-export declare function stringFormat(string: string, ...args: string[]): string;
-/**
- * @summary Deep Object Comparison
- * @description algorithm from {@link https://stackoverflow.com/questions/30476150/javascript-deep-comparison-recursively-objects-and-properties}
- * but with optional ignored properties
- *
- * @param {any} a
- * @param {any} b
- * @param {string} [propsToIgnore]
- *
- * @function isEqual
- * @memberOf module:decorator-validation.Utils.Equality
- * @category Validation
- */
-export declare function isEqual(a: any, b: any, ...propsToIgnore: string[]): boolean;
-/**
- * @summary Mimics Java's String's Hash implementation
- *
- * @param {string | number | symbol | Date} obj
- * @return {number} hash value of obj
- *
- * @function hashCode
- * @memberOf module:decorator-validation.Utils.Hashing
- * @category Hashing
- */
-export declare function hashCode(obj: string | number | symbol | Date): number;
-/**
- * @summary Defines teh type for a Hashing function
- * @memberOf module:decorator-validation.Utils.Hashing
- * @category Hashing
- */
-export type HashingFunction = (value: any) => string | number;
-/**
- * @summary Hashes an object serializing it and then hashing the string
- * @description The Serialization algorithm used by default (JSON.stringify)
- * is not deterministic and should not be used for hashing
- *
- * @param {Record<string, any>} obj
- * @return {string} the resulting hash
- *
- * @function hashSerialization
- * @memberOf module:decorator-validation.Utils.Hashing
- *
- * @category Hashing
- */
-export declare function hashSerialization(obj: Record<string, any> | any[]): number;
-/**
- * @summary Hashes an object by combining the hash of all its properties
- *
- * @param {Record<string, any>} obj
- * @return {string} the resulting hash
- *
- * @function hashObj
- * @memberOf module:decorator-validation.Utils.Hashing
- * @category Hashing
- */
-export declare function hashObj(obj: Record<string, any> | any[]): string | number;
-/**
- * @summary For Serialization/deserialization purposes.
- * @description Reads the {@link ModelKeys.ANCHOR} property of a {@link Model} to discover the class to instantiate
- *
- * @function isModel
- * @memberOf module:decorator-validation.Validation
- * @category Validation
- */
-export declare function isModel(target: Record<string, any>): boolean;
 /**
  * @summary Util function to retrieve the Class decorators
  *
@@ -180,14 +103,11 @@ export declare function evaluateDesignTypes(value: any, types: string | string[]
     name: string;
 }): any;
 /**
- * @summary Reverses the process from {@link formatDate}
- *
- * @param {string} date the date string to be converted back into date
- * @param {string} format the date format
- * @return {Date} the date from the format or the standard new Date({@prop date}) if the string couldn't be parsed (are you sure the format matches the string?)
+ * @summary For Serialization/deserialization purposes.
+ * @description Reads the {@link ModelKeys.ANCHOR} property of a {@link Model} to discover the class to instantiate
  *
- * @function dateFromFormat
- * @memberOf module:decorator-validation.Utils.Dates
- * @category Format
+ * @function isModel
+ * @memberOf module:decorator-validation.Validation
+ * @category Validation
  */
-export declare function dateFromFormat(date: string, format: string): Date;
+export declare function isModel(target: Record<string, any>): boolean;

package/lib/utils/constants.cjs

@@ -1 +1,28 @@
-"use strict";var ModelKeys;Object.defineProperty(exports,"__esModule",{value:!0}),exports.ModelKeys=void 0,function(e){e.REFLECT="model.definition.",e.TYPE="design:type",e.PARAMS="design:paramtypes",e.RETURN="design:returntype",e.MODEL="model",e.ANCHOR="__modelDefinition"}(ModelKeys||(exports.ModelKeys=ModelKeys={}));
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelKeys = void 0;
+/**
+ * @summary Defines the various Model keys used for reflection
+ *
+ * @property {string} REFLECT prefix to all other keys
+ * @property {string} TYPE type key
+ * @property {string} PARAMS method params key
+ * @property {string} RETURN method return key
+ * @property {string} MODEL model key
+ * @property {string} ANCHOR anchor key. will serve as a ghost property in the model
+ *
+ * @constant ModelKeys
+ * @memberOf module:decorator-validation.Model
+ * @category Model
+ */
+var ModelKeys;
+(function (ModelKeys) {
+    ModelKeys["REFLECT"] = "model.definition.";
+    ModelKeys["TYPE"] = "design:type";
+    ModelKeys["PARAMS"] = "design:paramtypes";
+    ModelKeys["RETURN"] = "design:returntype";
+    ModelKeys["MODEL"] = "model";
+    ModelKeys["ANCHOR"] = "__modelDefinition";
+})(ModelKeys || (exports.ModelKeys = ModelKeys = {}));
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy91dGlscy9jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUE7Ozs7Ozs7Ozs7Ozs7R0FhRztBQUNILElBQVksU0FPWDtBQVBELFdBQVksU0FBUztJQUNuQiwwQ0FBNkIsQ0FBQTtJQUM3QixpQ0FBb0IsQ0FBQTtJQUNwQix5Q0FBNEIsQ0FBQTtJQUM1Qix5Q0FBNEIsQ0FBQTtJQUM1Qiw0QkFBZSxDQUFBO0lBQ2YseUNBQTRCLENBQUE7QUFDOUIsQ0FBQyxFQVBXLFNBQVMseUJBQVQsU0FBUyxRQU9wQiIsImZpbGUiOiJ1dGlscy9jb25zdGFudHMuanMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBzdW1tYXJ5IERlZmluZXMgdGhlIHZhcmlvdXMgTW9kZWwga2V5cyB1c2VkIGZvciByZWZsZWN0aW9uXG4gKlxuICogQHByb3BlcnR5IHtzdHJpbmd9IFJFRkxFQ1QgcHJlZml4IHRvIGFsbCBvdGhlciBrZXlzXG4gKiBAcHJvcGVydHkge3N0cmluZ30gVFlQRSB0eXBlIGtleVxuICogQHByb3BlcnR5IHtzdHJpbmd9IFBBUkFNUyBtZXRob2QgcGFyYW1zIGtleVxuICogQHByb3BlcnR5IHtzdHJpbmd9IFJFVFVSTiBtZXRob2QgcmV0dXJuIGtleVxuICogQHByb3BlcnR5IHtzdHJpbmd9IE1PREVMIG1vZGVsIGtleVxuICogQHByb3BlcnR5IHtzdHJpbmd9IEFOQ0hPUiBhbmNob3Iga2V5LiB3aWxsIHNlcnZlIGFzIGEgZ2hvc3QgcHJvcGVydHkgaW4gdGhlIG1vZGVsXG4gKlxuICogQGNvbnN0YW50IE1vZGVsS2V5c1xuICogQG1lbWJlck9mIG1vZHVsZTpkZWNvcmF0b3ItdmFsaWRhdGlvbi5Nb2RlbFxuICogQGNhdGVnb3J5IE1vZGVsXG4gKi9cbmV4cG9ydCBlbnVtIE1vZGVsS2V5cyB7XG4gIFJFRkxFQ1QgPSBcIm1vZGVsLmRlZmluaXRpb24uXCIsXG4gIFRZUEUgPSBcImRlc2lnbjp0eXBlXCIsXG4gIFBBUkFNUyA9IFwiZGVzaWduOnBhcmFtdHlwZXNcIixcbiAgUkVUVVJOID0gXCJkZXNpZ246cmV0dXJudHlwZVwiLFxuICBNT0RFTCA9IFwibW9kZWxcIixcbiAgQU5DSE9SID0gXCJfX21vZGVsRGVmaW5pdGlvblwiLFxufVxuIl19