valgen 3.2.1 → 4.0.0-alpha.2

package/CHANGELOG.md

@@ -0,0 +1,6 @@
+# v4.0.0-alpha.1
+[2023-06-04]
+
+### Changes
+
+* Initial release of v4.0.0-alpha.1 ([`499af8e`](https://github.com/panates/valgen/commit/499af8eed81feeacb4bba5c254fbf1ede3933564))

package/README.md

@@ -1,12 +1,11 @@
-# Valgen
+# VALGEN
 
 [![NPM Version][npm-image]][npm-url]
 [![NPM Downloads][downloads-image]][downloads-url]
-[![Build Status][travis-image]][travis-url]
+[![CircleCI][circleci-image]][circleci-url]
 [![Test Coverage][coveralls-image]][coveralls-url]
-[![DevDependencies][devdependencies-image]][devdependencies-url]
 
-Fast type validation generator.
+Fast runtime type validator, converter and io (encoding/decoding) library.
 
 ## Installation
 
@@ -14,18 +13,24 @@ Fast type validation generator.
 
 ## Node Compatibility
 
-  - node `>= 10.0`;
+  - node `>= 16.0`;
   
 ### License
 [MIT](LICENSE)
 
 [npm-image]: https://img.shields.io/npm/v/valgen.svg
 [npm-url]: https://npmjs.org/package/valgen
-[travis-image]: https://img.shields.io/travis/panates/valgen/master.svg
-[travis-url]: https://travis-ci.org/panates/valgen
+[circleci-image]: https://circleci.com/gh/panates/valgen/tree/master.svg?style=shield
+[circleci-url]: https://circleci.com/gh/panates/valgen/tree/master
 [coveralls-image]: https://img.shields.io/coveralls/panates/valgen/master.svg
 [coveralls-url]: https://coveralls.io/r/panates/valgen
 [downloads-image]: https://img.shields.io/npm/dm/valgen.svg
 [downloads-url]: https://npmjs.org/package/valgen
+[gitter-image]: https://badges.gitter.im/panates/valgen.svg
+[gitter-url]: https://gitter.im/panates/valgen?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
+[dependencies-image]: https://david-dm.org/panates/valgen/status.svg
+[dependencies-url]:https://david-dm.org/panates/valgen
 [devdependencies-image]: https://david-dm.org/panates/valgen/dev-status.svg
 [devdependencies-url]:https://david-dm.org/panates/valgen?type=dev
+[quality-image]: http://npm.packagequality.com/shield/valgen.png
+[quality-url]: http://packagequality.com/#?package=valgen

package/cjs/core/constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kOptions = exports.kValidatorFn = void 0;
+exports.kValidatorFn = Symbol.for('kValidatorFn');
+exports.kOptions = Symbol.for('kOptions');

package/cjs/core/context.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Context = void 0;
+const constants_js_1 = require("./constants.js");
+const validation_error_js_1 = require("./validation-error.js");
+const VARIABLE_REPLACE_PATTERN = /{{([^}]*)}}/g;
+const OPTIONAL_VAR_PATTERN = /^([^?]+)(?:\||(.*))?$/;
+class Context {
+    constructor(rule, options) {
+        this.errors = [];
+        this.input = {};
+        this.rule = rule;
+        if (options?.maxErrors != null)
+            this.maxErrors = options.maxErrors;
+        if (typeof options?.onFail === 'function')
+            this.onFail = options.onFail;
+        if (options?.coerce != null)
+            this.coerce = options?.coerce;
+    }
+    failure(message) {
+        const issue = (typeof message === 'object'
+            ? { ...message, message: message.message }
+            : { message: '' + message });
+        issue.rule = this.rule.id;
+        Object.assign(issue, this.input);
+        if (this.onFail) {
+            const proto = Object.getPrototypeOf(this);
+            const x = this.onFail(issue, this, proto.onFail);
+            if (!x)
+                return;
+            if (typeof x === 'object') {
+                delete x.id;
+                delete x.input;
+                Object.assign(issue, x);
+            }
+            else
+                issue.message = String(x);
+        }
+        issue.message = ('' + issue.message).replace(VARIABLE_REPLACE_PATTERN, (x, g) => {
+            const m = OPTIONAL_VAR_PATTERN.exec(g);
+            if (!m)
+                return x;
+            const k = m[1];
+            const v = this.input[k] ??
+                (m[1] === 'label' ? this.input.property : undefined);
+            if (v != null)
+                return '`' + v + '`';
+            if (m[2])
+                return m[2];
+            return m[1] === 'label' ? 'Value' : x;
+        });
+        this.errors.push(issue);
+        if (this.errors.length >= (this.maxErrors ?? Infinity))
+            throw new validation_error_js_1.ValidationError(this.errors);
+    }
+    extend(rule, options) {
+        const extended = new Context(rule, { onFail: undefined, ...rule[constants_js_1.kOptions], ...options });
+        Object.setPrototypeOf(extended, this);
+        delete extended.errors;
+        extended.parent = this;
+        extended.root = this.root || this;
+        return extended;
+    }
+}
+exports.Context = Context;

package/cjs/core/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./context.js"), exports);
+__exportStar(require("./constants.js"), exports);
+__exportStar(require("./types.js"), exports);
+__exportStar(require("./validation-error.js"), exports);
+__exportStar(require("./validator.js"), exports);

package/cjs/core/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/core/validation-error.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationError = void 0;
+class ValidationError extends Error {
+    constructor(issues) {
+        super(issues[0].message);
+        this.issues = [];
+        this.issues = issues;
+    }
+}
+exports.ValidationError = ValidationError;

package/cjs/core/validator.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidator = exports.validator = void 0;
+const string_utils_js_1 = require("../helpers/string.utils.js");
+const constants_js_1 = require("./constants.js");
+const context_js_1 = require("./context.js");
+const validation_error_js_1 = require("./validation-error.js");
+function validator(arg0, arg1, arg2) {
+    let id = '';
+    let fn;
+    let validatorOptions;
+    if (typeof arg0 === 'string') {
+        id = arg0;
+        fn = arg1;
+        validatorOptions = arg2;
+    }
+    else {
+        fn = arg0;
+        validatorOptions = arg1;
+    }
+    if (typeof fn !== 'function')
+        throw new TypeError('You must provide a rule function argument');
+    id = id || fn.name || 'unnamed-rule';
+    const name = fn.name || (0, string_utils_js_1.camelCase)(id);
+    const _rule = ({
+        [name](input, options, parent) {
+            const ctx = parent ? parent.extend(_rule, options) : new context_js_1.Context(_rule, options);
+            let value;
+            try {
+                ctx.input.value = input;
+                value = fn(input, ctx, _rule);
+            }
+            catch (e) {
+                if (!parent && e instanceof validation_error_js_1.ValidationError)
+                    throw e;
+                ctx.failure(e);
+            }
+            if (!parent && ctx.errors.length)
+                throw new validation_error_js_1.ValidationError(ctx.errors);
+            return value;
+        }
+    })[name];
+    _rule.id = id;
+    _rule[constants_js_1.kValidatorFn] = fn;
+    _rule[constants_js_1.kOptions] = validatorOptions || {};
+    _rule.silent = (input, options, context) => {
+        try {
+            const value = _rule(input, options, context);
+            return { value };
+        }
+        catch (e) {
+            return { errors: e.issues };
+        }
+    };
+    return _rule;
+}
+exports.validator = validator;
+function isValidator(x) {
+    return !!(typeof x === 'function' && x.id && x[constants_js_1.kValidatorFn]);
+}
+exports.isValidator = isValidator;

package/cjs/helpers/object.utils.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pickKeys = exports.omitKeys = void 0;
+function omitKeys(o, keys) {
+    return Object.keys(o).reduce((a, k) => {
+        if (!keys.includes(k))
+            a[k] = o[k];
+        return a;
+    }, {});
+}
+exports.omitKeys = omitKeys;
+function pickKeys(o, keys) {
+    return Object.keys(o).reduce((a, k) => {
+        if (keys.includes(k))
+            a[k] = o[k];
+        return a;
+    }, {});
+}
+exports.pickKeys = pickKeys;

package/cjs/helpers/string.utils.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.camelCase = void 0;
+function camelCase(v) {
+    return v.replace(/[\W_\s]+([^\W_\s])/g, (arg$, c) => {
+        return c[0].toUpperCase();
+    });
+}
+exports.camelCase = camelCase;

package/cjs/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./core/index.js"), exports);
+__exportStar(require("./rules/index.js"), exports);

package/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/cjs/rules/index.js

@@ -0,0 +1,38 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./is-any.js"), exports);
+__exportStar(require("./is-array.js"), exports);
+__exportStar(require("./is-boolean.js"), exports);
+__exportStar(require("./is-date.js"), exports);
+__exportStar(require("./is-empty.js"), exports);
+__exportStar(require("./is-enum.js"), exports);
+__exportStar(require("./is-integer.js"), exports);
+__exportStar(require("./is-null.js"), exports);
+__exportStar(require("./is-matches.js"), exports);
+__exportStar(require("./is-number.js"), exports);
+__exportStar(require("./is-object.js"), exports);
+__exportStar(require("./is-object-id.js"), exports);
+__exportStar(require("./is-record.js"), exports);
+__exportStar(require("./is-string.js"), exports);
+__exportStar(require("./is-tuple.js"), exports);
+__exportStar(require("./length.js"), exports);
+__exportStar(require("./optional.js"), exports);
+__exportStar(require("./pipe.js"), exports);
+__exportStar(require("./range.js"), exports);
+__exportStar(require("./string-formats.js"), exports);
+__exportStar(require("./union.js"), exports);
+__exportStar(require("./utilities.js"), exports);

package/cjs/rules/is-any.js

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

package/cjs/rules/is-array.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isArray = void 0;
+const index_js_1 = require("../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', function (input, context) {
+        if (input != null && context.coerce && !Array.isArray(input))
+            input = [input];
+        if (!Array.isArray(input)) {
+            context.failure(`{{label}} is not an array`);
+            return;
+        }
+        if (!itemValidator)
+            return input;
+        const location = context.input.location || '';
+        const itemContext = context.extend(itemValidator);
+        let i;
+        let v;
+        const l = input.length;
+        const out = [];
+        for (i = 0; i < l; i++) {
+            v = input[i];
+            itemContext.input.value = v;
+            itemContext.input.label = ((context.input.label || context.input.property) || 'Item') +
+                `[${i}]`;
+            itemContext.input.property = i;
+            itemContext.input.location = location + '[' + i + ']';
+            out.push(itemValidator[index_js_1.kValidatorFn](v, itemContext, itemValidator));
+        }
+        return out;
+    }, options);
+}
+exports.isArray = isArray;

