valgen 5.7.0 → 5.8.0

package/esm/rules/logical-rules/range.js

@@ -1,20 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.lengthMax = exports.lengthMin = void 0;
-exports.range = range;
-exports.isGt = isGt;
-exports.isGte = isGte;
-exports.isLt = isLt;
-exports.isLte = isLte;
-const index_js_1 = require("../../core/index.js");
-const get_length_js_1 = require("../utility-rules/get-length.js");
-const pipe_js_1 = require("../utility-rules/pipe.js");
+import { validator, } from '../../core/index.js';
+import { getLength } from '../utility-rules/get-length.js';
+import { allOf, pipe } from '../utility-rules/pipe.js';
 /**
  * Checks if value is between minValue and maxValue
  * @validator range
  */
-function range(minValue, maxValue, options) {
-    return (0, index_js_1.validator)('range', (input, context, _this) => {
+export function range(minValue, maxValue, options) {
+    return validator('range', (input, context, _this) => {
         if ((typeof minValue === 'number' || typeof minValue === 'bigint') &&
             (typeof maxValue === 'number' || typeof maxValue === 'bigint') &&
             (typeof input === 'number' || typeof input === 'bigint') &&
@@ -39,8 +31,8 @@ function range(minValue, maxValue, options) {
         context.fail(_this, `Value must be between ${minValue} and ${maxValue}`, input);
     }, options);
 }
-function isGt(minValue, options) {
-    return (0, index_js_1.validator)('isGt', (input, context, _this) => {
+export function isGt(minValue, options) {
+    return validator('isGt', (input, context, _this) => {
         if ((typeof minValue === 'number' || typeof minValue === 'bigint') &&
             (typeof input === 'number' || typeof input === 'bigint') &&
             input > minValue) {
@@ -61,8 +53,8 @@ function isGt(minValue, options) {
         context.fail(_this, `{{label}} must be greater than ${typeof minValue === 'string' ? `"${minValue}"` : minValue}`, input);
     }, options);
 }
-function isGte(minValue, options) {
-    return (0, index_js_1.validator)('isGte', (input, context, _this) => {
+export function isGte(minValue, options) {
+    return validator('isGte', (input, context, _this) => {
         if ((typeof minValue === 'number' || typeof minValue === 'bigint') &&
             (typeof input === 'number' || typeof input === 'bigint') &&
             input >= minValue) {
@@ -83,8 +75,8 @@ function isGte(minValue, options) {
         context.fail(_this, `{{label}} must be greater than or equal to ${typeof minValue === 'string' ? `"${minValue}"` : minValue}`, input);
     }, options);
 }
-function isLt(maxValue, options) {
-    return (0, index_js_1.validator)('isLt', (input, context, _this) => {
+export function isLt(maxValue, options) {
+    return validator('isLt', (input, context, _this) => {
         if ((typeof maxValue === 'number' || typeof maxValue === 'bigint') &&
             (typeof input === 'number' || typeof input === 'bigint') &&
             input < maxValue) {
@@ -105,8 +97,8 @@ function isLt(maxValue, options) {
         context.fail(_this, `{{label}} must be lover than ${typeof maxValue === 'string' ? `"${maxValue}"` : maxValue}`, input);
     }, options);
 }
-function isLte(maxValue, options) {
-    return (0, index_js_1.validator)('isLte', (input, context, _this) => {
+export function isLte(maxValue, options) {
+    return validator('isLte', (input, context, _this) => {
         if ((typeof maxValue === 'number' || typeof maxValue === 'bigint') &&
             (typeof input === 'number' || typeof input === 'bigint') &&
             input <= maxValue) {
@@ -131,25 +123,23 @@ function isLte(maxValue, options) {
  * Checks the length is at least "minValue"
  * @validator lengthMin
  */
-const lengthMin = (minValue) => (0, pipe_js_1.allOf)([
-    (0, pipe_js_1.pipe)([
-        (0, get_length_js_1.getLength)(),
+export const lengthMin = (minValue) => allOf([
+    pipe([
+        getLength(),
         isGte(minValue, {
             onFail: () => `The length of {{label}} must be at least ${minValue}`,
         }),
     ]),
 ]);
-exports.lengthMin = lengthMin;
 /**
  * Checks if the length is at most "maxValue"
  * @validator lengthMax
  */
-const lengthMax = (maxValue) => (0, pipe_js_1.allOf)([
-    (0, pipe_js_1.pipe)([
-        (0, get_length_js_1.getLength)(),
+export const lengthMax = (maxValue) => allOf([
+    pipe([
+        getLength(),
         isLte(maxValue, {
             onFail: () => `The length of {{label}} must be at most ${maxValue}`,
         }),
     ]),
 ]);
-exports.lengthMax = lengthMax;

package/esm/rules/type-rules/is-any.js

@@ -1,10 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isAny = void 0;
-const index_js_1 = require("../../core/index.js");
+import { validator } from '../../core/index.js';
 /**
  * Does nothing, just returns original input value.
  * @validator isAny
  */
-const isAny = () => (0, index_js_1.validator)('is-any', (input) => input);
-exports.isAny = isAny;
+export const isAny = () => validator('is-any', (input) => input);

package/esm/rules/type-rules/is-array.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isArray = isArray;
-const index_js_1 = require("../../core/index.js");
+import { validator, } from '../../core/index.js';
 /**
  * Validates if value is "array" and applies validation for each item.
  * Converts input value to array if coerce option is set to 'true'.
  * @validator isArray
  */
-function isArray(itemValidator, options) {
-    return (0, index_js_1.validator)('isArray', (input, context, _this) => {
+export function isArray(itemValidator, options) {
+    return validator('isArray', (input, context, _this) => {
         const coerce = options?.coerce || context.coerce;
         let output = input;
         if (output != null && coerce && !Array.isArray(output))

package/esm/rules/type-rules/is-bigint.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isBigint = isBigint;
-const index_js_1 = require("../../core/index.js");
+import { validator } from '../../core/index.js';
 /**
  * Validates if value is "BigInt".
  * Converts input value to number if coerce option is set to 'true'.
  * @validator isNumber
  */
-function isBigint(options) {
-    return (0, index_js_1.validator)('isBigint', (input, context, _this) => {
+export function isBigint(options) {
+    return validator('isBigint', (input, context, _this) => {
         const coerce = options?.coerce || context.coerce;
         if (typeof input === 'bigint')
             return input;

package/esm/rules/type-rules/is-boolean.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isBoolean = isBoolean;
-const index_js_1 = require("../../core/index.js");
+import { validator, } from '../../core/index.js';
 const TRUE_PATTERN = /^true|t|1|yes|y$/i;
 const FALSE_PATTERN = /^false|f|0|no|n$/i;
 /**
@@ -9,8 +6,8 @@ const FALSE_PATTERN = /^false|f|0|no|n$/i;
  * Converts input value to boolean if coerce option is set to 'true'.
  * @validator isBoolean
  */
-function isBoolean(options) {
-    return (0, index_js_1.validator)('isBoolean', (input, context, _this) => {
+export function isBoolean(options) {
+    return validator('isBoolean', (input, context, _this) => {
         const coerce = options?.coerce || context.coerce;
         let output = input;
         if (output != null && typeof output !== 'boolean' && coerce) {

package/esm/rules/type-rules/is-date.js

@@ -1,9 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isDate = isDate;
-exports.isDateString = isDateString;
-const date_fns_1 = require("date-fns");
-const index_js_1 = require("../../core/index.js");
+import { formatISO, parseISO } from 'date-fns';
+import { validator } from '../../core/index.js';
 /* eslint-disable-next-line max-len */ // noinspection RegExpUnnecessaryNonCapturingGroup
 const DATE_PATTERN = 
 // eslint-disable-next-line max-len
@@ -13,16 +9,16 @@ const DATE_PATTERN =
  * Converts input value to Date if coerce option is set to 'true'.
  * @validator isDate
  */
-function isDate(options) {
+export function isDate(options) {
     const precision = options?.precision;
-    return (0, index_js_1.validator)('isDate', (input, context, _this) => {
+    return validator('isDate', (input, context, _this) => {
         const coerce = options?.coerce || context.coerce;
         let d;
         if (input instanceof Date)
             d = input;
         else if (input != null && coerce) {
             if (typeof input === 'string' && coerce) {
-                d = (0, date_fns_1.parseISO)(input);
+                d = parseISO(input);
             }
             else if (typeof input === 'number')
                 d = new Date(input);
@@ -50,15 +46,15 @@ function isDate(options) {
  * Converts input value to DFS if coerce option is set to 'true'.
  * @validator isDateString
  */
-function isDateString(options) {
+export function isDateString(options) {
     const precision = options?.precision;
     const trim = options?.trim;
-    return (0, index_js_1.validator)('isDateString', (input, context, _this) => {
+    return validator('isDateString', (input, context, _this) => {
         const coerce = options?.coerce || context.coerce;
         if (typeof input === 'string') {
             const m = DATE_PATTERN.exec(input);
             if (m) {
-                const d = (0, date_fns_1.parseISO)(input);
+                const d = parseISO(input);
                 if (d && !isNaN(d.getTime())) {
                     if (!precision ||
                         precision === 'year' ||
@@ -90,8 +86,8 @@ function isDateString(options) {
         }
         else if (input instanceof Date) {
             return trim === 'date'
-                ? (0, date_fns_1.formatISO)(input, { representation: 'date' })
-                : (0, date_fns_1.formatISO)(input).substring(0, 19);
+                ? formatISO(input, { representation: 'date' })
+                : formatISO(input).substring(0, 19);
         }
         context.fail(_this, `"{{value}}" is not a valid date string`, input, {
             ...options,

package/esm/rules/type-rules/is-enum.js

@@ -1,12 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isEnum = isEnum;
-const index_js_1 = require("../../core/index.js");
+import { validator, } from '../../core/index.js';
 /**
  * Validates if given value is one of enum values.
  * @validator isEnum
  */
-function isEnum(values, options) {
+export function isEnum(values, options) {
     const caseInSensitive = !!options?.caseInSensitive;
     const enumName = options?.enumName;
     // Prepare an object for fast lookup
@@ -17,7 +14,7 @@ function isEnum(values, options) {
             a[v] = true;
         return a;
     }, {});
-    return (0, index_js_1.validator)('isEnum', (input, context, _this) => {
+    return validator('isEnum', (input, context, _this) => {
         if (input != null &&
             valObj[typeof input === 'string' && caseInSensitive
                 ? input.toUpperCase()

package/esm/rules/type-rules/is-integer.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isInteger = isInteger;
-const index_js_1 = require("../../core/index.js");
+import { validator, } from '../../core/index.js';
 /**
  * Validates if value is "integer".
  * Converts input value to integer number if coerce option is set to 'true'.
  * @validator isInteger
  */
-function isInteger(options) {
-    return (0, index_js_1.validator)('isInteger', (input, context, _this) => {
+export function isInteger(options) {
+    return validator('isInteger', (input, context, _this) => {
         const coerce = options?.coerce || context.coerce;
         let output = input;
         if (output != null && typeof output !== 'number' && coerce) {

package/esm/rules/type-rules/is-null.js

@@ -1,16 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isNull = isNull;
-exports.isNotNull = isNotNull;
-exports.isNullish = isNullish;
-exports.isNotNullish = isNotNullish;
-const index_js_1 = require("../../core/index.js");
+import { validator } from '../../core/index.js';
 /**
  * Validates if value is "null".
  * @validator isNull
  */
-function isNull(options) {
-    return (0, index_js_1.validator)('isNull', (input, context, _this) => {
+export function isNull(options) {
+    return validator('isNull', (input, context, _this) => {
         if (input === null)
             return input;
         context.fail(_this, `{{label}} is not null`, input);
@@ -20,8 +14,8 @@ function isNull(options) {
  * Validates if value is not "null".
  * @validator isNotNull
  */
-function isNotNull(options) {
-    return (0, index_js_1.validator)('isNotNull', (input, context, _this) => {
+export function isNotNull(options) {
+    return validator('isNotNull', (input, context, _this) => {
         if (input !== null)
             return input;
         context.fail(_this, `{{label}} is null`, input);
@@ -31,8 +25,8 @@ function isNotNull(options) {
  * Validates if value is "null" or "undefined".
  * @validator isNullish
  */
-function isNullish(options) {
-    return (0, index_js_1.validator)('isNullish', (input, context, _this) => {
+export function isNullish(options) {
+    return validator('isNullish', (input, context, _this) => {
         if (input == null)
             return input;
         context.fail(_this, `{{label}} is not nullish`, input);
@@ -42,8 +36,8 @@ function isNullish(options) {
  * Validates if value is not "null" nor "undefined".
  * @validator isNotNullish
  */
-function isNotNullish(options) {
-    return (0, index_js_1.validator)('isNotNullish', (input, context, _this) => {
+export function isNotNullish(options) {
+    return validator('isNotNullish', (input, context, _this) => {
         if (input != null)
             return input;
         if (input === null)

package/esm/rules/type-rules/is-number.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isNumber = isNumber;
-const index_js_1 = require("../../core/index.js");
+import { validator } from '../../core/index.js';
 /**
  * Validates if value is "number".
  * Converts input value to number if coerce option is set to 'true'.
  * @validator isNumber
  */
-function isNumber(options) {
-    return (0, index_js_1.validator)('isNumber', (input, context, _this) => {
+export function isNumber(options) {
+    return validator('isNumber', (input, context, _this) => {
         const coerce = options?.coerce || context.coerce;
         let output = input;
         if (output != null && typeof output !== 'number' && coerce) {

package/esm/rules/type-rules/is-object.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isObject = isObject;
-const constants_js_1 = require("../../constants.js");
-const index_js_1 = require("../../core/index.js");
+import { postValidation, preValidation } from '../../constants.js';
+import { isValidator, validator, } from '../../core/index.js';
 /**
  * Validates object according to schema
  * Converts properties according to schema rules if coerce option is set to 'true'.
  * @validator isObject
  */
-function isObject(schema, options) {
+export function isObject(schema, options) {
     const ctor = options?.ctor;
     const ctorName = options?.name || ctor?.name;
     const additionalFields = options?.additionalFields ?? !schema;
@@ -22,13 +19,13 @@ function isObject(schema, options) {
         const n = schema[k];
         const key = caseInSensitive ? k.toLowerCase() : k;
         if (Array.isArray(n)) {
-            if (!(0, index_js_1.isValidator)(n[0])) {
+            if (!isValidator(n[0])) {
                 throw new TypeError(`Invalid tuple definition in validation schema (${k})`);
             }
             propertyRules[key] = n[0];
             propertyOptions[key] = { as: k, ...n[1] };
         }
-        else if ((0, index_js_1.isValidator)(n)) {
+        else if (isValidator(n)) {
             propertyRules[key] = n;
             propertyOptions[key] = { as: k };
         }
@@ -36,10 +33,10 @@ function isObject(schema, options) {
             throw new TypeError(`Invalid definition in validation schema (${k})`);
         }
     }
-    const _rule = (0, index_js_1.validator)('isObject', (input, context, _this) => {
+    const _rule = validator('isObject', (input, context, _this) => {
         let output = input;
-        if (ctor && ctor[constants_js_1.preValidation]) {
-            output = ctor[constants_js_1.preValidation](output, context, _this);
+        if (ctor && ctor[preValidation]) {
+            output = ctor[preValidation](output, context, _this);
         }
         const coerce = options?.coerce || context.coerce;
         if (typeof output === 'string' && coerce)
@@ -76,7 +73,7 @@ function isObject(schema, options) {
             v = output[inputKey];
             _propRule =
                 propertyRules[schemaKey] ||
-                    ((0, index_js_1.isValidator)(additionalFields) ? additionalFields : undefined);
+                    (isValidator(additionalFields) ? additionalFields : undefined);
             if (_propRule) {
                 if (processedSchemaKeys[schemaKey])
                     continue;
@@ -104,8 +101,8 @@ function isObject(schema, options) {
         }
         if (context.errors.length)
             return undefined;
-        if (ctor && ctor[constants_js_1.postValidation]) {
-            ctor[constants_js_1.postValidation](out, context, _this);
+        if (ctor && ctor[postValidation]) {
+            ctor[postValidation](out, context, _this);
             return out;
         }
         return out;

package/esm/rules/type-rules/is-record.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isRecord = isRecord;
-const index_js_1 = require("../../core/index.js");
+import { validator, } from '../../core/index.js';
 /**
  * Validates record object according to given "key" and "value" rules
  * Converts properties according to rules if coerce option is set to 'true'.
  * @validator isRecord
  */
-function isRecord(keyRule, valueRule, options) {
-    return (0, index_js_1.validator)('isRecord', (input, context, _this) => {
+export function isRecord(keyRule, valueRule, options) {
+    return validator('isRecord', (input, context, _this) => {
         if (!(input && typeof input === 'object')) {
             context.fail(_this, `{{label}} must be an object`, input);
             return;

package/esm/rules/type-rules/is-string.js

@@ -1,18 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.trimStart = exports.trimEnd = void 0;
-exports.isString = isString;
-exports.stringReplace = stringReplace;
-exports.stringSplit = stringSplit;
-exports.trim = trim;
-const index_js_1 = require("../../core/index.js");
+import { validator, } from '../../core/index.js';
 /**
  * Validates if value is "string".
  * Converts input value to string if coerce option is set to 'true'.
  * @validator isString
  */
-function isString(options) {
-    return (0, index_js_1.validator)('isString', (input, context, _this) => {
+export function isString(options) {
+    return validator('isString', (input, context, _this) => {
         const coerce = options?.coerce || context.coerce;
         let output = input;
         if (output != null && typeof output !== 'string' && coerce) {
@@ -30,15 +23,15 @@ function isString(options) {
         context.fail(_this, `"{{value}}" is not a string`, input);
     }, options);
 }
-function stringReplace(searchValue, replacer) {
-    return (0, index_js_1.validator)('stringReplace', (input) => {
+export function stringReplace(searchValue, replacer) {
+    return validator('stringReplace', (input) => {
         if (input == null)
             return input;
         return String(input).replace(searchValue, replacer);
     });
 }
-function stringSplit(splitter, limit) {
-    return (0, index_js_1.validator)('stringSplit', (input) => {
+export function stringSplit(splitter, limit) {
+    return validator('stringSplit', (input) => {
         if (input == null)
             return input;
         return String(input).split(splitter, limit);
@@ -48,8 +41,8 @@ function stringSplit(splitter, limit) {
  * Removes whitespace from both ends of a string
  * @validator trim
  */
-function trim() {
-    return (0, index_js_1.validator)('trim', (input) => {
+export function trim() {
+    return validator('trim', (input) => {
         if (input == null)
             return input;
         return String(input).trim();
@@ -60,9 +53,8 @@ function trim() {
  * Removes whitespace from the end of a string
  * @validator trimEnd
  */
-const trimEnd = () => trimEndRule;
-exports.trimEnd = trimEnd;
-const trimEndRule = (0, index_js_1.validator)('trimEnd', (input) => {
+export const trimEnd = () => trimEndRule;
+const trimEndRule = validator('trimEnd', (input) => {
     if (input == null)
         return input;
     return String(input).trimEnd();
@@ -72,9 +64,8 @@ const trimEndRule = (0, index_js_1.validator)('trimEnd', (input) => {
  * Removes whitespace from the beginning of a string
  * @validator trimStart
  */
-const trimStart = () => trimStartRule;
-exports.trimStart = trimStart;
-const trimStartRule = (0, index_js_1.validator)('trimStart', (input) => {
+export const trimStart = () => trimStartRule;
+const trimStartRule = validator('trimStart', (input) => {
     if (input == null)
         return input;
     return String(input).trimStart();

package/esm/rules/type-rules/is-tuple.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isTuple = isTuple;
-const index_js_1 = require("../../core/index.js");
-function isTuple(items, options) {
-    return (0, index_js_1.validator)('isTuple', (input, context, _this) => {
+import { validator, } from '../../core/index.js';
+export function isTuple(items, options) {
+    return validator('isTuple', (input, context, _this) => {
         const coerce = options?.coerce || context.coerce;
         let output = input;
         if (output != null && coerce && !Array.isArray(output))

package/esm/rules/type-rules/is-undefined.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isUndefined = isUndefined;
-const index_js_1 = require("../../core/index.js");
+import { validator, } from '../../core/index.js';
 /**
  * Validates if value is "undefined"
  * @validator isUndefined
  */
-function isUndefined(options) {
-    return (0, index_js_1.validator)('isUndefined', (input, context, _this) => {
+export function isUndefined(options) {
+    return validator('isUndefined', (input, context, _this) => {
         if (options?.coerce || context.coerce)
             return undefined;
         if (input === undefined)

package/esm/rules/utility-rules/exists.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.exists = exists;
-const index_js_1 = require("../../core/index.js");
+import { validator } from '../../core/index.js';
 /**
  * Validates if property exists
  * @validator exists
  */
-function exists(options) {
-    return (0, index_js_1.validator)('exists', (input, context, _this) => {
+export function exists(options) {
+    return validator('exists', (input, context, _this) => {
         if (input !== undefined ||
             (context.scope &&
                 Object.getOwnPropertyDescriptor(context.scope, input))) {

package/esm/rules/utility-rules/get-length.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getLength = getLength;
-const index_js_1 = require("../../core/index.js");
+import { validator } from '../../core/index.js';
 /**
  * Returns length of an Array, String, ArrayBuffer, Buffer or any object with the "length" property.
  * @validator getLength
  */
-function getLength() {
-    return (0, index_js_1.validator)('getLength', (input, context, _this) => {
+export function getLength() {
+    return validator('getLength', (input, context, _this) => {
         if (typeof input === 'string')
             return input.length;
         if (Array.isArray(input))

package/esm/rules/utility-rules/optional.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.optional = optional;
-const index_js_1 = require("../../core/index.js");
+import { validator, } from '../../core/index.js';
 /**
  * Makes sub-rule optional
  * @validator optional
  */
-function optional(nested, options) {
-    return (0, index_js_1.validator)('optional', (input, context) => {
+export function optional(nested, options) {
+    return validator('optional', (input, context) => {
         if (input == null)
             return input;
         return nested(input, context);

package/esm/rules/utility-rules/pipe.js

@@ -1,16 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.pipe = pipe;
-exports.allOf = allOf;
-const index_js_1 = require("../../core/index.js");
+import { validator, } from '../../core/index.js';
 /**
  *
  * @validator pipe
  */
-function pipe(rules, options) {
+export function pipe(rules, options) {
     const l = rules.length;
     const returnIndex = options?.returnIndex;
-    return (0, index_js_1.validator)('pipe', (input, context) => {
+    return validator('pipe', (input, context) => {
         let i;
         let c;
         let v = input;
@@ -30,8 +26,8 @@ function pipe(rules, options) {
  * Test given value against to all codecs and returns original input
  * @validator allOf
  */
-function allOf(rules) {
-    return (0, index_js_1.validator)('allOf', (input, context) => {
+export function allOf(rules) {
+    return validator('allOf', (input, context) => {
         let i;
         let c;
         const l = rules.length;

package/esm/rules/utility-rules/required.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.required = required;
-const index_js_1 = require("../../core/index.js");
+import { validator, } from '../../core/index.js';
 /**
  * Makes sub-rule required
  * @validator required
  */
-function required(nested, options) {
-    return (0, index_js_1.validator)('required', (input, context, _this) => {
+export function required(nested, options) {
+    return validator('required', (input, context, _this) => {
         if (input == null) {
             context.fail(_this, `{{label}} is required`, input);
             return;