validno 0.2.0 → 0.2.2

package/dist/ValidnoResult.js

@@ -0,0 +1,61 @@
+import _errors from "./utils/errors.js";
+class ValidnoResult {
+    constructor(results) {
+        this.ok = (results === null || results === void 0 ? void 0 : results.ok) !== undefined ? results.ok : null;
+        this.missed = (results === null || results === void 0 ? void 0 : results.missed) || [];
+        this.failed = (results === null || results === void 0 ? void 0 : results.failed) || [];
+        this.passed = (results === null || results === void 0 ? void 0 : results.passed) || [];
+        this.errors = (results === null || results === void 0 ? void 0 : results.errors) || [];
+        this.byKeys = (results === null || results === void 0 ? void 0 : results.byKeys) || {};
+        this.errorsByKeys = (results === null || results === void 0 ? void 0 : results.errorsByKeys) || {};
+        this.byKeys = (results === null || results === void 0 ? void 0 : results.byKeys) || {};
+    }
+    fixByKey(key, result) {
+        this.byKeys[key] = result;
+        if (result === true)
+            this.passed.push(key);
+        else
+            this.failed.push(key);
+    }
+    pushMissing(key, errMsg) {
+        this.missed.push(key);
+        this.fixByKey(key, false);
+        const error = errMsg || _errors.getMissingError(key);
+        this.pushError(key, error);
+    }
+    pushError(key, msg) {
+        if (key in this.errorsByKeys === false) {
+            this.errorsByKeys[key] = [];
+        }
+        this.byKeys[key] = false;
+        this.errors.push(msg);
+        this.errorsByKeys[key].push(msg);
+    }
+    joinErrors(separator = '; ') {
+        return _errors.joinErrors(this.errors, separator);
+    }
+    merge(resultsNew) {
+        this.failed = [...this.failed, ...resultsNew.failed];
+        this.errors = [...this.errors, ...resultsNew.errors];
+        this.missed = [...this.missed, ...resultsNew.missed];
+        this.passed = [...this.passed, ...resultsNew.passed];
+        this.byKeys = Object.assign(Object.assign({}, this.byKeys), resultsNew.byKeys);
+        for (const key in resultsNew.errorsByKeys) {
+            if (key in this.errorsByKeys === false)
+                this.errorsByKeys[key] = [];
+            this.errorsByKeys[key] = [
+                ...this.errorsByKeys[key],
+                ...resultsNew.errorsByKeys[key]
+            ];
+        }
+        return this;
+    }
+    finish() {
+        if (this.failed.length)
+            this.ok = false;
+        else
+            this.ok = true;
+        return this;
+    }
+}
+export default ValidnoResult;

package/dist/checkType.js