package/cjs/rules/is-boolean.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBoolean = void 0;
+const index_js_1 = require("../core/index.js");
+const TRUE_PATTERN = /^true|t|1|yes|y$/i;
+const FALSE_PATTERN = /^false|f|0|no|n$/i;
+/**
+ * Validates if value is "boolean".
+ * Converts input value to boolean if coerce option is set to 'true'.
+ * @validator isBoolean
+ */
+function isBoolean(options) {
+    return (0, index_js_1.validator)('isBoolean', function (input, context) {
+        if (input != null && typeof input !== 'boolean' && context.coerce) {
+            if (typeof input === 'string') {
+                if (TRUE_PATTERN.test(input))
+                    return true;
+                if (FALSE_PATTERN.test(input))
+                    return false;
+                throw new TypeError(`Invalid boolean string`);
+            }
+            if (input === 1 || input === 0)
+                input = !!input;
+        }
+        if (typeof input === 'boolean')
+            return input;
+        context.failure(`{{label}} is not a valid boolean`);
+    }, options);
+}
+exports.isBoolean = isBoolean;

package/cjs/rules/is-date.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDateString = exports.isDate = void 0;
+const dayjs_1 = __importDefault(require("dayjs"));
+const customParseFormat_1 = __importDefault(require("dayjs/plugin/customParseFormat"));
+const index_js_1 = require("../core/index.js");
+const object_utils_js_1 = require("../helpers/object.utils.js");
+dayjs_1.default.extend(customParseFormat_1.default);
+/**
+ * Validates if value is instance of "Date".
+ * Converts input value to Date if coerce option is set to 'true'.
+ * @validator isDate
+ */
+function isDate(options) {
+    return (0, index_js_1.validator)('isDate', function (input, context) {
+        if (input != null && !(input instanceof Date) && context.coerce) {
+            if (typeof input === 'string') {
+                const d = (0, dayjs_1.default)(input, options?.format);
+                if (d.isValid())
+                    input = d.toDate();
+            }
+            else if (typeof input === 'number')
+                input = new Date(input);
+        }
+        if (input && input instanceof Date && !isNaN(input.getTime()))
+            return input;
+        context.failure({
+            message: `{{label}} is not a valid Date instance` +
+                (context.coerce
+                    ? ` or a date formatted${options?.format ? " (" + options.format + ")" : ''} string`
+                    : ''),
+            format: options?.format
+        });
+    }, (0, object_utils_js_1.omitKeys)(options || {}, ['format']));
+}
+exports.isDate = isDate;
+/**
+ * Validates if value is DFS (date formatted string).
+ * Converts input value to DFS if coerce option is set to 'true'.
+ * @validator isDateString
+ */
+function isDateString(options) {
+    return (0, index_js_1.validator)('isDateString', function (input, context) {
+        if (input && typeof input !== 'string' && context.coerce) {
+            const d = (0, dayjs_1.default)(input);
+            if (d.isValid())
+                return options?.format ? d.format(options?.format) : d.toISOString();
+        }
+        if (typeof input === 'string') {
+            const d = (0, dayjs_1.default)(input, options?.format);
+            if (d.isValid())
+                return input;
+        }
+        context.failure({
+            message: `{{label}} is not a valid date formatted${options?.format ? " (" + options.format + ")" : ''} string`,
+            format: options?.format
+        });
+    }, (0, object_utils_js_1.omitKeys)(options || {}, ['format']));
+}
+exports.isDateString = isDateString;

