@warlock.js/core 2.0.5 → 2.1.1

package/cjs/validator/v/rules.js

@@ -1,4 +1,4 @@
-'use strict';var reinforcements=require('@mongez/reinforcements'),supportiveIs=require('@mongez/supportive-is'),cascade=require('@warlock.js/cascade'),UploadedFile=require('../../http/UploadedFile.js'),utils=require('./utils.js');const requiredRule = {
+'use strict';var reinforcements=require('@mongez/reinforcements'),supportiveIs=require('@mongez/supportive-is'),cascade=require('@warlock.js/cascade'),dayjs=require('dayjs'),net=require('net'),UploadedFile=require('../../http/UploadedFile.js'),upload=require('../../modules/uploads/models/upload.js'),utils=require('./utils.js');function _interopDefault(e){return e&&e.__esModule?e:{default:e}}var dayjs__default=/*#__PURE__*/_interopDefault(dayjs);const requiredRule = {
     name: "required",
     defaultErrorMessage: "The :input is required",
     requiresValue: false,
@@ -36,7 +36,7 @@ const requiredIfAbsentRule = {
     errorMessage: "The :input is required",
     async validate(value, context) {
         const otherField = this.context.options.field;
-        const fieldValue = reinforcements.get(context.allValues, otherField);
+        const fieldValue = reinforcements.get(context.allValues || {}, otherField);
         const isPresent = ![undefined, null].includes(fieldValue);
         if (!isPresent && supportiveIs.isEmpty(value)) {
             return utils.invalidRule(this, context);
@@ -44,6 +44,28 @@ const requiredIfAbsentRule = {
         return utils.VALID_RULE;
     },
 };
+const requiredIfSiblingFieldAllAbsentRule = {
+    name: "requiredIfSiblingFieldAllAbsent",
+    description: "The field is required if all other fields are absent",
+    sortOrder: -2,
+    requiresValue: false,
+    errorMessage: "The :input is required",
+    async validate(value, context) {
+        const fields = this.context.options.fields;
+        let isPresent = false;
+        for (const field of fields) {
+            const fieldValue = reinforcements.get(context.parent, field);
+            if (![undefined, null].includes(fieldValue)) {
+                isPresent = true;
+                break;
+            }
+        }
+        if (!isPresent && supportiveIs.isEmpty(value)) {
+            return utils.invalidRule(this, context);
+        }
+        return utils.VALID_RULE;
+    },
+};
 const requiredIfEmptyRule = {
     name: "requiredIfEmpty",
     description: "The field is required if another field is empty",
@@ -59,6 +81,22 @@ const requiredIfEmptyRule = {
         return utils.VALID_RULE;
     },
 };
+// required if sibling field is empty
+const requiredIfSiblingFieldEmptyRule = {
+    name: "requiredIfSiblingFieldEmpty",
+    description: "The field is required if another field in same parent context is empty",
+    sortOrder: -2,
+    requiresValue: false,
+    errorMessage: "The :input is required",
+    async validate(value, context) {
+        const otherField = this.context.options.field;
+        const fieldValue = reinforcements.get(context.parent, otherField);
+        if (supportiveIs.isEmpty(fieldValue) && supportiveIs.isEmpty(value)) {
+            return utils.invalidRule(this, context);
+        }
+        return utils.VALID_RULE;
+    },
+};
 const requiredIfFieldRule = {
     name: "requiredIfField",
     description: "The field is required if another field has a specific value",
@@ -78,21 +116,45 @@ const requiredIfFieldRule = {
         return utils.VALID_RULE;
     },
 };
-const objectRule = {
-    name: "object",
-    defaultErrorMessage: "The :input must be an object",
+const requiredIfSiblingFieldRule = {
+    name: "requiredIfSiblingField",
+    description: "The field is required if another field in same parent context has a specific value",
+    sortOrder: -2,
+    requiresValue: false,
+    errorMessage: "The :input is required",
     async validate(value, context) {
-        if (supportiveIs.isPlainObject(value)) {
-            return utils.VALID_RULE;
+        const otherField = this.context.options.field;
+        const otherFieldValue = this.context.options.value;
+        const parentValues = context.parent;
+        const fieldValue = reinforcements.get(parentValues, otherField);
+        if (fieldValue === otherFieldValue && supportiveIs.isEmpty(value)) {
+            return utils.invalidRule(this, context);
         }
-        return utils.invalidRule(this, context);
+        return utils.VALID_RULE;
     },
 };
-const arrayRule = {
-    name: "array",
-    defaultErrorMessage: "The :input must be an array",
+const requiredUnlessSiblingFieldRule = {
+    name: "requiredUnlessSiblingField",
+    description: "The field is required unless another field in same parent context has a specific value",
+    sortOrder: -2,
+    requiresValue: false,
+    errorMessage: "The :input is required",
     async validate(value, context) {
-        if (Array.isArray(value)) {
+        const otherField = this.context.options.field;
+        const otherFieldValue = this.context.options.value;
+        const parentValues = context.parent;
+        const fieldValue = reinforcements.get(parentValues, otherField);
+        if (fieldValue !== otherFieldValue && supportiveIs.isEmpty(value)) {
+            return utils.invalidRule(this, context);
+        }
+        return utils.VALID_RULE;
+    },
+};
+const objectRule = {
+    name: "object",
+    defaultErrorMessage: "The :input must be an object",
+    async validate(value, context) {
+        if (supportiveIs.isPlainObject(value)) {
             return utils.VALID_RULE;
         }
         return utils.invalidRule(this, context);
@@ -158,7 +220,59 @@ const inRule = {
         return utils.invalidRule(this, context);
     },
 };
-const enumRule = inRule;
+const enumRule = {
+    name: "enum",
+    errorMessage: "The :input must be one of the following values: :options",
+    async validate(value, context) {
+        const enumObject = this.context.options.enum;
+        const enumValues = Object.values(enumObject);
+        if (enumValues.includes(value)) {
+            return utils.VALID_RULE;
+        }
+        this.context.options.enum = enumValues.join(", ");
+        return utils.invalidRule(this, context);
+    },
+};
+const withoutWhitespaceRule = {
+    name: "withoutWhitespace",
+    errorMessage: "The :input must not contain whitespace",
+    async validate(value, context) {
+        if (!/\s/.test(value)) {
+            return utils.VALID_RULE;
+        }
+        return utils.invalidRule(this, context);
+    },
+};
+const minWordsRule = {
+    name: "minWords",
+    errorMessage: `The :input must be at least :minWords words`,
+    async validate(value, context) {
+        if (value?.split(" ").length >= this.context.options.minWords) {
+            return utils.VALID_RULE;
+        }
+        return utils.invalidRule(this, context);
+    },
+};
+const maxWordsRule = {
+    name: "maxWords",
+    errorMessage: `The :input must be at most :maxWords words`,
+    async validate(value, context) {
+        if (value?.split(" ").length <= this.context.options.maxWords) {
+            return utils.VALID_RULE;
+        }
+        return utils.invalidRule(this, context);
+    },
+};
+const wordsRule = {
+    name: "words",
+    errorMessage: `The :input must be exactly :words words`,
+    async validate(value, context) {
+        if (value?.split(" ").length === this.context.options.words) {
+            return utils.VALID_RULE;
+        }
+        return utils.invalidRule(this, context);
+    },
+};
 const minLengthRule = {
     name: "minLength",
     errorMessage: `The :input must be at least :minLength characters long`,
@@ -276,12 +390,44 @@ const dateRule = {
     name: "date",
     errorMessage: "The :input must be a valid date",
     async validate(value, context) {
+        const format = this.context.options.format;
+        // use dayjs for date validation
+        if (format) {
+            const date = dayjs__default.default(value, format);
+            if (date.isValid()) {
+                return utils.VALID_RULE;
+            }
+            return utils.invalidRule(this, context);
+        }
         if (new Date(value).toString() !== "Invalid Date") {
             return utils.VALID_RULE;
         }
         return utils.invalidRule(this, context);
     },
 };
+// Must be used with Date mutator
+const minDateRule = {
+    name: "minDate",
+    description: "The field must be at least the given date",
+    errorMessage: `The :input must be at least :minDate`,
+    async validate(value, context) {
+        if (value >= this.context.options.minDate) {
+            return utils.VALID_RULE;
+        }
+        return utils.invalidRule(this, context);
+    },
+};
+// Must be used with Date mutator
+const maxDateRule = {
+    name: "maxDate",
+    errorMessage: `The :input must be at most :maxDate`,
+    async validate(value, context) {
+        if (value <= this.context.options.maxDate) {
+            return utils.VALID_RULE;
+        }
+        return utils.invalidRule(this, context);
+    },
+};
 const urlRule = {
     name: "url",
     errorMessage: "The :input must be a valid URL",
@@ -295,6 +441,109 @@ const urlRule = {
         }
     },
 };
+const ipRule = {
+    name: "ip",
+    errorMessage: "The :input must be a valid IP address",
+    async validate(value, context) {
+        const result = net.isIP(value);
+        if (result !== 0) {
+            return utils.VALID_RULE;
+        }
+        return utils.invalidRule(this, context);
+    },
+};
+const ip4Rule = {
+    name: "ip4",
+    errorMessage: "The :input must be a valid IPv4 address",
+    async validate(value, context) {
+        const result = net.isIP(value);
+        if (result === 4) {
+            return utils.VALID_RULE;
+        }
+        return utils.invalidRule(this, context);
+    },
+};
+const ip6Rule = {
+    name: "ip6",
+    errorMessage: "The :input must be a valid IPv6 address",
+    async validate(value, context) {
+        const result = net.isIP(value);
+        if (result === 6) {
+            return utils.VALID_RULE;
+        }
+        return utils.invalidRule(this, context);
+    },
+};
+const isNumericRule = {
+    name: "isNumeric",
+    errorMessage: "The :input must be a numeric value",
+    async validate(value, context) {
+        if (supportiveIs.isNumeric(value)) {
+            return utils.VALID_RULE;
+        }
+        return utils.invalidRule(this, context);
+    },
+};
+const startsWithRule = {
+    name: "startsWith",
+    errorMessage: "The :input must start with :value",
+    async validate(value, context) {
+        if (value.startsWith(this.context.options.value)) {
+            return utils.VALID_RULE;
+        }
+        return utils.invalidRule(this, context);
+    },
+};
+const endsWithRule = {
+    name: "endsWith",
+    errorMessage: "The :input must end with :value",
+    async validate(value, context) {
+        if (value.endsWith(this.context.options.value)) {
+            return utils.VALID_RULE;
+        }
+        return utils.invalidRule(this, context);
+    },
+};
+const containsRule = {
+    name: "contains",
+    errorMessage: "The :input must contain :value",
+    async validate(value, context) {
+        if (value.includes(this.context.options.value)) {
+            return utils.VALID_RULE;
+        }
+        return utils.invalidRule(this, context);
+    },
+};
+const notContainsRule = {
+    name: "notContains",
+    errorMessage: "The :input must not contain :value",
+    async validate(value, context) {
+        if (!value.includes(this.context.options.value)) {
+            return utils.VALID_RULE;
+        }
+        return utils.invalidRule(this, context);
+    },
+};
+const alphaRule = {
+    name: "alpha",
+    errorMessage: "The :input must contain only alphabetic characters",
+    async validate(value, context) {
+        if (/^[a-zA-Z]+$/.test(value)) {
+            return utils.VALID_RULE;
+        }
+        return utils.invalidRule(this, context);
+    },
+};
+const alphaNumericRule = {
+    name: "alphaNumeric",
+    errorMessage: "The :input must contain only alphabetic and numeric characters",
+    async validate(value, context) {
+        if (/^[a-zA-Z0-9]+$/.test(value)) {
+            return utils.VALID_RULE;
+        }
+        return utils.invalidRule(this, context);
+    },
+};
 const patternRule = {
     name: "pattern",
     errorMessage: "The :input does not match the pattern",
@@ -305,6 +554,42 @@ const patternRule = {
         return utils.invalidRule(this, context);
     },
 };
+const moduloRule = {
+    name: "modulo",
+    errorMessage: "The :input must be a multiple of :value",
+    async validate(value, context) {
+        if (value % this.context.options.value === 0) {
+            return utils.VALID_RULE;
+        }
+        return utils.invalidRule(this, context);
+    },
+};
+const isCreditCardRule = {
+    name: "isCreditCard",
+    description: "The field must be a valid credit card number",
+    errorMessage: "The :input must be a valid credit card number",
+    async validate(value, context) {
+        // Luhn algorithm
+        const cardNumber = value.toString().replace(/\D/g, "");
+        let sum = 0;
+        let isEven = false;
+        for (let i = cardNumber.length - 1; i >= 0; i--) {
+            let digit = parseInt(cardNumber[i]);
+            if (isEven) {
+                digit *= 2;
+                if (digit > 9) {
+                    digit -= 9;
+                }
+            }
+            sum += digit;
+            isEven = !isEven;
+        }
+        if (sum % 10 === 0) {
+            return utils.VALID_RULE;
+        }
+        return utils.invalidRule(this, context);
+    },
+};
 const positiveRule = {
     name: "positive",
     errorMessage: "The :input must be a positive number",
@@ -361,6 +646,17 @@ const uniqueRule = {
         return utils.invalidRule(this, context);
     },
 };
+const uploadableRule = {
+    name: "uploadable",
+    errorMessage: "The :input must be a valid uploadable hash id",
+    async validate(value, context) {
+        const hashExists = await upload.Upload.aggregate().where("hash", value).exists();
+        if (hashExists) {
+            return utils.VALID_RULE;
+        }
+        return utils.invalidRule(this, context);
+    },
+};
 const existsRule = {
     name: "exists",
     errorMessage: "The :input must exist",
@@ -382,7 +678,7 @@ const existsRule = {
         return utils.invalidRule(this, context);
     },
 };
-const fileRile = {
+const fileRule = {
     name: "file",
     errorMessage: "The :input must be a file",
     async validate(value, context) {
@@ -392,6 +688,34 @@ const fileRile = {
         return utils.invalidRule(this, context);
     },
 };
+const fileTypeRule = {
+    name: "fileType",
+    errorMessage: "The :input must be a :types file",
+    async validate(value, context) {
+        let mimeTypes = this.context.options.mimeTypes;
+        if (typeof mimeTypes === "string") {
+            mimeTypes = [mimeTypes];
+        }
+        if (mimeTypes.includes(value.mimeType)) {
+            return utils.VALID_RULE;
+        }
+        return utils.invalidRule(this, context);
+    },
+};
+const fileExtensionRule = {
+    name: "fileExtension",
+    errorMessage: "The :input must have one of the following extensions: :extensions",
+    async validate(value, context) {
+        let extensions = this.context.options.extensions;
+        if (typeof extensions === "string") {
+            extensions = [extensions];
+        }
+        if (extensions.includes(value.extension)) {
+            return utils.VALID_RULE;
+        }
+        return utils.invalidRule(this, context);
+    },
+};
 const maxFileSizeRule = {
     name: "maxFileSize",
     errorMessage: "The :input must not exceed :maxFileSize",
@@ -454,4 +778,175 @@ const minHeightRule = {
         }
         return utils.invalidRule(this, context);
     },
-};exports.arrayRule=arrayRule;exports.booleanRule=booleanRule;exports.dateRule=dateRule;exports.emailRule=emailRule;exports.enumRule=enumRule;exports.equalRule=equalRule;exports.existsRule=existsRule;exports.fileRile=fileRile;exports.floatRule=floatRule;exports.imageRule=imageRule;exports.inRule=inRule;exports.intRule=intRule;exports.lengthRule=lengthRule;exports.matchesRule=matchesRule;exports.maxFileSizeRule=maxFileSizeRule;exports.maxLengthRule=maxLengthRule;exports.maxRule=maxRule;exports.maxWidthRule=maxWidthRule;exports.minFileSizeRule=minFileSizeRule;exports.minHeightRule=minHeightRule;exports.minLengthRule=minLengthRule;exports.minRule=minRule;exports.minWidthRule=minWidthRule;exports.numberRule=numberRule;exports.objectRule=objectRule;exports.patternRule=patternRule;exports.positiveRule=positiveRule;exports.requiredIfAbsentRule=requiredIfAbsentRule;exports.requiredIfEmptyRule=requiredIfEmptyRule;exports.requiredIfFieldRule=requiredIfFieldRule;exports.requiredRule=requiredRule;exports.requiredWithRule=requiredWithRule;exports.scalarRule=scalarRule;exports.stringRule=stringRule;exports.uniqueArrayRule=uniqueArrayRule;exports.uniqueRule=uniqueRule;exports.unknownKeyRule=unknownKeyRule;exports.urlRule=urlRule;//# sourceMappingURL=rules.js.map
+};
+const maxHeightRule = {
+    name: "maxHeight",
+    errorMessage: "The :input must be at most :maxHeight pixels tall",
+    async validate(value, context) {
+        const dimensions = await value.dimensions();
+        if (dimensions.height <= this.context.options.maxHeight) {
+            return utils.VALID_RULE;
+        }
+        return utils.invalidRule(this, context);
+    },
+};
+/**
+ * Check if the value is one of the allowed values
+ */
+const allowedValuesRule = {
+    name: "arrayOfValues",
+    errorMessage: "The :input must be an array containing only the allowed values: :allowedValues",
+    async validate(value, context) {
+        const allowedValues = this.context.options.allowedValues;
+        // Check if the value is an array
+        if (!Array.isArray(value)) {
+            return utils.invalidRule(this, context);
+        }
+        // Check if all elements in the array are allowed values
+        const isValid = value.every(item => allowedValues.includes(item));
+        if (isValid) {
+            return utils.VALID_RULE;
+        }
+        return utils.invalidRule(this, context);
+    },
+};
+/**
+ * Value must not be any of the given values
+ */
+const notAllowedValuesRule = {
+    name: "notAllowedValues",
+    errorMessage: "The :input must not be any of the following values: :notAllowedValues",
+    async validate(value, context) {
+        const notAllowedValues = this.context.options.notAllowedValues;
+        if (!notAllowedValues.includes(value)) {
+            return utils.VALID_RULE;
+        }
+        return utils.invalidRule(this, context);
+    },
+};
+// Array rules
+const arrayRule = {
+    name: "array",
+    defaultErrorMessage: "The :input must be an array",
+    async validate(value, context) {
+        if (Array.isArray(value)) {
+            return utils.VALID_RULE;
+        }
+        return utils.invalidRule(this, context);
+    },
+};
+// End of Array rules
+// Color rules
+const colorValidationRegex = {
+    hex: /^#([0-9a-f]{3}){1,2}$/i,
+    rgb: /^rgb\((\d{1,3}),\s*(\d{1,3}),\s*(\d{1,3})\)$/,
+    rgba: /^rgba\((\d{1,3}),\s*(\d{1,3}),\s*(\d{1,3}),\s*(0?\.\d+)\)$/,
+    hsl: /^hsl\((\d{1,3}),\s*(\d{1,3}),\s*(\d{1,3})\)$/,
+    light: /^#([0-9a-f]{3}){1,2}$/i,
+    dark: /^#([0-9a-f]{3}){1,2}$/i,
+};
+const rgbColorRule = {
+    name: "rgbColor",
+    errorMessage: "The :input must be a valid RGB color",
+    async validate(value, context) {
+        if (value.match(colorValidationRegex.rgb)) {
+            return utils.VALID_RULE;
+        }
+        return utils.invalidRule(this, context);
+    },
+};
+const rgbaColorRule = {
+    name: "rgbaColor",
+    errorMessage: "The :input must be a valid RGBA color",
+    async validate(value, context) {
+        if (value.match(colorValidationRegex.rgba)) {
+            return utils.VALID_RULE;
+        }
+        return utils.invalidRule(this, context);
+    },
+};
+const hexColorRule = {
+    name: "hexColor",
+    errorMessage: "The :input must be a valid hex color",
+    async validate(value, context) {
+        if (value.match(colorValidationRegex.hex)) {
+            return utils.VALID_RULE;
+        }
+        return utils.invalidRule(this, context);
+    },
+};
+const hslColorRule = {
+    name: "hslColor",
+    errorMessage: "The :input must be a valid HSL color",
+    async validate(value, context) {
+        if (value.match(colorValidationRegex.hsl)) {
+            return utils.VALID_RULE;
+        }
+        return utils.invalidRule(this, context);
+    },
+};
+const lightColorRule = {
+    name: "lightColor",
+    errorMessage: "The :input must be a light color",
+    async validate(value, context) {
+        if (value.match(colorValidationRegex.light)) {
+            return utils.VALID_RULE;
+        }
+        return utils.invalidRule(this, context);
+    },
+};
+const darkColorRule = {
+    name: "darkColor",
+    errorMessage: "The :input must be a dark color",
+    async validate(value, context) {
+        if (value.match(colorValidationRegex.dark)) {
+            return utils.VALID_RULE;
+        }
+        return utils.invalidRule(this, context);
+    },
+};
+const colorRule = {
+    name: "color",
+    errorMessage: "The :input must be a valid color",
+    async validate(value, context) {
+        if (value.match(colorValidationRegex.hex) ||
+            value.match(colorValidationRegex.rgb) ||
+            value.match(colorValidationRegex.rgba) ||
+            value.match(colorValidationRegex.hsl)) {
+            return utils.VALID_RULE;
+        }
+        return utils.invalidRule(this, context);
+    },
+};
+const forbiddenRule = {
+    name: "forbidden",
+    errorMessage: "The :input is forbidden",
+    async validate(_value, context) {
+        return utils.invalidRule(this, context);
+    },
+};
+/**
+ * When rule applies a condition validation rule based on another field value
+ */
+const whenRule = {
+    name: "when",
+    description: "Apply conditional validation rules based on another field value",
+    async validate(value, context) {
+        const { field, is, otherwise, local } = this.context.options;
+        const parent = local ? context.parent : context.allValues;
+        const fieldValue = reinforcements.get(parent, field);
+        const condition = is[fieldValue] || otherwise;
+        if (condition) {
+            const result = await condition.validate(value, context);
+            if (!result.isValid) {
+                return {
+                    isValid: false,
+                    error: result.errors[0].error,
+                    input: result.errors[0].input,
+                    path: context.path,
+                };
+            }
+        }
+        return utils.VALID_RULE;
+    },
+};exports.allowedValuesRule=allowedValuesRule;exports.alphaNumericRule=alphaNumericRule;exports.alphaRule=alphaRule;exports.arrayRule=arrayRule;exports.booleanRule=booleanRule;exports.colorRule=colorRule;exports.containsRule=containsRule;exports.darkColorRule=darkColorRule;exports.dateRule=dateRule;exports.emailRule=emailRule;exports.endsWithRule=endsWithRule;exports.enumRule=enumRule;exports.equalRule=equalRule;exports.existsRule=existsRule;exports.fileExtensionRule=fileExtensionRule;exports.fileRule=fileRule;exports.fileTypeRule=fileTypeRule;exports.floatRule=floatRule;exports.forbiddenRule=forbiddenRule;exports.hexColorRule=hexColorRule;exports.hslColorRule=hslColorRule;exports.imageRule=imageRule;exports.inRule=inRule;exports.intRule=intRule;exports.ip4Rule=ip4Rule;exports.ip6Rule=ip6Rule;exports.ipRule=ipRule;exports.isCreditCardRule=isCreditCardRule;exports.isNumericRule=isNumericRule;exports.lengthRule=lengthRule;exports.lightColorRule=lightColorRule;exports.matchesRule=matchesRule;exports.maxDateRule=maxDateRule;exports.maxFileSizeRule=maxFileSizeRule;exports.maxHeightRule=maxHeightRule;exports.maxLengthRule=maxLengthRule;exports.maxRule=maxRule;exports.maxWidthRule=maxWidthRule;exports.maxWordsRule=maxWordsRule;exports.minDateRule=minDateRule;exports.minFileSizeRule=minFileSizeRule;exports.minHeightRule=minHeightRule;exports.minLengthRule=minLengthRule;exports.minRule=minRule;exports.minWidthRule=minWidthRule;exports.minWordsRule=minWordsRule;exports.moduloRule=moduloRule;exports.notAllowedValuesRule=notAllowedValuesRule;exports.notContainsRule=notContainsRule;exports.numberRule=numberRule;exports.objectRule=objectRule;exports.patternRule=patternRule;exports.positiveRule=positiveRule;exports.requiredIfAbsentRule=requiredIfAbsentRule;exports.requiredIfEmptyRule=requiredIfEmptyRule;exports.requiredIfFieldRule=requiredIfFieldRule;exports.requiredIfSiblingFieldAllAbsentRule=requiredIfSiblingFieldAllAbsentRule;exports.requiredIfSiblingFieldEmptyRule=requiredIfSiblingFieldEmptyRule;exports.requiredIfSiblingFieldRule=requiredIfSiblingFieldRule;exports.requiredRule=requiredRule;exports.requiredUnlessSiblingFieldRule=requiredUnlessSiblingFieldRule;exports.requiredWithRule=requiredWithRule;exports.rgbColorRule=rgbColorRule;exports.rgbaColorRule=rgbaColorRule;exports.scalarRule=scalarRule;exports.startsWithRule=startsWithRule;exports.stringRule=stringRule;exports.uniqueArrayRule=uniqueArrayRule;exports.uniqueRule=uniqueRule;exports.unknownKeyRule=unknownKeyRule;exports.uploadableRule=uploadableRule;exports.urlRule=urlRule;exports.whenRule=whenRule;exports.withoutWhitespaceRule=withoutWhitespaceRule;exports.wordsRule=wordsRule;//# sourceMappingURL=rules.js.map