@@ -22,6 +22,7 @@ const checkTypeMultiple = (key, value, requirements, keyName = key) => {
     return result;
 };
 const checkType = (key, value, requirements, keyName = key) => {
+    var _a;
     const isNotNull = value !== null;
     const keyTitle = 'title' in requirements ? requirements.title : keyName;
     const hasCustomMessage = requirements.customMessage && typeof requirements.customMessage === 'function';
@@ -149,7 +150,7 @@ const checkType = (key, value, requirements, keyName = key) => {
             break;
         default:
             const isInstanceOf = value instanceof typeBySchema;
-            const isConstructorSame = value.constructor.name === typeBySchema.name;
+            const isConstructorSame = ((_a = value.constructor) === null || _a === void 0 ? void 0 : _a.name) === (typeBySchema === null || typeBySchema === void 0 ? void 0 : typeBySchema.name);
             const checked = isInstanceOf && isConstructorSame;
             result.push({
                 key: keyName,

package/dist/dev.js

@@ -1,52 +1,105 @@
-import { Schema } from "./Schema.js";
-class Parent {
-    constructor(value) {
-        this.value = value;
-        this.version = 1;
+import { isDeepStrictEqual } from 'node:util';
+import _validations from './utils/validations.js';
+const listSame = [];
+const TEST_MAX = 1 * 1000000;
+const TYPES = [
+    'json',
+    'date',
+    'string',
+    'number',
+    'array',
+    'null',
+    'boolean'
+];
+const str = 'string';
+const date = () => new Date(2025, 0, 1, 0, 0, 0, 0);
+const json = () => {
+    return {
+        "surname": "Иванов",
+        "name": "Иван",
+        "patronymic": "Иванович",
+        "birthdate": "01.01.1990",
+        "birthplace": "Москва",
+        "phone": "8 926 766 48 48"
+    };
+};
+console.time('autofill');
+let i = 0;
+while (i < TEST_MAX) {
+    if (TYPES.includes('null'))
+        listSame.push(null);
+    if (TYPES.includes('boolean'))
+        listSame.push(true);
+    if (TYPES.includes('json'))
+        listSame.push(() => json());
+    if (TYPES.includes('date'))
+        listSame.push(() => date());
+    if (TYPES.includes('string'))
+        listSame.push(str);
+    if (TYPES.includes('number'))
+        listSame.push(Math.random());
+    if (TYPES.includes('array'))
+        listSame.push(() => [{ x: 1, y: { z: 0 } }, { x: 1 }, { x: 1 }]);
+    if (TYPES.includes('array'))
+        listSame.push(() => [1234451, 5535433, 7839262, 2134573, 10239752]);
+    if (TYPES.includes('array'))
+        listSame.push(() => [true, true, false, true, false]);
+    if (TYPES.includes('array'))
+        listSame.push(() => ['true', 'true', 'false', 'true', 'false']);
+    i++;
+}
+console.timeEnd('autofill');
+const compareArrs = (v1, v2) => {
+    if (v1.length !== v2.length)
+        return false;
+    return v1.every((el, i) => {
+        if (_validations.isObject(el)) {
+            return JSON.stringify(el) === JSON.stringify(v2[i]);
+        }
+        return v2[i] === el;
+    });
+};
+const is = (value, compareTo) => {
+    if (value === compareTo) {
+        return true;
     }
-    getV() {
-        return this.version;
+    const bothArrays = _validations.isArray(value) && _validations.isArray(compareTo);
+    if (bothArrays) {
+        return compareArrs(value, compareTo);
     }
-}
-class Child extends Parent {
-    constructor(value) {
-        super(value);
-        this.isDeep = true;
+    const bothObjects = _validations.isObject(value) && _validations.isObject(compareTo);
+    if (bothObjects) {
+        const valueStr = JSON.stringify(value);
+        const compareToStr = JSON.stringify(compareTo);
+        return valueStr === compareToStr;
     }
-}
-const testCust = new Parent(12345678);
-const testCust2 = new Child(12345678);
-const schema = new Schema({
-    parent1: {
-        type: Parent,
-        required: true,
-        title: 'custom class test',
-    },
-    child1: {
-        type: Child,
-        required: true,
-        title: 'custom class test',
-    },
-    parent2: {
-        type: Parent,
-        required: true
-    },
-    err: {
-        type: Error,
-        required: true,
-        title: 'custom class test',
-    },
-    func: {
-        type: Function,
-        required: false,
+    const bothDates = _validations.isDate(value) && _validations.isDate(compareTo);
+    if (bothDates) {
+        return value.getTime() === compareTo.getTime();
+    }
+    return value === compareTo;
+};
+const is2 = (value, compareTo) => {
+    return true;
+};
+const is3 = (v1, v2) => {
+    return isDeepStrictEqual(v1, v2);
+};
+const doTest = (func) => {
+    console.time('test ' + func.name);
+    let y = 0;
+    while (y < TEST_MAX) {
+        const v1 = typeof listSame[y] === 'function' ? listSame[y]() : listSame[y];
+        const v2 = typeof listSame[y] === 'function' ? listSame[y]() : listSame[y];
+        const result = func(v1, v2);
+        if (result !== true) {
+            console.log(v1);
+            console.log(v2);
+            throw new Error('RESULT != TRUE');
+        }
+        y++;
     }
-});
-const obj = {
-    parent1: testCust,
-    child1: testCust2,
-    parent2: testCust2,
-    err: new Error('ops'),
-    func: () => { console.log('ya tut'); }
+    console.timeEnd('test ' + func.name);
 };
-const res = schema.validate(obj);
-console.log(res);
+doTest(is);
+doTest(is3);

package/dist/utils/helpers.js

@@ -0,0 +1,48 @@
+import { defaultSchemaKeys } from "../Schema.js";
+import ValidnoResult from "../ValidnoResult.js";
+import _validations from "./validations.js";
+const _helpers = {};
+_helpers.checkIsNested = (obj) => {
+    if (!_validations.isObject(obj))
+        return false;
+    const objKeys = Object.keys(obj);
+    if (objKeys.every((k) => defaultSchemaKeys.includes(k))) {
+        return false;
+    }
+    else {
+        return true;
+    }
+};
+_helpers.mergeResults = (resultsOld, resultsNew) => {
+    const output = new ValidnoResult();
+    output.failed = [...resultsOld.failed, ...resultsNew.failed];
+    output.errors = [...resultsOld.errors, ...resultsNew.errors];
+    output.missed = [...resultsOld.missed, ...resultsNew.missed];
+    output.passed = [...resultsOld.passed, ...resultsNew.passed];
+    output.byKeys = Object.assign(Object.assign({}, resultsOld.byKeys), resultsNew.byKeys);
+    output.errorsByKeys = Object.assign(Object.assign({}, resultsOld.errorsByKeys), resultsNew.errorsByKeys);
+    return output;
+};
+_helpers.checkNestedIsMissing = (reqs, data) => {
+    const isRequired = reqs.required;
+    const isUndef = data === undefined;
+    const isEmpty = _validations.isObject(data) && !Object.keys(data).length;
+    return isRequired && (isUndef || isEmpty);
+};
+_helpers.areKeysLimited = (onlyKeys) => {
+    const hasArrayOfKeys = (Array.isArray(onlyKeys) && onlyKeys.length > 0);
+    const hasStringKey = (typeof onlyKeys === 'string' && onlyKeys.length > 0);
+    return hasArrayOfKeys || hasStringKey;
+};
+_helpers.needValidation = (key, hasLimits, onlyKeys) => {
+    const noLimits = !hasLimits;
+    const keyIsInList = (key === onlyKeys || Array.isArray(onlyKeys) && (onlyKeys === null || onlyKeys === void 0 ? void 0 : onlyKeys.includes(key)));
+    return noLimits || keyIsInList;
+};
+_helpers.hasMissing = (input) => {
+    const { reqs, data, key } = input;
+    const isRequired = reqs.required === true;
+    const missingData = (data === undefined || key in data === false || data[key] === undefined);
+    return isRequired && missingData;
+};
+export default _helpers;

package/dist/utils/nested.js

@@ -0,0 +1 @@
+"use strict";

package/dist/utils/validations.js

@@ -2,86 +2,127 @@ const _validations = {};
 _validations.isString = (value) => {
     return typeof value === 'string';
 };
-_validations.isDate = (value) => {
-    return value instanceof Date && String(value) !== 'Invalid Date';
-};
 _validations.isNumber = (value) => {
     return typeof value === 'number';
 };
-_validations.isNumberGte = (value, gte) => {
-    return typeof value === 'number' && value >= gte;
-};
-_validations.isNumberLte = (value, lte) => {
-    return typeof value === 'number' && value <= lte;
-};
 _validations.isArray = (value) => {
     return Array.isArray(value);
 };
 _validations.isObject = (value) => {
-    return typeof value === 'object' && !Array.isArray(value) && value !== null;
+    var _a;
+    return value !== null && typeof value === 'object' && ((_a = value === null || value === void 0 ? void 0 : value.constructor) === null || _a === void 0 ? void 0 : _a.name) === 'Object' && !Array.isArray(value);
+};
+_validations.isDate = (value) => {
+    return value instanceof Date && String(value) !== 'Invalid Date';
+};
+_validations.isRegex = (value) => {
+    return value instanceof RegExp;
+};
+_validations.isBoolean = (value) => {
+    return typeof value === 'boolean';
+};
+_validations.isNull = (value) => {
+    return value === null;
+};
+_validations.isUndefined = (value) => {
+    return value === undefined;
+};
+_validations.isNullOrUndefined = (value) => {
+    return value === undefined || value === null;
+};
+_validations.isEmail = (value) => {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(value);
+};
+_validations.isDateYYYYMMDD = (value) => {
+    const regex = /^\d{4}-\d{2}-\d{2}$/;
+    return regex.test(value);
+};
+_validations.isHex = (value) => {
+    const regex = /^#(?:[0-9a-fA-F]{3}){1,2}$/;
+    return regex.test(value);
 };
 _validations.lengthIs = (value, length) => {
+    if (typeof value !== 'string' && !Array.isArray(value))
+        return false;
+    if (typeof length !== 'number')
+        return false;
     return value.length === length;
 };
 _validations.lengthNot = (value, length) => {
+    if (typeof value !== 'string' && !Array.isArray(value))
+        return false;
+    if (typeof length !== 'number')
+        return false;
     return value.length !== length;
 };
 _validations.lengthMin = (value, min) => {
+    if (typeof value !== 'string' && !Array.isArray(value))
+        return false;
+    if (typeof min !== 'number')
+        return false;
     return value.length >= min;
 };
 _validations.lengthMax = (value, max) => {
+    if (typeof value !== 'string' && !Array.isArray(value))
+        return false;
+    if (typeof max !== 'number')
+        return false;
     return value.length <= max;
 };
-_validations.isEmail = (value) => {
-    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-    return emailRegex.test(value);
+_validations.isNumberGte = (value, gte) => {
+    return typeof value === 'number' && value >= gte;
 };
-_validations.isRegex = (value) => {
-    return value instanceof RegExp;
+_validations.isNumberLte = (value, lte) => {
+    return typeof value === 'number' && value <= lte;
 };
 _validations.hasKey = (obj, key) => {
+    if (_validations.isObject(obj) === false)
+        return false;
     return key in obj;
 };
-_validations.isNot = (value, not) => {
-    if (typeof not === 'object' && Array.isArray(not)) {
-        for (let i = 0; i < not.length; i++) {
-            if (value === not[i])
-                return false;
+const compareArrs = (v1, v2) => {
+    if (v1.length !== v2.length)
+        return false;
+    return v1.every((el, i) => {
+        if (_validations.isObject(el)) {
+            return JSON.stringify(el) === JSON.stringify(v2[i]);
         }
-        return true;
-    }
-    return value !== not;
+        return v2[i] === el;
+    });
 };
 _validations.is = (value, compareTo) => {
-    if (typeof compareTo === 'object' && Array.isArray(compareTo)) {
-        for (let i = 0; i < compareTo.length; i++) {
-            if (value === compareTo[i])
-                return true;
-        }
-        return false;
+    if (value === compareTo) {
+        return true;
+    }
+    const bothArrays = _validations.isArray(value) && _validations.isArray(compareTo);
+    if (bothArrays) {
+        return compareArrs(value, compareTo);
+    }
+    const bothObjects = _validations.isObject(value) && _validations.isObject(compareTo);
+    if (bothObjects) {
+        const valueStr = JSON.stringify(value);
+        const compareToStr = JSON.stringify(compareTo);
+        return valueStr === compareToStr;
+    }
+    const bothDates = _validations.isDate(value) && _validations.isDate(compareTo);
+    if (bothDates) {
+        return value.getTime() === compareTo.getTime();
     }
     return value === compareTo;
 };
-_validations.isDateYYYYMMDD = (value) => {
-    const regex = /^\d{4}-\d{2}-\d{2}$/;
-    return regex.test(value);
-};
-_validations.regexTested = (value, regex) => {
-    if (!regex)
-        throw new Error('regex argument is not defined');
-    return regex.test(value);
-};
-_validations.isHex = (value) => {
-    const regex = /^#(?:[0-9a-fA-F]{3}){1,2}$/;
-    return regex.test(value);
-};
-_validations.isBoolean = (value) => {
-    return typeof value === 'boolean';
-};
-_validations.isNull = (value) => {
-    return value === null;
+_validations.not = (value, not) => {
+    return !_validations.is(value, not);
 };
-_validations.isUndefined = (value) => {
-    return value === undefined;
+_validations.isNot = _validations.not;
+_validations.ne = _validations.not;
+_validations.regexTested = (value, regexp) => {
+    if (!regexp || regexp instanceof RegExp !== true) {
+        throw new Error('regexp argument is incorrect');
+    }
+    return regexp.test(value);
 };
+_validations.regex = _validations.regexTested;
+_validations.regexp = _validations.regexTested;
+_validations.test = _validations.regexTested;
 export default _validations;

package/dist/validate.js

@@ -1,89 +1,67 @@
 import checkType from "./checkType.js";
 import _errors from "./utils/errors.js";
 import checkRules from "./checkRules.js";
-import _validations from "./utils/validations.js";
+import _helpers from "./utils/helpers.js";
 import { ErrorKeywords } from "./constants/details.js";
-import { defaultSchemaKeys } from "./Schema.js";
-export const getResultDefaults = () => {
-    return {
-        ok: null,
-        missed: [],
-        failed: [],
-        passed: [],
-        errors: [],
-        byKeys: {},
-        errorsByKeys: {},
-    };
-};
-const checkIsNested = (obj) => {
-    if (!_validations.isObject(obj))
-        return false;
-    const objKeys = Object.keys(obj);
-    if (objKeys.every((k) => defaultSchemaKeys.includes(k))) {
-        return false;
+import ValidnoResult from "./ValidnoResult.js";
+function generateMsg(input) {
+    let { results, key, deepKey, data, reqs } = input;
+    const keyForMsg = deepKey || key;
+    const keyTitle = 'title' in reqs ? reqs.title : keyForMsg;
+    if (reqs.customMessage && typeof reqs.customMessage === 'function') {
+        const errMsg = reqs.customMessage({
+            keyword: ErrorKeywords.Missing,
+            value: data[key],
+            key: keyForMsg,
+            title: keyTitle,
+            reqs: reqs,
+            schema: this.schema
+        });
+        return errMsg;
     }
-    else {
-        return true;
+    return _errors.getMissingError(keyForMsg);
+}
+function handleDeepKey(input) {
+    const { results, key, deepKey, data, reqs } = input;
+    const nesctedKeys = Object.keys(reqs);
+    results.fixByKey(deepKey, false);
+    let i = 0;
+    while (i < nesctedKeys.length) {
+        const nestedKey = nesctedKeys[i];
+        const deepParams = {
+            key: nestedKey,
+            data: data[key],
+            reqs: reqs[nestedKey],
+            deepKey: `${deepKey}.${nestedKey}`
+        };
+        const deepResults = handleKey.call(this, deepParams);
+        results.merge(deepResults);
+        i++;
     }
-};
-export const mergeResults = (resultsOld, resultsNew) => {
-    const output = getResultDefaults();
-    output.failed = [...resultsOld.failed, ...resultsNew.failed];
-    output.errors = [...resultsOld.errors, ...resultsNew.errors];
-    output.missed = [...resultsOld.missed, ...resultsNew.missed];
-    output.passed = [...resultsOld.passed, ...resultsNew.passed];
-    output.byKeys = Object.assign(Object.assign({}, resultsOld.byKeys), resultsNew.byKeys);
-    output.errorsByKeys = Object.assign(Object.assign({}, resultsOld.errorsByKeys), resultsNew.errorsByKeys);
-    return output;
-};
-export function handleReqKey(key, data, reqs, deepKey = key) {
-    let results = getResultDefaults();
-    const hasNested = checkIsNested(reqs);
-    const keyTitle = 'title' in reqs ? reqs.title : deepKey;
+    return results;
+}
+export function handleKey(input) {
+    let { results, key, deepKey, data, reqs } = input;
+    if (!results)
+        results = new ValidnoResult();
+    if (!deepKey)
+        deepKey = key;
+    const hasNested = _helpers.checkIsNested(reqs);
+    const hasMissing = _helpers.hasMissing(input);
     const missedCheck = [];
     const typeChecked = [];
     const rulesChecked = [];
-    if (reqs.required && (data === undefined ||
-        (_validations.isObject(data) && !Object.keys(data).length))) {
-        results.missed.push(deepKey);
-        results.failed.push(deepKey);
-        results.byKeys[deepKey] = false;
+    if (_helpers.checkNestedIsMissing(reqs, data)) {
+        results.pushMissing(deepKey);
         return results;
     }
     if (hasNested) {
-        const nestedReqKeys = Object.keys(reqs);
-        results.byKeys[deepKey] = true;
-        let i = 0;
-        while (i < nestedReqKeys.length) {
-            const reqKeyI = nestedReqKeys[i];
-            const deepResults = handleReqKey.call(this, reqKeyI, data[key], reqs[reqKeyI], deepKey + '.' + reqKeyI);
-            results = mergeResults(results, deepResults);
-            i++;
-        }
-        return results;
+        return handleDeepKey.call(this, { results, key, data, reqs, deepKey });
     }
-    if (reqs.required === true &&
-        (key in data === false || data === undefined || data[key] === undefined)) {
-        console.log(data);
-        let errMsg = _errors.getMissingError(deepKey);
-        if (reqs.customMessage && typeof reqs.customMessage === 'function') {
-            errMsg = reqs.customMessage({
-                keyword: ErrorKeywords.Missing,
-                value: data[key],
-                key: deepKey,
-                title: keyTitle,
-                reqs: reqs,
-                schema: this.schema
-            });
-        }
+    if (hasMissing) {
+        let errMsg = generateMsg.call(this, input);
         missedCheck.push(false);
-        results.missed.push(deepKey);
-        results.failed.push(deepKey);
-        results.errors.push(errMsg);
-        if (deepKey in results.errorsByKeys === false)
-            results.errorsByKeys[deepKey] = [];
-        results.errorsByKeys[deepKey].push(errMsg);
-        results.byKeys[deepKey] = false;
+        results.pushMissing(deepKey, errMsg);
         return results;
     }
     const typeCheck = checkType(key, data[key], reqs, deepKey);
@@ -104,52 +82,27 @@ export function handleReqKey(key, data, reqs, deepKey = key) {
         });
     }
     if (missedCheck.length)
-        results.missed.push(deepKey);
-    if (typeChecked.length || rulesChecked.length) {
-        results.failed.push(deepKey);
-    }
-    else {
-        results.passed.push(deepKey);
-    }
+        results.pushMissing(deepKey);
+    const isPassed = (!typeChecked.length && !rulesChecked.length && !missedCheck.length);
+    results.fixByKey(deepKey, isPassed);
     results.errorsByKeys[deepKey] = [
         ...results.errors
     ];
-    results.byKeys[deepKey] = (missedCheck.length + typeChecked.length + rulesChecked.length) === 0;
-    return results;
+    return results.finish();
 }
-const checkIfValidationIsNeeded = (key, hasLimits, onlyKeys) => {
-    return !hasLimits || (key === onlyKeys || Array.isArray(onlyKeys) && (onlyKeys === null || onlyKeys === void 0 ? void 0 : onlyKeys.includes(key)));
-};
-function validate(schema, data, onlyKeys) {
-    let results = getResultDefaults();
-    const areKeysLimited = (Array.isArray(onlyKeys) && onlyKeys.length > 0) || (typeof onlyKeys === 'string' && onlyKeys.length > 0);
-    for (const [key, reqs] of Object.entries(schema.schema)) {
-        const isValidationRequired = checkIfValidationIsNeeded(key, areKeysLimited, onlyKeys);
-        if (isValidationRequired) {
-            const keyResult = handleReqKey.call(this, key, data, reqs);
-            results = mergeResults(results, keyResult);
-        }
+function validate(schema, data, keysToCheck) {
+    const results = new ValidnoResult();
+    const hasKeysToCheck = _helpers.areKeysLimited(keysToCheck);
+    const schemaKeys = Object.entries(schema.schema);
+    for (const [key, reqs] of schemaKeys) {
+        const toBeValidated = _helpers.needValidation(key, hasKeysToCheck, keysToCheck);
+        if (!toBeValidated)
+            continue;
+        const keyResult = handleKey.call(this, { key, data, reqs });
+        results.merge(keyResult);
     }
-    if (results.failed.length)
-        results.ok = false;
-    else
-        results.ok = true;
-    return new ValidnoResult(results);
+    results.finish();
+    return results;
 }
 ;
-class ValidnoResult {
-    constructor(results) {
-        this.ok = results.ok;
-        this.missed = results.missed;
-        this.failed = results.failed;
-        this.passed = results.passed;
-        this.errors = results.errors;
-        this.byKeys = results.byKeys;
-        this.errorsByKeys = results.errorsByKeys;
-        this.byKeys = results.byKeys;
-    }
-    joinErrors(separator = '; ') {
-        return _errors.joinErrors(this.errors, separator);
-    }
-}
 export default validate;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "validno",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "",
   "main": "dist/index.js",
   "scripts": {