package/cjs/rules/is-empty.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNotEmpty = exports.isEmpty = void 0;
+const index_js_1 = require("../core/index.js");
+/**
+ * Checks if value is an empty. Value should be string, array, set, map or object
+ * @validator isEmpty
+ */
+function isEmpty(options) {
+    return (0, index_js_1.validator)('isEmpty', function (input, context) {
+        if (input != null) {
+            if (typeof input === 'string') {
+                if (!input)
+                    return input;
+            }
+            else if (Array.isArray(input)) {
+                if (!input.length)
+                    return input;
+            }
+            else if (input instanceof Set) {
+                if (!input.size)
+                    return input;
+            }
+            else if (input instanceof Map) {
+                if (!input.size)
+                    return input;
+            }
+            else if (typeof input === 'object') {
+                if (!Object.keys(input).length)
+                    return input;
+            }
+        }
+        context.failure(`{{label}} is not empty`);
+    }, options);
+}
+exports.isEmpty = isEmpty;
+/**
+ * Checks if value is a not empty. Value should be string, array, set, map or object
+ * @validator isNotEmpty
+ */
+function isNotEmpty(options) {
+    return (0, index_js_1.validator)('isNotEmpty', function (input, context) {
+        if (input != null) {
+            if (typeof input === 'string') {
+                if (input)
+                    return input;
+            }
+            else if (Array.isArray(input)) {
+                if (input.length)
+                    return input;
+            }
+            else if (input instanceof Set) {
+                if (input.size)
+                    return input;
+            }
+            else if (input instanceof Map) {
+                if (input.size)
+                    return input;
+            }
+            else if (typeof input === 'object') {
+                if (Object.keys(input).length)
+                    return input;
+            }
+        }
+        context.failure(`{{label}} is empty`);
+    }, options);
+}
+exports.isNotEmpty = isNotEmpty;

package/cjs/rules/is-enum.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEnum = void 0;
+const index_js_1 = require("../core/index.js");
+/**
+ * Validates if given value is one of enum values.
+ * @validator isEnum
+ */
+function isEnum(values, options) {
+    const caseInSensitive = !!(options?.caseInSensitive);
+    const enumName = options?.enumName;
+    // Prepare an object for fast lookup
+    const valObj = (Array.isArray(values) ? values : [values])
+        .reduce((a, v) => {
+        if (typeof v === 'string' && caseInSensitive)
+            a[v.toUpperCase()] = true;
+        else
+            a[v] = true;
+        return a;
+    }, {});
+    return (0, index_js_1.validator)('isEnum', function (input, context) {
+        if (input != null && valObj[typeof input === 'string' && caseInSensitive ? input.toUpperCase() : input])
+            return input;
+        context.failure({
+            message: `Value must be one of enumeration member${enumName ? ` (${enumName})` : ''}`,
+            enum: enumName
+        });
+    }, options);
+}
+exports.isEnum = isEnum;

package/cjs/rules/is-integer.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInteger = void 0;
+const index_js_1 = require("../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', function (input, context) {
+        if (input != null && typeof input !== 'number' && context.coerce) {
+            if (typeof input === 'string')
+                input = parseFloat(input);
+            if (typeof input === 'bigint') {
+                const v = Number(input);
+                if (input === BigInt(v))
+                    input = v;
+            }
+        }
+        if (typeof input === 'number' && !isNaN(input) && Number.isInteger(input))
+            return input;
+        context.failure(`{{label}} is not a valid integer number`);
+    }, options);
+}
+exports.isInteger = isInteger;

package/cjs/rules/is-matches.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMatches = void 0;
+const index_js_1 = require("../core/index.js");
+/**
+ * Coerces given value to "UUID" format or returns undefined if nullish
+ * @validator uuid
+ */
+function isMatches(format, options) {
+    const regExp = format instanceof RegExp ? format : new RegExp(format);
+    const formatName = options?.formatName;
+    return (0, index_js_1.validator)('matches', function (input, context) {
+        if (input == null)
+            return;
+        if (typeof input === 'string' && regExp.test(input))
+            return input;
+        context.failure({
+            message: `{{label}} does not match ${formatName || 'requested'} format`,
+            format,
+            formatName
+        });
+    }, options);
+}
+exports.isMatches = isMatches;

package/cjs/rules/is-null.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUndefined = exports.isDefined = exports.isNull = void 0;
+const index_js_1 = require("../core/index.js");
+/**
+ * Validates if value is "null".
+ * @validator isNull
+ */
+function isNull(options) {
+    return (0, index_js_1.validator)('isNull', function (input, context) {
+        if (input === null)
+            return input;
+        context.failure(`{{label}} is not null`);
+    }, options);
+}
+exports.isNull = isNull;
+/**
+ * Validates if value is not "undefined" nor "null"
+ * @validator isDefined
+ */
+function isDefined(options) {
+    return (0, index_js_1.validator)('is-defined', function (input, context) {
+        if (input !== undefined)
+            return input;
+        context.failure(`{{label}} is not defined`);
+    }, options);
+}
+exports.isDefined = isDefined;
+/**
+ * Validates if value is "undefined"
+ * @validator isNotDefined
+ */
+function isUndefined(options) {
+    return (0, index_js_1.validator)('isUndefined', function (input, context) {
+        if (input === undefined)
+            return;
+        context.failure(`{{label}} defined`);
+    }, options);
+}
+exports.isUndefined = isUndefined;