You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
7345 lines
255 KiB
7345 lines
255 KiB
(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.Ajv = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){ |
|
'use strict'; |
|
|
|
var KEYWORDS = [ |
|
'multipleOf', |
|
'maximum', |
|
'exclusiveMaximum', |
|
'minimum', |
|
'exclusiveMinimum', |
|
'maxLength', |
|
'minLength', |
|
'pattern', |
|
'additionalItems', |
|
'maxItems', |
|
'minItems', |
|
'uniqueItems', |
|
'maxProperties', |
|
'minProperties', |
|
'required', |
|
'additionalProperties', |
|
'enum', |
|
'format', |
|
'const' |
|
]; |
|
|
|
module.exports = function (metaSchema, keywordsJsonPointers) { |
|
for (var i=0; i<keywordsJsonPointers.length; i++) { |
|
metaSchema = JSON.parse(JSON.stringify(metaSchema)); |
|
var segments = keywordsJsonPointers[i].split('/'); |
|
var keywords = metaSchema; |
|
var j; |
|
for (j=1; j<segments.length; j++) |
|
keywords = keywords[segments[j]]; |
|
|
|
for (j=0; j<KEYWORDS.length; j++) { |
|
var key = KEYWORDS[j]; |
|
var schema = keywords[key]; |
|
if (schema) { |
|
keywords[key] = { |
|
anyOf: [ |
|
schema, |
|
{ $ref: 'https://raw.githubusercontent.com/epoberezkin/ajv/master/lib/refs/$data.json#' } |
|
] |
|
}; |
|
} |
|
} |
|
} |
|
|
|
return metaSchema; |
|
}; |
|
|
|
},{}],2:[function(require,module,exports){ |
|
'use strict'; |
|
|
|
|
|
var Cache = module.exports = function Cache() { |
|
this._cache = {}; |
|
}; |
|
|
|
|
|
Cache.prototype.put = function Cache_put(key, value) { |
|
this._cache[key] = value; |
|
}; |
|
|
|
|
|
Cache.prototype.get = function Cache_get(key) { |
|
return this._cache[key]; |
|
}; |
|
|
|
|
|
Cache.prototype.del = function Cache_del(key) { |
|
delete this._cache[key]; |
|
}; |
|
|
|
|
|
Cache.prototype.clear = function Cache_clear() { |
|
this._cache = {}; |
|
}; |
|
|
|
},{}],3:[function(require,module,exports){ |
|
'use strict'; |
|
|
|
//all requires must be explicit because browserify won't work with dynamic requires |
|
module.exports = { |
|
'$ref': require('../dotjs/ref'), |
|
allOf: require('../dotjs/allOf'), |
|
anyOf: require('../dotjs/anyOf'), |
|
const: require('../dotjs/const'), |
|
contains: require('../dotjs/contains'), |
|
dependencies: require('../dotjs/dependencies'), |
|
'enum': require('../dotjs/enum'), |
|
format: require('../dotjs/format'), |
|
items: require('../dotjs/items'), |
|
maximum: require('../dotjs/_limit'), |
|
minimum: require('../dotjs/_limit'), |
|
maxItems: require('../dotjs/_limitItems'), |
|
minItems: require('../dotjs/_limitItems'), |
|
maxLength: require('../dotjs/_limitLength'), |
|
minLength: require('../dotjs/_limitLength'), |
|
maxProperties: require('../dotjs/_limitProperties'), |
|
minProperties: require('../dotjs/_limitProperties'), |
|
multipleOf: require('../dotjs/multipleOf'), |
|
not: require('../dotjs/not'), |
|
oneOf: require('../dotjs/oneOf'), |
|
pattern: require('../dotjs/pattern'), |
|
properties: require('../dotjs/properties'), |
|
propertyNames: require('../dotjs/propertyNames'), |
|
required: require('../dotjs/required'), |
|
uniqueItems: require('../dotjs/uniqueItems'), |
|
validate: require('../dotjs/validate') |
|
}; |
|
|
|
},{"../dotjs/_limit":13,"../dotjs/_limitItems":14,"../dotjs/_limitLength":15,"../dotjs/_limitProperties":16,"../dotjs/allOf":17,"../dotjs/anyOf":18,"../dotjs/const":19,"../dotjs/contains":20,"../dotjs/dependencies":22,"../dotjs/enum":23,"../dotjs/format":24,"../dotjs/items":25,"../dotjs/multipleOf":26,"../dotjs/not":27,"../dotjs/oneOf":28,"../dotjs/pattern":29,"../dotjs/properties":30,"../dotjs/propertyNames":31,"../dotjs/ref":32,"../dotjs/required":33,"../dotjs/uniqueItems":34,"../dotjs/validate":35}],4:[function(require,module,exports){ |
|
'use strict'; |
|
|
|
var MissingRefError = require('./error_classes').MissingRef; |
|
|
|
module.exports = compileAsync; |
|
|
|
|
|
/** |
|
* Creates validating function for passed schema with asynchronous loading of missing schemas. |
|
* `loadSchema` option should be a function that accepts schema uri and returns promise that resolves with the schema. |
|
* @this Ajv |
|
* @param {Object} schema schema object |
|
* @param {Boolean} meta optional true to compile meta-schema; this parameter can be skipped |
|
* @param {Function} callback an optional node-style callback, it is called with 2 parameters: error (or null) and validating function. |
|
* @return {Promise} promise that resolves with a validating function. |
|
*/ |
|
function compileAsync(schema, meta, callback) { |
|
/* eslint no-shadow: 0 */ |
|
/* global Promise */ |
|
/* jshint validthis: true */ |
|
var self = this; |
|
if (typeof this._opts.loadSchema != 'function') |
|
throw new Error('options.loadSchema should be a function'); |
|
|
|
if (typeof meta == 'function') { |
|
callback = meta; |
|
meta = undefined; |
|
} |
|
|
|
var p = loadMetaSchemaOf(schema).then(function () { |
|
var schemaObj = self._addSchema(schema, undefined, meta); |
|
return schemaObj.validate || _compileAsync(schemaObj); |
|
}); |
|
|
|
if (callback) { |
|
p.then( |
|
function(v) { callback(null, v); }, |
|
callback |
|
); |
|
} |
|
|
|
return p; |
|
|
|
|
|
function loadMetaSchemaOf(sch) { |
|
var $schema = sch.$schema; |
|
return $schema && !self.getSchema($schema) |
|
? compileAsync.call(self, { $ref: $schema }, true) |
|
: Promise.resolve(); |
|
} |
|
|
|
|
|
function _compileAsync(schemaObj) { |
|
try { return self._compile(schemaObj); } |
|
catch(e) { |
|
if (e instanceof MissingRefError) return loadMissingSchema(e); |
|
throw e; |
|
} |
|
|
|
|
|
function loadMissingSchema(e) { |
|
var ref = e.missingSchema; |
|
if (added(ref)) throw new Error('Schema ' + ref + ' is loaded but ' + e.missingRef + ' cannot be resolved'); |
|
|
|
var schemaPromise = self._loadingSchemas[ref]; |
|
if (!schemaPromise) { |
|
schemaPromise = self._loadingSchemas[ref] = self._opts.loadSchema(ref); |
|
schemaPromise.then(removePromise, removePromise); |
|
} |
|
|
|
return schemaPromise.then(function (sch) { |
|
if (!added(ref)) { |
|
return loadMetaSchemaOf(sch).then(function () { |
|
if (!added(ref)) self.addSchema(sch, ref, undefined, meta); |
|
}); |
|
} |
|
}).then(function() { |
|
return _compileAsync(schemaObj); |
|
}); |
|
|
|
function removePromise() { |
|
delete self._loadingSchemas[ref]; |
|
} |
|
|
|
function added(ref) { |
|
return self._refs[ref] || self._schemas[ref]; |
|
} |
|
} |
|
} |
|
} |
|
|
|
},{"./error_classes":5}],5:[function(require,module,exports){ |
|
'use strict'; |
|
|
|
var resolve = require('./resolve'); |
|
|
|
module.exports = { |
|
Validation: errorSubclass(ValidationError), |
|
MissingRef: errorSubclass(MissingRefError) |
|
}; |
|
|
|
|
|
function ValidationError(errors) { |
|
this.message = 'validation failed'; |
|
this.errors = errors; |
|
this.ajv = this.validation = true; |
|
} |
|
|
|
|
|
MissingRefError.message = function (baseId, ref) { |
|
return 'can\'t resolve reference ' + ref + ' from id ' + baseId; |
|
}; |
|
|
|
|
|
function MissingRefError(baseId, ref, message) { |
|
this.message = message || MissingRefError.message(baseId, ref); |
|
this.missingRef = resolve.url(baseId, ref); |
|
this.missingSchema = resolve.normalizeId(resolve.fullPath(this.missingRef)); |
|
} |
|
|
|
|
|
function errorSubclass(Subclass) { |
|
Subclass.prototype = Object.create(Error.prototype); |
|
Subclass.prototype.constructor = Subclass; |
|
return Subclass; |
|
} |
|
|
|
},{"./resolve":8}],6:[function(require,module,exports){ |
|
'use strict'; |
|
|
|
var util = require('./util'); |
|
|
|
var DATE = /^\d\d\d\d-(\d\d)-(\d\d)$/; |
|
var DAYS = [0,31,29,31,30,31,30,31,31,30,31,30,31]; |
|
var TIME = /^(\d\d):(\d\d):(\d\d)(\.\d+)?(z|[+-]\d\d:\d\d)?$/i; |
|
var HOSTNAME = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*$/i; |
|
var URI = /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)(?:\?(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i; |
|
var URIREF = /^(?:[a-z][a-z0-9+\-.]*:)?(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'"()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\?(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i; |
|
// uri-template: https://tools.ietf.org/html/rfc6570 |
|
var URITEMPLATE = /^(?:(?:[^\x00-\x20"'<>%\\^`{|}]|%[0-9a-f]{2})|\{[+#./;?&=,!@|]?(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?(?:,(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?)*\})*$/i; |
|
// For the source: https://gist.github.com/dperini/729294 |
|
// For test cases: https://mathiasbynens.be/demo/url-regex |
|
// @todo Delete current URL in favour of the commented out URL rule when this issue is fixed https://github.com/eslint/eslint/issues/7983. |
|
// var URL = /^(?:(?:https?|ftp):\/\/)(?:\S+(?::\S*)?@)?(?:(?!10(?:\.\d{1,3}){3})(?!127(?:\.\d{1,3}){3})(?!169\.254(?:\.\d{1,3}){2})(?!192\.168(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z\u{00a1}-\u{ffff}0-9]+-?)*[a-z\u{00a1}-\u{ffff}0-9]+)(?:\.(?:[a-z\u{00a1}-\u{ffff}0-9]+-?)*[a-z\u{00a1}-\u{ffff}0-9]+)*(?:\.(?:[a-z\u{00a1}-\u{ffff}]{2,})))(?::\d{2,5})?(?:\/[^\s]*)?$/iu; |
|
var URL = /^(?:(?:http[s\u017F]?|ftp):\/\/)(?:(?:[\0-\x08\x0E-\x1F!-\x9F\xA1-\u167F\u1681-\u1FFF\u200B-\u2027\u202A-\u202E\u2030-\u205E\u2060-\u2FFF\u3001-\uD7FF\uE000-\uFEFE\uFF00-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+(?::(?:[\0-\x08\x0E-\x1F!-\x9F\xA1-\u167F\u1681-\u1FFF\u200B-\u2027\u202A-\u202E\u2030-\u205E\u2060-\u2FFF\u3001-\uD7FF\uE000-\uFEFE\uFF00-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])*)?@)?(?:(?!10(?:\.[0-9]{1,3}){3})(?!127(?:\.[0-9]{1,3}){3})(?!169\.254(?:\.[0-9]{1,3}){2})(?!192\.168(?:\.[0-9]{1,3}){2})(?!172\.(?:1[6-9]|2[0-9]|3[01])(?:\.[0-9]{1,3}){2})(?:[1-9][0-9]?|1[0-9][0-9]|2[01][0-9]|22[0-3])(?:\.(?:1?[0-9]{1,2}|2[0-4][0-9]|25[0-5])){2}(?:\.(?:[1-9][0-9]?|1[0-9][0-9]|2[0-4][0-9]|25[0-4]))|(?:(?:(?:[0-9KSa-z\xA1-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+-?)*(?:[0-9KSa-z\xA1-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+)(?:\.(?:(?:[0-9KSa-z\xA1-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+-?)*(?:[0-9KSa-z\xA1-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+)*(?:\.(?:(?:[KSa-z\xA1-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]){2,})))(?::[0-9]{2,5})?(?:\/(?:[\0-\x08\x0E-\x1F!-\x9F\xA1-\u167F\u1681-\u1FFF\u200B-\u2027\u202A-\u202E\u2030-\u205E\u2060-\u2FFF\u3001-\uD7FF\uE000-\uFEFE\uFF00-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])*)?$/i; |
|
var UUID = /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i; |
|
var JSON_POINTER = /^(?:\/(?:[^~/]|~0|~1)*)*$|^#(?:\/(?:[a-z0-9_\-.!$&'()*+,;:=@]|%[0-9a-f]{2}|~0|~1)*)*$/i; |
|
var RELATIVE_JSON_POINTER = /^(?:0|[1-9][0-9]*)(?:#|(?:\/(?:[^~/]|~0|~1)*)*)$/; |
|
|
|
|
|
module.exports = formats; |
|
|
|
function formats(mode) { |
|
mode = mode == 'full' ? 'full' : 'fast'; |
|
return util.copy(formats[mode]); |
|
} |
|
|
|
|
|
formats.fast = { |
|
// date: http://tools.ietf.org/html/rfc3339#section-5.6 |
|
date: /^\d\d\d\d-[0-1]\d-[0-3]\d$/, |
|
// date-time: http://tools.ietf.org/html/rfc3339#section-5.6 |
|
time: /^[0-2]\d:[0-5]\d:[0-5]\d(?:\.\d+)?(?:z|[+-]\d\d:\d\d)?$/i, |
|
'date-time': /^\d\d\d\d-[0-1]\d-[0-3]\d[t\s][0-2]\d:[0-5]\d:[0-5]\d(?:\.\d+)?(?:z|[+-]\d\d:\d\d)$/i, |
|
// uri: https://github.com/mafintosh/is-my-json-valid/blob/master/formats.js |
|
uri: /^(?:[a-z][a-z0-9+-.]*)(?::|\/)\/?[^\s]*$/i, |
|
'uri-reference': /^(?:(?:[a-z][a-z0-9+-.]*:)?\/\/)?[^\s]*$/i, |
|
'uri-template': URITEMPLATE, |
|
url: URL, |
|
// email (sources from jsen validator): |
|
// http://stackoverflow.com/questions/201323/using-a-regular-expression-to-validate-an-email-address#answer-8829363 |
|
// http://www.w3.org/TR/html5/forms.html#valid-e-mail-address (search for 'willful violation') |
|
email: /^[a-z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$/i, |
|
hostname: HOSTNAME, |
|
// optimized https://www.safaribooksonline.com/library/view/regular-expressions-cookbook/9780596802837/ch07s16.html |
|
ipv4: /^(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)$/, |
|
// optimized http://stackoverflow.com/questions/53497/regular-expression-that-matches-valid-ipv6-addresses |
|
ipv6: /^\s*(?:(?:(?:[0-9a-f]{1,4}:){7}(?:[0-9a-f]{1,4}|:))|(?:(?:[0-9a-f]{1,4}:){6}(?::[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(?:(?:[0-9a-f]{1,4}:){5}(?:(?:(?::[0-9a-f]{1,4}){1,2})|:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(?:(?:[0-9a-f]{1,4}:){4}(?:(?:(?::[0-9a-f]{1,4}){1,3})|(?:(?::[0-9a-f]{1,4})?:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){3}(?:(?:(?::[0-9a-f]{1,4}){1,4})|(?:(?::[0-9a-f]{1,4}){0,2}:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){2}(?:(?:(?::[0-9a-f]{1,4}){1,5})|(?:(?::[0-9a-f]{1,4}){0,3}:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){1}(?:(?:(?::[0-9a-f]{1,4}){1,6})|(?:(?::[0-9a-f]{1,4}){0,4}:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(?::(?:(?:(?::[0-9a-f]{1,4}){1,7})|(?:(?::[0-9a-f]{1,4}){0,5}:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))(?:%.+)?\s*$/i, |
|
regex: regex, |
|
// uuid: http://tools.ietf.org/html/rfc4122 |
|
uuid: UUID, |
|
// JSON-pointer: https://tools.ietf.org/html/rfc6901 |
|
// uri fragment: https://tools.ietf.org/html/rfc3986#appendix-A |
|
'json-pointer': JSON_POINTER, |
|
// relative JSON-pointer: http://tools.ietf.org/html/draft-luff-relative-json-pointer-00 |
|
'relative-json-pointer': RELATIVE_JSON_POINTER |
|
}; |
|
|
|
|
|
formats.full = { |
|
date: date, |
|
time: time, |
|
'date-time': date_time, |
|
uri: uri, |
|
'uri-reference': URIREF, |
|
'uri-template': URITEMPLATE, |
|
url: URL, |
|
email: /^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&''*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i, |
|
hostname: hostname, |
|
ipv4: /^(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)$/, |
|
ipv6: /^\s*(?:(?:(?:[0-9a-f]{1,4}:){7}(?:[0-9a-f]{1,4}|:))|(?:(?:[0-9a-f]{1,4}:){6}(?::[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(?:(?:[0-9a-f]{1,4}:){5}(?:(?:(?::[0-9a-f]{1,4}){1,2})|:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(?:(?:[0-9a-f]{1,4}:){4}(?:(?:(?::[0-9a-f]{1,4}){1,3})|(?:(?::[0-9a-f]{1,4})?:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){3}(?:(?:(?::[0-9a-f]{1,4}){1,4})|(?:(?::[0-9a-f]{1,4}){0,2}:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){2}(?:(?:(?::[0-9a-f]{1,4}){1,5})|(?:(?::[0-9a-f]{1,4}){0,3}:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){1}(?:(?:(?::[0-9a-f]{1,4}){1,6})|(?:(?::[0-9a-f]{1,4}){0,4}:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(?::(?:(?:(?::[0-9a-f]{1,4}){1,7})|(?:(?::[0-9a-f]{1,4}){0,5}:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))(?:%.+)?\s*$/i, |
|
regex: regex, |
|
uuid: UUID, |
|
'json-pointer': JSON_POINTER, |
|
'relative-json-pointer': RELATIVE_JSON_POINTER |
|
}; |
|
|
|
|
|
function date(str) { |
|
// full-date from http://tools.ietf.org/html/rfc3339#section-5.6 |
|
var matches = str.match(DATE); |
|
if (!matches) return false; |
|
|
|
var month = +matches[1]; |
|
var day = +matches[2]; |
|
return month >= 1 && month <= 12 && day >= 1 && day <= DAYS[month]; |
|
} |
|
|
|
|
|
function time(str, full) { |
|
var matches = str.match(TIME); |
|
if (!matches) return false; |
|
|
|
var hour = matches[1]; |
|
var minute = matches[2]; |
|
var second = matches[3]; |
|
var timeZone = matches[5]; |
|
return hour <= 23 && minute <= 59 && second <= 59 && (!full || timeZone); |
|
} |
|
|
|
|
|
var DATE_TIME_SEPARATOR = /t|\s/i; |
|
function date_time(str) { |
|
// http://tools.ietf.org/html/rfc3339#section-5.6 |
|
var dateTime = str.split(DATE_TIME_SEPARATOR); |
|
return dateTime.length == 2 && date(dateTime[0]) && time(dateTime[1], true); |
|
} |
|
|
|
|
|
function hostname(str) { |
|
// https://tools.ietf.org/html/rfc1034#section-3.5 |
|
// https://tools.ietf.org/html/rfc1123#section-2 |
|
return str.length <= 255 && HOSTNAME.test(str); |
|
} |
|
|
|
|
|
var NOT_URI_FRAGMENT = /\/|:/; |
|
function uri(str) { |
|
// http://jmrware.com/articles/2009/uri_regexp/URI_regex.html + optional protocol + required "." |
|
return NOT_URI_FRAGMENT.test(str) && URI.test(str); |
|
} |
|
|
|
|
|
var Z_ANCHOR = /[^\\]\\Z/; |
|
function regex(str) { |
|
if (Z_ANCHOR.test(str)) return false; |
|
try { |
|
new RegExp(str); |
|
return true; |
|
} catch(e) { |
|
return false; |
|
} |
|
} |
|
|
|
},{"./util":12}],7:[function(require,module,exports){ |
|
'use strict'; |
|
|
|
var resolve = require('./resolve') |
|
, util = require('./util') |
|
, errorClasses = require('./error_classes') |
|
, stableStringify = require('fast-json-stable-stringify'); |
|
|
|
var validateGenerator = require('../dotjs/validate'); |
|
|
|
/** |
|
* Functions below are used inside compiled validations function |
|
*/ |
|
|
|
var co = require('co'); |
|
var ucs2length = util.ucs2length; |
|
var equal = require('fast-deep-equal'); |
|
|
|
// this error is thrown by async schemas to return validation errors via exception |
|
var ValidationError = errorClasses.Validation; |
|
|
|
module.exports = compile; |
|
|
|
|
|
/** |
|
* Compiles schema to validation function |
|
* @this Ajv |
|
* @param {Object} schema schema object |
|
* @param {Object} root object with information about the root schema for this schema |
|
* @param {Object} localRefs the hash of local references inside the schema (created by resolve.id), used for inline resolution |
|
* @param {String} baseId base ID for IDs in the schema |
|
* @return {Function} validation function |
|
*/ |
|
function compile(schema, root, localRefs, baseId) { |
|
/* jshint validthis: true, evil: true */ |
|
/* eslint no-shadow: 0 */ |
|
var self = this |
|
, opts = this._opts |
|
, refVal = [ undefined ] |
|
, refs = {} |
|
, patterns = [] |
|
, patternsHash = {} |
|
, defaults = [] |
|
, defaultsHash = {} |
|
, customRules = []; |
|
|
|
root = root || { schema: schema, refVal: refVal, refs: refs }; |
|
|
|
var c = checkCompiling.call(this, schema, root, baseId); |
|
var compilation = this._compilations[c.index]; |
|
if (c.compiling) return (compilation.callValidate = callValidate); |
|
|
|
var formats = this._formats; |
|
var RULES = this.RULES; |
|
|
|
try { |
|
var v = localCompile(schema, root, localRefs, baseId); |
|
compilation.validate = v; |
|
var cv = compilation.callValidate; |
|
if (cv) { |
|
cv.schema = v.schema; |
|
cv.errors = null; |
|
cv.refs = v.refs; |
|
cv.refVal = v.refVal; |
|
cv.root = v.root; |
|
cv.$async = v.$async; |
|
if (opts.sourceCode) cv.source = v.source; |
|
} |
|
return v; |
|
} finally { |
|
endCompiling.call(this, schema, root, baseId); |
|
} |
|
|
|
function callValidate() { |
|
var validate = compilation.validate; |
|
var result = validate.apply(null, arguments); |
|
callValidate.errors = validate.errors; |
|
return result; |
|
} |
|
|
|
function localCompile(_schema, _root, localRefs, baseId) { |
|
var isRoot = !_root || (_root && _root.schema == _schema); |
|
if (_root.schema != root.schema) |
|
return compile.call(self, _schema, _root, localRefs, baseId); |
|
|
|
var $async = _schema.$async === true; |
|
|
|
var sourceCode = validateGenerator({ |
|
isTop: true, |
|
schema: _schema, |
|
isRoot: isRoot, |
|
baseId: baseId, |
|
root: _root, |
|
schemaPath: '', |
|
errSchemaPath: '#', |
|
errorPath: '""', |
|
MissingRefError: errorClasses.MissingRef, |
|
RULES: RULES, |
|
validate: validateGenerator, |
|
util: util, |
|
resolve: resolve, |
|
resolveRef: resolveRef, |
|
usePattern: usePattern, |
|
useDefault: useDefault, |
|
useCustomRule: useCustomRule, |
|
opts: opts, |
|
formats: formats, |
|
logger: self.logger, |
|
self: self |
|
}); |
|
|
|
sourceCode = vars(refVal, refValCode) + vars(patterns, patternCode) |
|
+ vars(defaults, defaultCode) + vars(customRules, customRuleCode) |
|
+ sourceCode; |
|
|
|
if (opts.processCode) sourceCode = opts.processCode(sourceCode); |
|
// console.log('\n\n\n *** \n', JSON.stringify(sourceCode)); |
|
var validate; |
|
try { |
|
var makeValidate = new Function( |
|
'self', |
|
'RULES', |
|
'formats', |
|
'root', |
|
'refVal', |
|
'defaults', |
|
'customRules', |
|
'co', |
|
'equal', |
|
'ucs2length', |
|
'ValidationError', |
|
sourceCode |
|
); |
|
|
|
validate = makeValidate( |
|
self, |
|
RULES, |
|
formats, |
|
root, |
|
refVal, |
|
defaults, |
|
customRules, |
|
co, |
|
equal, |
|
ucs2length, |
|
ValidationError |
|
); |
|
|
|
refVal[0] = validate; |
|
} catch(e) { |
|
self.logger.error('Error compiling schema, function code:', sourceCode); |
|
throw e; |
|
} |
|
|
|
validate.schema = _schema; |
|
validate.errors = null; |
|
validate.refs = refs; |
|
validate.refVal = refVal; |
|
validate.root = isRoot ? validate : _root; |
|
if ($async) validate.$async = true; |
|
if (opts.sourceCode === true) { |
|
validate.source = { |
|
code: sourceCode, |
|
patterns: patterns, |
|
defaults: defaults |
|
}; |
|
} |
|
|
|
return validate; |
|
} |
|
|
|
function resolveRef(baseId, ref, isRoot) { |
|
ref = resolve.url(baseId, ref); |
|
var refIndex = refs[ref]; |
|
var _refVal, refCode; |
|
if (refIndex !== undefined) { |
|
_refVal = refVal[refIndex]; |
|
refCode = 'refVal[' + refIndex + ']'; |
|
return resolvedRef(_refVal, refCode); |
|
} |
|
if (!isRoot && root.refs) { |
|
var rootRefId = root.refs[ref]; |
|
if (rootRefId !== undefined) { |
|
_refVal = root.refVal[rootRefId]; |
|
refCode = addLocalRef(ref, _refVal); |
|
return resolvedRef(_refVal, refCode); |
|
} |
|
} |
|
|
|
refCode = addLocalRef(ref); |
|
var v = resolve.call(self, localCompile, root, ref); |
|
if (v === undefined) { |
|
var localSchema = localRefs && localRefs[ref]; |
|
if (localSchema) { |
|
v = resolve.inlineRef(localSchema, opts.inlineRefs) |
|
? localSchema |
|
: compile.call(self, localSchema, root, localRefs, baseId); |
|
} |
|
} |
|
|
|
if (v === undefined) { |
|
removeLocalRef(ref); |
|
} else { |
|
replaceLocalRef(ref, v); |
|
return resolvedRef(v, refCode); |
|
} |
|
} |
|
|
|
function addLocalRef(ref, v) { |
|
var refId = refVal.length; |
|
refVal[refId] = v; |
|
refs[ref] = refId; |
|
return 'refVal' + refId; |
|
} |
|
|
|
function removeLocalRef(ref) { |
|
delete refs[ref]; |
|
} |
|
|
|
function replaceLocalRef(ref, v) { |
|
var refId = refs[ref]; |
|
refVal[refId] = v; |
|
} |
|
|
|
function resolvedRef(refVal, code) { |
|
return typeof refVal == 'object' || typeof refVal == 'boolean' |
|
? { code: code, schema: refVal, inline: true } |
|
: { code: code, $async: refVal && refVal.$async }; |
|
} |
|
|
|
function usePattern(regexStr) { |
|
var index = patternsHash[regexStr]; |
|
if (index === undefined) { |
|
index = patternsHash[regexStr] = patterns.length; |
|
patterns[index] = regexStr; |
|
} |
|
return 'pattern' + index; |
|
} |
|
|
|
function useDefault(value) { |
|
switch (typeof value) { |
|
case 'boolean': |
|
case 'number': |
|
return '' + value; |
|
case 'string': |
|
return util.toQuotedString(value); |
|
case 'object': |
|
if (value === null) return 'null'; |
|
var valueStr = stableStringify(value); |
|
var index = defaultsHash[valueStr]; |
|
if (index === undefined) { |
|
index = defaultsHash[valueStr] = defaults.length; |
|
defaults[index] = value; |
|
} |
|
return 'default' + index; |
|
} |
|
} |
|
|
|
function useCustomRule(rule, schema, parentSchema, it) { |
|
var validateSchema = rule.definition.validateSchema; |
|
if (validateSchema && self._opts.validateSchema !== false) { |
|
var valid = validateSchema(schema); |
|
if (!valid) { |
|
var message = 'keyword schema is invalid: ' + self.errorsText(validateSchema.errors); |
|
if (self._opts.validateSchema == 'log') self.logger.error(message); |
|
else throw new Error(message); |
|
} |
|
} |
|
|
|
var compile = rule.definition.compile |
|
, inline = rule.definition.inline |
|
, macro = rule.definition.macro; |
|
|
|
var validate; |
|
if (compile) { |
|
validate = compile.call(self, schema, parentSchema, it); |
|
} else if (macro) { |
|
validate = macro.call(self, schema, parentSchema, it); |
|
if (opts.validateSchema !== false) self.validateSchema(validate, true); |
|
} else if (inline) { |
|
validate = inline.call(self, it, rule.keyword, schema, parentSchema); |
|
} else { |
|
validate = rule.definition.validate; |
|
if (!validate) return; |
|
} |
|
|
|
if (validate === undefined) |
|
throw new Error('custom keyword "' + rule.keyword + '"failed to compile'); |
|
|
|
var index = customRules.length; |
|
customRules[index] = validate; |
|
|
|
return { |
|
code: 'customRule' + index, |
|
validate: validate |
|
}; |
|
} |
|
} |
|
|
|
|
|
/** |
|
* Checks if the schema is currently compiled |
|
* @this Ajv |
|
* @param {Object} schema schema to compile |
|
* @param {Object} root root object |
|
* @param {String} baseId base schema ID |
|
* @return {Object} object with properties "index" (compilation index) and "compiling" (boolean) |
|
*/ |
|
function checkCompiling(schema, root, baseId) { |
|
/* jshint validthis: true */ |
|
var index = compIndex.call(this, schema, root, baseId); |
|
if (index >= 0) return { index: index, compiling: true }; |
|
index = this._compilations.length; |
|
this._compilations[index] = { |
|
schema: schema, |
|
root: root, |
|
baseId: baseId |
|
}; |
|
return { index: index, compiling: false }; |
|
} |
|
|
|
|
|
/** |
|
* Removes the schema from the currently compiled list |
|
* @this Ajv |
|
* @param {Object} schema schema to compile |
|
* @param {Object} root root object |
|
* @param {String} baseId base schema ID |
|
*/ |
|
function endCompiling(schema, root, baseId) { |
|
/* jshint validthis: true */ |
|
var i = compIndex.call(this, schema, root, baseId); |
|
if (i >= 0) this._compilations.splice(i, 1); |
|
} |
|
|
|
|
|
/** |
|
* Index of schema compilation in the currently compiled list |
|
* @this Ajv |
|
* @param {Object} schema schema to compile |
|
* @param {Object} root root object |
|
* @param {String} baseId base schema ID |
|
* @return {Integer} compilation index |
|
*/ |
|
function compIndex(schema, root, baseId) { |
|
/* jshint validthis: true */ |
|
for (var i=0; i<this._compilations.length; i++) { |
|
var c = this._compilations[i]; |
|
if (c.schema == schema && c.root == root && c.baseId == baseId) return i; |
|
} |
|
return -1; |
|
} |
|
|
|
|
|
function patternCode(i, patterns) { |
|
return 'var pattern' + i + ' = new RegExp(' + util.toQuotedString(patterns[i]) + ');'; |
|
} |
|
|
|
|
|
function defaultCode(i) { |
|
return 'var default' + i + ' = defaults[' + i + '];'; |
|
} |
|
|
|
|
|
function refValCode(i, refVal) { |
|
return refVal[i] === undefined ? '' : 'var refVal' + i + ' = refVal[' + i + '];'; |
|
} |
|
|
|
|
|
function customRuleCode(i) { |
|
return 'var customRule' + i + ' = customRules[' + i + '];'; |
|
} |
|
|
|
|
|
function vars(arr, statement) { |
|
if (!arr.length) return ''; |
|
var code = ''; |
|
for (var i=0; i<arr.length; i++) |
|
code += statement(i, arr); |
|
return code; |
|
} |
|
|
|
},{"../dotjs/validate":35,"./error_classes":5,"./resolve":8,"./util":12,"co":40,"fast-deep-equal":41,"fast-json-stable-stringify":42}],8:[function(require,module,exports){ |
|
'use strict'; |
|
|
|
var url = require('url') |
|
, equal = require('fast-deep-equal') |
|
, util = require('./util') |
|
, SchemaObject = require('./schema_obj') |
|
, traverse = require('json-schema-traverse'); |
|
|
|
module.exports = resolve; |
|
|
|
resolve.normalizeId = normalizeId; |
|
resolve.fullPath = getFullPath; |
|
resolve.url = resolveUrl; |
|
resolve.ids = resolveIds; |
|
resolve.inlineRef = inlineRef; |
|
resolve.schema = resolveSchema; |
|
|
|
/** |
|
* [resolve and compile the references ($ref)] |
|
* @this Ajv |
|
* @param {Function} compile reference to schema compilation funciton (localCompile) |
|
* @param {Object} root object with information about the root schema for the current schema |
|
* @param {String} ref reference to resolve |
|
* @return {Object|Function} schema object (if the schema can be inlined) or validation function |
|
*/ |
|
function resolve(compile, root, ref) { |
|
/* jshint validthis: true */ |
|
var refVal = this._refs[ref]; |
|
if (typeof refVal == 'string') { |
|
if (this._refs[refVal]) refVal = this._refs[refVal]; |
|
else return resolve.call(this, compile, root, refVal); |
|
} |
|
|
|
refVal = refVal || this._schemas[ref]; |
|
if (refVal instanceof SchemaObject) { |
|
return inlineRef(refVal.schema, this._opts.inlineRefs) |
|
? refVal.schema |
|
: refVal.validate || this._compile(refVal); |
|
} |
|
|
|
var res = resolveSchema.call(this, root, ref); |
|
var schema, v, baseId; |
|
if (res) { |
|
schema = res.schema; |
|
root = res.root; |
|
baseId = res.baseId; |
|
} |
|
|
|
if (schema instanceof SchemaObject) { |
|
v = schema.validate || compile.call(this, schema.schema, root, undefined, baseId); |
|
} else if (schema !== undefined) { |
|
v = inlineRef(schema, this._opts.inlineRefs) |
|
? schema |
|
: compile.call(this, schema, root, undefined, baseId); |
|
} |
|
|
|
return v; |
|
} |
|
|
|
|
|
/** |
|
* Resolve schema, its root and baseId |
|
* @this Ajv |
|
* @param {Object} root root object with properties schema, refVal, refs |
|
* @param {String} ref reference to resolve |
|
* @return {Object} object with properties schema, root, baseId |
|
*/ |
|
function resolveSchema(root, ref) { |
|
/* jshint validthis: true */ |
|
var p = url.parse(ref, false, true) |
|
, refPath = _getFullPath(p) |
|
, baseId = getFullPath(this._getId(root.schema)); |
|
if (refPath !== baseId) { |
|
var id = normalizeId(refPath); |
|
var refVal = this._refs[id]; |
|
if (typeof refVal == 'string') { |
|
return resolveRecursive.call(this, root, refVal, p); |
|
} else if (refVal instanceof SchemaObject) { |
|
if (!refVal.validate) this._compile(refVal); |
|
root = refVal; |
|
} else { |
|
refVal = this._schemas[id]; |
|
if (refVal instanceof SchemaObject) { |
|
if (!refVal.validate) this._compile(refVal); |
|
if (id == normalizeId(ref)) |
|
return { schema: refVal, root: root, baseId: baseId }; |
|
root = refVal; |
|
} else { |
|
return; |
|
} |
|
} |
|
if (!root.schema) return; |
|
baseId = getFullPath(this._getId(root.schema)); |
|
} |
|
return getJsonPointer.call(this, p, baseId, root.schema, root); |
|
} |
|
|
|
|
|
/* @this Ajv */ |
|
function resolveRecursive(root, ref, parsedRef) { |
|
/* jshint validthis: true */ |
|
var res = resolveSchema.call(this, root, ref); |
|
if (res) { |
|
var schema = res.schema; |
|
var baseId = res.baseId; |
|
root = res.root; |
|
var id = this._getId(schema); |
|
if (id) baseId = resolveUrl(baseId, id); |
|
return getJsonPointer.call(this, parsedRef, baseId, schema, root); |
|
} |
|
} |
|
|
|
|
|
var PREVENT_SCOPE_CHANGE = util.toHash(['properties', 'patternProperties', 'enum', 'dependencies', 'definitions']); |
|
/* @this Ajv */ |
|
function getJsonPointer(parsedRef, baseId, schema, root) { |
|
/* jshint validthis: true */ |
|
parsedRef.hash = parsedRef.hash || ''; |
|
if (parsedRef.hash.slice(0,2) != '#/') return; |
|
var parts = parsedRef.hash.split('/'); |
|
|
|
for (var i = 1; i < parts.length; i++) { |
|
var part = parts[i]; |
|
if (part) { |
|
part = util.unescapeFragment(part); |
|
schema = schema[part]; |
|
if (schema === undefined) break; |
|
var id; |
|
if (!PREVENT_SCOPE_CHANGE[part]) { |
|
id = this._getId(schema); |
|
if (id) baseId = resolveUrl(baseId, id); |
|
if (schema.$ref) { |
|
var $ref = resolveUrl(baseId, schema.$ref); |
|
var res = resolveSchema.call(this, root, $ref); |
|
if (res) { |
|
schema = res.schema; |
|
root = res.root; |
|
baseId = res.baseId; |
|
} |
|
} |
|
} |
|
} |
|
} |
|
if (schema !== undefined && schema !== root.schema) |
|
return { schema: schema, root: root, baseId: baseId }; |
|
} |
|
|
|
|
|
var SIMPLE_INLINED = util.toHash([ |
|
'type', 'format', 'pattern', |
|
'maxLength', 'minLength', |
|
'maxProperties', 'minProperties', |
|
'maxItems', 'minItems', |
|
'maximum', 'minimum', |
|
'uniqueItems', 'multipleOf', |
|
'required', 'enum' |
|
]); |
|
function inlineRef(schema, limit) { |
|
if (limit === false) return false; |
|
if (limit === undefined || limit === true) return checkNoRef(schema); |
|
else if (limit) return countKeys(schema) <= limit; |
|
} |
|
|
|
|
|
function checkNoRef(schema) { |
|
var item; |
|
if (Array.isArray(schema)) { |
|
for (var i=0; i<schema.length; i++) { |
|
item = schema[i]; |
|
if (typeof item == 'object' && !checkNoRef(item)) return false; |
|
} |
|
} else { |
|
for (var key in schema) { |
|
if (key == '$ref') return false; |
|
item = schema[key]; |
|
if (typeof item == 'object' && !checkNoRef(item)) return false; |
|
} |
|
} |
|
return true; |
|
} |
|
|
|
|
|
function countKeys(schema) { |
|
var count = 0, item; |
|
if (Array.isArray(schema)) { |
|
for (var i=0; i<schema.length; i++) { |
|
item = schema[i]; |
|
if (typeof item == 'object') count += countKeys(item); |
|
if (count == Infinity) return Infinity; |
|
} |
|
} else { |
|
for (var key in schema) { |
|
if (key == '$ref') return Infinity; |
|
if (SIMPLE_INLINED[key]) { |
|
count++; |
|
} else { |
|
item = schema[key]; |
|
if (typeof item == 'object') count += countKeys(item) + 1; |
|
if (count == Infinity) return Infinity; |
|
} |
|
} |
|
} |
|
return count; |
|
} |
|
|
|
|
|
function getFullPath(id, normalize) { |
|
if (normalize !== false) id = normalizeId(id); |
|
var p = url.parse(id, false, true); |
|
return _getFullPath(p); |
|
} |
|
|
|
|
|
function _getFullPath(p) { |
|
var protocolSeparator = p.protocol || p.href.slice(0,2) == '//' ? '//' : ''; |
|
return (p.protocol||'') + protocolSeparator + (p.host||'') + (p.path||'') + '#'; |
|
} |
|
|
|
|
|
var TRAILING_SLASH_HASH = /#\/?$/; |
|
function normalizeId(id) { |
|
return id ? id.replace(TRAILING_SLASH_HASH, '') : ''; |
|
} |
|
|
|
|
|
function resolveUrl(baseId, id) { |
|
id = normalizeId(id); |
|
return url.resolve(baseId, id); |
|
} |
|
|
|
|
|
/* @this Ajv */ |
|
function resolveIds(schema) { |
|
var schemaId = normalizeId(this._getId(schema)); |
|
var baseIds = {'': schemaId}; |
|
var fullPaths = {'': getFullPath(schemaId, false)}; |
|
var localRefs = {}; |
|
var self = this; |
|
|
|
traverse(schema, {allKeys: true}, function(sch, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) { |
|
if (jsonPtr === '') return; |
|
var id = self._getId(sch); |
|
var baseId = baseIds[parentJsonPtr]; |
|
var fullPath = fullPaths[parentJsonPtr] + '/' + parentKeyword; |
|
if (keyIndex !== undefined) |
|
fullPath += '/' + (typeof keyIndex == 'number' ? keyIndex : util.escapeFragment(keyIndex)); |
|
|
|
if (typeof id == 'string') { |
|
id = baseId = normalizeId(baseId ? url.resolve(baseId, id) : id); |
|
|
|
var refVal = self._refs[id]; |
|
if (typeof refVal == 'string') refVal = self._refs[refVal]; |
|
if (refVal && refVal.schema) { |
|
if (!equal(sch, refVal.schema)) |
|
throw new Error('id "' + id + '" resolves to more than one schema'); |
|
} else if (id != normalizeId(fullPath)) { |
|
if (id[0] == '#') { |
|
if (localRefs[id] && !equal(sch, localRefs[id])) |
|
throw new Error('id "' + id + '" resolves to more than one schema'); |
|
localRefs[id] = sch; |
|
} else { |
|
self._refs[id] = fullPath; |
|
} |
|
} |
|
} |
|
baseIds[jsonPtr] = baseId; |
|
fullPaths[jsonPtr] = fullPath; |
|
}); |
|
|
|
return localRefs; |
|
} |
|
|
|
},{"./schema_obj":10,"./util":12,"fast-deep-equal":41,"json-schema-traverse":43,"url":48}],9:[function(require,module,exports){ |
|
'use strict'; |
|
|
|
var ruleModules = require('./_rules') |
|
, toHash = require('./util').toHash; |
|
|
|
module.exports = function rules() { |
|
var RULES = [ |
|
{ type: 'number', |
|
rules: [ { 'maximum': ['exclusiveMaximum'] }, |
|
{ 'minimum': ['exclusiveMinimum'] }, 'multipleOf', 'format'] }, |
|
{ type: 'string', |
|
rules: [ 'maxLength', 'minLength', 'pattern', 'format' ] }, |
|
{ type: 'array', |
|
rules: [ 'maxItems', 'minItems', 'uniqueItems', 'contains', 'items' ] }, |
|
{ type: 'object', |
|
rules: [ 'maxProperties', 'minProperties', 'required', 'dependencies', 'propertyNames', |
|
{ 'properties': ['additionalProperties', 'patternProperties'] } ] }, |
|
{ rules: [ '$ref', 'const', 'enum', 'not', 'anyOf', 'oneOf', 'allOf' ] } |
|
]; |
|
|
|
var ALL = [ 'type' ]; |
|
var KEYWORDS = [ |
|
'additionalItems', '$schema', '$id', 'id', 'title', |
|
'description', 'default', 'definitions' |
|
]; |
|
var TYPES = [ 'number', 'integer', 'string', 'array', 'object', 'boolean', 'null' ]; |
|
RULES.all = toHash(ALL); |
|
RULES.types = toHash(TYPES); |
|
|
|
RULES.forEach(function (group) { |
|
group.rules = group.rules.map(function (keyword) { |
|
var implKeywords; |
|
if (typeof keyword == 'object') { |
|
var key = Object.keys(keyword)[0]; |
|
implKeywords = keyword[key]; |
|
keyword = key; |
|
implKeywords.forEach(function (k) { |
|
ALL.push(k); |
|
RULES.all[k] = true; |
|
}); |
|
} |
|
ALL.push(keyword); |
|
var rule = RULES.all[keyword] = { |
|
keyword: keyword, |
|
code: ruleModules[keyword], |
|
implements: implKeywords |
|
}; |
|
return rule; |
|
}); |
|
|
|
if (group.type) RULES.types[group.type] = group; |
|
}); |
|
|
|
RULES.keywords = toHash(ALL.concat(KEYWORDS)); |
|
RULES.custom = {}; |
|
|
|
return RULES; |
|
}; |
|
|
|
},{"./_rules":3,"./util":12}],10:[function(require,module,exports){ |
|
'use strict'; |
|
|
|
var util = require('./util'); |
|
|
|
module.exports = SchemaObject; |
|
|
|
function SchemaObject(obj) { |
|
util.copy(obj, this); |
|
} |
|
|
|
},{"./util":12}],11:[function(require,module,exports){ |
|
'use strict'; |
|
|
|
// https://mathiasbynens.be/notes/javascript-encoding |
|
// https://github.com/bestiejs/punycode.js - punycode.ucs2.decode |
|
module.exports = function ucs2length(str) { |
|
var length = 0 |
|
, len = str.length |
|
, pos = 0 |
|
, value; |
|
while (pos < len) { |
|
length++; |
|
value = str.charCodeAt(pos++); |
|
if (value >= 0xD800 && value <= 0xDBFF && pos < len) { |
|
// high surrogate, and there is a next character |
|
value = str.charCodeAt(pos); |
|
if ((value & 0xFC00) == 0xDC00) pos++; // low surrogate |
|
} |
|
} |
|
return length; |
|
}; |
|
|
|
},{}],12:[function(require,module,exports){ |
|
'use strict'; |
|
|
|
|
|
module.exports = { |
|
copy: copy, |
|
checkDataType: checkDataType, |
|
checkDataTypes: checkDataTypes, |
|
coerceToTypes: coerceToTypes, |
|
toHash: toHash, |
|
getProperty: getProperty, |
|
escapeQuotes: escapeQuotes, |
|
equal: require('fast-deep-equal'), |
|
ucs2length: require('./ucs2length'), |
|
varOccurences: varOccurences, |
|
varReplace: varReplace, |
|
cleanUpCode: cleanUpCode, |
|
finalCleanUpCode: finalCleanUpCode, |
|
schemaHasRules: schemaHasRules, |
|
schemaHasRulesExcept: schemaHasRulesExcept, |
|
toQuotedString: toQuotedString, |
|
getPathExpr: getPathExpr, |
|
getPath: getPath, |
|
getData: getData, |
|
unescapeFragment: unescapeFragment, |
|
unescapeJsonPointer: unescapeJsonPointer, |
|
escapeFragment: escapeFragment, |
|
escapeJsonPointer: escapeJsonPointer |
|
}; |
|
|
|
|
|
function copy(o, to) { |
|
to = to || {}; |
|
for (var key in o) to[key] = o[key]; |
|
return to; |
|
} |
|
|
|
|
|
function checkDataType(dataType, data, negate) { |
|
var EQUAL = negate ? ' !== ' : ' === ' |
|
, AND = negate ? ' || ' : ' && ' |
|
, OK = negate ? '!' : '' |
|
, NOT = negate ? '' : '!'; |
|
switch (dataType) { |
|
case 'null': return data + EQUAL + 'null'; |
|
case 'array': return OK + 'Array.isArray(' + data + ')'; |
|
case 'object': return '(' + OK + data + AND + |
|
'typeof ' + data + EQUAL + '"object"' + AND + |
|
NOT + 'Array.isArray(' + data + '))'; |
|
case 'integer': return '(typeof ' + data + EQUAL + '"number"' + AND + |
|
NOT + '(' + data + ' % 1)' + |
|
AND + data + EQUAL + data + ')'; |
|
default: return 'typeof ' + data + EQUAL + '"' + dataType + '"'; |
|
} |
|
} |
|
|
|
|
|
function checkDataTypes(dataTypes, data) { |
|
switch (dataTypes.length) { |
|
case 1: return checkDataType(dataTypes[0], data, true); |
|
default: |
|
var code = ''; |
|
var types = toHash(dataTypes); |
|
if (types.array && types.object) { |
|
code = types.null ? '(': '(!' + data + ' || '; |
|
code += 'typeof ' + data + ' !== "object")'; |
|
delete types.null; |
|
delete types.array; |
|
delete types.object; |
|
} |
|
if (types.number) delete types.integer; |
|
for (var t in types) |
|
code += (code ? ' && ' : '' ) + checkDataType(t, data, true); |
|
|
|
return code; |
|
} |
|
} |
|
|
|
|
|
var COERCE_TO_TYPES = toHash([ 'string', 'number', 'integer', 'boolean', 'null' ]); |
|
function coerceToTypes(optionCoerceTypes, dataTypes) { |
|
if (Array.isArray(dataTypes)) { |
|
var types = []; |
|
for (var i=0; i<dataTypes.length; i++) { |
|
var t = dataTypes[i]; |
|
if (COERCE_TO_TYPES[t]) types[types.length] = t; |
|
else if (optionCoerceTypes === 'array' && t === 'array') types[types.length] = t; |
|
} |
|
if (types.length) return types; |
|
} else if (COERCE_TO_TYPES[dataTypes]) { |
|
return [dataTypes]; |
|
} else if (optionCoerceTypes === 'array' && dataTypes === 'array') { |
|
return ['array']; |
|
} |
|
} |
|
|
|
|
|
function toHash(arr) { |
|
var hash = {}; |
|
for (var i=0; i<arr.length; i++) hash[arr[i]] = true; |
|
return hash; |
|
} |
|
|
|
|
|
var IDENTIFIER = /^[a-z$_][a-z$_0-9]*$/i; |
|
var SINGLE_QUOTE = /'|\\/g; |
|
function getProperty(key) { |
|
return typeof key == 'number' |
|
? '[' + key + ']' |
|
: IDENTIFIER.test(key) |
|
? '.' + key |
|
: "['" + escapeQuotes(key) + "']"; |
|
} |
|
|
|
|
|
function escapeQuotes(str) { |
|
return str.replace(SINGLE_QUOTE, '\\$&') |
|
.replace(/\n/g, '\\n') |
|
.replace(/\r/g, '\\r') |
|
.replace(/\f/g, '\\f') |
|
.replace(/\t/g, '\\t'); |
|
} |
|
|
|
|
|
function varOccurences(str, dataVar) { |
|
dataVar += '[^0-9]'; |
|
var matches = str.match(new RegExp(dataVar, 'g')); |
|
return matches ? matches.length : 0; |
|
} |
|
|
|
|
|
function varReplace(str, dataVar, expr) { |
|
dataVar += '([^0-9])'; |
|
expr = expr.replace(/\$/g, '$$$$'); |
|
return str.replace(new RegExp(dataVar, 'g'), expr + '$1'); |
|
} |
|
|
|
|
|
var EMPTY_ELSE = /else\s*{\s*}/g |
|
, EMPTY_IF_NO_ELSE = /if\s*\([^)]+\)\s*\{\s*\}(?!\s*else)/g |
|
, EMPTY_IF_WITH_ELSE = /if\s*\(([^)]+)\)\s*\{\s*\}\s*else(?!\s*if)/g; |
|
function cleanUpCode(out) { |
|
return out.replace(EMPTY_ELSE, '') |
|
.replace(EMPTY_IF_NO_ELSE, '') |
|
.replace(EMPTY_IF_WITH_ELSE, 'if (!($1))'); |
|
} |
|
|
|
|
|
var ERRORS_REGEXP = /[^v.]errors/g |
|
, REMOVE_ERRORS = /var errors = 0;|var vErrors = null;|validate.errors = vErrors;/g |
|
, REMOVE_ERRORS_ASYNC = /var errors = 0;|var vErrors = null;/g |
|
, RETURN_VALID = 'return errors === 0;' |
|
, RETURN_TRUE = 'validate.errors = null; return true;' |
|
, RETURN_ASYNC = /if \(errors === 0\) return data;\s*else throw new ValidationError\(vErrors\);/ |
|
, RETURN_DATA_ASYNC = 'return data;' |
|
, ROOTDATA_REGEXP = /[^A-Za-z_$]rootData[^A-Za-z0-9_$]/g |
|
, REMOVE_ROOTDATA = /if \(rootData === undefined\) rootData = data;/; |
|
|
|
function finalCleanUpCode(out, async) { |
|
var matches = out.match(ERRORS_REGEXP); |
|
if (matches && matches.length == 2) { |
|
out = async |
|
? out.replace(REMOVE_ERRORS_ASYNC, '') |
|
.replace(RETURN_ASYNC, RETURN_DATA_ASYNC) |
|
: out.replace(REMOVE_ERRORS, '') |
|
.replace(RETURN_VALID, RETURN_TRUE); |
|
} |
|
|
|
matches = out.match(ROOTDATA_REGEXP); |
|
if (!matches || matches.length !== 3) return out; |
|
return out.replace(REMOVE_ROOTDATA, ''); |
|
} |
|
|
|
|
|
function schemaHasRules(schema, rules) { |
|
if (typeof schema == 'boolean') return !schema; |
|
for (var key in schema) if (rules[key]) return true; |
|
} |
|
|
|
|
|
function schemaHasRulesExcept(schema, rules, exceptKeyword) { |
|
if (typeof schema == 'boolean') return !schema && exceptKeyword != 'not'; |
|
for (var key in schema) if (key != exceptKeyword && rules[key]) return true; |
|
} |
|
|
|
|
|
function toQuotedString(str) { |
|
return '\'' + escapeQuotes(str) + '\''; |
|
} |
|
|
|
|
|
function getPathExpr(currentPath, expr, jsonPointers, isNumber) { |
|
var path = jsonPointers // false by default |
|
? '\'/\' + ' + expr + (isNumber ? '' : '.replace(/~/g, \'~0\').replace(/\\//g, \'~1\')') |
|
: (isNumber ? '\'[\' + ' + expr + ' + \']\'' : '\'[\\\'\' + ' + expr + ' + \'\\\']\''); |
|
return joinPaths(currentPath, path); |
|
} |
|
|
|
|
|
function getPath(currentPath, prop, jsonPointers) { |
|
var path = jsonPointers // false by default |
|
? toQuotedString('/' + escapeJsonPointer(prop)) |
|
: toQuotedString(getProperty(prop)); |
|
return joinPaths(currentPath, path); |
|
} |
|
|
|
|
|
var JSON_POINTER = /^\/(?:[^~]|~0|~1)*$/; |
|
var RELATIVE_JSON_POINTER = /^([0-9]+)(#|\/(?:[^~]|~0|~1)*)?$/; |
|
function getData($data, lvl, paths) { |
|
var up, jsonPointer, data, matches; |
|
if ($data === '') return 'rootData'; |
|
if ($data[0] == '/') { |
|
if (!JSON_POINTER.test($data)) throw new Error('Invalid JSON-pointer: ' + $data); |
|
jsonPointer = $data; |
|
data = 'rootData'; |
|
} else { |
|
matches = $data.match(RELATIVE_JSON_POINTER); |
|
if (!matches) throw new Error('Invalid JSON-pointer: ' + $data); |
|
up = +matches[1]; |
|
jsonPointer = matches[2]; |
|
if (jsonPointer == '#') { |
|
if (up >= lvl) throw new Error('Cannot access property/index ' + up + ' levels up, current level is ' + lvl); |
|
return paths[lvl - up]; |
|
} |
|
|
|
if (up > lvl) throw new Error('Cannot access data ' + up + ' levels up, current level is ' + lvl); |
|
data = 'data' + ((lvl - up) || ''); |
|
if (!jsonPointer) return data; |
|
} |
|
|
|
var expr = data; |
|
var segments = jsonPointer.split('/'); |
|
for (var i=0; i<segments.length; i++) { |
|
var segment = segments[i]; |
|
if (segment) { |
|
data += getProperty(unescapeJsonPointer(segment)); |
|
expr += ' && ' + data; |
|
} |
|
} |
|
return expr; |
|
} |
|
|
|
|
|
function joinPaths (a, b) { |
|
if (a == '""') return b; |
|
return (a + ' + ' + b).replace(/' \+ '/g, ''); |
|
} |
|
|
|
|
|
function unescapeFragment(str) { |
|
return unescapeJsonPointer(decodeURIComponent(str)); |
|
} |
|
|
|
|
|
function escapeFragment(str) { |
|
return encodeURIComponent(escapeJsonPointer(str)); |
|
} |
|
|
|
|
|
function escapeJsonPointer(str) { |
|
return str.replace(/~/g, '~0').replace(/\//g, '~1'); |
|
} |
|
|
|
|
|
function unescapeJsonPointer(str) { |
|
return str.replace(/~1/g, '/').replace(/~0/g, '~'); |
|
} |
|
|
|
},{"./ucs2length":11,"fast-deep-equal":41}],13:[function(require,module,exports){ |
|
'use strict'; |
|
module.exports = function generate__limit(it, $keyword, $ruleType) { |
|
var out = ' '; |
|
var $lvl = it.level; |
|
var $dataLvl = it.dataLevel; |
|
var $schema = it.schema[$keyword]; |
|
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|
var $breakOnError = !it.opts.allErrors; |
|
var $errorKeyword; |
|
var $data = 'data' + ($dataLvl || ''); |
|
var $isData = it.opts.$data && $schema && $schema.$data, |
|
$schemaValue; |
|
if ($isData) { |
|
out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; '; |
|
$schemaValue = 'schema' + $lvl; |
|
} else { |
|
$schemaValue = $schema; |
|
} |
|
var $isMax = $keyword == 'maximum', |
|
$exclusiveKeyword = $isMax ? 'exclusiveMaximum' : 'exclusiveMinimum', |
|
$schemaExcl = it.schema[$exclusiveKeyword], |
|
$isDataExcl = it.opts.$data && $schemaExcl && $schemaExcl.$data, |
|
$op = $isMax ? '<' : '>', |
|
$notOp = $isMax ? '>' : '<', |
|
$errorKeyword = undefined; |
|
if ($isDataExcl) { |
|
var $schemaValueExcl = it.util.getData($schemaExcl.$data, $dataLvl, it.dataPathArr), |
|
$exclusive = 'exclusive' + $lvl, |
|
$exclType = 'exclType' + $lvl, |
|
$exclIsNumber = 'exclIsNumber' + $lvl, |
|
$opExpr = 'op' + $lvl, |
|
$opStr = '\' + ' + $opExpr + ' + \''; |
|
out += ' var schemaExcl' + ($lvl) + ' = ' + ($schemaValueExcl) + '; '; |
|
$schemaValueExcl = 'schemaExcl' + $lvl; |
|
out += ' var ' + ($exclusive) + '; var ' + ($exclType) + ' = typeof ' + ($schemaValueExcl) + '; if (' + ($exclType) + ' != \'boolean\' && ' + ($exclType) + ' != \'undefined\' && ' + ($exclType) + ' != \'number\') { '; |
|
var $errorKeyword = $exclusiveKeyword; |
|
var $$outStack = $$outStack || []; |
|
$$outStack.push(out); |
|
out = ''; /* istanbul ignore else */ |
|
if (it.createErrors !== false) { |
|
out += ' { keyword: \'' + ($errorKeyword || '_exclusiveLimit') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: {} '; |
|
if (it.opts.messages !== false) { |
|
out += ' , message: \'' + ($exclusiveKeyword) + ' should be boolean\' '; |
|
} |
|
if (it.opts.verbose) { |
|
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|
} |
|
out += ' } '; |
|
} else { |
|
out += ' {} '; |
|
} |
|
var __err = out; |
|
out = $$outStack.pop(); |
|
if (!it.compositeRule && $breakOnError) { /* istanbul ignore if */ |
|
if (it.async) { |
|
out += ' throw new ValidationError([' + (__err) + ']); '; |
|
} else { |
|
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|
} |
|
} else { |
|
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|
} |
|
out += ' } else if ( '; |
|
if ($isData) { |
|
out += ' (' + ($schemaValue) + ' !== undefined && typeof ' + ($schemaValue) + ' != \'number\') || '; |
|
} |
|
out += ' ' + ($exclType) + ' == \'number\' ? ( (' + ($exclusive) + ' = ' + ($schemaValue) + ' === undefined || ' + ($schemaValueExcl) + ' ' + ($op) + '= ' + ($schemaValue) + ') ? ' + ($data) + ' ' + ($notOp) + '= ' + ($schemaValueExcl) + ' : ' + ($data) + ' ' + ($notOp) + ' ' + ($schemaValue) + ' ) : ( (' + ($exclusive) + ' = ' + ($schemaValueExcl) + ' === true) ? ' + ($data) + ' ' + ($notOp) + '= ' + ($schemaValue) + ' : ' + ($data) + ' ' + ($notOp) + ' ' + ($schemaValue) + ' ) || ' + ($data) + ' !== ' + ($data) + ') { var op' + ($lvl) + ' = ' + ($exclusive) + ' ? \'' + ($op) + '\' : \'' + ($op) + '=\';'; |
|
} else { |
|
var $exclIsNumber = typeof $schemaExcl == 'number', |
|
$opStr = $op; |
|
if ($exclIsNumber && $isData) { |
|
var $opExpr = '\'' + $opStr + '\''; |
|
out += ' if ( '; |
|
if ($isData) { |
|
out += ' (' + ($schemaValue) + ' !== undefined && typeof ' + ($schemaValue) + ' != \'number\') || '; |
|
} |
|
out += ' ( ' + ($schemaValue) + ' === undefined || ' + ($schemaExcl) + ' ' + ($op) + '= ' + ($schemaValue) + ' ? ' + ($data) + ' ' + ($notOp) + '= ' + ($schemaExcl) + ' : ' + ($data) + ' ' + ($notOp) + ' ' + ($schemaValue) + ' ) || ' + ($data) + ' !== ' + ($data) + ') { '; |
|
} else { |
|
if ($exclIsNumber && $schema === undefined) { |
|
$exclusive = true; |
|
$errorKeyword = $exclusiveKeyword; |
|
$errSchemaPath = it.errSchemaPath + '/' + $exclusiveKeyword; |
|
$schemaValue = $schemaExcl; |
|
$notOp += '='; |
|
} else { |
|
if ($exclIsNumber) $schemaValue = Math[$isMax ? 'min' : 'max']($schemaExcl, $schema); |
|
if ($schemaExcl === ($exclIsNumber ? $schemaValue : true)) { |
|
$exclusive = true; |
|
$errorKeyword = $exclusiveKeyword; |
|
$errSchemaPath = it.errSchemaPath + '/' + $exclusiveKeyword; |
|
$notOp += '='; |
|
} else { |
|
$exclusive = false; |
|
$opStr += '='; |
|
} |
|
} |
|
var $opExpr = '\'' + $opStr + '\''; |
|
out += ' if ( '; |
|
if ($isData) { |
|
out += ' (' + ($schemaValue) + ' !== undefined && typeof ' + ($schemaValue) + ' != \'number\') || '; |
|
} |
|
out += ' ' + ($data) + ' ' + ($notOp) + ' ' + ($schemaValue) + ' || ' + ($data) + ' !== ' + ($data) + ') { '; |
|
} |
|
} |
|
$errorKeyword = $errorKeyword || $keyword; |
|
var $$outStack = $$outStack || []; |
|
$$outStack.push(out); |
|
out = ''; /* istanbul ignore else */ |
|
if (it.createErrors !== false) { |
|
out += ' { keyword: \'' + ($errorKeyword || '_limit') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { comparison: ' + ($opExpr) + ', limit: ' + ($schemaValue) + ', exclusive: ' + ($exclusive) + ' } '; |
|
if (it.opts.messages !== false) { |
|
out += ' , message: \'should be ' + ($opStr) + ' '; |
|
if ($isData) { |
|
out += '\' + ' + ($schemaValue); |
|
} else { |
|
out += '' + ($schemaValue) + '\''; |
|
} |
|
} |
|
if (it.opts.verbose) { |
|
out += ' , schema: '; |
|
if ($isData) { |
|
out += 'validate.schema' + ($schemaPath); |
|
} else { |
|
out += '' + ($schema); |
|
} |
|
out += ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|
} |
|
out += ' } '; |
|
} else { |
|
out += ' {} '; |
|
} |
|
var __err = out; |
|
out = $$outStack.pop(); |
|
if (!it.compositeRule && $breakOnError) { /* istanbul ignore if */ |
|
if (it.async) { |
|
out += ' throw new ValidationError([' + (__err) + ']); '; |
|
} else { |
|
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|
} |
|
} else { |
|
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|
} |
|
out += ' } '; |
|
if ($breakOnError) { |
|
out += ' else { '; |
|
} |
|
return out; |
|
} |
|
|
|
},{}],14:[function(require,module,exports){ |
|
'use strict'; |
|
module.exports = function generate__limitItems(it, $keyword, $ruleType) { |
|
var out = ' '; |
|
var $lvl = it.level; |
|
var $dataLvl = it.dataLevel; |
|
var $schema = it.schema[$keyword]; |
|
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|
var $breakOnError = !it.opts.allErrors; |
|
var $errorKeyword; |
|
var $data = 'data' + ($dataLvl || ''); |
|
var $isData = it.opts.$data && $schema && $schema.$data, |
|
$schemaValue; |
|
if ($isData) { |
|
out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; '; |
|
$schemaValue = 'schema' + $lvl; |
|
} else { |
|
$schemaValue = $schema; |
|
} |
|
var $op = $keyword == 'maxItems' ? '>' : '<'; |
|
out += 'if ( '; |
|
if ($isData) { |
|
out += ' (' + ($schemaValue) + ' !== undefined && typeof ' + ($schemaValue) + ' != \'number\') || '; |
|
} |
|
out += ' ' + ($data) + '.length ' + ($op) + ' ' + ($schemaValue) + ') { '; |
|
var $errorKeyword = $keyword; |
|
var $$outStack = $$outStack || []; |
|
$$outStack.push(out); |
|
out = ''; /* istanbul ignore else */ |
|
if (it.createErrors !== false) { |
|
out += ' { keyword: \'' + ($errorKeyword || '_limitItems') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { limit: ' + ($schemaValue) + ' } '; |
|
if (it.opts.messages !== false) { |
|
out += ' , message: \'should NOT have '; |
|
if ($keyword == 'maxItems') { |
|
out += 'more'; |
|
} else { |
|
out += 'less'; |
|
} |
|
out += ' than '; |
|
if ($isData) { |
|
out += '\' + ' + ($schemaValue) + ' + \''; |
|
} else { |
|
out += '' + ($schema); |
|
} |
|
out += ' items\' '; |
|
} |
|
if (it.opts.verbose) { |
|
out += ' , schema: '; |
|
if ($isData) { |
|
out += 'validate.schema' + ($schemaPath); |
|
} else { |
|
out += '' + ($schema); |
|
} |
|
out += ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|
} |
|
out += ' } '; |
|
} else { |
|
out += ' {} '; |
|
} |
|
var __err = out; |
|
out = $$outStack.pop(); |
|
if (!it.compositeRule && $breakOnError) { /* istanbul ignore if */ |
|
if (it.async) { |
|
out += ' throw new ValidationError([' + (__err) + ']); '; |
|
} else { |
|
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|
} |
|
} else { |
|
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|
} |
|
out += '} '; |
|
if ($breakOnError) { |
|
out += ' else { '; |
|
} |
|
return out; |
|
} |
|
|
|
},{}],15:[function(require,module,exports){ |
|
'use strict'; |
|
module.exports = function generate__limitLength(it, $keyword, $ruleType) { |
|
var out = ' '; |
|
var $lvl = it.level; |
|
var $dataLvl = it.dataLevel; |
|
var $schema = it.schema[$keyword]; |
|
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|
var $breakOnError = !it.opts.allErrors; |
|
var $errorKeyword; |
|
var $data = 'data' + ($dataLvl || ''); |
|
var $isData = it.opts.$data && $schema && $schema.$data, |
|
$schemaValue; |
|
if ($isData) { |
|
out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; '; |
|
$schemaValue = 'schema' + $lvl; |
|
} else { |
|
$schemaValue = $schema; |
|
} |
|
var $op = $keyword == 'maxLength' ? '>' : '<'; |
|
out += 'if ( '; |
|
if ($isData) { |
|
out += ' (' + ($schemaValue) + ' !== undefined && typeof ' + ($schemaValue) + ' != \'number\') || '; |
|
} |
|
if (it.opts.unicode === false) { |
|
out += ' ' + ($data) + '.length '; |
|
} else { |
|
out += ' ucs2length(' + ($data) + ') '; |
|
} |
|
out += ' ' + ($op) + ' ' + ($schemaValue) + ') { '; |
|
var $errorKeyword = $keyword; |
|
var $$outStack = $$outStack || []; |
|
$$outStack.push(out); |
|
out = ''; /* istanbul ignore else */ |
|
if (it.createErrors !== false) { |
|
out += ' { keyword: \'' + ($errorKeyword || '_limitLength') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { limit: ' + ($schemaValue) + ' } '; |
|
if (it.opts.messages !== false) { |
|
out += ' , message: \'should NOT be '; |
|
if ($keyword == 'maxLength') { |
|
out += 'longer'; |
|
} else { |
|
out += 'shorter'; |
|
} |
|
out += ' than '; |
|
if ($isData) { |
|
out += '\' + ' + ($schemaValue) + ' + \''; |
|
} else { |
|
out += '' + ($schema); |
|
} |
|
out += ' characters\' '; |
|
} |
|
if (it.opts.verbose) { |
|
out += ' , schema: '; |
|
if ($isData) { |
|
out += 'validate.schema' + ($schemaPath); |
|
} else { |
|
out += '' + ($schema); |
|
} |
|
out += ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|
} |
|
out += ' } '; |
|
} else { |
|
out += ' {} '; |
|
} |
|
var __err = out; |
|
out = $$outStack.pop(); |
|
if (!it.compositeRule && $breakOnError) { /* istanbul ignore if */ |
|
if (it.async) { |
|
out += ' throw new ValidationError([' + (__err) + ']); '; |
|
} else { |
|
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|
} |
|
} else { |
|
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|
} |
|
out += '} '; |
|
if ($breakOnError) { |
|
out += ' else { '; |
|
} |
|
return out; |
|
} |
|
|
|
},{}],16:[function(require,module,exports){ |
|
'use strict'; |
|
module.exports = function generate__limitProperties(it, $keyword, $ruleType) { |
|
var out = ' '; |
|
var $lvl = it.level; |
|
var $dataLvl = it.dataLevel; |
|
var $schema = it.schema[$keyword]; |
|
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|
var $breakOnError = !it.opts.allErrors; |
|
var $errorKeyword; |
|
var $data = 'data' + ($dataLvl || ''); |
|
var $isData = it.opts.$data && $schema && $schema.$data, |
|
$schemaValue; |
|
if ($isData) { |
|
out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; '; |
|
$schemaValue = 'schema' + $lvl; |
|
} else { |
|
$schemaValue = $schema; |
|
} |
|
var $op = $keyword == 'maxProperties' ? '>' : '<'; |
|
out += 'if ( '; |
|
if ($isData) { |
|
out += ' (' + ($schemaValue) + ' !== undefined && typeof ' + ($schemaValue) + ' != \'number\') || '; |
|
} |
|
out += ' Object.keys(' + ($data) + ').length ' + ($op) + ' ' + ($schemaValue) + ') { '; |
|
var $errorKeyword = $keyword; |
|
var $$outStack = $$outStack || []; |
|
$$outStack.push(out); |
|
out = ''; /* istanbul ignore else */ |
|
if (it.createErrors !== false) { |
|
out += ' { keyword: \'' + ($errorKeyword || '_limitProperties') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { limit: ' + ($schemaValue) + ' } '; |
|
if (it.opts.messages !== false) { |
|
out += ' , message: \'should NOT have '; |
|
if ($keyword == 'maxProperties') { |
|
out += 'more'; |
|
} else { |
|
out += 'less'; |
|
} |
|
out += ' than '; |
|
if ($isData) { |
|
out += '\' + ' + ($schemaValue) + ' + \''; |
|
} else { |
|
out += '' + ($schema); |
|
} |
|
out += ' properties\' '; |
|
} |
|
if (it.opts.verbose) { |
|
out += ' , schema: '; |
|
if ($isData) { |
|
out += 'validate.schema' + ($schemaPath); |
|
} else { |
|
out += '' + ($schema); |
|
} |
|
out += ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|
} |
|
out += ' } '; |
|
} else { |
|
out += ' {} '; |
|
} |
|
var __err = out; |
|
out = $$outStack.pop(); |
|
if (!it.compositeRule && $breakOnError) { /* istanbul ignore if */ |
|
if (it.async) { |
|
out += ' throw new ValidationError([' + (__err) + ']); '; |
|
} else { |
|
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|
} |
|
} else { |
|
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|
} |
|
out += '} '; |
|
if ($breakOnError) { |
|
out += ' else { '; |
|
} |
|
return out; |
|
} |
|
|
|
},{}],17:[function(require,module,exports){ |
|
'use strict'; |
|
module.exports = function generate_allOf(it, $keyword, $ruleType) { |
|
var out = ' '; |
|
var $schema = it.schema[$keyword]; |
|
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|
var $breakOnError = !it.opts.allErrors; |
|
var $it = it.util.copy(it); |
|
var $closingBraces = ''; |
|
$it.level++; |
|
var $nextValid = 'valid' + $it.level; |
|
var $currentBaseId = $it.baseId, |
|
$allSchemasEmpty = true; |
|
var arr1 = $schema; |
|
if (arr1) { |
|
var $sch, $i = -1, |
|
l1 = arr1.length - 1; |
|
while ($i < l1) { |
|
$sch = arr1[$i += 1]; |
|
if (it.util.schemaHasRules($sch, it.RULES.all)) { |
|
$allSchemasEmpty = false; |
|
$it.schema = $sch; |
|
$it.schemaPath = $schemaPath + '[' + $i + ']'; |
|
$it.errSchemaPath = $errSchemaPath + '/' + $i; |
|
out += ' ' + (it.validate($it)) + ' '; |
|
$it.baseId = $currentBaseId; |
|
if ($breakOnError) { |
|
out += ' if (' + ($nextValid) + ') { '; |
|
$closingBraces += '}'; |
|
} |
|
} |
|
} |
|
} |
|
if ($breakOnError) { |
|
if ($allSchemasEmpty) { |
|
out += ' if (true) { '; |
|
} else { |
|
out += ' ' + ($closingBraces.slice(0, -1)) + ' '; |
|
} |
|
} |
|
out = it.util.cleanUpCode(out); |
|
return out; |
|
} |
|
|
|
},{}],18:[function(require,module,exports){ |
|
'use strict'; |
|
module.exports = function generate_anyOf(it, $keyword, $ruleType) { |
|
var out = ' '; |
|
var $lvl = it.level; |
|
var $dataLvl = it.dataLevel; |
|
var $schema = it.schema[$keyword]; |
|
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|
var $breakOnError = !it.opts.allErrors; |
|
var $data = 'data' + ($dataLvl || ''); |
|
var $valid = 'valid' + $lvl; |
|
var $errs = 'errs__' + $lvl; |
|
var $it = it.util.copy(it); |
|
var $closingBraces = ''; |
|
$it.level++; |
|
var $nextValid = 'valid' + $it.level; |
|
var $noEmptySchema = $schema.every(function($sch) { |
|
return it.util.schemaHasRules($sch, it.RULES.all); |
|
}); |
|
if ($noEmptySchema) { |
|
var $currentBaseId = $it.baseId; |
|
out += ' var ' + ($errs) + ' = errors; var ' + ($valid) + ' = false; '; |
|
var $wasComposite = it.compositeRule; |
|
it.compositeRule = $it.compositeRule = true; |
|
var arr1 = $schema; |
|
if (arr1) { |
|
var $sch, $i = -1, |
|
l1 = arr1.length - 1; |
|
while ($i < l1) { |
|
$sch = arr1[$i += 1]; |
|
$it.schema = $sch; |
|
$it.schemaPath = $schemaPath + '[' + $i + ']'; |
|
$it.errSchemaPath = $errSchemaPath + '/' + $i; |
|
out += ' ' + (it.validate($it)) + ' '; |
|
$it.baseId = $currentBaseId; |
|
out += ' ' + ($valid) + ' = ' + ($valid) + ' || ' + ($nextValid) + '; if (!' + ($valid) + ') { '; |
|
$closingBraces += '}'; |
|
} |
|
} |
|
it.compositeRule = $it.compositeRule = $wasComposite; |
|
out += ' ' + ($closingBraces) + ' if (!' + ($valid) + ') { var err = '; /* istanbul ignore else */ |
|
if (it.createErrors !== false) { |
|
out += ' { keyword: \'' + ('anyOf') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: {} '; |
|
if (it.opts.messages !== false) { |
|
out += ' , message: \'should match some schema in anyOf\' '; |
|
} |
|
if (it.opts.verbose) { |
|
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|
} |
|
out += ' } '; |
|
} else { |
|
out += ' {} '; |
|
} |
|
out += '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|
if (!it.compositeRule && $breakOnError) { /* istanbul ignore if */ |
|
if (it.async) { |
|
out += ' throw new ValidationError(vErrors); '; |
|
} else { |
|
out += ' validate.errors = vErrors; return false; '; |
|
} |
|
} |
|
out += ' } else { errors = ' + ($errs) + '; if (vErrors !== null) { if (' + ($errs) + ') vErrors.length = ' + ($errs) + '; else vErrors = null; } '; |
|
if (it.opts.allErrors) { |
|
out += ' } '; |
|
} |
|
out = it.util.cleanUpCode(out); |
|
} else { |
|
if ($breakOnError) { |
|
out += ' if (true) { '; |
|
} |
|
} |
|
return out; |
|
} |
|
|
|
},{}],19:[function(require,module,exports){ |
|
'use strict'; |
|
module.exports = function generate_const(it, $keyword, $ruleType) { |
|
var out = ' '; |
|
var $lvl = it.level; |
|
var $dataLvl = it.dataLevel; |
|
var $schema = it.schema[$keyword]; |
|
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|
var $breakOnError = !it.opts.allErrors; |
|
var $data = 'data' + ($dataLvl || ''); |
|
var $valid = 'valid' + $lvl; |
|
var $isData = it.opts.$data && $schema && $schema.$data, |
|
$schemaValue; |
|
if ($isData) { |
|
out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; '; |
|
$schemaValue = 'schema' + $lvl; |
|
} else { |
|
$schemaValue = $schema; |
|
} |
|
if (!$isData) { |
|
out += ' var schema' + ($lvl) + ' = validate.schema' + ($schemaPath) + ';'; |
|
} |
|
out += 'var ' + ($valid) + ' = equal(' + ($data) + ', schema' + ($lvl) + '); if (!' + ($valid) + ') { '; |
|
var $$outStack = $$outStack || []; |
|
$$outStack.push(out); |
|
out = ''; /* istanbul ignore else */ |
|
if (it.createErrors !== false) { |
|
out += ' { keyword: \'' + ('const') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: {} '; |
|
if (it.opts.messages !== false) { |
|
out += ' , message: \'should be equal to constant\' '; |
|
} |
|
if (it.opts.verbose) { |
|
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|
} |
|
out += ' } '; |
|
} else { |
|
out += ' {} '; |
|
} |
|
var __err = out; |
|
out = $$outStack.pop(); |
|
if (!it.compositeRule && $breakOnError) { /* istanbul ignore if */ |
|
if (it.async) { |
|
out += ' throw new ValidationError([' + (__err) + ']); '; |
|
} else { |
|
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|
} |
|
} else { |
|
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|
} |
|
out += ' }'; |
|
if ($breakOnError) { |
|
out += ' else { '; |
|
} |
|
return out; |
|
} |
|
|
|
},{}],20:[function(require,module,exports){ |
|
'use strict'; |
|
module.exports = function generate_contains(it, $keyword, $ruleType) { |
|
var out = ' '; |
|
var $lvl = it.level; |
|
var $dataLvl = it.dataLevel; |
|
var $schema = it.schema[$keyword]; |
|
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|
var $breakOnError = !it.opts.allErrors; |
|
var $data = 'data' + ($dataLvl || ''); |
|
var $valid = 'valid' + $lvl; |
|
var $errs = 'errs__' + $lvl; |
|
var $it = it.util.copy(it); |
|
var $closingBraces = ''; |
|
$it.level++; |
|
var $nextValid = 'valid' + $it.level; |
|
var $idx = 'i' + $lvl, |
|
$dataNxt = $it.dataLevel = it.dataLevel + 1, |
|
$nextData = 'data' + $dataNxt, |
|
$currentBaseId = it.baseId, |
|
$nonEmptySchema = it.util.schemaHasRules($schema, it.RULES.all); |
|
out += 'var ' + ($errs) + ' = errors;var ' + ($valid) + ';'; |
|
if ($nonEmptySchema) { |
|
var $wasComposite = it.compositeRule; |
|
it.compositeRule = $it.compositeRule = true; |
|
$it.schema = $schema; |
|
$it.schemaPath = $schemaPath; |
|
$it.errSchemaPath = $errSchemaPath; |
|
out += ' var ' + ($nextValid) + ' = false; for (var ' + ($idx) + ' = 0; ' + ($idx) + ' < ' + ($data) + '.length; ' + ($idx) + '++) { '; |
|
$it.errorPath = it.util.getPathExpr(it.errorPath, $idx, it.opts.jsonPointers, true); |
|
var $passData = $data + '[' + $idx + ']'; |
|
$it.dataPathArr[$dataNxt] = $idx; |
|
var $code = it.validate($it); |
|
$it.baseId = $currentBaseId; |
|
if (it.util.varOccurences($code, $nextData) < 2) { |
|
out += ' ' + (it.util.varReplace($code, $nextData, $passData)) + ' '; |
|
} else { |
|
out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ' + ($code) + ' '; |
|
} |
|
out += ' if (' + ($nextValid) + ') break; } '; |
|
it.compositeRule = $it.compositeRule = $wasComposite; |
|
out += ' ' + ($closingBraces) + ' if (!' + ($nextValid) + ') {'; |
|
} else { |
|
out += ' if (' + ($data) + '.length == 0) {'; |
|
} |
|
var $$outStack = $$outStack || []; |
|
$$outStack.push(out); |
|
out = ''; /* istanbul ignore else */ |
|
if (it.createErrors !== false) { |
|
out += ' { keyword: \'' + ('contains') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: {} '; |
|
if (it.opts.messages !== false) { |
|
out += ' , message: \'should contain a valid item\' '; |
|
} |
|
if (it.opts.verbose) { |
|
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|
} |
|
out += ' } '; |
|
} else { |
|
out += ' {} '; |
|
} |
|
var __err = out; |
|
out = $$outStack.pop(); |
|
if (!it.compositeRule && $breakOnError) { /* istanbul ignore if */ |
|
if (it.async) { |
|
out += ' throw new ValidationError([' + (__err) + ']); '; |
|
} else { |
|
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|
} |
|
} else { |
|
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|
} |
|
out += ' } else { '; |
|
if ($nonEmptySchema) { |
|
out += ' errors = ' + ($errs) + '; if (vErrors !== null) { if (' + ($errs) + ') vErrors.length = ' + ($errs) + '; else vErrors = null; } '; |
|
} |
|
if (it.opts.allErrors) { |
|
out += ' } '; |
|
} |
|
out = it.util.cleanUpCode(out); |
|
return out; |
|
} |
|
|
|
},{}],21:[function(require,module,exports){ |
|
'use strict'; |
|
module.exports = function generate_custom(it, $keyword, $ruleType) { |
|
var out = ' '; |
|
var $lvl = it.level; |
|
var $dataLvl = it.dataLevel; |
|
var $schema = it.schema[$keyword]; |
|
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|
var $breakOnError = !it.opts.allErrors; |
|
var $errorKeyword; |
|
var $data = 'data' + ($dataLvl || ''); |
|
var $valid = 'valid' + $lvl; |
|
var $errs = 'errs__' + $lvl; |
|
var $isData = it.opts.$data && $schema && $schema.$data, |
|
$schemaValue; |
|
if ($isData) { |
|
out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; '; |
|
$schemaValue = 'schema' + $lvl; |
|
} else { |
|
$schemaValue = $schema; |
|
} |
|
var $rule = this, |
|
$definition = 'definition' + $lvl, |
|
$rDef = $rule.definition, |
|
$closingBraces = ''; |
|
var $compile, $inline, $macro, $ruleValidate, $validateCode; |
|
if ($isData && $rDef.$data) { |
|
$validateCode = 'keywordValidate' + $lvl; |
|
var $validateSchema = $rDef.validateSchema; |
|
out += ' var ' + ($definition) + ' = RULES.custom[\'' + ($keyword) + '\'].definition; var ' + ($validateCode) + ' = ' + ($definition) + '.validate;'; |
|
} else { |
|
$ruleValidate = it.useCustomRule($rule, $schema, it.schema, it); |
|
if (!$ruleValidate) return; |
|
$schemaValue = 'validate.schema' + $schemaPath; |
|
$validateCode = $ruleValidate.code; |
|
$compile = $rDef.compile; |
|
$inline = $rDef.inline; |
|
$macro = $rDef.macro; |
|
} |
|
var $ruleErrs = $validateCode + '.errors', |
|
$i = 'i' + $lvl, |
|
$ruleErr = 'ruleErr' + $lvl, |
|
$asyncKeyword = $rDef.async; |
|
if ($asyncKeyword && !it.async) throw new Error('async keyword in sync schema'); |
|
if (!($inline || $macro)) { |
|
out += '' + ($ruleErrs) + ' = null;'; |
|
} |
|
out += 'var ' + ($errs) + ' = errors;var ' + ($valid) + ';'; |
|
if ($isData && $rDef.$data) { |
|
$closingBraces += '}'; |
|
out += ' if (' + ($schemaValue) + ' === undefined) { ' + ($valid) + ' = true; } else { '; |
|
if ($validateSchema) { |
|
$closingBraces += '}'; |
|
out += ' ' + ($valid) + ' = ' + ($definition) + '.validateSchema(' + ($schemaValue) + '); if (' + ($valid) + ') { '; |
|
} |
|
} |
|
if ($inline) { |
|
if ($rDef.statements) { |
|
out += ' ' + ($ruleValidate.validate) + ' '; |
|
} else { |
|
out += ' ' + ($valid) + ' = ' + ($ruleValidate.validate) + '; '; |
|
} |
|
} else if ($macro) { |
|
var $it = it.util.copy(it); |
|
var $closingBraces = ''; |
|
$it.level++; |
|
var $nextValid = 'valid' + $it.level; |
|
$it.schema = $ruleValidate.validate; |
|
$it.schemaPath = ''; |
|
var $wasComposite = it.compositeRule; |
|
it.compositeRule = $it.compositeRule = true; |
|
var $code = it.validate($it).replace(/validate\.schema/g, $validateCode); |
|
it.compositeRule = $it.compositeRule = $wasComposite; |
|
out += ' ' + ($code); |
|
} else { |
|
var $$outStack = $$outStack || []; |
|
$$outStack.push(out); |
|
out = ''; |
|
out += ' ' + ($validateCode) + '.call( '; |
|
if (it.opts.passContext) { |
|
out += 'this'; |
|
} else { |
|
out += 'self'; |
|
} |
|
if ($compile || $rDef.schema === false) { |
|
out += ' , ' + ($data) + ' '; |
|
} else { |
|
out += ' , ' + ($schemaValue) + ' , ' + ($data) + ' , validate.schema' + (it.schemaPath) + ' '; |
|
} |
|
out += ' , (dataPath || \'\')'; |
|
if (it.errorPath != '""') { |
|
out += ' + ' + (it.errorPath); |
|
} |
|
var $parentData = $dataLvl ? 'data' + (($dataLvl - 1) || '') : 'parentData', |
|
$parentDataProperty = $dataLvl ? it.dataPathArr[$dataLvl] : 'parentDataProperty'; |
|
out += ' , ' + ($parentData) + ' , ' + ($parentDataProperty) + ' , rootData ) '; |
|
var def_callRuleValidate = out; |
|
out = $$outStack.pop(); |
|
if ($rDef.errors === false) { |
|
out += ' ' + ($valid) + ' = '; |
|
if ($asyncKeyword) { |
|
out += '' + (it.yieldAwait); |
|
} |
|
out += '' + (def_callRuleValidate) + '; '; |
|
} else { |
|
if ($asyncKeyword) { |
|
$ruleErrs = 'customErrors' + $lvl; |
|
out += ' var ' + ($ruleErrs) + ' = null; try { ' + ($valid) + ' = ' + (it.yieldAwait) + (def_callRuleValidate) + '; } catch (e) { ' + ($valid) + ' = false; if (e instanceof ValidationError) ' + ($ruleErrs) + ' = e.errors; else throw e; } '; |
|
} else { |
|
out += ' ' + ($ruleErrs) + ' = null; ' + ($valid) + ' = ' + (def_callRuleValidate) + '; '; |
|
} |
|
} |
|
} |
|
if ($rDef.modifying) { |
|
out += ' if (' + ($parentData) + ') ' + ($data) + ' = ' + ($parentData) + '[' + ($parentDataProperty) + '];'; |
|
} |
|
out += '' + ($closingBraces); |
|
if ($rDef.valid) { |
|
if ($breakOnError) { |
|
out += ' if (true) { '; |
|
} |
|
} else { |
|
out += ' if ( '; |
|
if ($rDef.valid === undefined) { |
|
out += ' !'; |
|
if ($macro) { |
|
out += '' + ($nextValid); |
|
} else { |
|
out += '' + ($valid); |
|
} |
|
} else { |
|
out += ' ' + (!$rDef.valid) + ' '; |
|
} |
|
out += ') { '; |
|
$errorKeyword = $rule.keyword; |
|
var $$outStack = $$outStack || []; |
|
$$outStack.push(out); |
|
out = ''; |
|
var $$outStack = $$outStack || []; |
|
$$outStack.push(out); |
|
out = ''; /* istanbul ignore else */ |
|
if (it.createErrors !== false) { |
|
out += ' { keyword: \'' + ($errorKeyword || 'custom') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { keyword: \'' + ($rule.keyword) + '\' } '; |
|
if (it.opts.messages !== false) { |
|
out += ' , message: \'should pass "' + ($rule.keyword) + '" keyword validation\' '; |
|
} |
|
if (it.opts.verbose) { |
|
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|
} |
|
out += ' } '; |
|
} else { |
|
out += ' {} '; |
|
} |
|
var __err = out; |
|
out = $$outStack.pop(); |
|
if (!it.compositeRule && $breakOnError) { /* istanbul ignore if */ |
|
if (it.async) { |
|
out += ' throw new ValidationError([' + (__err) + ']); '; |
|
} else { |
|
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|
} |
|
} else { |
|
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|
} |
|
var def_customError = out; |
|
out = $$outStack.pop(); |
|
if ($inline) { |
|
if ($rDef.errors) { |
|
if ($rDef.errors != 'full') { |
|
out += ' for (var ' + ($i) + '=' + ($errs) + '; ' + ($i) + '<errors; ' + ($i) + '++) { var ' + ($ruleErr) + ' = vErrors[' + ($i) + ']; if (' + ($ruleErr) + '.dataPath === undefined) ' + ($ruleErr) + '.dataPath = (dataPath || \'\') + ' + (it.errorPath) + '; if (' + ($ruleErr) + '.schemaPath === undefined) { ' + ($ruleErr) + '.schemaPath = "' + ($errSchemaPath) + '"; } '; |
|
if (it.opts.verbose) { |
|
out += ' ' + ($ruleErr) + '.schema = ' + ($schemaValue) + '; ' + ($ruleErr) + '.data = ' + ($data) + '; '; |
|
} |
|
out += ' } '; |
|
} |
|
} else { |
|
if ($rDef.errors === false) { |
|
out += ' ' + (def_customError) + ' '; |
|
} else { |
|
out += ' if (' + ($errs) + ' == errors) { ' + (def_customError) + ' } else { for (var ' + ($i) + '=' + ($errs) + '; ' + ($i) + '<errors; ' + ($i) + '++) { var ' + ($ruleErr) + ' = vErrors[' + ($i) + ']; if (' + ($ruleErr) + '.dataPath === undefined) ' + ($ruleErr) + '.dataPath = (dataPath || \'\') + ' + (it.errorPath) + '; if (' + ($ruleErr) + '.schemaPath === undefined) { ' + ($ruleErr) + '.schemaPath = "' + ($errSchemaPath) + '"; } '; |
|
if (it.opts.verbose) { |
|
out += ' ' + ($ruleErr) + '.schema = ' + ($schemaValue) + '; ' + ($ruleErr) + '.data = ' + ($data) + '; '; |
|
} |
|
out += ' } } '; |
|
} |
|
} |
|
} else if ($macro) { |
|
out += ' var err = '; /* istanbul ignore else */ |
|
if (it.createErrors !== false) { |
|
out += ' { keyword: \'' + ($errorKeyword || 'custom') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { keyword: \'' + ($rule.keyword) + '\' } '; |
|
if (it.opts.messages !== false) { |
|
out += ' , message: \'should pass "' + ($rule.keyword) + '" keyword validation\' '; |
|
} |
|
if (it.opts.verbose) { |
|
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|
} |
|
out += ' } '; |
|
} else { |
|
out += ' {} '; |
|
} |
|
out += '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|
if (!it.compositeRule && $breakOnError) { /* istanbul ignore if */ |
|
if (it.async) { |
|
out += ' throw new ValidationError(vErrors); '; |
|
} else { |
|
out += ' validate.errors = vErrors; return false; '; |
|
} |
|
} |
|
} else { |
|
if ($rDef.errors === false) { |
|
out += ' ' + (def_customError) + ' '; |
|
} else { |
|
out += ' if (Array.isArray(' + ($ruleErrs) + ')) { if (vErrors === null) vErrors = ' + ($ruleErrs) + '; else vErrors = vErrors.concat(' + ($ruleErrs) + '); errors = vErrors.length; for (var ' + ($i) + '=' + ($errs) + '; ' + ($i) + '<errors; ' + ($i) + '++) { var ' + ($ruleErr) + ' = vErrors[' + ($i) + ']; if (' + ($ruleErr) + '.dataPath === undefined) ' + ($ruleErr) + '.dataPath = (dataPath || \'\') + ' + (it.errorPath) + '; ' + ($ruleErr) + '.schemaPath = "' + ($errSchemaPath) + '"; '; |
|
if (it.opts.verbose) { |
|
out += ' ' + ($ruleErr) + '.schema = ' + ($schemaValue) + '; ' + ($ruleErr) + '.data = ' + ($data) + '; '; |
|
} |
|
out += ' } } else { ' + (def_customError) + ' } '; |
|
} |
|
} |
|
out += ' } '; |
|
if ($breakOnError) { |
|
out += ' else { '; |
|
} |
|
} |
|
return out; |
|
} |
|
|
|
},{}],22:[function(require,module,exports){ |
|
'use strict'; |
|
module.exports = function generate_dependencies(it, $keyword, $ruleType) { |
|
var out = ' '; |
|
var $lvl = it.level; |
|
var $dataLvl = it.dataLevel; |
|
var $schema = it.schema[$keyword]; |
|
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|
var $breakOnError = !it.opts.allErrors; |
|
var $data = 'data' + ($dataLvl || ''); |
|
var $errs = 'errs__' + $lvl; |
|
var $it = it.util.copy(it); |
|
var $closingBraces = ''; |
|
$it.level++; |
|
var $nextValid = 'valid' + $it.level; |
|
var $schemaDeps = {}, |
|
$propertyDeps = {}, |
|
$ownProperties = it.opts.ownProperties; |
|
for ($property in $schema) { |
|
var $sch = $schema[$property]; |
|
var $deps = Array.isArray($sch) ? $propertyDeps : $schemaDeps; |
|
$deps[$property] = $sch; |
|
} |
|
out += 'var ' + ($errs) + ' = errors;'; |
|
var $currentErrorPath = it.errorPath; |
|
out += 'var missing' + ($lvl) + ';'; |
|
for (var $property in $propertyDeps) { |
|
$deps = $propertyDeps[$property]; |
|
if ($deps.length) { |
|
out += ' if ( ' + ($data) + (it.util.getProperty($property)) + ' !== undefined '; |
|
if ($ownProperties) { |
|
out += ' && Object.prototype.hasOwnProperty.call(' + ($data) + ', \'' + (it.util.escapeQuotes($property)) + '\') '; |
|
} |
|
if ($breakOnError) { |
|
out += ' && ( '; |
|
var arr1 = $deps; |
|
if (arr1) { |
|
var $propertyKey, $i = -1, |
|
l1 = arr1.length - 1; |
|
while ($i < l1) { |
|
$propertyKey = arr1[$i += 1]; |
|
if ($i) { |
|
out += ' || '; |
|
} |
|
var $prop = it.util.getProperty($propertyKey), |
|
$useData = $data + $prop; |
|
out += ' ( ( ' + ($useData) + ' === undefined '; |
|
if ($ownProperties) { |
|
out += ' || ! Object.prototype.hasOwnProperty.call(' + ($data) + ', \'' + (it.util.escapeQuotes($propertyKey)) + '\') '; |
|
} |
|
out += ') && (missing' + ($lvl) + ' = ' + (it.util.toQuotedString(it.opts.jsonPointers ? $propertyKey : $prop)) + ') ) '; |
|
} |
|
} |
|
out += ')) { '; |
|
var $propertyPath = 'missing' + $lvl, |
|
$missingProperty = '\' + ' + $propertyPath + ' + \''; |
|
if (it.opts._errorDataPathProperty) { |
|
it.errorPath = it.opts.jsonPointers ? it.util.getPathExpr($currentErrorPath, $propertyPath, true) : $currentErrorPath + ' + ' + $propertyPath; |
|
} |
|
var $$outStack = $$outStack || []; |
|
$$outStack.push(out); |
|
out = ''; /* istanbul ignore else */ |
|
if (it.createErrors !== false) { |
|
out += ' { keyword: \'' + ('dependencies') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { property: \'' + (it.util.escapeQuotes($property)) + '\', missingProperty: \'' + ($missingProperty) + '\', depsCount: ' + ($deps.length) + ', deps: \'' + (it.util.escapeQuotes($deps.length == 1 ? $deps[0] : $deps.join(", "))) + '\' } '; |
|
if (it.opts.messages !== false) { |
|
out += ' , message: \'should have '; |
|
if ($deps.length == 1) { |
|
out += 'property ' + (it.util.escapeQuotes($deps[0])); |
|
} else { |
|
out += 'properties ' + (it.util.escapeQuotes($deps.join(", "))); |
|
} |
|
out += ' when property ' + (it.util.escapeQuotes($property)) + ' is present\' '; |
|
} |
|
if (it.opts.verbose) { |
|
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|
} |
|
out += ' } '; |
|
} else { |
|
out += ' {} '; |
|
} |
|
var __err = out; |
|
out = $$outStack.pop(); |
|
if (!it.compositeRule && $breakOnError) { /* istanbul ignore if */ |
|
if (it.async) { |
|
out += ' throw new ValidationError([' + (__err) + ']); '; |
|
} else { |
|
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|
} |
|
} else { |
|
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|
} |
|
} else { |
|
out += ' ) { '; |
|
var arr2 = $deps; |
|
if (arr2) { |
|
var $propertyKey, i2 = -1, |
|
l2 = arr2.length - 1; |
|
while (i2 < l2) { |
|
$propertyKey = arr2[i2 += 1]; |
|
var $prop = it.util.getProperty($propertyKey), |
|
$missingProperty = it.util.escapeQuotes($propertyKey), |
|
$useData = $data + $prop; |
|
if (it.opts._errorDataPathProperty) { |
|
it.errorPath = it.util.getPath($currentErrorPath, $propertyKey, it.opts.jsonPointers); |
|
} |
|
out += ' if ( ' + ($useData) + ' === undefined '; |
|
if ($ownProperties) { |
|
out += ' || ! Object.prototype.hasOwnProperty.call(' + ($data) + ', \'' + (it.util.escapeQuotes($propertyKey)) + '\') '; |
|
} |
|
out += ') { var err = '; /* istanbul ignore else */ |
|
if (it.createErrors !== false) { |
|
out += ' { keyword: \'' + ('dependencies') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { property: \'' + (it.util.escapeQuotes($property)) + '\', missingProperty: \'' + ($missingProperty) + '\', depsCount: ' + ($deps.length) + ', deps: \'' + (it.util.escapeQuotes($deps.length == 1 ? $deps[0] : $deps.join(", "))) + '\' } '; |
|
if (it.opts.messages !== false) { |
|
out += ' , message: \'should have '; |
|
if ($deps.length == 1) { |
|
out += 'property ' + (it.util.escapeQuotes($deps[0])); |
|
} else { |
|
out += 'properties ' + (it.util.escapeQuotes($deps.join(", "))); |
|
} |
|
out += ' when property ' + (it.util.escapeQuotes($property)) + ' is present\' '; |
|
} |
|
if (it.opts.verbose) { |
|
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|
} |
|
out += ' } '; |
|
} else { |
|
out += ' {} '; |
|
} |
|
out += '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; } '; |
|
} |
|
} |
|
} |
|
out += ' } '; |
|
if ($breakOnError) { |
|
$closingBraces += '}'; |
|
out += ' else { '; |
|
} |
|
} |
|
} |
|
it.errorPath = $currentErrorPath; |
|
var $currentBaseId = $it.baseId; |
|
for (var $property in $schemaDeps) { |
|
var $sch = $schemaDeps[$property]; |
|
if (it.util.schemaHasRules($sch, it.RULES.all)) { |
|
out += ' ' + ($nextValid) + ' = true; if ( ' + ($data) + (it.util.getProperty($property)) + ' !== undefined '; |
|
if ($ownProperties) { |
|
out += ' && Object.prototype.hasOwnProperty.call(' + ($data) + ', \'' + (it.util.escapeQuotes($property)) + '\') '; |
|
} |
|
out += ') { '; |
|
$it.schema = $sch; |
|
$it.schemaPath = $schemaPath + it.util.getProperty($property); |
|
$it.errSchemaPath = $errSchemaPath + '/' + it.util.escapeFragment($property); |
|
out += ' ' + (it.validate($it)) + ' '; |
|
$it.baseId = $currentBaseId; |
|
out += ' } '; |
|
if ($breakOnError) { |
|
out += ' if (' + ($nextValid) + ') { '; |
|
$closingBraces += '}'; |
|
} |
|
} |
|
} |
|
if ($breakOnError) { |
|
out += ' ' + ($closingBraces) + ' if (' + ($errs) + ' == errors) {'; |
|
} |
|
out = it.util.cleanUpCode(out); |
|
return out; |
|
} |
|
|
|
},{}],23:[function(require,module,exports){ |
|
'use strict'; |
|
module.exports = function generate_enum(it, $keyword, $ruleType) { |
|
var out = ' '; |
|
var $lvl = it.level; |
|
var $dataLvl = it.dataLevel; |
|
var $schema = it.schema[$keyword]; |
|
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|
var $breakOnError = !it.opts.allErrors; |
|
var $data = 'data' + ($dataLvl || ''); |
|
var $valid = 'valid' + $lvl; |
|
var $isData = it.opts.$data && $schema && $schema.$data, |
|
$schemaValue; |
|
if ($isData) { |
|
out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; '; |
|
$schemaValue = 'schema' + $lvl; |
|
} else { |
|
$schemaValue = $schema; |
|
} |
|
var $i = 'i' + $lvl, |
|
$vSchema = 'schema' + $lvl; |
|
if (!$isData) { |
|
out += ' var ' + ($vSchema) + ' = validate.schema' + ($schemaPath) + ';'; |
|
} |
|
out += 'var ' + ($valid) + ';'; |
|
if ($isData) { |
|
out += ' if (schema' + ($lvl) + ' === undefined) ' + ($valid) + ' = true; else if (!Array.isArray(schema' + ($lvl) + ')) ' + ($valid) + ' = false; else {'; |
|
} |
|
out += '' + ($valid) + ' = false;for (var ' + ($i) + '=0; ' + ($i) + '<' + ($vSchema) + '.length; ' + ($i) + '++) if (equal(' + ($data) + ', ' + ($vSchema) + '[' + ($i) + '])) { ' + ($valid) + ' = true; break; }'; |
|
if ($isData) { |
|
out += ' } '; |
|
} |
|
out += ' if (!' + ($valid) + ') { '; |
|
var $$outStack = $$outStack || []; |
|
$$outStack.push(out); |
|
out = ''; /* istanbul ignore else */ |
|
if (it.createErrors !== false) { |
|
out += ' { keyword: \'' + ('enum') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { allowedValues: schema' + ($lvl) + ' } '; |
|
if (it.opts.messages !== false) { |
|
out += ' , message: \'should be equal to one of the allowed values\' '; |
|
} |
|
if (it.opts.verbose) { |
|
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|
} |
|
out += ' } '; |
|
} else { |
|
out += ' {} '; |
|
} |
|
var __err = out; |
|
out = $$outStack.pop(); |
|
if (!it.compositeRule && $breakOnError) { /* istanbul ignore if */ |
|
if (it.async) { |
|
out += ' throw new ValidationError([' + (__err) + ']); '; |
|
} else { |
|
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|
} |
|
} else { |
|
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|
} |
|
out += ' }'; |
|
if ($breakOnError) { |
|
out += ' else { '; |
|
} |
|
return out; |
|
} |
|
|
|
},{}],24:[function(require,module,exports){ |
|
'use strict'; |
|
module.exports = function generate_format(it, $keyword, $ruleType) { |
|
var out = ' '; |
|
var $lvl = it.level; |
|
var $dataLvl = it.dataLevel; |
|
var $schema = it.schema[$keyword]; |
|
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|
var $breakOnError = !it.opts.allErrors; |
|
var $data = 'data' + ($dataLvl || ''); |
|
if (it.opts.format === false) { |
|
if ($breakOnError) { |
|
out += ' if (true) { '; |
|
} |
|
return out; |
|
} |
|
var $isData = it.opts.$data && $schema && $schema.$data, |
|
$schemaValue; |
|
if ($isData) { |
|
out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; '; |
|
$schemaValue = 'schema' + $lvl; |
|
} else { |
|
$schemaValue = $schema; |
|
} |
|
var $unknownFormats = it.opts.unknownFormats, |
|
$allowUnknown = Array.isArray($unknownFormats); |
|
if ($isData) { |
|
var $format = 'format' + $lvl, |
|
$isObject = 'isObject' + $lvl, |
|
$formatType = 'formatType' + $lvl; |
|
out += ' var ' + ($format) + ' = formats[' + ($schemaValue) + ']; var ' + ($isObject) + ' = typeof ' + ($format) + ' == \'object\' && !(' + ($format) + ' instanceof RegExp) && ' + ($format) + '.validate; var ' + ($formatType) + ' = ' + ($isObject) + ' && ' + ($format) + '.type || \'string\'; if (' + ($isObject) + ') { '; |
|
if (it.async) { |
|
out += ' var async' + ($lvl) + ' = ' + ($format) + '.async; '; |
|
} |
|
out += ' ' + ($format) + ' = ' + ($format) + '.validate; } if ( '; |
|
if ($isData) { |
|
out += ' (' + ($schemaValue) + ' !== undefined && typeof ' + ($schemaValue) + ' != \'string\') || '; |
|
} |
|
out += ' ('; |
|
if ($unknownFormats != 'ignore') { |
|
out += ' (' + ($schemaValue) + ' && !' + ($format) + ' '; |
|
if ($allowUnknown) { |
|
out += ' && self._opts.unknownFormats.indexOf(' + ($schemaValue) + ') == -1 '; |
|
} |
|
out += ') || '; |
|
} |
|
out += ' (' + ($format) + ' && ' + ($formatType) + ' == \'' + ($ruleType) + '\' && !(typeof ' + ($format) + ' == \'function\' ? '; |
|
if (it.async) { |
|
out += ' (async' + ($lvl) + ' ? ' + (it.yieldAwait) + ' ' + ($format) + '(' + ($data) + ') : ' + ($format) + '(' + ($data) + ')) '; |
|
} else { |
|
out += ' ' + ($format) + '(' + ($data) + ') '; |
|
} |
|
out += ' : ' + ($format) + '.test(' + ($data) + '))))) {'; |
|
} else { |
|
var $format = it.formats[$schema]; |
|
if (!$format) { |
|
if ($unknownFormats == 'ignore') { |
|
it.logger.warn('unknown format "' + $schema + '" ignored in schema at path "' + it.errSchemaPath + '"'); |
|
if ($breakOnError) { |
|
out += ' if (true) { '; |
|
} |
|
return out; |
|
} else if ($allowUnknown && $unknownFormats.indexOf($schema) >= 0) { |
|
if ($breakOnError) { |
|
out += ' if (true) { '; |
|
} |
|
return out; |
|
} else { |
|
throw new Error('unknown format "' + $schema + '" is used in schema at path "' + it.errSchemaPath + '"'); |
|
} |
|
} |
|
var $isObject = typeof $format == 'object' && !($format instanceof RegExp) && $format.validate; |
|
var $formatType = $isObject && $format.type || 'string'; |
|
if ($isObject) { |
|
var $async = $format.async === true; |
|
$format = $format.validate; |
|
} |
|
if ($formatType != $ruleType) { |
|
if ($breakOnError) { |
|
out += ' if (true) { '; |
|
} |
|
return out; |
|
} |
|
if ($async) { |
|
if (!it.async) throw new Error('async format in sync schema'); |
|
var $formatRef = 'formats' + it.util.getProperty($schema) + '.validate'; |
|
out += ' if (!(' + (it.yieldAwait) + ' ' + ($formatRef) + '(' + ($data) + '))) { '; |
|
} else { |
|
out += ' if (! '; |
|
var $formatRef = 'formats' + it.util.getProperty($schema); |
|
if ($isObject) $formatRef += '.validate'; |
|
if (typeof $format == 'function') { |
|
out += ' ' + ($formatRef) + '(' + ($data) + ') '; |
|
} else { |
|
out += ' ' + ($formatRef) + '.test(' + ($data) + ') '; |
|
} |
|
out += ') { '; |
|
} |
|
} |
|
var $$outStack = $$outStack || []; |
|
$$outStack.push(out); |
|
out = ''; /* istanbul ignore else */ |
|
if (it.createErrors !== false) { |
|
out += ' { keyword: \'' + ('format') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { format: '; |
|
if ($isData) { |
|
out += '' + ($schemaValue); |
|
} else { |
|
out += '' + (it.util.toQuotedString($schema)); |
|
} |
|
out += ' } '; |
|
if (it.opts.messages !== false) { |
|
out += ' , message: \'should match format "'; |
|
if ($isData) { |
|
out += '\' + ' + ($schemaValue) + ' + \''; |
|
} else { |
|
out += '' + (it.util.escapeQuotes($schema)); |
|
} |
|
out += '"\' '; |
|
} |
|
if (it.opts.verbose) { |
|
out += ' , schema: '; |
|
if ($isData) { |
|
out += 'validate.schema' + ($schemaPath); |
|
} else { |
|
out += '' + (it.util.toQuotedString($schema)); |
|
} |
|
out += ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|
} |
|
out += ' } '; |
|
} else { |
|
out += ' {} '; |
|
} |
|
var __err = out; |
|
out = $$outStack.pop(); |
|
if (!it.compositeRule && $breakOnError) { /* istanbul ignore if */ |
|
if (it.async) { |
|
out += ' throw new ValidationError([' + (__err) + ']); '; |
|
} else { |
|
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|
} |
|
} else { |
|
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|
} |
|
out += ' } '; |
|
if ($breakOnError) { |
|
out += ' else { '; |
|
} |
|
return out; |
|
} |
|
|
|
},{}],25:[function(require,module,exports){ |
|
'use strict'; |
|
module.exports = function generate_items(it, $keyword, $ruleType) { |
|
var out = ' '; |
|
var $lvl = it.level; |
|
var $dataLvl = it.dataLevel; |
|
var $schema = it.schema[$keyword]; |
|
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|
var $breakOnError = !it.opts.allErrors; |
|
var $data = 'data' + ($dataLvl || ''); |
|
var $valid = 'valid' + $lvl; |
|
var $errs = 'errs__' + $lvl; |
|
var $it = it.util.copy(it); |
|
var $closingBraces = ''; |
|
$it.level++; |
|
var $nextValid = 'valid' + $it.level; |
|
var $idx = 'i' + $lvl, |
|
$dataNxt = $it.dataLevel = it.dataLevel + 1, |
|
$nextData = 'data' + $dataNxt, |
|
$currentBaseId = it.baseId; |
|
out += 'var ' + ($errs) + ' = errors;var ' + ($valid) + ';'; |
|
if (Array.isArray($schema)) { |
|
var $additionalItems = it.schema.additionalItems; |
|
if ($additionalItems === false) { |
|
out += ' ' + ($valid) + ' = ' + ($data) + '.length <= ' + ($schema.length) + '; '; |
|
var $currErrSchemaPath = $errSchemaPath; |
|
$errSchemaPath = it.errSchemaPath + '/additionalItems'; |
|
out += ' if (!' + ($valid) + ') { '; |
|
var $$outStack = $$outStack || []; |
|
$$outStack.push(out); |
|
out = ''; /* istanbul ignore else */ |
|
if (it.createErrors !== false) { |
|
out += ' { keyword: \'' + ('additionalItems') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { limit: ' + ($schema.length) + ' } '; |
|
if (it.opts.messages !== false) { |
|
out += ' , message: \'should NOT have more than ' + ($schema.length) + ' items\' '; |
|
} |
|
if (it.opts.verbose) { |
|
out += ' , schema: false , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|
} |
|
out += ' } '; |
|
} else { |
|
out += ' {} '; |
|
} |
|
var __err = out; |
|
out = $$outStack.pop(); |
|
if (!it.compositeRule && $breakOnError) { /* istanbul ignore if */ |
|
if (it.async) { |
|
out += ' throw new ValidationError([' + (__err) + ']); '; |
|
} else { |
|
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|
} |
|
} else { |
|
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|
} |
|
out += ' } '; |
|
$errSchemaPath = $currErrSchemaPath; |
|
if ($breakOnError) { |
|
$closingBraces += '}'; |
|
out += ' else { '; |
|
} |
|
} |
|
var arr1 = $schema; |
|
if (arr1) { |
|
var $sch, $i = -1, |
|
l1 = arr1.length - 1; |
|
while ($i < l1) { |
|
$sch = arr1[$i += 1]; |
|
if (it.util.schemaHasRules($sch, it.RULES.all)) { |
|
out += ' ' + ($nextValid) + ' = true; if (' + ($data) + '.length > ' + ($i) + ') { '; |
|
var $passData = $data + '[' + $i + ']'; |
|
$it.schema = $sch; |
|
$it.schemaPath = $schemaPath + '[' + $i + ']'; |
|
$it.errSchemaPath = $errSchemaPath + '/' + $i; |
|
$it.errorPath = it.util.getPathExpr(it.errorPath, $i, it.opts.jsonPointers, true); |
|
$it.dataPathArr[$dataNxt] = $i; |
|
var $code = it.validate($it); |
|
$it.baseId = $currentBaseId; |
|
if (it.util.varOccurences($code, $nextData) < 2) { |
|
out += ' ' + (it.util.varReplace($code, $nextData, $passData)) + ' '; |
|
} else { |
|
out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ' + ($code) + ' '; |
|
} |
|
out += ' } '; |
|
if ($breakOnError) { |
|
out += ' if (' + ($nextValid) + ') { '; |
|
$closingBraces += '}'; |
|
} |
|
} |
|
} |
|
} |
|
if (typeof $additionalItems == 'object' && it.util.schemaHasRules($additionalItems, it.RULES.all)) { |
|
$it.schema = $additionalItems; |
|
$it.schemaPath = it.schemaPath + '.additionalItems'; |
|
$it.errSchemaPath = it.errSchemaPath + '/additionalItems'; |
|
out += ' ' + ($nextValid) + ' = true; if (' + ($data) + '.length > ' + ($schema.length) + ') { for (var ' + ($idx) + ' = ' + ($schema.length) + '; ' + ($idx) + ' < ' + ($data) + '.length; ' + ($idx) + '++) { '; |
|
$it.errorPath = it.util.getPathExpr(it.errorPath, $idx, it.opts.jsonPointers, true); |
|
var $passData = $data + '[' + $idx + ']'; |
|
$it.dataPathArr[$dataNxt] = $idx; |
|
var $code = it.validate($it); |
|
$it.baseId = $currentBaseId; |
|
if (it.util.varOccurences($code, $nextData) < 2) { |
|
out += ' ' + (it.util.varReplace($code, $nextData, $passData)) + ' '; |
|
} else { |
|
out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ' + ($code) + ' '; |
|
} |
|
if ($breakOnError) { |
|
out += ' if (!' + ($nextValid) + ') break; '; |
|
} |
|
out += ' } } '; |
|
if ($breakOnError) { |
|
out += ' if (' + ($nextValid) + ') { '; |
|
$closingBraces += '}'; |
|
} |
|
} |
|
} else if (it.util.schemaHasRules($schema, it.RULES.all)) { |
|
$it.schema = $schema; |
|
$it.schemaPath = $schemaPath; |
|
$it.errSchemaPath = $errSchemaPath; |
|
out += ' for (var ' + ($idx) + ' = ' + (0) + '; ' + ($idx) + ' < ' + ($data) + '.length; ' + ($idx) + '++) { '; |
|
$it.errorPath = it.util.getPathExpr(it.errorPath, $idx, it.opts.jsonPointers, true); |
|
var $passData = $data + '[' + $idx + ']'; |
|
$it.dataPathArr[$dataNxt] = $idx; |
|
var $code = it.validate($it); |
|
$it.baseId = $currentBaseId; |
|
if (it.util.varOccurences($code, $nextData) < 2) { |
|
out += ' ' + (it.util.varReplace($code, $nextData, $passData)) + ' '; |
|
} else { |
|
out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ' + ($code) + ' '; |
|
} |
|
if ($breakOnError) { |
|
out += ' if (!' + ($nextValid) + ') break; '; |
|
} |
|
out += ' }'; |
|
} |
|
if ($breakOnError) { |
|
out += ' ' + ($closingBraces) + ' if (' + ($errs) + ' == errors) {'; |
|
} |
|
out = it.util.cleanUpCode(out); |
|
return out; |
|
} |
|
|
|
},{}],26:[function(require,module,exports){ |
|
'use strict'; |
|
module.exports = function generate_multipleOf(it, $keyword, $ruleType) { |
|
var out = ' '; |
|
var $lvl = it.level; |
|
var $dataLvl = it.dataLevel; |
|
var $schema = it.schema[$keyword]; |
|
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|
var $breakOnError = !it.opts.allErrors; |
|
var $data = 'data' + ($dataLvl || ''); |
|
var $isData = it.opts.$data && $schema && $schema.$data, |
|
$schemaValue; |
|
if ($isData) { |
|
out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; '; |
|
$schemaValue = 'schema' + $lvl; |
|
} else { |
|
$schemaValue = $schema; |
|
} |
|
out += 'var division' + ($lvl) + ';if ('; |
|
if ($isData) { |
|
out += ' ' + ($schemaValue) + ' !== undefined && ( typeof ' + ($schemaValue) + ' != \'number\' || '; |
|
} |
|
out += ' (division' + ($lvl) + ' = ' + ($data) + ' / ' + ($schemaValue) + ', '; |
|
if (it.opts.multipleOfPrecision) { |
|
out += ' Math.abs(Math.round(division' + ($lvl) + ') - division' + ($lvl) + ') > 1e-' + (it.opts.multipleOfPrecision) + ' '; |
|
} else { |
|
out += ' division' + ($lvl) + ' !== parseInt(division' + ($lvl) + ') '; |
|
} |
|
out += ' ) '; |
|
if ($isData) { |
|
out += ' ) '; |
|
} |
|
out += ' ) { '; |
|
var $$outStack = $$outStack || []; |
|
$$outStack.push(out); |
|
out = ''; /* istanbul ignore else */ |
|
if (it.createErrors !== false) { |
|
out += ' { keyword: \'' + ('multipleOf') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { multipleOf: ' + ($schemaValue) + ' } '; |
|
if (it.opts.messages !== false) { |
|
out += ' , message: \'should be multiple of '; |
|
if ($isData) { |
|
out += '\' + ' + ($schemaValue); |
|
} else { |
|
out += '' + ($schemaValue) + '\''; |
|
} |
|
} |
|
if (it.opts.verbose) { |
|
out += ' , schema: '; |
|
if ($isData) { |
|
out += 'validate.schema' + ($schemaPath); |
|
} else { |
|
out += '' + ($schema); |
|
} |
|
out += ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|
} |
|
out += ' } '; |
|
} else { |
|
out += ' {} '; |
|
} |
|
var __err = out; |
|
out = $$outStack.pop(); |
|
if (!it.compositeRule && $breakOnError) { /* istanbul ignore if */ |
|
if (it.async) { |
|
out += ' throw new ValidationError([' + (__err) + ']); '; |
|
} else { |
|
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|
} |
|
} else { |
|
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|
} |
|
out += '} '; |
|
if ($breakOnError) { |
|
out += ' else { '; |
|
} |
|
return out; |
|
} |
|
|
|
},{}],27:[function(require,module,exports){ |
|
'use strict'; |
|
module.exports = function generate_not(it, $keyword, $ruleType) { |
|
var out = ' '; |
|
var $lvl = it.level; |
|
var $dataLvl = it.dataLevel; |
|
var $schema = it.schema[$keyword]; |
|
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|
var $breakOnError = !it.opts.allErrors; |
|
var $data = 'data' + ($dataLvl || ''); |
|
var $errs = 'errs__' + $lvl; |
|
var $it = it.util.copy(it); |
|
$it.level++; |
|
var $nextValid = 'valid' + $it.level; |
|
if (it.util.schemaHasRules($schema, it.RULES.all)) { |
|
$it.schema = $schema; |
|
$it.schemaPath = $schemaPath; |
|
$it.errSchemaPath = $errSchemaPath; |
|
out += ' var ' + ($errs) + ' = errors; '; |
|
var $wasComposite = it.compositeRule; |
|
it.compositeRule = $it.compositeRule = true; |
|
$it.createErrors = false; |
|
var $allErrorsOption; |
|
if ($it.opts.allErrors) { |
|
$allErrorsOption = $it.opts.allErrors; |
|
$it.opts.allErrors = false; |
|
} |
|
out += ' ' + (it.validate($it)) + ' '; |
|
$it.createErrors = true; |
|
if ($allErrorsOption) $it.opts.allErrors = $allErrorsOption; |
|
it.compositeRule = $it.compositeRule = $wasComposite; |
|
out += ' if (' + ($nextValid) + ') { '; |
|
var $$outStack = $$outStack || []; |
|
$$outStack.push(out); |
|
out = ''; /* istanbul ignore else */ |
|
if (it.createErrors !== false) { |
|
out += ' { keyword: \'' + ('not') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: {} '; |
|
if (it.opts.messages !== false) { |
|
out += ' , message: \'should NOT be valid\' '; |
|
} |
|
if (it.opts.verbose) { |
|
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|
} |
|
out += ' } '; |
|
} else { |
|
out += ' {} '; |
|
} |
|
var __err = out; |
|
out = $$outStack.pop(); |
|
if (!it.compositeRule && $breakOnError) { /* istanbul ignore if */ |
|
if (it.async) { |
|
out += ' throw new ValidationError([' + (__err) + ']); '; |
|
} else { |
|
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|
} |
|
} else { |
|
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|
} |
|
out += ' } else { errors = ' + ($errs) + '; if (vErrors !== null) { if (' + ($errs) + ') vErrors.length = ' + ($errs) + '; else vErrors = null; } '; |
|
if (it.opts.allErrors) { |
|
out += ' } '; |
|
} |
|
} else { |
|
out += ' var err = '; /* istanbul ignore else */ |
|
if (it.createErrors !== false) { |
|
out += ' { keyword: \'' + ('not') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: {} '; |
|
if (it.opts.messages !== false) { |
|
out += ' , message: \'should NOT be valid\' '; |
|
} |
|
if (it.opts.verbose) { |
|
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|
} |
|
out += ' } '; |
|
} else { |
|
out += ' {} '; |
|
} |
|
out += '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|
if ($breakOnError) { |
|
out += ' if (false) { '; |
|
} |
|
} |
|
return out; |
|
} |
|
|
|
},{}],28:[function(require,module,exports){ |
|
'use strict'; |
|
module.exports = function generate_oneOf(it, $keyword, $ruleType) { |
|
var out = ' '; |
|
var $lvl = it.level; |
|
var $dataLvl = it.dataLevel; |
|
var $schema = it.schema[$keyword]; |
|
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|
var $breakOnError = !it.opts.allErrors; |
|
var $data = 'data' + ($dataLvl || ''); |
|
var $valid = 'valid' + $lvl; |
|
var $errs = 'errs__' + $lvl; |
|
var $it = it.util.copy(it); |
|
var $closingBraces = ''; |
|
$it.level++; |
|
var $nextValid = 'valid' + $it.level; |
|
out += 'var ' + ($errs) + ' = errors;var prevValid' + ($lvl) + ' = false;var ' + ($valid) + ' = false;'; |
|
var $currentBaseId = $it.baseId; |
|
var $wasComposite = it.compositeRule; |
|
it.compositeRule = $it.compositeRule = true; |
|
var arr1 = $schema; |
|
if (arr1) { |
|
var $sch, $i = -1, |
|
l1 = arr1.length - 1; |
|
while ($i < l1) { |
|
$sch = arr1[$i += 1]; |
|
if (it.util.schemaHasRules($sch, it.RULES.all)) { |
|
$it.schema = $sch; |
|
$it.schemaPath = $schemaPath + '[' + $i + ']'; |
|
$it.errSchemaPath = $errSchemaPath + '/' + $i; |
|
out += ' ' + (it.validate($it)) + ' '; |
|
$it.baseId = $currentBaseId; |
|
} else { |
|
out += ' var ' + ($nextValid) + ' = true; '; |
|
} |
|
if ($i) { |
|
out += ' if (' + ($nextValid) + ' && prevValid' + ($lvl) + ') ' + ($valid) + ' = false; else { '; |
|
$closingBraces += '}'; |
|
} |
|
out += ' if (' + ($nextValid) + ') ' + ($valid) + ' = prevValid' + ($lvl) + ' = true;'; |
|
} |
|
} |
|
it.compositeRule = $it.compositeRule = $wasComposite; |
|
out += '' + ($closingBraces) + 'if (!' + ($valid) + ') { var err = '; /* istanbul ignore else */ |
|
if (it.createErrors !== false) { |
|
out += ' { keyword: \'' + ('oneOf') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: {} '; |
|
if (it.opts.messages !== false) { |
|
out += ' , message: \'should match exactly one schema in oneOf\' '; |
|
} |
|
if (it.opts.verbose) { |
|
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|
} |
|
out += ' } '; |
|
} else { |
|
out += ' {} '; |
|
} |
|
out += '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|
if (!it.compositeRule && $breakOnError) { /* istanbul ignore if */ |
|
if (it.async) { |
|
out += ' throw new ValidationError(vErrors); '; |
|
} else { |
|
out += ' validate.errors = vErrors; return false; '; |
|
} |
|
} |
|
out += '} else { errors = ' + ($errs) + '; if (vErrors !== null) { if (' + ($errs) + ') vErrors.length = ' + ($errs) + '; else vErrors = null; }'; |
|
if (it.opts.allErrors) { |
|
out += ' } '; |
|
} |
|
return out; |
|
} |
|
|
|
},{}],29:[function(require,module,exports){ |
|
'use strict'; |
|
module.exports = function generate_pattern(it, $keyword, $ruleType) { |
|
var out = ' '; |
|
var $lvl = it.level; |
|
var $dataLvl = it.dataLevel; |
|
var $schema = it.schema[$keyword]; |
|
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|
var $breakOnError = !it.opts.allErrors; |
|
var $data = 'data' + ($dataLvl || ''); |
|
var $isData = it.opts.$data && $schema && $schema.$data, |
|
$schemaValue; |
|
if ($isData) { |
|
out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; '; |
|
$schemaValue = 'schema' + $lvl; |
|
} else { |
|
$schemaValue = $schema; |
|
} |
|
var $regexp = $isData ? '(new RegExp(' + $schemaValue + '))' : it.usePattern($schema); |
|
out += 'if ( '; |
|
if ($isData) { |
|
out += ' (' + ($schemaValue) + ' !== undefined && typeof ' + ($schemaValue) + ' != \'string\') || '; |
|
} |
|
out += ' !' + ($regexp) + '.test(' + ($data) + ') ) { '; |
|
var $$outStack = $$outStack || []; |
|
$$outStack.push(out); |
|
out = ''; /* istanbul ignore else */ |
|
if (it.createErrors !== false) { |
|
out += ' { keyword: \'' + ('pattern') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { pattern: '; |
|
if ($isData) { |
|
out += '' + ($schemaValue); |
|
} else { |
|
out += '' + (it.util.toQuotedString($schema)); |
|
} |
|
out += ' } '; |
|
if (it.opts.messages !== false) { |
|
out += ' , message: \'should match pattern "'; |
|
if ($isData) { |
|
out += '\' + ' + ($schemaValue) + ' + \''; |
|
} else { |
|
out += '' + (it.util.escapeQuotes($schema)); |
|
} |
|
out += '"\' '; |
|
} |
|
if (it.opts.verbose) { |
|
out += ' , schema: '; |
|
if ($isData) { |
|
out += 'validate.schema' + ($schemaPath); |
|
} else { |
|
out += '' + (it.util.toQuotedString($schema)); |
|
} |
|
out += ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|
} |
|
out += ' } '; |
|
} else { |
|
out += ' {} '; |
|
} |
|
var __err = out; |
|
out = $$outStack.pop(); |
|
if (!it.compositeRule && $breakOnError) { /* istanbul ignore if */ |
|
if (it.async) { |
|
out += ' throw new ValidationError([' + (__err) + ']); '; |
|
} else { |
|
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|
} |
|
} else { |
|
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|
} |
|
out += '} '; |
|
if ($breakOnError) { |
|
out += ' else { '; |
|
} |
|
return out; |
|
} |
|
|
|
},{}],30:[function(require,module,exports){ |
|
'use strict'; |
|
module.exports = function generate_properties(it, $keyword, $ruleType) { |
|
var out = ' '; |
|
var $lvl = it.level; |
|
var $dataLvl = it.dataLevel; |
|
var $schema = it.schema[$keyword]; |
|
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|
var $breakOnError = !it.opts.allErrors; |
|
var $data = 'data' + ($dataLvl || ''); |
|
var $valid = 'valid' + $lvl; |
|
var $errs = 'errs__' + $lvl; |
|
var $it = it.util.copy(it); |
|
var $closingBraces = ''; |
|
$it.level++; |
|
var $nextValid = 'valid' + $it.level; |
|
var $key = 'key' + $lvl, |
|
$idx = 'idx' + $lvl, |
|
$dataNxt = $it.dataLevel = it.dataLevel + 1, |
|
$nextData = 'data' + $dataNxt, |
|
$dataProperties = 'dataProperties' + $lvl; |
|
var $schemaKeys = Object.keys($schema || {}), |
|
$pProperties = it.schema.patternProperties || {}, |
|
$pPropertyKeys = Object.keys($pProperties), |
|
$aProperties = it.schema.additionalProperties, |
|
$someProperties = $schemaKeys.length || $pPropertyKeys.length, |
|
$noAdditional = $aProperties === false, |
|
$additionalIsSchema = typeof $aProperties == 'object' && Object.keys($aProperties).length, |
|
$removeAdditional = it.opts.removeAdditional, |
|
$checkAdditional = $noAdditional || $additionalIsSchema || $removeAdditional, |
|
$ownProperties = it.opts.ownProperties, |
|
$currentBaseId = it.baseId; |
|
var $required = it.schema.required; |
|
if ($required && !(it.opts.v5 && $required.$data) && $required.length < it.opts.loopRequired) var $requiredHash = it.util.toHash($required); |
|
if (it.opts.patternGroups) { |
|
var $pgProperties = it.schema.patternGroups || {}, |
|
$pgPropertyKeys = Object.keys($pgProperties); |
|
} |
|
out += 'var ' + ($errs) + ' = errors;var ' + ($nextValid) + ' = true;'; |
|
if ($ownProperties) { |
|
out += ' var ' + ($dataProperties) + ' = undefined;'; |
|
} |
|
if ($checkAdditional) { |
|
if ($ownProperties) { |
|
out += ' ' + ($dataProperties) + ' = ' + ($dataProperties) + ' || Object.keys(' + ($data) + '); for (var ' + ($idx) + '=0; ' + ($idx) + '<' + ($dataProperties) + '.length; ' + ($idx) + '++) { var ' + ($key) + ' = ' + ($dataProperties) + '[' + ($idx) + ']; '; |
|
} else { |
|
out += ' for (var ' + ($key) + ' in ' + ($data) + ') { '; |
|
} |
|
if ($someProperties) { |
|
out += ' var isAdditional' + ($lvl) + ' = !(false '; |
|
if ($schemaKeys.length) { |
|
if ($schemaKeys.length > 5) { |
|
out += ' || validate.schema' + ($schemaPath) + '[' + ($key) + '] '; |
|
} else { |
|
var arr1 = $schemaKeys; |
|
if (arr1) { |
|
var $propertyKey, i1 = -1, |
|
l1 = arr1.length - 1; |
|
while (i1 < l1) { |
|
$propertyKey = arr1[i1 += 1]; |
|
out += ' || ' + ($key) + ' == ' + (it.util.toQuotedString($propertyKey)) + ' '; |
|
} |
|
} |
|
} |
|
} |
|
if ($pPropertyKeys.length) { |
|
var arr2 = $pPropertyKeys; |
|
if (arr2) { |
|
var $pProperty, $i = -1, |
|
l2 = arr2.length - 1; |
|
while ($i < l2) { |
|
$pProperty = arr2[$i += 1]; |
|
out += ' || ' + (it.usePattern($pProperty)) + '.test(' + ($key) + ') '; |
|
} |
|
} |
|
} |
|
if (it.opts.patternGroups && $pgPropertyKeys.length) { |
|
var arr3 = $pgPropertyKeys; |
|
if (arr3) { |
|
var $pgProperty, $i = -1, |
|
l3 = arr3.length - 1; |
|
while ($i < l3) { |
|
$pgProperty = arr3[$i += 1]; |
|
out += ' || ' + (it.usePattern($pgProperty)) + '.test(' + ($key) + ') '; |
|
} |
|
} |
|
} |
|
out += ' ); if (isAdditional' + ($lvl) + ') { '; |
|
} |
|
if ($removeAdditional == 'all') { |
|
out += ' delete ' + ($data) + '[' + ($key) + ']; '; |
|
} else { |
|
var $currentErrorPath = it.errorPath; |
|
var $additionalProperty = '\' + ' + $key + ' + \''; |
|
if (it.opts._errorDataPathProperty) { |
|
it.errorPath = it.util.getPathExpr(it.errorPath, $key, it.opts.jsonPointers); |
|
} |
|
if ($noAdditional) { |
|
if ($removeAdditional) { |
|
out += ' delete ' + ($data) + '[' + ($key) + ']; '; |
|
} else { |
|
out += ' ' + ($nextValid) + ' = false; '; |
|
var $currErrSchemaPath = $errSchemaPath; |
|
$errSchemaPath = it.errSchemaPath + '/additionalProperties'; |
|
var $$outStack = $$outStack || []; |
|
$$outStack.push(out); |
|
out = ''; /* istanbul ignore else */ |
|
if (it.createErrors !== false) { |
|
out += ' { keyword: \'' + ('additionalProperties') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { additionalProperty: \'' + ($additionalProperty) + '\' } '; |
|
if (it.opts.messages !== false) { |
|
out += ' , message: \'should NOT have additional properties\' '; |
|
} |
|
if (it.opts.verbose) { |
|
out += ' , schema: false , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|
} |
|
out += ' } '; |
|
} else { |
|
out += ' {} '; |
|
} |
|
var __err = out; |
|
out = $$outStack.pop(); |
|
if (!it.compositeRule && $breakOnError) { /* istanbul ignore if */ |
|
if (it.async) { |
|
out += ' throw new ValidationError([' + (__err) + ']); '; |
|
} else { |
|
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|
} |
|
} else { |
|
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|
} |
|
$errSchemaPath = $currErrSchemaPath; |
|
if ($breakOnError) { |
|
out += ' break; '; |
|
} |
|
} |
|
} else if ($additionalIsSchema) { |
|
if ($removeAdditional == 'failing') { |
|
out += ' var ' + ($errs) + ' = errors; '; |
|
var $wasComposite = it.compositeRule; |
|
it.compositeRule = $it.compositeRule = true; |
|
$it.schema = $aProperties; |
|
$it.schemaPath = it.schemaPath + '.additionalProperties'; |
|
$it.errSchemaPath = it.errSchemaPath + '/additionalProperties'; |
|
$it.errorPath = it.opts._errorDataPathProperty ? it.errorPath : it.util.getPathExpr(it.errorPath, $key, it.opts.jsonPointers); |
|
var $passData = $data + '[' + $key + ']'; |
|
$it.dataPathArr[$dataNxt] = $key; |
|
var $code = it.validate($it); |
|
$it.baseId = $currentBaseId; |
|
if (it.util.varOccurences($code, $nextData) < 2) { |
|
out += ' ' + (it.util.varReplace($code, $nextData, $passData)) + ' '; |
|
} else { |
|
out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ' + ($code) + ' '; |
|
} |
|
out += ' if (!' + ($nextValid) + ') { errors = ' + ($errs) + '; if (validate.errors !== null) { if (errors) validate.errors.length = errors; else validate.errors = null; } delete ' + ($data) + '[' + ($key) + ']; } '; |
|
it.compositeRule = $it.compositeRule = $wasComposite; |
|
} else { |
|
$it.schema = $aProperties; |
|
$it.schemaPath = it.schemaPath + '.additionalProperties'; |
|
$it.errSchemaPath = it.errSchemaPath + '/additionalProperties'; |
|
$it.errorPath = it.opts._errorDataPathProperty ? it.errorPath : it.util.getPathExpr(it.errorPath, $key, it.opts.jsonPointers); |
|
var $passData = $data + '[' + $key + ']'; |
|
$it.dataPathArr[$dataNxt] = $key; |
|
var $code = it.validate($it); |
|
$it.baseId = $currentBaseId; |
|
if (it.util.varOccurences($code, $nextData) < 2) { |
|
out += ' ' + (it.util.varReplace($code, $nextData, $passData)) + ' '; |
|
} else { |
|
out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ' + ($code) + ' '; |
|
} |
|
if ($breakOnError) { |
|
out += ' if (!' + ($nextValid) + ') break; '; |
|
} |
|
} |
|
} |
|
it.errorPath = $currentErrorPath; |
|
} |
|
if ($someProperties) { |
|
out += ' } '; |
|
} |
|
out += ' } '; |
|
if ($breakOnError) { |
|
out += ' if (' + ($nextValid) + ') { '; |
|
$closingBraces += '}'; |
|
} |
|
} |
|
var $useDefaults = it.opts.useDefaults && !it.compositeRule; |
|
if ($schemaKeys.length) { |
|
var arr4 = $schemaKeys; |
|
if (arr4) { |
|
var $propertyKey, i4 = -1, |
|
l4 = arr4.length - 1; |
|
while (i4 < l4) { |
|
$propertyKey = arr4[i4 += 1]; |
|
var $sch = $schema[$propertyKey]; |
|
if (it.util.schemaHasRules($sch, it.RULES.all)) { |
|
var $prop = it.util.getProperty($propertyKey), |
|
$passData = $data + $prop, |
|
$hasDefault = $useDefaults && $sch.default !== undefined; |
|
$it.schema = $sch; |
|
$it.schemaPath = $schemaPath + $prop; |
|
$it.errSchemaPath = $errSchemaPath + '/' + it.util.escapeFragment($propertyKey); |
|
$it.errorPath = it.util.getPath(it.errorPath, $propertyKey, it.opts.jsonPointers); |
|
$it.dataPathArr[$dataNxt] = it.util.toQuotedString($propertyKey); |
|
var $code = it.validate($it); |
|
$it.baseId = $currentBaseId; |
|
if (it.util.varOccurences($code, $nextData) < 2) { |
|
$code = it.util.varReplace($code, $nextData, $passData); |
|
var $useData = $passData; |
|
} else { |
|
var $useData = $nextData; |
|
out += ' var ' + ($nextData) + ' = ' + ($passData) + '; '; |
|
} |
|
if ($hasDefault) { |
|
out += ' ' + ($code) + ' '; |
|
} else { |
|
if ($requiredHash && $requiredHash[$propertyKey]) { |
|
out += ' if ( ' + ($useData) + ' === undefined '; |
|
if ($ownProperties) { |
|
out += ' || ! Object.prototype.hasOwnProperty.call(' + ($data) + ', \'' + (it.util.escapeQuotes($propertyKey)) + '\') '; |
|
} |
|
out += ') { ' + ($nextValid) + ' = false; '; |
|
var $currentErrorPath = it.errorPath, |
|
$currErrSchemaPath = $errSchemaPath, |
|
$missingProperty = it.util.escapeQuotes($propertyKey); |
|
if (it.opts._errorDataPathProperty) { |
|
it.errorPath = it.util.getPath($currentErrorPath, $propertyKey, it.opts.jsonPointers); |
|
} |
|
$errSchemaPath = it.errSchemaPath + '/required'; |
|
var $$outStack = $$outStack || []; |
|
$$outStack.push(out); |
|
out = ''; /* istanbul ignore else */ |
|
if (it.createErrors !== false) { |
|
out += ' { keyword: \'' + ('required') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { missingProperty: \'' + ($missingProperty) + '\' } '; |
|
if (it.opts.messages !== false) { |
|
out += ' , message: \''; |
|
if (it.opts._errorDataPathProperty) { |
|
out += 'is a required property'; |
|
} else { |
|
out += 'should have required property \\\'' + ($missingProperty) + '\\\''; |
|
} |
|
out += '\' '; |
|
} |
|
if (it.opts.verbose) { |
|
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|
} |
|
out += ' } '; |
|
} else { |
|
out += ' {} '; |
|
} |
|
var __err = out; |
|
out = $$outStack.pop(); |
|
if (!it.compositeRule && $breakOnError) { /* istanbul ignore if */ |
|
if (it.async) { |
|
out += ' throw new ValidationError([' + (__err) + ']); '; |
|
} else { |
|
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|
} |
|
} else { |
|
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|
} |
|
$errSchemaPath = $currErrSchemaPath; |
|
it.errorPath = $currentErrorPath; |
|
out += ' } else { '; |
|
} else { |
|
if ($breakOnError) { |
|
out += ' if ( ' + ($useData) + ' === undefined '; |
|
if ($ownProperties) { |
|
out += ' || ! Object.prototype.hasOwnProperty.call(' + ($data) + ', \'' + (it.util.escapeQuotes($propertyKey)) + '\') '; |
|
} |
|
out += ') { ' + ($nextValid) + ' = true; } else { '; |
|
} else { |
|
out += ' if (' + ($useData) + ' !== undefined '; |
|
if ($ownProperties) { |
|
out += ' && Object.prototype.hasOwnProperty.call(' + ($data) + ', \'' + (it.util.escapeQuotes($propertyKey)) + '\') '; |
|
} |
|
out += ' ) { '; |
|
} |
|
} |
|
out += ' ' + ($code) + ' } '; |
|
} |
|
} |
|
if ($breakOnError) { |
|
out += ' if (' + ($nextValid) + ') { '; |
|
$closingBraces += '}'; |
|
} |
|
} |
|
} |
|
} |
|
if ($pPropertyKeys.length) { |
|
var arr5 = $pPropertyKeys; |
|
if (arr5) { |
|
var $pProperty, i5 = -1, |
|
l5 = arr5.length - 1; |
|
while (i5 < l5) { |
|
$pProperty = arr5[i5 += 1]; |
|
var $sch = $pProperties[$pProperty]; |
|
if (it.util.schemaHasRules($sch, it.RULES.all)) { |
|
$it.schema = $sch; |
|
$it.schemaPath = it.schemaPath + '.patternProperties' + it.util.getProperty($pProperty); |
|
$it.errSchemaPath = it.errSchemaPath + '/patternProperties/' + it.util.escapeFragment($pProperty); |
|
if ($ownProperties) { |
|
out += ' ' + ($dataProperties) + ' = ' + ($dataProperties) + ' || Object.keys(' + ($data) + '); for (var ' + ($idx) + '=0; ' + ($idx) + '<' + ($dataProperties) + '.length; ' + ($idx) + '++) { var ' + ($key) + ' = ' + ($dataProperties) + '[' + ($idx) + ']; '; |
|
} else { |
|
out += ' for (var ' + ($key) + ' in ' + ($data) + ') { '; |
|
} |
|
out += ' if (' + (it.usePattern($pProperty)) + '.test(' + ($key) + ')) { '; |
|
$it.errorPath = it.util.getPathExpr(it.errorPath, $key, it.opts.jsonPointers); |
|
var $passData = $data + '[' + $key + ']'; |
|
$it.dataPathArr[$dataNxt] = $key; |
|
var $code = it.validate($it); |
|
$it.baseId = $currentBaseId; |
|
if (it.util.varOccurences($code, $nextData) < 2) { |
|
out += ' ' + (it.util.varReplace($code, $nextData, $passData)) + ' '; |
|
} else { |
|
out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ' + ($code) + ' '; |
|
} |
|
if ($breakOnError) { |
|
out += ' if (!' + ($nextValid) + ') break; '; |
|
} |
|
out += ' } '; |
|
if ($breakOnError) { |
|
out += ' else ' + ($nextValid) + ' = true; '; |
|
} |
|
out += ' } '; |
|
if ($breakOnError) { |
|
out += ' if (' + ($nextValid) + ') { '; |
|
$closingBraces += '}'; |
|
} |
|
} |
|
} |
|
} |
|
} |
|
if (it.opts.patternGroups && $pgPropertyKeys.length) { |
|
var arr6 = $pgPropertyKeys; |
|
if (arr6) { |
|
var $pgProperty, i6 = -1, |
|
l6 = arr6.length - 1; |
|
while (i6 < l6) { |
|
$pgProperty = arr6[i6 += 1]; |
|
var $pgSchema = $pgProperties[$pgProperty], |
|
$sch = $pgSchema.schema; |
|
if (it.util.schemaHasRules($sch, it.RULES.all)) { |
|
$it.schema = $sch; |
|
$it.schemaPath = it.schemaPath + '.patternGroups' + it.util.getProperty($pgProperty) + '.schema'; |
|
$it.errSchemaPath = it.errSchemaPath + '/patternGroups/' + it.util.escapeFragment($pgProperty) + '/schema'; |
|
out += ' var pgPropCount' + ($lvl) + ' = 0; '; |
|
if ($ownProperties) { |
|
out += ' ' + ($dataProperties) + ' = ' + ($dataProperties) + ' || Object.keys(' + ($data) + '); for (var ' + ($idx) + '=0; ' + ($idx) + '<' + ($dataProperties) + '.length; ' + ($idx) + '++) { var ' + ($key) + ' = ' + ($dataProperties) + '[' + ($idx) + ']; '; |
|
} else { |
|
out += ' for (var ' + ($key) + ' in ' + ($data) + ') { '; |
|
} |
|
out += ' if (' + (it.usePattern($pgProperty)) + '.test(' + ($key) + ')) { pgPropCount' + ($lvl) + '++; '; |
|
$it.errorPath = it.util.getPathExpr(it.errorPath, $key, it.opts.jsonPointers); |
|
var $passData = $data + '[' + $key + ']'; |
|
$it.dataPathArr[$dataNxt] = $key; |
|
var $code = it.validate($it); |
|
$it.baseId = $currentBaseId; |
|
if (it.util.varOccurences($code, $nextData) < 2) { |
|
out += ' ' + (it.util.varReplace($code, $nextData, $passData)) + ' '; |
|
} else { |
|
out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ' + ($code) + ' '; |
|
} |
|
if ($breakOnError) { |
|
out += ' if (!' + ($nextValid) + ') break; '; |
|
} |
|
out += ' } '; |
|
if ($breakOnError) { |
|
out += ' else ' + ($nextValid) + ' = true; '; |
|
} |
|
out += ' } '; |
|
if ($breakOnError) { |
|
out += ' if (' + ($nextValid) + ') { '; |
|
$closingBraces += '}'; |
|
} |
|
var $pgMin = $pgSchema.minimum, |
|
$pgMax = $pgSchema.maximum; |
|
if ($pgMin !== undefined || $pgMax !== undefined) { |
|
out += ' var ' + ($valid) + ' = true; '; |
|
var $currErrSchemaPath = $errSchemaPath; |
|
if ($pgMin !== undefined) { |
|
var $limit = $pgMin, |
|
$reason = 'minimum', |
|
$moreOrLess = 'less'; |
|
out += ' ' + ($valid) + ' = pgPropCount' + ($lvl) + ' >= ' + ($pgMin) + '; '; |
|
$errSchemaPath = it.errSchemaPath + '/patternGroups/minimum'; |
|
out += ' if (!' + ($valid) + ') { '; |
|
var $$outStack = $$outStack || []; |
|
$$outStack.push(out); |
|
out = ''; /* istanbul ignore else */ |
|
if (it.createErrors !== false) { |
|
out += ' { keyword: \'' + ('patternGroups') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { reason: \'' + ($reason) + '\', limit: ' + ($limit) + ', pattern: \'' + (it.util.escapeQuotes($pgProperty)) + '\' } '; |
|
if (it.opts.messages !== false) { |
|
out += ' , message: \'should NOT have ' + ($moreOrLess) + ' than ' + ($limit) + ' properties matching pattern "' + (it.util.escapeQuotes($pgProperty)) + '"\' '; |
|
} |
|
if (it.opts.verbose) { |
|
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|
} |
|
out += ' } '; |
|
} else { |
|
out += ' {} '; |
|
} |
|
var __err = out; |
|
out = $$outStack.pop(); |
|
if (!it.compositeRule && $breakOnError) { /* istanbul ignore if */ |
|
if (it.async) { |
|
out += ' throw new ValidationError([' + (__err) + ']); '; |
|
} else { |
|
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|
} |
|
} else { |
|
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|
} |
|
out += ' } '; |
|
if ($pgMax !== undefined) { |
|
out += ' else '; |
|
} |
|
} |
|
if ($pgMax !== undefined) { |
|
var $limit = $pgMax, |
|
$reason = 'maximum', |
|
$moreOrLess = 'more'; |
|
out += ' ' + ($valid) + ' = pgPropCount' + ($lvl) + ' <= ' + ($pgMax) + '; '; |
|
$errSchemaPath = it.errSchemaPath + '/patternGroups/maximum'; |
|
out += ' if (!' + ($valid) + ') { '; |
|
var $$outStack = $$outStack || []; |
|
$$outStack.push(out); |
|
out = ''; /* istanbul ignore else */ |
|
if (it.createErrors !== false) { |
|
out += ' { keyword: \'' + ('patternGroups') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { reason: \'' + ($reason) + '\', limit: ' + ($limit) + ', pattern: \'' + (it.util.escapeQuotes($pgProperty)) + '\' } '; |
|
if (it.opts.messages !== false) { |
|
out += ' , message: \'should NOT have ' + ($moreOrLess) + ' than ' + ($limit) + ' properties matching pattern "' + (it.util.escapeQuotes($pgProperty)) + '"\' '; |
|
} |
|
if (it.opts.verbose) { |
|
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|
} |
|
out += ' } '; |
|
} else { |
|
out += ' {} '; |
|
} |
|
var __err = out; |
|
out = $$outStack.pop(); |
|
if (!it.compositeRule && $breakOnError) { /* istanbul ignore if */ |
|
if (it.async) { |
|
out += ' throw new ValidationError([' + (__err) + ']); '; |
|
} else { |
|
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|
} |
|
} else { |
|
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|
} |
|
out += ' } '; |
|
} |
|
$errSchemaPath = $currErrSchemaPath; |
|
if ($breakOnError) { |
|
out += ' if (' + ($valid) + ') { '; |
|
$closingBraces += '}'; |
|
} |
|
} |
|
} |
|
} |
|
} |
|
} |
|
if ($breakOnError) { |
|
out += ' ' + ($closingBraces) + ' if (' + ($errs) + ' == errors) {'; |
|
} |
|
out = it.util.cleanUpCode(out); |
|
return out; |
|
} |
|
|
|
},{}],31:[function(require,module,exports){ |
|
'use strict'; |
|
module.exports = function generate_propertyNames(it, $keyword, $ruleType) { |
|
var out = ' '; |
|
var $lvl = it.level; |
|
var $dataLvl = it.dataLevel; |
|
var $schema = it.schema[$keyword]; |
|
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|
var $breakOnError = !it.opts.allErrors; |
|
var $data = 'data' + ($dataLvl || ''); |
|
var $errs = 'errs__' + $lvl; |
|
var $it = it.util.copy(it); |
|
var $closingBraces = ''; |
|
$it.level++; |
|
var $nextValid = 'valid' + $it.level; |
|
if (it.util.schemaHasRules($schema, it.RULES.all)) { |
|
$it.schema = $schema; |
|
$it.schemaPath = $schemaPath; |
|
$it.errSchemaPath = $errSchemaPath; |
|
var $key = 'key' + $lvl, |
|
$idx = 'idx' + $lvl, |
|
$i = 'i' + $lvl, |
|
$invalidName = '\' + ' + $key + ' + \'', |
|
$dataNxt = $it.dataLevel = it.dataLevel + 1, |
|
$nextData = 'data' + $dataNxt, |
|
$dataProperties = 'dataProperties' + $lvl, |
|
$ownProperties = it.opts.ownProperties, |
|
$currentBaseId = it.baseId; |
|
out += ' var ' + ($errs) + ' = errors; '; |
|
if ($ownProperties) { |
|
out += ' var ' + ($dataProperties) + ' = undefined; '; |
|
} |
|
if ($ownProperties) { |
|
out += ' ' + ($dataProperties) + ' = ' + ($dataProperties) + ' || Object.keys(' + ($data) + '); for (var ' + ($idx) + '=0; ' + ($idx) + '<' + ($dataProperties) + '.length; ' + ($idx) + '++) { var ' + ($key) + ' = ' + ($dataProperties) + '[' + ($idx) + ']; '; |
|
} else { |
|
out += ' for (var ' + ($key) + ' in ' + ($data) + ') { '; |
|
} |
|
out += ' var startErrs' + ($lvl) + ' = errors; '; |
|
var $passData = $key; |
|
var $wasComposite = it.compositeRule; |
|
it.compositeRule = $it.compositeRule = true; |
|
var $code = it.validate($it); |
|
$it.baseId = $currentBaseId; |
|
if (it.util.varOccurences($code, $nextData) < 2) { |
|
out += ' ' + (it.util.varReplace($code, $nextData, $passData)) + ' '; |
|
} else { |
|
out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ' + ($code) + ' '; |
|
} |
|
it.compositeRule = $it.compositeRule = $wasComposite; |
|
out += ' if (!' + ($nextValid) + ') { for (var ' + ($i) + '=startErrs' + ($lvl) + '; ' + ($i) + '<errors; ' + ($i) + '++) { vErrors[' + ($i) + '].propertyName = ' + ($key) + '; } var err = '; /* istanbul ignore else */ |
|
if (it.createErrors !== false) { |
|
out += ' { keyword: \'' + ('propertyNames') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { propertyName: \'' + ($invalidName) + '\' } '; |
|
if (it.opts.messages !== false) { |
|
out += ' , message: \'property name \\\'' + ($invalidName) + '\\\' is invalid\' '; |
|
} |
|
if (it.opts.verbose) { |
|
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|
} |
|
out += ' } '; |
|
} else { |
|
out += ' {} '; |
|
} |
|
out += '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|
if (!it.compositeRule && $breakOnError) { /* istanbul ignore if */ |
|
if (it.async) { |
|
out += ' throw new ValidationError(vErrors); '; |
|
} else { |
|
out += ' validate.errors = vErrors; return false; '; |
|
} |
|
} |
|
if ($breakOnError) { |
|
out += ' break; '; |
|
} |
|
out += ' } }'; |
|
} |
|
if ($breakOnError) { |
|
out += ' ' + ($closingBraces) + ' if (' + ($errs) + ' == errors) {'; |
|
} |
|
out = it.util.cleanUpCode(out); |
|
return out; |
|
} |
|
|
|
},{}],32:[function(require,module,exports){ |
|
'use strict'; |
|
module.exports = function generate_ref(it, $keyword, $ruleType) { |
|
var out = ' '; |
|
var $lvl = it.level; |
|
var $dataLvl = it.dataLevel; |
|
var $schema = it.schema[$keyword]; |
|
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|
var $breakOnError = !it.opts.allErrors; |
|
var $data = 'data' + ($dataLvl || ''); |
|
var $valid = 'valid' + $lvl; |
|
var $async, $refCode; |
|
if ($schema == '#' || $schema == '#/') { |
|
if (it.isRoot) { |
|
$async = it.async; |
|
$refCode = 'validate'; |
|
} else { |
|
$async = it.root.schema.$async === true; |
|
$refCode = 'root.refVal[0]'; |
|
} |
|
} else { |
|
var $refVal = it.resolveRef(it.baseId, $schema, it.isRoot); |
|
if ($refVal === undefined) { |
|
var $message = it.MissingRefError.message(it.baseId, $schema); |
|
if (it.opts.missingRefs == 'fail') { |
|
it.logger.error($message); |
|
var $$outStack = $$outStack || []; |
|
$$outStack.push(out); |
|
out = ''; /* istanbul ignore else */ |
|
if (it.createErrors !== false) { |
|
out += ' { keyword: \'' + ('$ref') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { ref: \'' + (it.util.escapeQuotes($schema)) + '\' } '; |
|
if (it.opts.messages !== false) { |
|
out += ' , message: \'can\\\'t resolve reference ' + (it.util.escapeQuotes($schema)) + '\' '; |
|
} |
|
if (it.opts.verbose) { |
|
out += ' , schema: ' + (it.util.toQuotedString($schema)) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|
} |
|
out += ' } '; |
|
} else { |
|
out += ' {} '; |
|
} |
|
var __err = out; |
|
out = $$outStack.pop(); |
|
if (!it.compositeRule && $breakOnError) { /* istanbul ignore if */ |
|
if (it.async) { |
|
out += ' throw new ValidationError([' + (__err) + ']); '; |
|
} else { |
|
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|
} |
|
} else { |
|
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|
} |
|
if ($breakOnError) { |
|
out += ' if (false) { '; |
|
} |
|
} else if (it.opts.missingRefs == 'ignore') { |
|
it.logger.warn($message); |
|
if ($breakOnError) { |
|
out += ' if (true) { '; |
|
} |
|
} else { |
|
throw new it.MissingRefError(it.baseId, $schema, $message); |
|
} |
|
} else if ($refVal.inline) { |
|
var $it = it.util.copy(it); |
|
$it.level++; |
|
var $nextValid = 'valid' + $it.level; |
|
$it.schema = $refVal.schema; |
|
$it.schemaPath = ''; |
|
$it.errSchemaPath = $schema; |
|
var $code = it.validate($it).replace(/validate\.schema/g, $refVal.code); |
|
out += ' ' + ($code) + ' '; |
|
if ($breakOnError) { |
|
out += ' if (' + ($nextValid) + ') { '; |
|
} |
|
} else { |
|
$async = $refVal.$async === true; |
|
$refCode = $refVal.code; |
|
} |
|
} |
|
if ($refCode) { |
|
var $$outStack = $$outStack || []; |
|
$$outStack.push(out); |
|
out = ''; |
|
if (it.opts.passContext) { |
|
out += ' ' + ($refCode) + '.call(this, '; |
|
} else { |
|
out += ' ' + ($refCode) + '( '; |
|
} |
|
out += ' ' + ($data) + ', (dataPath || \'\')'; |
|
if (it.errorPath != '""') { |
|
out += ' + ' + (it.errorPath); |
|
} |
|
var $parentData = $dataLvl ? 'data' + (($dataLvl - 1) || '') : 'parentData', |
|
$parentDataProperty = $dataLvl ? it.dataPathArr[$dataLvl] : 'parentDataProperty'; |
|
out += ' , ' + ($parentData) + ' , ' + ($parentDataProperty) + ', rootData) '; |
|
var __callValidate = out; |
|
out = $$outStack.pop(); |
|
if ($async) { |
|
if (!it.async) throw new Error('async schema referenced by sync schema'); |
|
if ($breakOnError) { |
|
out += ' var ' + ($valid) + '; '; |
|
} |
|
out += ' try { ' + (it.yieldAwait) + ' ' + (__callValidate) + '; '; |
|
if ($breakOnError) { |
|
out += ' ' + ($valid) + ' = true; '; |
|
} |
|
out += ' } catch (e) { if (!(e instanceof ValidationError)) throw e; if (vErrors === null) vErrors = e.errors; else vErrors = vErrors.concat(e.errors); errors = vErrors.length; '; |
|
if ($breakOnError) { |
|
out += ' ' + ($valid) + ' = false; '; |
|
} |
|
out += ' } '; |
|
if ($breakOnError) { |
|
out += ' if (' + ($valid) + ') { '; |
|
} |
|
} else { |
|
out += ' if (!' + (__callValidate) + ') { if (vErrors === null) vErrors = ' + ($refCode) + '.errors; else vErrors = vErrors.concat(' + ($refCode) + '.errors); errors = vErrors.length; } '; |
|
if ($breakOnError) { |
|
out += ' else { '; |
|
} |
|
} |
|
} |
|
return out; |
|
} |
|
|
|
},{}],33:[function(require,module,exports){ |
|
'use strict'; |
|
module.exports = function generate_required(it, $keyword, $ruleType) { |
|
var out = ' '; |
|
var $lvl = it.level; |
|
var $dataLvl = it.dataLevel; |
|
var $schema = it.schema[$keyword]; |
|
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|
var $breakOnError = !it.opts.allErrors; |
|
var $data = 'data' + ($dataLvl || ''); |
|
var $valid = 'valid' + $lvl; |
|
var $isData = it.opts.$data && $schema && $schema.$data, |
|
$schemaValue; |
|
if ($isData) { |
|
out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; '; |
|
$schemaValue = 'schema' + $lvl; |
|
} else { |
|
$schemaValue = $schema; |
|
} |
|
var $vSchema = 'schema' + $lvl; |
|
if (!$isData) { |
|
if ($schema.length < it.opts.loopRequired && it.schema.properties && Object.keys(it.schema.properties).length) { |
|
var $required = []; |
|
var arr1 = $schema; |
|
if (arr1) { |
|
var $property, i1 = -1, |
|
l1 = arr1.length - 1; |
|
while (i1 < l1) { |
|
$property = arr1[i1 += 1]; |
|
var $propertySch = it.schema.properties[$property]; |
|
if (!($propertySch && it.util.schemaHasRules($propertySch, it.RULES.all))) { |
|
$required[$required.length] = $property; |
|
} |
|
} |
|
} |
|
} else { |
|
var $required = $schema; |
|
} |
|
} |
|
if ($isData || $required.length) { |
|
var $currentErrorPath = it.errorPath, |
|
$loopRequired = $isData || $required.length >= it.opts.loopRequired, |
|
$ownProperties = it.opts.ownProperties; |
|
if ($breakOnError) { |
|
out += ' var missing' + ($lvl) + '; '; |
|
if ($loopRequired) { |
|
if (!$isData) { |
|
out += ' var ' + ($vSchema) + ' = validate.schema' + ($schemaPath) + '; '; |
|
} |
|
var $i = 'i' + $lvl, |
|
$propertyPath = 'schema' + $lvl + '[' + $i + ']', |
|
$missingProperty = '\' + ' + $propertyPath + ' + \''; |
|
if (it.opts._errorDataPathProperty) { |
|
it.errorPath = it.util.getPathExpr($currentErrorPath, $propertyPath, it.opts.jsonPointers); |
|
} |
|
out += ' var ' + ($valid) + ' = true; '; |
|
if ($isData) { |
|
out += ' if (schema' + ($lvl) + ' === undefined) ' + ($valid) + ' = true; else if (!Array.isArray(schema' + ($lvl) + ')) ' + ($valid) + ' = false; else {'; |
|
} |
|
out += ' for (var ' + ($i) + ' = 0; ' + ($i) + ' < ' + ($vSchema) + '.length; ' + ($i) + '++) { ' + ($valid) + ' = ' + ($data) + '[' + ($vSchema) + '[' + ($i) + ']] !== undefined '; |
|
if ($ownProperties) { |
|
out += ' && Object.prototype.hasOwnProperty.call(' + ($data) + ', ' + ($vSchema) + '[' + ($i) + ']) '; |
|
} |
|
out += '; if (!' + ($valid) + ') break; } '; |
|
if ($isData) { |
|
out += ' } '; |
|
} |
|
out += ' if (!' + ($valid) + ') { '; |
|
var $$outStack = $$outStack || []; |
|
$$outStack.push(out); |
|
out = ''; /* istanbul ignore else */ |
|
if (it.createErrors !== false) { |
|
out += ' { keyword: \'' + ('required') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { missingProperty: \'' + ($missingProperty) + '\' } '; |
|
if (it.opts.messages !== false) { |
|
out += ' , message: \''; |
|
if (it.opts._errorDataPathProperty) { |
|
out += 'is a required property'; |
|
} else { |
|
out += 'should have required property \\\'' + ($missingProperty) + '\\\''; |
|
} |
|
out += '\' '; |
|
} |
|
if (it.opts.verbose) { |
|
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|
} |
|
out += ' } '; |
|
} else { |
|
out += ' {} '; |
|
} |
|
var __err = out; |
|
out = $$outStack.pop(); |
|
if (!it.compositeRule && $breakOnError) { /* istanbul ignore if */ |
|
if (it.async) { |
|
out += ' throw new ValidationError([' + (__err) + ']); '; |
|
} else { |
|
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|
} |
|
} else { |
|
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|
} |
|
out += ' } else { '; |
|
} else { |
|
out += ' if ( '; |
|
var arr2 = $required; |
|
if (arr2) { |
|
var $propertyKey, $i = -1, |
|
l2 = arr2.length - 1; |
|
while ($i < l2) { |
|
$propertyKey = arr2[$i += 1]; |
|
if ($i) { |
|
out += ' || '; |
|
} |
|
var $prop = it.util.getProperty($propertyKey), |
|
$useData = $data + $prop; |
|
out += ' ( ( ' + ($useData) + ' === undefined '; |
|
if ($ownProperties) { |
|
out += ' || ! Object.prototype.hasOwnProperty.call(' + ($data) + ', \'' + (it.util.escapeQuotes($propertyKey)) + '\') '; |
|
} |
|
out += ') && (missing' + ($lvl) + ' = ' + (it.util.toQuotedString(it.opts.jsonPointers ? $propertyKey : $prop)) + ') ) '; |
|
} |
|
} |
|
out += ') { '; |
|
var $propertyPath = 'missing' + $lvl, |
|
$missingProperty = '\' + ' + $propertyPath + ' + \''; |
|
if (it.opts._errorDataPathProperty) { |
|
it.errorPath = it.opts.jsonPointers ? it.util.getPathExpr($currentErrorPath, $propertyPath, true) : $currentErrorPath + ' + ' + $propertyPath; |
|
} |
|
var $$outStack = $$outStack || []; |
|
$$outStack.push(out); |
|
out = ''; /* istanbul ignore else */ |
|
if (it.createErrors !== false) { |
|
out += ' { keyword: \'' + ('required') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { missingProperty: \'' + ($missingProperty) + '\' } '; |
|
if (it.opts.messages !== false) { |
|
out += ' , message: \''; |
|
if (it.opts._errorDataPathProperty) { |
|
out += 'is a required property'; |
|
} else { |
|
out += 'should have required property \\\'' + ($missingProperty) + '\\\''; |
|
} |
|
out += '\' '; |
|
} |
|
if (it.opts.verbose) { |
|
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|
} |
|
out += ' } '; |
|
} else { |
|
out += ' {} '; |
|
} |
|
var __err = out; |
|
out = $$outStack.pop(); |
|
if (!it.compositeRule && $breakOnError) { /* istanbul ignore if */ |
|
if (it.async) { |
|
out += ' throw new ValidationError([' + (__err) + ']); '; |
|
} else { |
|
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|
} |
|
} else { |
|
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|
} |
|
out += ' } else { '; |
|
} |
|
} else { |
|
if ($loopRequired) { |
|
if (!$isData) { |
|
out += ' var ' + ($vSchema) + ' = validate.schema' + ($schemaPath) + '; '; |
|
} |
|
var $i = 'i' + $lvl, |
|
$propertyPath = 'schema' + $lvl + '[' + $i + ']', |
|
$missingProperty = '\' + ' + $propertyPath + ' + \''; |
|
if (it.opts._errorDataPathProperty) { |
|
it.errorPath = it.util.getPathExpr($currentErrorPath, $propertyPath, it.opts.jsonPointers); |
|
} |
|
if ($isData) { |
|
out += ' if (' + ($vSchema) + ' && !Array.isArray(' + ($vSchema) + ')) { var err = '; /* istanbul ignore else */ |
|
if (it.createErrors !== false) { |
|
out += ' { keyword: \'' + ('required') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { missingProperty: \'' + ($missingProperty) + '\' } '; |
|
if (it.opts.messages !== false) { |
|
out += ' , message: \''; |
|
if (it.opts._errorDataPathProperty) { |
|
out += 'is a required property'; |
|
} else { |
|
out += 'should have required property \\\'' + ($missingProperty) + '\\\''; |
|
} |
|
out += '\' '; |
|
} |
|
if (it.opts.verbose) { |
|
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|
} |
|
out += ' } '; |
|
} else { |
|
out += ' {} '; |
|
} |
|
out += '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; } else if (' + ($vSchema) + ' !== undefined) { '; |
|
} |
|
out += ' for (var ' + ($i) + ' = 0; ' + ($i) + ' < ' + ($vSchema) + '.length; ' + ($i) + '++) { if (' + ($data) + '[' + ($vSchema) + '[' + ($i) + ']] === undefined '; |
|
if ($ownProperties) { |
|
out += ' || ! Object.prototype.hasOwnProperty.call(' + ($data) + ', ' + ($vSchema) + '[' + ($i) + ']) '; |
|
} |
|
out += ') { var err = '; /* istanbul ignore else */ |
|
if (it.createErrors !== false) { |
|
out += ' { keyword: \'' + ('required') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { missingProperty: \'' + ($missingProperty) + '\' } '; |
|
if (it.opts.messages !== false) { |
|
out += ' , message: \''; |
|
if (it.opts._errorDataPathProperty) { |
|
out += 'is a required property'; |
|
} else { |
|
out += 'should have required property \\\'' + ($missingProperty) + '\\\''; |
|
} |
|
out += '\' '; |
|
} |
|
if (it.opts.verbose) { |
|
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|
} |
|
out += ' } '; |
|
} else { |
|
out += ' {} '; |
|
} |
|
out += '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; } } '; |
|
if ($isData) { |
|
out += ' } '; |
|
} |
|
} else { |
|
var arr3 = $required; |
|
if (arr3) { |
|
var $propertyKey, i3 = -1, |
|
l3 = arr3.length - 1; |
|
while (i3 < l3) { |
|
$propertyKey = arr3[i3 += 1]; |
|
var $prop = it.util.getProperty($propertyKey), |
|
$missingProperty = it.util.escapeQuotes($propertyKey), |
|
$useData = $data + $prop; |
|
if (it.opts._errorDataPathProperty) { |
|
it.errorPath = it.util.getPath($currentErrorPath, $propertyKey, it.opts.jsonPointers); |
|
} |
|
out += ' if ( ' + ($useData) + ' === undefined '; |
|
if ($ownProperties) { |
|
out += ' || ! Object.prototype.hasOwnProperty.call(' + ($data) + ', \'' + (it.util.escapeQuotes($propertyKey)) + '\') '; |
|
} |
|
out += ') { var err = '; /* istanbul ignore else */ |
|
if (it.createErrors !== false) { |
|
out += ' { keyword: \'' + ('required') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { missingProperty: \'' + ($missingProperty) + '\' } '; |
|
if (it.opts.messages !== false) { |
|
out += ' , message: \''; |
|
if (it.opts._errorDataPathProperty) { |
|
out += 'is a required property'; |
|
} else { |
|
out += 'should have required property \\\'' + ($missingProperty) + '\\\''; |
|
} |
|
out += '\' '; |
|
} |
|
if (it.opts.verbose) { |
|
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|
} |
|
out += ' } '; |
|
} else { |
|
out += ' {} '; |
|
} |
|
out += '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; } '; |
|
} |
|
} |
|
} |
|
} |
|
it.errorPath = $currentErrorPath; |
|
} else if ($breakOnError) { |
|
out += ' if (true) {'; |
|
} |
|
return out; |
|
} |
|
|
|
},{}],34:[function(require,module,exports){ |
|
'use strict'; |
|
module.exports = function generate_uniqueItems(it, $keyword, $ruleType) { |
|
var out = ' '; |
|
var $lvl = it.level; |
|
var $dataLvl = it.dataLevel; |
|
var $schema = it.schema[$keyword]; |
|
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|
var $breakOnError = !it.opts.allErrors; |
|
var $data = 'data' + ($dataLvl || ''); |
|
var $valid = 'valid' + $lvl; |
|
var $isData = it.opts.$data && $schema && $schema.$data, |
|
$schemaValue; |
|
if ($isData) { |
|
out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; '; |
|
$schemaValue = 'schema' + $lvl; |
|
} else { |
|
$schemaValue = $schema; |
|
} |
|
if (($schema || $isData) && it.opts.uniqueItems !== false) { |
|
if ($isData) { |
|
out += ' var ' + ($valid) + '; if (' + ($schemaValue) + ' === false || ' + ($schemaValue) + ' === undefined) ' + ($valid) + ' = true; else if (typeof ' + ($schemaValue) + ' != \'boolean\') ' + ($valid) + ' = false; else { '; |
|
} |
|
out += ' var ' + ($valid) + ' = true; if (' + ($data) + '.length > 1) { var i = ' + ($data) + '.length, j; outer: for (;i--;) { for (j = i; j--;) { if (equal(' + ($data) + '[i], ' + ($data) + '[j])) { ' + ($valid) + ' = false; break outer; } } } } '; |
|
if ($isData) { |
|
out += ' } '; |
|
} |
|
out += ' if (!' + ($valid) + ') { '; |
|
var $$outStack = $$outStack || []; |
|
$$outStack.push(out); |
|
out = ''; /* istanbul ignore else */ |
|
if (it.createErrors !== false) { |
|
out += ' { keyword: \'' + ('uniqueItems') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { i: i, j: j } '; |
|
if (it.opts.messages !== false) { |
|
out += ' , message: \'should NOT have duplicate items (items ## \' + j + \' and \' + i + \' are identical)\' '; |
|
} |
|
if (it.opts.verbose) { |
|
out += ' , schema: '; |
|
if ($isData) { |
|
out += 'validate.schema' + ($schemaPath); |
|
} else { |
|
out += '' + ($schema); |
|
} |
|
out += ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|
} |
|
out += ' } '; |
|
} else { |
|
out += ' {} '; |
|
} |
|
var __err = out; |
|
out = $$outStack.pop(); |
|
if (!it.compositeRule && $breakOnError) { /* istanbul ignore if */ |
|
if (it.async) { |
|
out += ' throw new ValidationError([' + (__err) + ']); '; |
|
} else { |
|
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|
} |
|
} else { |
|
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|
} |
|
out += ' } '; |
|
if ($breakOnError) { |
|
out += ' else { '; |
|
} |
|
} else { |
|
if ($breakOnError) { |
|
out += ' if (true) { '; |
|
} |
|
} |
|
return out; |
|
} |
|
|
|
},{}],35:[function(require,module,exports){ |
|
'use strict'; |
|
module.exports = function generate_validate(it, $keyword, $ruleType) { |
|
var out = ''; |
|
var $async = it.schema.$async === true, |
|
$refKeywords = it.util.schemaHasRulesExcept(it.schema, it.RULES.all, '$ref'), |
|
$id = it.self._getId(it.schema); |
|
if (it.isTop) { |
|
if ($async) { |
|
it.async = true; |
|
var $es7 = it.opts.async == 'es7'; |
|
it.yieldAwait = $es7 ? 'await' : 'yield'; |
|
} |
|
out += ' var validate = '; |
|
if ($async) { |
|
if ($es7) { |
|
out += ' (async function '; |
|
} else { |
|
if (it.opts.async != '*') { |
|
out += 'co.wrap'; |
|
} |
|
out += '(function* '; |
|
} |
|
} else { |
|
out += ' (function '; |
|
} |
|
out += ' (data, dataPath, parentData, parentDataProperty, rootData) { \'use strict\'; '; |
|
if ($id && (it.opts.sourceCode || it.opts.processCode)) { |
|
out += ' ' + ('/\*# sourceURL=' + $id + ' */') + ' '; |
|
} |
|
} |
|
if (typeof it.schema == 'boolean' || !($refKeywords || it.schema.$ref)) { |
|
var $keyword = 'false schema'; |
|
var $lvl = it.level; |
|
var $dataLvl = it.dataLevel; |
|
var $schema = it.schema[$keyword]; |
|
var $schemaPath = it.schemaPath + it.util.getProperty($keyword); |
|
var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
|
var $breakOnError = !it.opts.allErrors; |
|
var $errorKeyword; |
|
var $data = 'data' + ($dataLvl || ''); |
|
var $valid = 'valid' + $lvl; |
|
if (it.schema === false) { |
|
if (it.isTop) { |
|
$breakOnError = true; |
|
} else { |
|
out += ' var ' + ($valid) + ' = false; '; |
|
} |
|
var $$outStack = $$outStack || []; |
|
$$outStack.push(out); |
|
out = ''; /* istanbul ignore else */ |
|
if (it.createErrors !== false) { |
|
out += ' { keyword: \'' + ($errorKeyword || 'false schema') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: {} '; |
|
if (it.opts.messages !== false) { |
|
out += ' , message: \'boolean schema is false\' '; |
|
} |
|
if (it.opts.verbose) { |
|
out += ' , schema: false , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|
} |
|
out += ' } '; |
|
} else { |
|
out += ' {} '; |
|
} |
|
var __err = out; |
|
out = $$outStack.pop(); |
|
if (!it.compositeRule && $breakOnError) { /* istanbul ignore if */ |
|
if (it.async) { |
|
out += ' throw new ValidationError([' + (__err) + ']); '; |
|
} else { |
|
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|
} |
|
} else { |
|
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|
} |
|
} else { |
|
if (it.isTop) { |
|
if ($async) { |
|
out += ' return data; '; |
|
} else { |
|
out += ' validate.errors = null; return true; '; |
|
} |
|
} else { |
|
out += ' var ' + ($valid) + ' = true; '; |
|
} |
|
} |
|
if (it.isTop) { |
|
out += ' }); return validate; '; |
|
} |
|
return out; |
|
} |
|
if (it.isTop) { |
|
var $top = it.isTop, |
|
$lvl = it.level = 0, |
|
$dataLvl = it.dataLevel = 0, |
|
$data = 'data'; |
|
it.rootId = it.resolve.fullPath(it.self._getId(it.root.schema)); |
|
it.baseId = it.baseId || it.rootId; |
|
delete it.isTop; |
|
it.dataPathArr = [undefined]; |
|
out += ' var vErrors = null; '; |
|
out += ' var errors = 0; '; |
|
out += ' if (rootData === undefined) rootData = data; '; |
|
} else { |
|
var $lvl = it.level, |
|
$dataLvl = it.dataLevel, |
|
$data = 'data' + ($dataLvl || ''); |
|
if ($id) it.baseId = it.resolve.url(it.baseId, $id); |
|
if ($async && !it.async) throw new Error('async schema in sync schema'); |
|
out += ' var errs_' + ($lvl) + ' = errors;'; |
|
} |
|
var $valid = 'valid' + $lvl, |
|
$breakOnError = !it.opts.allErrors, |
|
$closingBraces1 = '', |
|
$closingBraces2 = ''; |
|
var $errorKeyword; |
|
var $typeSchema = it.schema.type, |
|
$typeIsArray = Array.isArray($typeSchema); |
|
if ($typeIsArray && $typeSchema.length == 1) { |
|
$typeSchema = $typeSchema[0]; |
|
$typeIsArray = false; |
|
} |
|
if (it.schema.$ref && $refKeywords) { |
|
if (it.opts.extendRefs == 'fail') { |
|
throw new Error('$ref: validation keywords used in schema at path "' + it.errSchemaPath + '" (see option extendRefs)'); |
|
} else if (it.opts.extendRefs !== true) { |
|
$refKeywords = false; |
|
it.logger.warn('$ref: keywords ignored in schema at path "' + it.errSchemaPath + '"'); |
|
} |
|
} |
|
if ($typeSchema) { |
|
if (it.opts.coerceTypes) { |
|
var $coerceToTypes = it.util.coerceToTypes(it.opts.coerceTypes, $typeSchema); |
|
} |
|
var $rulesGroup = it.RULES.types[$typeSchema]; |
|
if ($coerceToTypes || $typeIsArray || $rulesGroup === true || ($rulesGroup && !$shouldUseGroup($rulesGroup))) { |
|
var $schemaPath = it.schemaPath + '.type', |
|
$errSchemaPath = it.errSchemaPath + '/type'; |
|
var $schemaPath = it.schemaPath + '.type', |
|
$errSchemaPath = it.errSchemaPath + '/type', |
|
$method = $typeIsArray ? 'checkDataTypes' : 'checkDataType'; |
|
out += ' if (' + (it.util[$method]($typeSchema, $data, true)) + ') { '; |
|
if ($coerceToTypes) { |
|
var $dataType = 'dataType' + $lvl, |
|
$coerced = 'coerced' + $lvl; |
|
out += ' var ' + ($dataType) + ' = typeof ' + ($data) + '; '; |
|
if (it.opts.coerceTypes == 'array') { |
|
out += ' if (' + ($dataType) + ' == \'object\' && Array.isArray(' + ($data) + ')) ' + ($dataType) + ' = \'array\'; '; |
|
} |
|
out += ' var ' + ($coerced) + ' = undefined; '; |
|
var $bracesCoercion = ''; |
|
var arr1 = $coerceToTypes; |
|
if (arr1) { |
|
var $type, $i = -1, |
|
l1 = arr1.length - 1; |
|
while ($i < l1) { |
|
$type = arr1[$i += 1]; |
|
if ($i) { |
|
out += ' if (' + ($coerced) + ' === undefined) { '; |
|
$bracesCoercion += '}'; |
|
} |
|
if (it.opts.coerceTypes == 'array' && $type != 'array') { |
|
out += ' if (' + ($dataType) + ' == \'array\' && ' + ($data) + '.length == 1) { ' + ($coerced) + ' = ' + ($data) + ' = ' + ($data) + '[0]; ' + ($dataType) + ' = typeof ' + ($data) + '; } '; |
|
} |
|
if ($type == 'string') { |
|
out += ' if (' + ($dataType) + ' == \'number\' || ' + ($dataType) + ' == \'boolean\') ' + ($coerced) + ' = \'\' + ' + ($data) + '; else if (' + ($data) + ' === null) ' + ($coerced) + ' = \'\'; '; |
|
} else if ($type == 'number' || $type == 'integer') { |
|
out += ' if (' + ($dataType) + ' == \'boolean\' || ' + ($data) + ' === null || (' + ($dataType) + ' == \'string\' && ' + ($data) + ' && ' + ($data) + ' == +' + ($data) + ' '; |
|
if ($type == 'integer') { |
|
out += ' && !(' + ($data) + ' % 1)'; |
|
} |
|
out += ')) ' + ($coerced) + ' = +' + ($data) + '; '; |
|
} else if ($type == 'boolean') { |
|
out += ' if (' + ($data) + ' === \'false\' || ' + ($data) + ' === 0 || ' + ($data) + ' === null) ' + ($coerced) + ' = false; else if (' + ($data) + ' === \'true\' || ' + ($data) + ' === 1) ' + ($coerced) + ' = true; '; |
|
} else if ($type == 'null') { |
|
out += ' if (' + ($data) + ' === \'\' || ' + ($data) + ' === 0 || ' + ($data) + ' === false) ' + ($coerced) + ' = null; '; |
|
} else if (it.opts.coerceTypes == 'array' && $type == 'array') { |
|
out += ' if (' + ($dataType) + ' == \'string\' || ' + ($dataType) + ' == \'number\' || ' + ($dataType) + ' == \'boolean\' || ' + ($data) + ' == null) ' + ($coerced) + ' = [' + ($data) + ']; '; |
|
} |
|
} |
|
} |
|
out += ' ' + ($bracesCoercion) + ' if (' + ($coerced) + ' === undefined) { '; |
|
var $$outStack = $$outStack || []; |
|
$$outStack.push(out); |
|
out = ''; /* istanbul ignore else */ |
|
if (it.createErrors !== false) { |
|
out += ' { keyword: \'' + ($errorKeyword || 'type') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { type: \''; |
|
if ($typeIsArray) { |
|
out += '' + ($typeSchema.join(",")); |
|
} else { |
|
out += '' + ($typeSchema); |
|
} |
|
out += '\' } '; |
|
if (it.opts.messages !== false) { |
|
out += ' , message: \'should be '; |
|
if ($typeIsArray) { |
|
out += '' + ($typeSchema.join(",")); |
|
} else { |
|
out += '' + ($typeSchema); |
|
} |
|
out += '\' '; |
|
} |
|
if (it.opts.verbose) { |
|
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|
} |
|
out += ' } '; |
|
} else { |
|
out += ' {} '; |
|
} |
|
var __err = out; |
|
out = $$outStack.pop(); |
|
if (!it.compositeRule && $breakOnError) { /* istanbul ignore if */ |
|
if (it.async) { |
|
out += ' throw new ValidationError([' + (__err) + ']); '; |
|
} else { |
|
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|
} |
|
} else { |
|
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|
} |
|
out += ' } else { '; |
|
var $parentData = $dataLvl ? 'data' + (($dataLvl - 1) || '') : 'parentData', |
|
$parentDataProperty = $dataLvl ? it.dataPathArr[$dataLvl] : 'parentDataProperty'; |
|
out += ' ' + ($data) + ' = ' + ($coerced) + '; '; |
|
if (!$dataLvl) { |
|
out += 'if (' + ($parentData) + ' !== undefined)'; |
|
} |
|
out += ' ' + ($parentData) + '[' + ($parentDataProperty) + '] = ' + ($coerced) + '; } '; |
|
} else { |
|
var $$outStack = $$outStack || []; |
|
$$outStack.push(out); |
|
out = ''; /* istanbul ignore else */ |
|
if (it.createErrors !== false) { |
|
out += ' { keyword: \'' + ($errorKeyword || 'type') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { type: \''; |
|
if ($typeIsArray) { |
|
out += '' + ($typeSchema.join(",")); |
|
} else { |
|
out += '' + ($typeSchema); |
|
} |
|
out += '\' } '; |
|
if (it.opts.messages !== false) { |
|
out += ' , message: \'should be '; |
|
if ($typeIsArray) { |
|
out += '' + ($typeSchema.join(",")); |
|
} else { |
|
out += '' + ($typeSchema); |
|
} |
|
out += '\' '; |
|
} |
|
if (it.opts.verbose) { |
|
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|
} |
|
out += ' } '; |
|
} else { |
|
out += ' {} '; |
|
} |
|
var __err = out; |
|
out = $$outStack.pop(); |
|
if (!it.compositeRule && $breakOnError) { /* istanbul ignore if */ |
|
if (it.async) { |
|
out += ' throw new ValidationError([' + (__err) + ']); '; |
|
} else { |
|
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|
} |
|
} else { |
|
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|
} |
|
} |
|
out += ' } '; |
|
} |
|
} |
|
if (it.schema.$ref && !$refKeywords) { |
|
out += ' ' + (it.RULES.all.$ref.code(it, '$ref')) + ' '; |
|
if ($breakOnError) { |
|
out += ' } if (errors === '; |
|
if ($top) { |
|
out += '0'; |
|
} else { |
|
out += 'errs_' + ($lvl); |
|
} |
|
out += ') { '; |
|
$closingBraces2 += '}'; |
|
} |
|
} else { |
|
if (it.opts.v5 && it.schema.patternGroups) { |
|
it.logger.warn('keyword "patternGroups" is deprecated and disabled. Use option patternGroups: true to enable.'); |
|
} |
|
var arr2 = it.RULES; |
|
if (arr2) { |
|
var $rulesGroup, i2 = -1, |
|
l2 = arr2.length - 1; |
|
while (i2 < l2) { |
|
$rulesGroup = arr2[i2 += 1]; |
|
if ($shouldUseGroup($rulesGroup)) { |
|
if ($rulesGroup.type) { |
|
out += ' if (' + (it.util.checkDataType($rulesGroup.type, $data)) + ') { '; |
|
} |
|
if (it.opts.useDefaults && !it.compositeRule) { |
|
if ($rulesGroup.type == 'object' && it.schema.properties) { |
|
var $schema = it.schema.properties, |
|
$schemaKeys = Object.keys($schema); |
|
var arr3 = $schemaKeys; |
|
if (arr3) { |
|
var $propertyKey, i3 = -1, |
|
l3 = arr3.length - 1; |
|
while (i3 < l3) { |
|
$propertyKey = arr3[i3 += 1]; |
|
var $sch = $schema[$propertyKey]; |
|
if ($sch.default !== undefined) { |
|
var $passData = $data + it.util.getProperty($propertyKey); |
|
out += ' if (' + ($passData) + ' === undefined) ' + ($passData) + ' = '; |
|
if (it.opts.useDefaults == 'shared') { |
|
out += ' ' + (it.useDefault($sch.default)) + ' '; |
|
} else { |
|
out += ' ' + (JSON.stringify($sch.default)) + ' '; |
|
} |
|
out += '; '; |
|
} |
|
} |
|
} |
|
} else if ($rulesGroup.type == 'array' && Array.isArray(it.schema.items)) { |
|
var arr4 = it.schema.items; |
|
if (arr4) { |
|
var $sch, $i = -1, |
|
l4 = arr4.length - 1; |
|
while ($i < l4) { |
|
$sch = arr4[$i += 1]; |
|
if ($sch.default !== undefined) { |
|
var $passData = $data + '[' + $i + ']'; |
|
out += ' if (' + ($passData) + ' === undefined) ' + ($passData) + ' = '; |
|
if (it.opts.useDefaults == 'shared') { |
|
out += ' ' + (it.useDefault($sch.default)) + ' '; |
|
} else { |
|
out += ' ' + (JSON.stringify($sch.default)) + ' '; |
|
} |
|
out += '; '; |
|
} |
|
} |
|
} |
|
} |
|
} |
|
var arr5 = $rulesGroup.rules; |
|
if (arr5) { |
|
var $rule, i5 = -1, |
|
l5 = arr5.length - 1; |
|
while (i5 < l5) { |
|
$rule = arr5[i5 += 1]; |
|
if ($shouldUseRule($rule)) { |
|
var $code = $rule.code(it, $rule.keyword, $rulesGroup.type); |
|
if ($code) { |
|
out += ' ' + ($code) + ' '; |
|
if ($breakOnError) { |
|
$closingBraces1 += '}'; |
|
} |
|
} |
|
} |
|
} |
|
} |
|
if ($breakOnError) { |
|
out += ' ' + ($closingBraces1) + ' '; |
|
$closingBraces1 = ''; |
|
} |
|
if ($rulesGroup.type) { |
|
out += ' } '; |
|
if ($typeSchema && $typeSchema === $rulesGroup.type && !$coerceToTypes) { |
|
out += ' else { '; |
|
var $schemaPath = it.schemaPath + '.type', |
|
$errSchemaPath = it.errSchemaPath + '/type'; |
|
var $$outStack = $$outStack || []; |
|
$$outStack.push(out); |
|
out = ''; /* istanbul ignore else */ |
|
if (it.createErrors !== false) { |
|
out += ' { keyword: \'' + ($errorKeyword || 'type') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { type: \''; |
|
if ($typeIsArray) { |
|
out += '' + ($typeSchema.join(",")); |
|
} else { |
|
out += '' + ($typeSchema); |
|
} |
|
out += '\' } '; |
|
if (it.opts.messages !== false) { |
|
out += ' , message: \'should be '; |
|
if ($typeIsArray) { |
|
out += '' + ($typeSchema.join(",")); |
|
} else { |
|
out += '' + ($typeSchema); |
|
} |
|
out += '\' '; |
|
} |
|
if (it.opts.verbose) { |
|
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' '; |
|
} |
|
out += ' } '; |
|
} else { |
|
out += ' {} '; |
|
} |
|
var __err = out; |
|
out = $$outStack.pop(); |
|
if (!it.compositeRule && $breakOnError) { /* istanbul ignore if */ |
|
if (it.async) { |
|
out += ' throw new ValidationError([' + (__err) + ']); '; |
|
} else { |
|
out += ' validate.errors = [' + (__err) + ']; return false; '; |
|
} |
|
} else { |
|
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; '; |
|
} |
|
out += ' } '; |
|
} |
|
} |
|
if ($breakOnError) { |
|
out += ' if (errors === '; |
|
if ($top) { |
|
out += '0'; |
|
} else { |
|
out += 'errs_' + ($lvl); |
|
} |
|
out += ') { '; |
|
$closingBraces2 += '}'; |
|
} |
|
} |
|
} |
|
} |
|
} |
|
if ($breakOnError) { |
|
out += ' ' + ($closingBraces2) + ' '; |
|
} |
|
if ($top) { |
|
if ($async) { |
|
out += ' if (errors === 0) return data; '; |
|
out += ' else throw new ValidationError(vErrors); '; |
|
} else { |
|
out += ' validate.errors = vErrors; '; |
|
out += ' return errors === 0; '; |
|
} |
|
out += ' }); return validate;'; |
|
} else { |
|
out += ' var ' + ($valid) + ' = errors === errs_' + ($lvl) + ';'; |
|
} |
|
out = it.util.cleanUpCode(out); |
|
if ($top) { |
|
out = it.util.finalCleanUpCode(out, $async); |
|
} |
|
|
|
function $shouldUseGroup($rulesGroup) { |
|
var rules = $rulesGroup.rules; |
|
for (var i = 0; i < rules.length; i++) |
|
if ($shouldUseRule(rules[i])) return true; |
|
} |
|
|
|
function $shouldUseRule($rule) { |
|
return it.schema[$rule.keyword] !== undefined || ($rule.implements && $ruleImplementsSomeKeyword($rule)); |
|
} |
|
|
|
function $ruleImplementsSomeKeyword($rule) { |
|
var impl = $rule.implements; |
|
for (var i = 0; i < impl.length; i++) |
|
if (it.schema[impl[i]] !== undefined) return true; |
|
} |
|
return out; |
|
} |
|
|
|
},{}],36:[function(require,module,exports){ |
|
'use strict'; |
|
|
|
var IDENTIFIER = /^[a-z_$][a-z0-9_$-]*$/i; |
|
var customRuleCode = require('./dotjs/custom'); |
|
|
|
module.exports = { |
|
add: addKeyword, |
|
get: getKeyword, |
|
remove: removeKeyword |
|
}; |
|
|
|
/** |
|
* Define custom keyword |
|
* @this Ajv |
|
* @param {String} keyword custom keyword, should be unique (including different from all standard, custom and macro keywords). |
|
* @param {Object} definition keyword definition object with properties `type` (type(s) which the keyword applies to), `validate` or `compile`. |
|
* @return {Ajv} this for method chaining |
|
*/ |
|
function addKeyword(keyword, definition) { |
|
/* jshint validthis: true */ |
|
/* eslint no-shadow: 0 */ |
|
var RULES = this.RULES; |
|
|
|
if (RULES.keywords[keyword]) |
|
throw new Error('Keyword ' + keyword + ' is already defined'); |
|
|
|
if (!IDENTIFIER.test(keyword)) |
|
throw new Error('Keyword ' + keyword + ' is not a valid identifier'); |
|
|
|
if (definition) { |
|
if (definition.macro && definition.valid !== undefined) |
|
throw new Error('"valid" option cannot be used with macro keywords'); |
|
|
|
var dataType = definition.type; |
|
if (Array.isArray(dataType)) { |
|
var i, len = dataType.length; |
|
for (i=0; i<len; i++) checkDataType(dataType[i]); |
|
for (i=0; i<len; i++) _addRule(keyword, dataType[i], definition); |
|
} else { |
|
if (dataType) checkDataType(dataType); |
|
_addRule(keyword, dataType, definition); |
|
} |
|
|
|
var $data = definition.$data === true && this._opts.$data; |
|
if ($data && !definition.validate) |
|
throw new Error('$data support: "validate" function is not defined'); |
|
|
|
var metaSchema = definition.metaSchema; |
|
if (metaSchema) { |
|
if ($data) { |
|
metaSchema = { |
|
anyOf: [ |
|
metaSchema, |
|
{ '$ref': 'https://raw.githubusercontent.com/epoberezkin/ajv/master/lib/refs/$data.json#' } |
|
] |
|
}; |
|
} |
|
definition.validateSchema = this.compile(metaSchema, true); |
|
} |
|
} |
|
|
|
RULES.keywords[keyword] = RULES.all[keyword] = true; |
|
|
|
|
|
function _addRule(keyword, dataType, definition) { |
|
var ruleGroup; |
|
for (var i=0; i<RULES.length; i++) { |
|
var rg = RULES[i]; |
|
if (rg.type == dataType) { |
|
ruleGroup = rg; |
|
break; |
|
} |
|
} |
|
|
|
if (!ruleGroup) { |
|
ruleGroup = { type: dataType, rules: [] }; |
|
RULES.push(ruleGroup); |
|
} |
|
|
|
var rule = { |
|
keyword: keyword, |
|
definition: definition, |
|
custom: true, |
|
code: customRuleCode, |
|
implements: definition.implements |
|
}; |
|
ruleGroup.rules.push(rule); |
|
RULES.custom[keyword] = rule; |
|
} |
|
|
|
|
|
function checkDataType(dataType) { |
|
if (!RULES.types[dataType]) throw new Error('Unknown type ' + dataType); |
|
} |
|
|
|
return this; |
|
} |
|
|
|
|
|
/** |
|
* Get keyword |
|
* @this Ajv |
|
* @param {String} keyword pre-defined or custom keyword. |
|
* @return {Object|Boolean} custom keyword definition, `true` if it is a predefined keyword, `false` otherwise. |
|
*/ |
|
function getKeyword(keyword) { |
|
/* jshint validthis: true */ |
|
var rule = this.RULES.custom[keyword]; |
|
return rule ? rule.definition : this.RULES.keywords[keyword] || false; |
|
} |
|
|
|
|
|
/** |
|
* Remove keyword |
|
* @this Ajv |
|
* @param {String} keyword pre-defined or custom keyword. |
|
* @return {Ajv} this for method chaining |
|
*/ |
|
function removeKeyword(keyword) { |
|
/* jshint validthis: true */ |
|
var RULES = this.RULES; |
|
delete RULES.keywords[keyword]; |
|
delete RULES.all[keyword]; |
|
delete RULES.custom[keyword]; |
|
for (var i=0; i<RULES.length; i++) { |
|
var rules = RULES[i].rules; |
|
for (var j=0; j<rules.length; j++) { |
|
if (rules[j].keyword == keyword) { |
|
rules.splice(j, 1); |
|
break; |
|
} |
|
} |
|
} |
|
return this; |
|
} |
|
|
|
},{"./dotjs/custom":21}],37:[function(require,module,exports){ |
|
'use strict'; |
|
|
|
var META_SCHEMA_ID = 'http://json-schema.org/draft-06/schema'; |
|
|
|
module.exports = function (ajv) { |
|
var defaultMeta = ajv._opts.defaultMeta; |
|
var metaSchemaRef = typeof defaultMeta == 'string' |
|
? { $ref: defaultMeta } |
|
: ajv.getSchema(META_SCHEMA_ID) |
|
? { $ref: META_SCHEMA_ID } |
|
: {}; |
|
|
|
ajv.addKeyword('patternGroups', { |
|
// implemented in properties.jst |
|
metaSchema: { |
|
type: 'object', |
|
additionalProperties: { |
|
type: 'object', |
|
required: [ 'schema' ], |
|
properties: { |
|
maximum: { |
|
type: 'integer', |
|
minimum: 0 |
|
}, |
|
minimum: { |
|
type: 'integer', |
|
minimum: 0 |
|
}, |
|
schema: metaSchemaRef |
|
}, |
|
additionalProperties: false |
|
} |
|
} |
|
}); |
|
ajv.RULES.all.properties.implements.push('patternGroups'); |
|
}; |
|
|
|
},{}],38:[function(require,module,exports){ |
|
module.exports={ |
|
"$schema": "http://json-schema.org/draft-06/schema#", |
|
"$id": "https://raw.githubusercontent.com/epoberezkin/ajv/master/lib/refs/$data.json#", |
|
"description": "Meta-schema for $data reference (JSON-schema extension proposal)", |
|
"type": "object", |
|
"required": [ "$data" ], |
|
"properties": { |
|
"$data": { |
|
"type": "string", |
|
"anyOf": [ |
|
{ "format": "relative-json-pointer" }, |
|
{ "format": "json-pointer" } |
|
] |
|
} |
|
}, |
|
"additionalProperties": false |
|
} |
|
|
|
},{}],39:[function(require,module,exports){ |
|
module.exports={ |
|
"$schema": "http://json-schema.org/draft-06/schema#", |
|
"$id": "http://json-schema.org/draft-06/schema#", |
|
"title": "Core schema meta-schema", |
|
"definitions": { |
|
"schemaArray": { |
|
"type": "array", |
|
"minItems": 1, |
|
"items": { "$ref": "#" } |
|
}, |
|
"nonNegativeInteger": { |
|
"type": "integer", |
|
"minimum": 0 |
|
}, |
|
"nonNegativeIntegerDefault0": { |
|
"allOf": [ |
|
{ "$ref": "#/definitions/nonNegativeInteger" }, |
|
{ "default": 0 } |
|
] |
|
}, |
|
"simpleTypes": { |
|
"enum": [ |
|
"array", |
|
"boolean", |
|
"integer", |
|
"null", |
|
"number", |
|
"object", |
|
"string" |
|
] |
|
}, |
|
"stringArray": { |
|
"type": "array", |
|
"items": { "type": "string" }, |
|
"uniqueItems": true, |
|
"default": [] |
|
} |
|
}, |
|
"type": ["object", "boolean"], |
|
"properties": { |
|
"$id": { |
|
"type": "string", |
|
"format": "uri-reference" |
|
}, |
|
"$schema": { |
|
"type": "string", |
|
"format": "uri" |
|
}, |
|
"$ref": { |
|
"type": "string", |
|
"format": "uri-reference" |
|
}, |
|
"title": { |
|
"type": "string" |
|
}, |
|
"description": { |
|
"type": "string" |
|
}, |
|
"default": {}, |
|
"examples": { |
|
"type": "array", |
|
"items": {} |
|
}, |
|
"multipleOf": { |
|
"type": "number", |
|
"exclusiveMinimum": 0 |
|
}, |
|
"maximum": { |
|
"type": "number" |
|
}, |
|
"exclusiveMaximum": { |
|
"type": "number" |
|
}, |
|
"minimum": { |
|
"type": "number" |
|
}, |
|
"exclusiveMinimum": { |
|
"type": "number" |
|
}, |
|
"maxLength": { "$ref": "#/definitions/nonNegativeInteger" }, |
|
"minLength": { "$ref": "#/definitions/nonNegativeIntegerDefault0" }, |
|
"pattern": { |
|
"type": "string", |
|
"format": "regex" |
|
}, |
|
"additionalItems": { "$ref": "#" }, |
|
"items": { |
|
"anyOf": [ |
|
{ "$ref": "#" }, |
|
{ "$ref": "#/definitions/schemaArray" } |
|
], |
|
"default": {} |
|
}, |
|
"maxItems": { "$ref": "#/definitions/nonNegativeInteger" }, |
|
"minItems": { "$ref": "#/definitions/nonNegativeIntegerDefault0" }, |
|
"uniqueItems": { |
|
"type": "boolean", |
|
"default": false |
|
}, |
|
"contains": { "$ref": "#" }, |
|
"maxProperties": { "$ref": "#/definitions/nonNegativeInteger" }, |
|
"minProperties": { "$ref": "#/definitions/nonNegativeIntegerDefault0" }, |
|
"required": { "$ref": "#/definitions/stringArray" }, |
|
"additionalProperties": { "$ref": "#" }, |
|
"definitions": { |
|
"type": "object", |
|
"additionalProperties": { "$ref": "#" }, |
|
"default": {} |
|
}, |
|
"properties": { |
|
"type": "object", |
|
"additionalProperties": { "$ref": "#" }, |
|
"default": {} |
|
}, |
|
"patternProperties": { |
|
"type": "object", |
|
"additionalProperties": { "$ref": "#" }, |
|
"default": {} |
|
}, |
|
"dependencies": { |
|
"type": "object", |
|
"additionalProperties": { |
|
"anyOf": [ |
|
{ "$ref": "#" }, |
|
{ "$ref": "#/definitions/stringArray" } |
|
] |
|
} |
|
}, |
|
"propertyNames": { "$ref": "#" }, |
|
"const": {}, |
|
"enum": { |
|
"type": "array", |
|
"minItems": 1, |
|
"uniqueItems": true |
|
}, |
|
"type": { |
|
"anyOf": [ |
|
{ "$ref": "#/definitions/simpleTypes" }, |
|
{ |
|
"type": "array", |
|
"items": { "$ref": "#/definitions/simpleTypes" }, |
|
"minItems": 1, |
|
"uniqueItems": true |
|
} |
|
] |
|
}, |
|
"format": { "type": "string" }, |
|
"allOf": { "$ref": "#/definitions/schemaArray" }, |
|
"anyOf": { "$ref": "#/definitions/schemaArray" }, |
|
"oneOf": { "$ref": "#/definitions/schemaArray" }, |
|
"not": { "$ref": "#" } |
|
}, |
|
"default": {} |
|
} |
|
|
|
},{}],40:[function(require,module,exports){ |
|
|
|
/** |
|
* slice() reference. |
|
*/ |
|
|
|
var slice = Array.prototype.slice; |
|
|
|
/** |
|
* Expose `co`. |
|
*/ |
|
|
|
module.exports = co['default'] = co.co = co; |
|
|
|
/** |
|
* Wrap the given generator `fn` into a |
|
* function that returns a promise. |
|
* This is a separate function so that |
|
* every `co()` call doesn't create a new, |
|
* unnecessary closure. |
|
* |
|
* @param {GeneratorFunction} fn |
|
* @return {Function} |
|
* @api public |
|
*/ |
|
|
|
co.wrap = function (fn) { |
|
createPromise.__generatorFunction__ = fn; |
|
return createPromise; |
|
function createPromise() { |
|
return co.call(this, fn.apply(this, arguments)); |
|
} |
|
}; |
|
|
|
/** |
|
* Execute the generator function or a generator |
|
* and return a promise. |
|
* |
|
* @param {Function} fn |
|
* @return {Promise} |
|
* @api public |
|
*/ |
|
|
|
function co(gen) { |
|
var ctx = this; |
|
var args = slice.call(arguments, 1) |
|
|
|
// we wrap everything in a promise to avoid promise chaining, |
|
// which leads to memory leak errors. |
|
// see https://github.com/tj/co/issues/180 |
|
return new Promise(function(resolve, reject) { |
|
if (typeof gen === 'function') gen = gen.apply(ctx, args); |
|
if (!gen || typeof gen.next !== 'function') return resolve(gen); |
|
|
|
onFulfilled(); |
|
|
|
/** |
|
* @param {Mixed} res |
|
* @return {Promise} |
|
* @api private |
|
*/ |
|
|
|
function onFulfilled(res) { |
|
var ret; |
|
try { |
|
ret = gen.next(res); |
|
} catch (e) { |
|
return reject(e); |
|
} |
|
next(ret); |
|
} |
|
|
|
/** |
|
* @param {Error} err |
|
* @return {Promise} |
|
* @api private |
|
*/ |
|
|
|
function onRejected(err) { |
|
var ret; |
|
try { |
|
ret = gen.throw(err); |
|
} catch (e) { |
|
return reject(e); |
|
} |
|
next(ret); |
|
} |
|
|
|
/** |
|
* Get the next value in the generator, |
|
* return a promise. |
|
* |
|
* @param {Object} ret |
|
* @return {Promise} |
|
* @api private |
|
*/ |
|
|
|
function next(ret) { |
|
if (ret.done) return resolve(ret.value); |
|
var value = toPromise.call(ctx, ret.value); |
|
if (value && isPromise(value)) return value.then(onFulfilled, onRejected); |
|
return onRejected(new TypeError('You may only yield a function, promise, generator, array, or object, ' |
|
+ 'but the following object was passed: "' + String(ret.value) + '"')); |
|
} |
|
}); |
|
} |
|
|
|
/** |
|
* Convert a `yield`ed value into a promise. |
|
* |
|
* @param {Mixed} obj |
|
* @return {Promise} |
|
* @api private |
|
*/ |
|
|
|
function toPromise(obj) { |
|
if (!obj) return obj; |
|
if (isPromise(obj)) return obj; |
|
if (isGeneratorFunction(obj) || isGenerator(obj)) return co.call(this, obj); |
|
if ('function' == typeof obj) return thunkToPromise.call(this, obj); |
|
if (Array.isArray(obj)) return arrayToPromise.call(this, obj); |
|
if (isObject(obj)) return objectToPromise.call(this, obj); |
|
return obj; |
|
} |
|
|
|
/** |
|
* Convert a thunk to a promise. |
|
* |
|
* @param {Function} |
|
* @return {Promise} |
|
* @api private |
|
*/ |
|
|
|
function thunkToPromise(fn) { |
|
var ctx = this; |
|
return new Promise(function (resolve, reject) { |
|
fn.call(ctx, function (err, res) { |
|
if (err) return reject(err); |
|
if (arguments.length > 2) res = slice.call(arguments, 1); |
|
resolve(res); |
|
}); |
|
}); |
|
} |
|
|
|
/** |
|
* Convert an array of "yieldables" to a promise. |
|
* Uses `Promise.all()` internally. |
|
* |
|
* @param {Array} obj |
|
* @return {Promise} |
|
* @api private |
|
*/ |
|
|
|
function arrayToPromise(obj) { |
|
return Promise.all(obj.map(toPromise, this)); |
|
} |
|
|
|
/** |
|
* Convert an object of "yieldables" to a promise. |
|
* Uses `Promise.all()` internally. |
|
* |
|
* @param {Object} obj |
|
* @return {Promise} |
|
* @api private |
|
*/ |
|
|
|
function objectToPromise(obj){ |
|
var results = new obj.constructor(); |
|
var keys = Object.keys(obj); |
|
var promises = []; |
|
for (var i = 0; i < keys.length; i++) { |
|
var key = keys[i]; |
|
var promise = toPromise.call(this, obj[key]); |
|
if (promise && isPromise(promise)) defer(promise, key); |
|
else results[key] = obj[key]; |
|
} |
|
return Promise.all(promises).then(function () { |
|
return results; |
|
}); |
|
|
|
function defer(promise, key) { |
|
// predefine the key in the result |
|
results[key] = undefined; |
|
promises.push(promise.then(function (res) { |
|
results[key] = res; |
|
})); |
|
} |
|
} |
|
|
|
/** |
|
* Check if `obj` is a promise. |
|
* |
|
* @param {Object} obj |
|
* @return {Boolean} |
|
* @api private |
|
*/ |
|
|
|
function isPromise(obj) { |
|
return 'function' == typeof obj.then; |
|
} |
|
|
|
/** |
|
* Check if `obj` is a generator. |
|
* |
|
* @param {Mixed} obj |
|
* @return {Boolean} |
|
* @api private |
|
*/ |
|
|
|
function isGenerator(obj) { |
|
return 'function' == typeof obj.next && 'function' == typeof obj.throw; |
|
} |
|
|
|
/** |
|
* Check if `obj` is a generator function. |
|
* |
|
* @param {Mixed} obj |
|
* @return {Boolean} |
|
* @api private |
|
*/ |
|
function isGeneratorFunction(obj) { |
|
var constructor = obj.constructor; |
|
if (!constructor) return false; |
|
if ('GeneratorFunction' === constructor.name || 'GeneratorFunction' === constructor.displayName) return true; |
|
return isGenerator(constructor.prototype); |
|
} |
|
|
|
/** |
|
* Check for plain object. |
|
* |
|
* @param {Mixed} val |
|
* @return {Boolean} |
|
* @api private |
|
*/ |
|
|
|
function isObject(val) { |
|
return Object == val.constructor; |
|
} |
|
|
|
},{}],41:[function(require,module,exports){ |
|
'use strict'; |
|
|
|
module.exports = function equal(a, b) { |
|
if (a === b) return true; |
|
|
|
var arrA = Array.isArray(a) |
|
, arrB = Array.isArray(b) |
|
, i; |
|
|
|
if (arrA && arrB) { |
|
if (a.length != b.length) return false; |
|
for (i = 0; i < a.length; i++) |
|
if (!equal(a[i], b[i])) return false; |
|
return true; |
|
} |
|
|
|
if (arrA != arrB) return false; |
|
|
|
if (a && b && typeof a === 'object' && typeof b === 'object') { |
|
var keys = Object.keys(a); |
|
if (keys.length !== Object.keys(b).length) return false; |
|
|
|
var dateA = a instanceof Date |
|
, dateB = b instanceof Date; |
|
if (dateA && dateB) return a.getTime() == b.getTime(); |
|
if (dateA != dateB) return false; |
|
|
|
var regexpA = a instanceof RegExp |
|
, regexpB = b instanceof RegExp; |
|
if (regexpA && regexpB) return a.toString() == b.toString(); |
|
if (regexpA != regexpB) return false; |
|
|
|
for (i = 0; i < keys.length; i++) |
|
if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false; |
|
|
|
for (i = 0; i < keys.length; i++) |
|
if(!equal(a[keys[i]], b[keys[i]])) return false; |
|
|
|
return true; |
|
} |
|
|
|
return false; |
|
}; |
|
|
|
},{}],42:[function(require,module,exports){ |
|
'use strict'; |
|
|
|
module.exports = function (data, opts) { |
|
if (!opts) opts = {}; |
|
if (typeof opts === 'function') opts = { cmp: opts }; |
|
var cycles = (typeof opts.cycles === 'boolean') ? opts.cycles : false; |
|
|
|
var cmp = opts.cmp && (function (f) { |
|
return function (node) { |
|
return function (a, b) { |
|
var aobj = { key: a, value: node[a] }; |
|
var bobj = { key: b, value: node[b] }; |
|
return f(aobj, bobj); |
|
}; |
|
}; |
|
})(opts.cmp); |
|
|
|
var seen = []; |
|
return (function stringify (node) { |
|
if (node && node.toJSON && typeof node.toJSON === 'function') { |
|
node = node.toJSON(); |
|
} |
|
|
|
if (node === undefined) return; |
|
if (typeof node == 'number') return isFinite(node) ? '' + node : 'null'; |
|
if (typeof node !== 'object') return JSON.stringify(node); |
|
|
|
var i, out; |
|
if (Array.isArray(node)) { |
|
out = '['; |
|
for (i = 0; i < node.length; i++) { |
|
if (i) out += ','; |
|
out += stringify(node[i]) || 'null'; |
|
} |
|
return out + ']'; |
|
} |
|
|
|
if (node === null) return 'null'; |
|
|
|
if (seen.indexOf(node) !== -1) { |
|
if (cycles) return JSON.stringify('__cycle__'); |
|
throw new TypeError('Converting circular structure to JSON'); |
|
} |
|
|
|
var seenIndex = seen.push(node) - 1; |
|
var keys = Object.keys(node).sort(cmp && cmp(node)); |
|
out = ''; |
|
for (i = 0; i < keys.length; i++) { |
|
var key = keys[i]; |
|
var value = stringify(node[key]); |
|
|
|
if (!value) continue; |
|
if (out) out += ','; |
|
out += JSON.stringify(key) + ':' + value; |
|
} |
|
seen.splice(seenIndex, 1); |
|
return '{' + out + '}'; |
|
})(data); |
|
}; |
|
|
|
},{}],43:[function(require,module,exports){ |
|
'use strict'; |
|
|
|
var traverse = module.exports = function (schema, opts, cb) { |
|
if (typeof opts == 'function') { |
|
cb = opts; |
|
opts = {}; |
|
} |
|
_traverse(opts, cb, schema, '', schema); |
|
}; |
|
|
|
|
|
traverse.keywords = { |
|
additionalItems: true, |
|
items: true, |
|
contains: true, |
|
additionalProperties: true, |
|
propertyNames: true, |
|
not: true |
|
}; |
|
|
|
traverse.arrayKeywords = { |
|
items: true, |
|
allOf: true, |
|
anyOf: true, |
|
oneOf: true |
|
}; |
|
|
|
traverse.propsKeywords = { |
|
definitions: true, |
|
properties: true, |
|
patternProperties: true, |
|
dependencies: true |
|
}; |
|
|
|
traverse.skipKeywords = { |
|
enum: true, |
|
const: true, |
|
required: true, |
|
maximum: true, |
|
minimum: true, |
|
exclusiveMaximum: true, |
|
exclusiveMinimum: true, |
|
multipleOf: true, |
|
maxLength: true, |
|
minLength: true, |
|
pattern: true, |
|
format: true, |
|
maxItems: true, |
|
minItems: true, |
|
uniqueItems: true, |
|
maxProperties: true, |
|
minProperties: true |
|
}; |
|
|
|
|
|
function _traverse(opts, cb, schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) { |
|
if (schema && typeof schema == 'object' && !Array.isArray(schema)) { |
|
cb(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex); |
|
for (var key in schema) { |
|
var sch = schema[key]; |
|
if (Array.isArray(sch)) { |
|
if (key in traverse.arrayKeywords) { |
|
for (var i=0; i<sch.length; i++) |
|
_traverse(opts, cb, sch[i], jsonPtr + '/' + key + '/' + i, rootSchema, jsonPtr, key, schema, i); |
|
} |
|
} else if (key in traverse.propsKeywords) { |
|
if (sch && typeof sch == 'object') { |
|
for (var prop in sch) |
|
_traverse(opts, cb, sch[prop], jsonPtr + '/' + key + '/' + escapeJsonPtr(prop), rootSchema, jsonPtr, key, schema, prop); |
|
} |
|
} else if (key in traverse.keywords || (opts.allKeys && !(key in traverse.skipKeywords))) { |
|
_traverse(opts, cb, sch, jsonPtr + '/' + key, rootSchema, jsonPtr, key, schema); |
|
} |
|
} |
|
} |
|
} |
|
|
|
|
|
function escapeJsonPtr(str) { |
|
return str.replace(/~/g, '~0').replace(/\//g, '~1'); |
|
} |
|
|
|
},{}],44:[function(require,module,exports){ |
|
(function (global){ |
|
/*! https://mths.be/punycode v1.4.1 by @mathias */ |
|
;(function(root) { |
|
|
|
/** Detect free variables */ |
|
var freeExports = typeof exports == 'object' && exports && |
|
!exports.nodeType && exports; |
|
var freeModule = typeof module == 'object' && module && |
|
!module.nodeType && module; |
|
var freeGlobal = typeof global == 'object' && global; |
|
if ( |
|
freeGlobal.global === freeGlobal || |
|
freeGlobal.window === freeGlobal || |
|
freeGlobal.self === freeGlobal |
|
) { |
|
root = freeGlobal; |
|
} |
|
|
|
/** |
|
* The `punycode` object. |
|
* @name punycode |
|
* @type Object |
|
*/ |
|
var punycode, |
|
|
|
/** Highest positive signed 32-bit float value */ |
|
maxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1 |
|
|
|
/** Bootstring parameters */ |
|
base = 36, |
|
tMin = 1, |
|
tMax = 26, |
|
skew = 38, |
|
damp = 700, |
|
initialBias = 72, |
|
initialN = 128, // 0x80 |
|
delimiter = '-', // '\x2D' |
|
|
|
/** Regular expressions */ |
|
regexPunycode = /^xn--/, |
|
regexNonASCII = /[^\x20-\x7E]/, // unprintable ASCII chars + non-ASCII chars |
|
regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, // RFC 3490 separators |
|
|
|
/** Error messages */ |
|
errors = { |
|
'overflow': 'Overflow: input needs wider integers to process', |
|
'not-basic': 'Illegal input >= 0x80 (not a basic code point)', |
|
'invalid-input': 'Invalid input' |
|
}, |
|
|
|
/** Convenience shortcuts */ |
|
baseMinusTMin = base - tMin, |
|
floor = Math.floor, |
|
stringFromCharCode = String.fromCharCode, |
|
|
|
/** Temporary variable */ |
|
key; |
|
|
|
/*--------------------------------------------------------------------------*/ |
|
|
|
/** |
|
* A generic error utility function. |
|
* @private |
|
* @param {String} type The error type. |
|
* @returns {Error} Throws a `RangeError` with the applicable error message. |
|
*/ |
|
function error(type) { |
|
throw new RangeError(errors[type]); |
|
} |
|
|
|
/** |
|
* A generic `Array#map` utility function. |
|
* @private |
|
* @param {Array} array The array to iterate over. |
|
* @param {Function} callback The function that gets called for every array |
|
* item. |
|
* @returns {Array} A new array of values returned by the callback function. |
|
*/ |
|
function map(array, fn) { |
|
var length = array.length; |
|
var result = []; |
|
while (length--) { |
|
result[length] = fn(array[length]); |
|
} |
|
return result; |
|
} |
|
|
|
/** |
|
* A simple `Array#map`-like wrapper to work with domain name strings or email |
|
* addresses. |
|
* @private |
|
* @param {String} domain The domain name or email address. |
|
* @param {Function} callback The function that gets called for every |
|
* character. |
|
* @returns {Array} A new string of characters returned by the callback |
|
* function. |
|
*/ |
|
function mapDomain(string, fn) { |
|
var parts = string.split('@'); |
|
var result = ''; |
|
if (parts.length > 1) { |
|
// In email addresses, only the domain name should be punycoded. Leave |
|
// the local part (i.e. everything up to `@`) intact. |
|
result = parts[0] + '@'; |
|
string = parts[1]; |
|
} |
|
// Avoid `split(regex)` for IE8 compatibility. See #17. |
|
string = string.replace(regexSeparators, '\x2E'); |
|
var labels = string.split('.'); |
|
var encoded = map(labels, fn).join('.'); |
|
return result + encoded; |
|
} |
|
|
|
/** |
|
* Creates an array containing the numeric code points of each Unicode |
|
* character in the string. While JavaScript uses UCS-2 internally, |
|
* this function will convert a pair of surrogate halves (each of which |
|
* UCS-2 exposes as separate characters) into a single code point, |
|
* matching UTF-16. |
|
* @see `punycode.ucs2.encode` |
|
* @see <https://mathiasbynens.be/notes/javascript-encoding> |
|
* @memberOf punycode.ucs2 |
|
* @name decode |
|
* @param {String} string The Unicode input string (UCS-2). |
|
* @returns {Array} The new array of code points. |
|
*/ |
|
function ucs2decode(string) { |
|
var output = [], |
|
counter = 0, |
|
length = string.length, |
|
value, |
|
extra; |
|
while (counter < length) { |
|
value = string.charCodeAt(counter++); |
|
if (value >= 0xD800 && value <= 0xDBFF && counter < length) { |
|
// high surrogate, and there is a next character |
|
extra = string.charCodeAt(counter++); |
|
if ((extra & 0xFC00) == 0xDC00) { // low surrogate |
|
output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000); |
|
} else { |
|
// unmatched surrogate; only append this code unit, in case the next |
|
// code unit is the high surrogate of a surrogate pair |
|
output.push(value); |
|
counter--; |
|
} |
|
} else { |
|
output.push(value); |
|
} |
|
} |
|
return output; |
|
} |
|
|
|
/** |
|
* Creates a string based on an array of numeric code points. |
|
* @see `punycode.ucs2.decode` |
|
* @memberOf punycode.ucs2 |
|
* @name encode |
|
* @param {Array} codePoints The array of numeric code points. |
|
* @returns {String} The new Unicode string (UCS-2). |
|
*/ |
|
function ucs2encode(array) { |
|
return map(array, function(value) { |
|
var output = ''; |
|
if (value > 0xFFFF) { |
|
value -= 0x10000; |
|
output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800); |
|
value = 0xDC00 | value & 0x3FF; |
|
} |
|
output += stringFromCharCode(value); |
|
return output; |
|
}).join(''); |
|
} |
|
|
|
/** |
|
* Converts a basic code point into a digit/integer. |
|
* @see `digitToBasic()` |
|
* @private |
|
* @param {Number} codePoint The basic numeric code point value. |
|
* @returns {Number} The numeric value of a basic code point (for use in |
|
* representing integers) in the range `0` to `base - 1`, or `base` if |
|
* the code point does not represent a value. |
|
*/ |
|
function basicToDigit(codePoint) { |
|
if (codePoint - 48 < 10) { |
|
return codePoint - 22; |
|
} |
|
if (codePoint - 65 < 26) { |
|
return codePoint - 65; |
|
} |
|
if (codePoint - 97 < 26) { |
|
return codePoint - 97; |
|
} |
|
return base; |
|
} |
|
|
|
/** |
|
* Converts a digit/integer into a basic code point. |
|
* @see `basicToDigit()` |
|
* @private |
|
* @param {Number} digit The numeric value of a basic code point. |
|
* @returns {Number} The basic code point whose value (when used for |
|
* representing integers) is `digit`, which needs to be in the range |
|
* `0` to `base - 1`. If `flag` is non-zero, the uppercase form is |
|
* used; else, the lowercase form is used. The behavior is undefined |
|
* if `flag` is non-zero and `digit` has no uppercase form. |
|
*/ |
|
function digitToBasic(digit, flag) { |
|
// 0..25 map to ASCII a..z or A..Z |
|
// 26..35 map to ASCII 0..9 |
|
return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5); |
|
} |
|
|
|
/** |
|
* Bias adaptation function as per section 3.4 of RFC 3492. |
|
* https://tools.ietf.org/html/rfc3492#section-3.4 |
|
* @private |
|
*/ |
|
function adapt(delta, numPoints, firstTime) { |
|
var k = 0; |
|
delta = firstTime ? floor(delta / damp) : delta >> 1; |
|
delta += floor(delta / numPoints); |
|
for (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) { |
|
delta = floor(delta / baseMinusTMin); |
|
} |
|
return floor(k + (baseMinusTMin + 1) * delta / (delta + skew)); |
|
} |
|
|
|
/** |
|
* Converts a Punycode string of ASCII-only symbols to a string of Unicode |
|
* symbols. |
|
* @memberOf punycode |
|
* @param {String} input The Punycode string of ASCII-only symbols. |
|
* @returns {String} The resulting string of Unicode symbols. |
|
*/ |
|
function decode(input) { |
|
// Don't use UCS-2 |
|
var output = [], |
|
inputLength = input.length, |
|
out, |
|
i = 0, |
|
n = initialN, |
|
bias = initialBias, |
|
basic, |
|
j, |
|
index, |
|
oldi, |
|
w, |
|
k, |
|
digit, |
|
t, |
|
/** Cached calculation results */ |
|
baseMinusT; |
|
|
|
// Handle the basic code points: let `basic` be the number of input code |
|
// points before the last delimiter, or `0` if there is none, then copy |
|
// the first basic code points to the output. |
|
|
|
basic = input.lastIndexOf(delimiter); |
|
if (basic < 0) { |
|
basic = 0; |
|
} |
|
|
|
for (j = 0; j < basic; ++j) { |
|
// if it's not a basic code point |
|
if (input.charCodeAt(j) >= 0x80) { |
|
error('not-basic'); |
|
} |
|
output.push(input.charCodeAt(j)); |
|
} |
|
|
|
// Main decoding loop: start just after the last delimiter if any basic code |
|
// points were copied; start at the beginning otherwise. |
|
|
|
for (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) { |
|
|
|
// `index` is the index of the next character to be consumed. |
|
// Decode a generalized variable-length integer into `delta`, |
|
// which gets added to `i`. The overflow checking is easier |
|
// if we increase `i` as we go, then subtract off its starting |
|
// value at the end to obtain `delta`. |
|
for (oldi = i, w = 1, k = base; /* no condition */; k += base) { |
|
|
|
if (index >= inputLength) { |
|
error('invalid-input'); |
|
} |
|
|
|
digit = basicToDigit(input.charCodeAt(index++)); |
|
|
|
if (digit >= base || digit > floor((maxInt - i) / w)) { |
|
error('overflow'); |
|
} |
|
|
|
i += digit * w; |
|
t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias); |
|
|
|
if (digit < t) { |
|
break; |
|
} |
|
|
|
baseMinusT = base - t; |
|
if (w > floor(maxInt / baseMinusT)) { |
|
error('overflow'); |
|
} |
|
|
|
w *= baseMinusT; |
|
|
|
} |
|
|
|
out = output.length + 1; |
|
bias = adapt(i - oldi, out, oldi == 0); |
|
|
|
// `i` was supposed to wrap around from `out` to `0`, |
|
// incrementing `n` each time, so we'll fix that now: |
|
if (floor(i / out) > maxInt - n) { |
|
error('overflow'); |
|
} |
|
|
|
n += floor(i / out); |
|
i %= out; |
|
|
|
// Insert `n` at position `i` of the output |
|
output.splice(i++, 0, n); |
|
|
|
} |
|
|
|
return ucs2encode(output); |
|
} |
|
|
|
/** |
|
* Converts a string of Unicode symbols (e.g. a domain name label) to a |
|
* Punycode string of ASCII-only symbols. |
|
* @memberOf punycode |
|
* @param {String} input The string of Unicode symbols. |
|
* @returns {String} The resulting Punycode string of ASCII-only symbols. |
|
*/ |
|
function encode(input) { |
|
var n, |
|
delta, |
|
handledCPCount, |
|
basicLength, |
|
bias, |
|
j, |
|
m, |
|
q, |
|
k, |
|
t, |
|
currentValue, |
|
output = [], |
|
/** `inputLength` will hold the number of code points in `input`. */ |
|
inputLength, |
|
/** Cached calculation results */ |
|
handledCPCountPlusOne, |
|
baseMinusT, |
|
qMinusT; |
|
|
|
// Convert the input in UCS-2 to Unicode |
|
input = ucs2decode(input); |
|
|
|
// Cache the length |
|
inputLength = input.length; |
|
|
|
// Initialize the state |
|
n = initialN; |
|
delta = 0; |
|
bias = initialBias; |
|
|
|
// Handle the basic code points |
|
for (j = 0; j < inputLength; ++j) { |
|
currentValue = input[j]; |
|
if (currentValue < 0x80) { |
|
output.push(stringFromCharCode(currentValue)); |
|
} |
|
} |
|
|
|
handledCPCount = basicLength = output.length; |
|
|
|
// `handledCPCount` is the number of code points that have been handled; |
|
// `basicLength` is the number of basic code points. |
|
|
|
// Finish the basic string - if it is not empty - with a delimiter |
|
if (basicLength) { |
|
output.push(delimiter); |
|
} |
|
|
|
// Main encoding loop: |
|
while (handledCPCount < inputLength) { |
|
|
|
// All non-basic code points < n have been handled already. Find the next |
|
// larger one: |
|
for (m = maxInt, j = 0; j < inputLength; ++j) { |
|
currentValue = input[j]; |
|
if (currentValue >= n && currentValue < m) { |
|
m = currentValue; |
|
} |
|
} |
|
|
|
// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>, |
|
// but guard against overflow |
|
handledCPCountPlusOne = handledCPCount + 1; |
|
if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) { |
|
error('overflow'); |
|
} |
|
|
|
delta += (m - n) * handledCPCountPlusOne; |
|
n = m; |
|
|
|
for (j = 0; j < inputLength; ++j) { |
|
currentValue = input[j]; |
|
|
|
if (currentValue < n && ++delta > maxInt) { |
|
error('overflow'); |
|
} |
|
|
|
if (currentValue == n) { |
|
// Represent delta as a generalized variable-length integer |
|
for (q = delta, k = base; /* no condition */; k += base) { |
|
t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias); |
|
if (q < t) { |
|
break; |
|
} |
|
qMinusT = q - t; |
|
baseMinusT = base - t; |
|
output.push( |
|
stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0)) |
|
); |
|
q = floor(qMinusT / baseMinusT); |
|
} |
|
|
|
output.push(stringFromCharCode(digitToBasic(q, 0))); |
|
bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength); |
|
delta = 0; |
|
++handledCPCount; |
|
} |
|
} |
|
|
|
++delta; |
|
++n; |
|
|
|
} |
|
return output.join(''); |
|
} |
|
|
|
/** |
|
* Converts a Punycode string representing a domain name or an email address |
|
* to Unicode. Only the Punycoded parts of the input will be converted, i.e. |
|
* it doesn't matter if you call it on a string that has already been |
|
* converted to Unicode. |
|
* @memberOf punycode |
|
* @param {String} input The Punycoded domain name or email address to |
|
* convert to Unicode. |
|
* @returns {String} The Unicode representation of the given Punycode |
|
* string. |
|
*/ |
|
function toUnicode(input) { |
|
return mapDomain(input, function(string) { |
|
return regexPunycode.test(string) |
|
? decode(string.slice(4).toLowerCase()) |
|
: string; |
|
}); |
|
} |
|
|
|
/** |
|
* Converts a Unicode string representing a domain name or an email address to |
|
* Punycode. Only the non-ASCII parts of the domain name will be converted, |
|
* i.e. it doesn't matter if you call it with a domain that's already in |
|
* ASCII. |
|
* @memberOf punycode |
|
* @param {String} input The domain name or email address to convert, as a |
|
* Unicode string. |
|
* @returns {String} The Punycode representation of the given domain name or |
|
* email address. |
|
*/ |
|
function toASCII(input) { |
|
return mapDomain(input, function(string) { |
|
return regexNonASCII.test(string) |
|
? 'xn--' + encode(string) |
|
: string; |
|
}); |
|
} |
|
|
|
/*--------------------------------------------------------------------------*/ |
|
|
|
/** Define the public API */ |
|
punycode = { |
|
/** |
|
* A string representing the current Punycode.js version number. |
|
* @memberOf punycode |
|
* @type String |
|
*/ |
|
'version': '1.4.1', |
|
/** |
|
* An object of methods to convert from JavaScript's internal character |
|
* representation (UCS-2) to Unicode code points, and back. |
|
* @see <https://mathiasbynens.be/notes/javascript-encoding> |
|
* @memberOf punycode |
|
* @type Object |
|
*/ |
|
'ucs2': { |
|
'decode': ucs2decode, |
|
'encode': ucs2encode |
|
}, |
|
'decode': decode, |
|
'encode': encode, |
|
'toASCII': toASCII, |
|
'toUnicode': toUnicode |
|
}; |
|
|
|
/** Expose `punycode` */ |
|
// Some AMD build optimizers, like r.js, check for specific condition patterns |
|
// like the following: |
|
if ( |
|
typeof define == 'function' && |
|
typeof define.amd == 'object' && |
|
define.amd |
|
) { |
|
define('punycode', function() { |
|
return punycode; |
|
}); |
|
} else if (freeExports && freeModule) { |
|
if (module.exports == freeExports) { |
|
// in Node.js, io.js, or RingoJS v0.8.0+ |
|
freeModule.exports = punycode; |
|
} else { |
|
// in Narwhal or RingoJS v0.7.0- |
|
for (key in punycode) { |
|
punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]); |
|
} |
|
} |
|
} else { |
|
// in Rhino or a web browser |
|
root.punycode = punycode; |
|
} |
|
|
|
}(this)); |
|
|
|
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) |
|
},{}],45:[function(require,module,exports){ |
|
// Copyright Joyent, Inc. and other Node contributors. |
|
// |
|
// Permission is hereby granted, free of charge, to any person obtaining a |
|
// copy of this software and associated documentation files (the |
|
// "Software"), to deal in the Software without restriction, including |
|
// without limitation the rights to use, copy, modify, merge, publish, |
|
// distribute, sublicense, and/or sell copies of the Software, and to permit |
|
// persons to whom the Software is furnished to do so, subject to the |
|
// following conditions: |
|
// |
|
// The above copyright notice and this permission notice shall be included |
|
// in all copies or substantial portions of the Software. |
|
// |
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
|
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN |
|
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, |
|
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR |
|
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE |
|
// USE OR OTHER DEALINGS IN THE SOFTWARE. |
|
|
|
'use strict'; |
|
|
|
// If obj.hasOwnProperty has been overridden, then calling |
|
// obj.hasOwnProperty(prop) will break. |
|
// See: https://github.com/joyent/node/issues/1707 |
|
function hasOwnProperty(obj, prop) { |
|
return Object.prototype.hasOwnProperty.call(obj, prop); |
|
} |
|
|
|
module.exports = function(qs, sep, eq, options) { |
|
sep = sep || '&'; |
|
eq = eq || '='; |
|
var obj = {}; |
|
|
|
if (typeof qs !== 'string' || qs.length === 0) { |
|
return obj; |
|
} |
|
|
|
var regexp = /\+/g; |
|
qs = qs.split(sep); |
|
|
|
var maxKeys = 1000; |
|
if (options && typeof options.maxKeys === 'number') { |
|
maxKeys = options.maxKeys; |
|
} |
|
|
|
var len = qs.length; |
|
// maxKeys <= 0 means that we should not limit keys count |
|
if (maxKeys > 0 && len > maxKeys) { |
|
len = maxKeys; |
|
} |
|
|
|
for (var i = 0; i < len; ++i) { |
|
var x = qs[i].replace(regexp, '%20'), |
|
idx = x.indexOf(eq), |
|
kstr, vstr, k, v; |
|
|
|
if (idx >= 0) { |
|
kstr = x.substr(0, idx); |
|
vstr = x.substr(idx + 1); |
|
} else { |
|
kstr = x; |
|
vstr = ''; |
|
} |
|
|
|
k = decodeURIComponent(kstr); |
|
v = decodeURIComponent(vstr); |
|
|
|
if (!hasOwnProperty(obj, k)) { |
|
obj[k] = v; |
|
} else if (isArray(obj[k])) { |
|
obj[k].push(v); |
|
} else { |
|
obj[k] = [obj[k], v]; |
|
} |
|
} |
|
|
|
return obj; |
|
}; |
|
|
|
var isArray = Array.isArray || function (xs) { |
|
return Object.prototype.toString.call(xs) === '[object Array]'; |
|
}; |
|
|
|
},{}],46:[function(require,module,exports){ |
|
// Copyright Joyent, Inc. and other Node contributors. |
|
// |
|
// Permission is hereby granted, free of charge, to any person obtaining a |
|
// copy of this software and associated documentation files (the |
|
// "Software"), to deal in the Software without restriction, including |
|
// without limitation the rights to use, copy, modify, merge, publish, |
|
// distribute, sublicense, and/or sell copies of the Software, and to permit |
|
// persons to whom the Software is furnished to do so, subject to the |
|
// following conditions: |
|
// |
|
// The above copyright notice and this permission notice shall be included |
|
// in all copies or substantial portions of the Software. |
|
// |
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
|
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN |
|
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, |
|
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR |
|
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE |
|
// USE OR OTHER DEALINGS IN THE SOFTWARE. |
|
|
|
'use strict'; |
|
|
|
var stringifyPrimitive = function(v) { |
|
switch (typeof v) { |
|
case 'string': |
|
return v; |
|
|
|
case 'boolean': |
|
return v ? 'true' : 'false'; |
|
|
|
case 'number': |
|
return isFinite(v) ? v : ''; |
|
|
|
default: |
|
return ''; |
|
} |
|
}; |
|
|
|
module.exports = function(obj, sep, eq, name) { |
|
sep = sep || '&'; |
|
eq = eq || '='; |
|
if (obj === null) { |
|
obj = undefined; |
|
} |
|
|
|
if (typeof obj === 'object') { |
|
return map(objectKeys(obj), function(k) { |
|
var ks = encodeURIComponent(stringifyPrimitive(k)) + eq; |
|
if (isArray(obj[k])) { |
|
return map(obj[k], function(v) { |
|
return ks + encodeURIComponent(stringifyPrimitive(v)); |
|
}).join(sep); |
|
} else { |
|
return ks + encodeURIComponent(stringifyPrimitive(obj[k])); |
|
} |
|
}).join(sep); |
|
|
|
} |
|
|
|
if (!name) return ''; |
|
return encodeURIComponent(stringifyPrimitive(name)) + eq + |
|
encodeURIComponent(stringifyPrimitive(obj)); |
|
}; |
|
|
|
var isArray = Array.isArray || function (xs) { |
|
return Object.prototype.toString.call(xs) === '[object Array]'; |
|
}; |
|
|
|
function map (xs, f) { |
|
if (xs.map) return xs.map(f); |
|
var res = []; |
|
for (var i = 0; i < xs.length; i++) { |
|
res.push(f(xs[i], i)); |
|
} |
|
return res; |
|
} |
|
|
|
var objectKeys = Object.keys || function (obj) { |
|
var res = []; |
|
for (var key in obj) { |
|
if (Object.prototype.hasOwnProperty.call(obj, key)) res.push(key); |
|
} |
|
return res; |
|
}; |
|
|
|
},{}],47:[function(require,module,exports){ |
|
'use strict'; |
|
|
|
exports.decode = exports.parse = require('./decode'); |
|
exports.encode = exports.stringify = require('./encode'); |
|
|
|
},{"./decode":45,"./encode":46}],48:[function(require,module,exports){ |
|
// Copyright Joyent, Inc. and other Node contributors. |
|
// |
|
// Permission is hereby granted, free of charge, to any person obtaining a |
|
// copy of this software and associated documentation files (the |
|
// "Software"), to deal in the Software without restriction, including |
|
// without limitation the rights to use, copy, modify, merge, publish, |
|
// distribute, sublicense, and/or sell copies of the Software, and to permit |
|
// persons to whom the Software is furnished to do so, subject to the |
|
// following conditions: |
|
// |
|
// The above copyright notice and this permission notice shall be included |
|
// in all copies or substantial portions of the Software. |
|
// |
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
|
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN |
|
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, |
|
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR |
|
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE |
|
// USE OR OTHER DEALINGS IN THE SOFTWARE. |
|
|
|
'use strict'; |
|
|
|
var punycode = require('punycode'); |
|
var util = require('./util'); |
|
|
|
exports.parse = urlParse; |
|
exports.resolve = urlResolve; |
|
exports.resolveObject = urlResolveObject; |
|
exports.format = urlFormat; |
|
|
|
exports.Url = Url; |
|
|
|
function Url() { |
|
this.protocol = null; |
|
this.slashes = null; |
|
this.auth = null; |
|
this.host = null; |
|
this.port = null; |
|
this.hostname = null; |
|
this.hash = null; |
|
this.search = null; |
|
this.query = null; |
|
this.pathname = null; |
|
this.path = null; |
|
this.href = null; |
|
} |
|
|
|
// Reference: RFC 3986, RFC 1808, RFC 2396 |
|
|
|
// define these here so at least they only have to be |
|
// compiled once on the first module load. |
|
var protocolPattern = /^([a-z0-9.+-]+:)/i, |
|
portPattern = /:[0-9]*$/, |
|
|
|
// Special case for a simple path URL |
|
simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/, |
|
|
|
// RFC 2396: characters reserved for delimiting URLs. |
|
// We actually just auto-escape these. |
|
delims = ['<', '>', '"', '`', ' ', '\r', '\n', '\t'], |
|
|
|
// RFC 2396: characters not allowed for various reasons. |
|
unwise = ['{', '}', '|', '\\', '^', '`'].concat(delims), |
|
|
|
// Allowed by RFCs, but cause of XSS attacks. Always escape these. |
|
autoEscape = ['\''].concat(unwise), |
|
// Characters that are never ever allowed in a hostname. |
|
// Note that any invalid chars are also handled, but these |
|
// are the ones that are *expected* to be seen, so we fast-path |
|
// them. |
|
nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape), |
|
hostEndingChars = ['/', '?', '#'], |
|
hostnameMaxLen = 255, |
|
hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/, |
|
hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/, |
|
// protocols that can allow "unsafe" and "unwise" chars. |
|
unsafeProtocol = { |
|
'javascript': true, |
|
'javascript:': true |
|
}, |
|
// protocols that never have a hostname. |
|
hostlessProtocol = { |
|
'javascript': true, |
|
'javascript:': true |
|
}, |
|
// protocols that always contain a // bit. |
|
slashedProtocol = { |
|
'http': true, |
|
'https': true, |
|
'ftp': true, |
|
'gopher': true, |
|
'file': true, |
|
'http:': true, |
|
'https:': true, |
|
'ftp:': true, |
|
'gopher:': true, |
|
'file:': true |
|
}, |
|
querystring = require('querystring'); |
|
|
|
function urlParse(url, parseQueryString, slashesDenoteHost) { |
|
if (url && util.isObject(url) && url instanceof Url) return url; |
|
|
|
var u = new Url; |
|
u.parse(url, parseQueryString, slashesDenoteHost); |
|
return u; |
|
} |
|
|
|
Url.prototype.parse = function(url, parseQueryString, slashesDenoteHost) { |
|
if (!util.isString(url)) { |
|
throw new TypeError("Parameter 'url' must be a string, not " + typeof url); |
|
} |
|
|
|
// Copy chrome, IE, opera backslash-handling behavior. |
|
// Back slashes before the query string get converted to forward slashes |
|
// See: https://code.google.com/p/chromium/issues/detail?id=25916 |
|
var queryIndex = url.indexOf('?'), |
|
splitter = |
|
(queryIndex !== -1 && queryIndex < url.indexOf('#')) ? '?' : '#', |
|
uSplit = url.split(splitter), |
|
slashRegex = /\\/g; |
|
uSplit[0] = uSplit[0].replace(slashRegex, '/'); |
|
url = uSplit.join(splitter); |
|
|
|
var rest = url; |
|
|
|
// trim before proceeding. |
|
// This is to support parse stuff like " http://foo.com \n" |
|
rest = rest.trim(); |
|
|
|
if (!slashesDenoteHost && url.split('#').length === 1) { |
|
// Try fast path regexp |
|
var simplePath = simplePathPattern.exec(rest); |
|
if (simplePath) { |
|
this.path = rest; |
|
this.href = rest; |
|
this.pathname = simplePath[1]; |
|
if (simplePath[2]) { |
|
this.search = simplePath[2]; |
|
if (parseQueryString) { |
|
this.query = querystring.parse(this.search.substr(1)); |
|
} else { |
|
this.query = this.search.substr(1); |
|
} |
|
} else if (parseQueryString) { |
|
this.search = ''; |
|
this.query = {}; |
|
} |
|
return this; |
|
} |
|
} |
|
|
|
var proto = protocolPattern.exec(rest); |
|
if (proto) { |
|
proto = proto[0]; |
|
var lowerProto = proto.toLowerCase(); |
|
this.protocol = lowerProto; |
|
rest = rest.substr(proto.length); |
|
} |
|
|
|
// figure out if it's got a host |
|
// user@server is *always* interpreted as a hostname, and url |
|
// resolution will treat //foo/bar as host=foo,path=bar because that's |
|
// how the browser resolves relative URLs. |
|
if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) { |
|
var slashes = rest.substr(0, 2) === '//'; |
|
if (slashes && !(proto && hostlessProtocol[proto])) { |
|
rest = rest.substr(2); |
|
this.slashes = true; |
|
} |
|
} |
|
|
|
if (!hostlessProtocol[proto] && |
|
(slashes || (proto && !slashedProtocol[proto]))) { |
|
|
|
// there's a hostname. |
|
// the first instance of /, ?, ;, or # ends the host. |
|
// |
|
// If there is an @ in the hostname, then non-host chars *are* allowed |
|
// to the left of the last @ sign, unless some host-ending character |
|
// comes *before* the @-sign. |
|
// URLs are obnoxious. |
|
// |
|
// ex: |
|
// http://a@b@c/ => user:a@b host:c |
|
// http://a@b?@c => user:a host:c path:/?@c |
|
|
|
// v0.12 TODO(isaacs): This is not quite how Chrome does things. |
|
// Review our test case against browsers more comprehensively. |
|
|
|
// find the first instance of any hostEndingChars |
|
var hostEnd = -1; |
|
for (var i = 0; i < hostEndingChars.length; i++) { |
|
var hec = rest.indexOf(hostEndingChars[i]); |
|
if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) |
|
hostEnd = hec; |
|
} |
|
|
|
// at this point, either we have an explicit point where the |
|
// auth portion cannot go past, or the last @ char is the decider. |
|
var auth, atSign; |
|
if (hostEnd === -1) { |
|
// atSign can be anywhere. |
|
atSign = rest.lastIndexOf('@'); |
|
} else { |
|
// atSign must be in auth portion. |
|
// http://a@b/c@d => host:b auth:a path:/c@d |
|
atSign = rest.lastIndexOf('@', hostEnd); |
|
} |
|
|
|
// Now we have a portion which is definitely the auth. |
|
// Pull that off. |
|
if (atSign !== -1) { |
|
auth = rest.slice(0, atSign); |
|
rest = rest.slice(atSign + 1); |
|
this.auth = decodeURIComponent(auth); |
|
} |
|
|
|
// the host is the remaining to the left of the first non-host char |
|
hostEnd = -1; |
|
for (var i = 0; i < nonHostChars.length; i++) { |
|
var hec = rest.indexOf(nonHostChars[i]); |
|
if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) |
|
hostEnd = hec; |
|
} |
|
// if we still have not hit it, then the entire thing is a host. |
|
if (hostEnd === -1) |
|
hostEnd = rest.length; |
|
|
|
this.host = rest.slice(0, hostEnd); |
|
rest = rest.slice(hostEnd); |
|
|
|
// pull out port. |
|
this.parseHost(); |
|
|
|
// we've indicated that there is a hostname, |
|
// so even if it's empty, it has to be present. |
|
this.hostname = this.hostname || ''; |
|
|
|
// if hostname begins with [ and ends with ] |
|
// assume that it's an IPv6 address. |
|
var ipv6Hostname = this.hostname[0] === '[' && |
|
this.hostname[this.hostname.length - 1] === ']'; |
|
|
|
// validate a little. |
|
if (!ipv6Hostname) { |
|
var hostparts = this.hostname.split(/\./); |
|
for (var i = 0, l = hostparts.length; i < l; i++) { |
|
var part = hostparts[i]; |
|
if (!part) continue; |
|
if (!part.match(hostnamePartPattern)) { |
|
var newpart = ''; |
|
for (var j = 0, k = part.length; j < k; j++) { |
|
if (part.charCodeAt(j) > 127) { |
|
// we replace non-ASCII char with a temporary placeholder |
|
// we need this to make sure size of hostname is not |
|
// broken by replacing non-ASCII by nothing |
|
newpart += 'x'; |
|
} else { |
|
newpart += part[j]; |
|
} |
|
} |
|
// we test again with ASCII char only |
|
if (!newpart.match(hostnamePartPattern)) { |
|
var validParts = hostparts.slice(0, i); |
|
var notHost = hostparts.slice(i + 1); |
|
var bit = part.match(hostnamePartStart); |
|
if (bit) { |
|
validParts.push(bit[1]); |
|
notHost.unshift(bit[2]); |
|
} |
|
if (notHost.length) { |
|
rest = '/' + notHost.join('.') + rest; |
|
} |
|
this.hostname = validParts.join('.'); |
|
break; |
|
} |
|
} |
|
} |
|
} |
|
|
|
if (this.hostname.length > hostnameMaxLen) { |
|
this.hostname = ''; |
|
} else { |
|
// hostnames are always lower case. |
|
this.hostname = this.hostname.toLowerCase(); |
|
} |
|
|
|
if (!ipv6Hostname) { |
|
// IDNA Support: Returns a punycoded representation of "domain". |
|
// It only converts parts of the domain name that |
|
// have non-ASCII characters, i.e. it doesn't matter if |
|
// you call it with a domain that already is ASCII-only. |
|
this.hostname = punycode.toASCII(this.hostname); |
|
} |
|
|
|
var p = this.port ? ':' + this.port : ''; |
|
var h = this.hostname || ''; |
|
this.host = h + p; |
|
this.href += this.host; |
|
|
|
// strip [ and ] from the hostname |
|
// the host field still retains them, though |
|
if (ipv6Hostname) { |
|
this.hostname = this.hostname.substr(1, this.hostname.length - 2); |
|
if (rest[0] !== '/') { |
|
rest = '/' + rest; |
|
} |
|
} |
|
} |
|
|
|
// now rest is set to the post-host stuff. |
|
// chop off any delim chars. |
|
if (!unsafeProtocol[lowerProto]) { |
|
|
|
// First, make 100% sure that any "autoEscape" chars get |
|
// escaped, even if encodeURIComponent doesn't think they |
|
// need to be. |
|
for (var i = 0, l = autoEscape.length; i < l; i++) { |
|
var ae = autoEscape[i]; |
|
if (rest.indexOf(ae) === -1) |
|
continue; |
|
var esc = encodeURIComponent(ae); |
|
if (esc === ae) { |
|
esc = escape(ae); |
|
} |
|
rest = rest.split(ae).join(esc); |
|
} |
|
} |
|
|
|
|
|
// chop off from the tail first. |
|
var hash = rest.indexOf('#'); |
|
if (hash !== -1) { |
|
// got a fragment string. |
|
this.hash = rest.substr(hash); |
|
rest = rest.slice(0, hash); |
|
} |
|
var qm = rest.indexOf('?'); |
|
if (qm !== -1) { |
|
this.search = rest.substr(qm); |
|
this.query = rest.substr(qm + 1); |
|
if (parseQueryString) { |
|
this.query = querystring.parse(this.query); |
|
} |
|
rest = rest.slice(0, qm); |
|
} else if (parseQueryString) { |
|
// no query string, but parseQueryString still requested |
|
this.search = ''; |
|
this.query = {}; |
|
} |
|
if (rest) this.pathname = rest; |
|
if (slashedProtocol[lowerProto] && |
|
this.hostname && !this.pathname) { |
|
this.pathname = '/'; |
|
} |
|
|
|
//to support http.request |
|
if (this.pathname || this.search) { |
|
var p = this.pathname || ''; |
|
var s = this.search || ''; |
|
this.path = p + s; |
|
} |
|
|
|
// finally, reconstruct the href based on what has been validated. |
|
this.href = this.format(); |
|
return this; |
|
}; |
|
|
|
// format a parsed object into a url string |
|
function urlFormat(obj) { |
|
// ensure it's an object, and not a string url. |
|
// If it's an obj, this is a no-op. |
|
// this way, you can call url_format() on strings |
|
// to clean up potentially wonky urls. |
|
if (util.isString(obj)) obj = urlParse(obj); |
|
if (!(obj instanceof Url)) return Url.prototype.format.call(obj); |
|
return obj.format(); |
|
} |
|
|
|
Url.prototype.format = function() { |
|
var auth = this.auth || ''; |
|
if (auth) { |
|
auth = encodeURIComponent(auth); |
|
auth = auth.replace(/%3A/i, ':'); |
|
auth += '@'; |
|
} |
|
|
|
var protocol = this.protocol || '', |
|
pathname = this.pathname || '', |
|
hash = this.hash || '', |
|
host = false, |
|
query = ''; |
|
|
|
if (this.host) { |
|
host = auth + this.host; |
|
} else if (this.hostname) { |
|
host = auth + (this.hostname.indexOf(':') === -1 ? |
|
this.hostname : |
|
'[' + this.hostname + ']'); |
|
if (this.port) { |
|
host += ':' + this.port; |
|
} |
|
} |
|
|
|
if (this.query && |
|
util.isObject(this.query) && |
|
Object.keys(this.query).length) { |
|
query = querystring.stringify(this.query); |
|
} |
|
|
|
var search = this.search || (query && ('?' + query)) || ''; |
|
|
|
if (protocol && protocol.substr(-1) !== ':') protocol += ':'; |
|
|
|
// only the slashedProtocols get the //. Not mailto:, xmpp:, etc. |
|
// unless they had them to begin with. |
|
if (this.slashes || |
|
(!protocol || slashedProtocol[protocol]) && host !== false) { |
|
host = '//' + (host || ''); |
|
if (pathname && pathname.charAt(0) !== '/') pathname = '/' + pathname; |
|
} else if (!host) { |
|
host = ''; |
|
} |
|
|
|
if (hash && hash.charAt(0) !== '#') hash = '#' + hash; |
|
if (search && search.charAt(0) !== '?') search = '?' + search; |
|
|
|
pathname = pathname.replace(/[?#]/g, function(match) { |
|
return encodeURIComponent(match); |
|
}); |
|
search = search.replace('#', '%23'); |
|
|
|
return protocol + host + pathname + search + hash; |
|
}; |
|
|
|
function urlResolve(source, relative) { |
|
return urlParse(source, false, true).resolve(relative); |
|
} |
|
|
|
Url.prototype.resolve = function(relative) { |
|
return this.resolveObject(urlParse(relative, false, true)).format(); |
|
}; |
|
|
|
function urlResolveObject(source, relative) { |
|
if (!source) return relative; |
|
return urlParse(source, false, true).resolveObject(relative); |
|
} |
|
|
|
Url.prototype.resolveObject = function(relative) { |
|
if (util.isString(relative)) { |
|
var rel = new Url(); |
|
rel.parse(relative, false, true); |
|
relative = rel; |
|
} |
|
|
|
var result = new Url(); |
|
var tkeys = Object.keys(this); |
|
for (var tk = 0; tk < tkeys.length; tk++) { |
|
var tkey = tkeys[tk]; |
|
result[tkey] = this[tkey]; |
|
} |
|
|
|
// hash is always overridden, no matter what. |
|
// even href="" will remove it. |
|
result.hash = relative.hash; |
|
|
|
// if the relative url is empty, then there's nothing left to do here. |
|
if (relative.href === '') { |
|
result.href = result.format(); |
|
return result; |
|
} |
|
|
|
// hrefs like //foo/bar always cut to the protocol. |
|
if (relative.slashes && !relative.protocol) { |
|
// take everything except the protocol from relative |
|
var rkeys = Object.keys(relative); |
|
for (var rk = 0; rk < rkeys.length; rk++) { |
|
var rkey = rkeys[rk]; |
|
if (rkey !== 'protocol') |
|
result[rkey] = relative[rkey]; |
|
} |
|
|
|
//urlParse appends trailing / to urls like http://www.example.com |
|
if (slashedProtocol[result.protocol] && |
|
result.hostname && !result.pathname) { |
|
result.path = result.pathname = '/'; |
|
} |
|
|
|
result.href = result.format(); |
|
return result; |
|
} |
|
|
|
if (relative.protocol && relative.protocol !== result.protocol) { |
|
// if it's a known url protocol, then changing |
|
// the protocol does weird things |
|
// first, if it's not file:, then we MUST have a host, |
|
// and if there was a path |
|
// to begin with, then we MUST have a path. |
|
// if it is file:, then the host is dropped, |
|
// because that's known to be hostless. |
|
// anything else is assumed to be absolute. |
|
if (!slashedProtocol[relative.protocol]) { |
|
var keys = Object.keys(relative); |
|
for (var v = 0; v < keys.length; v++) { |
|
var k = keys[v]; |
|
result[k] = relative[k]; |
|
} |
|
result.href = result.format(); |
|
return result; |
|
} |
|
|
|
result.protocol = relative.protocol; |
|
if (!relative.host && !hostlessProtocol[relative.protocol]) { |
|
var relPath = (relative.pathname || '').split('/'); |
|
while (relPath.length && !(relative.host = relPath.shift())); |
|
if (!relative.host) relative.host = ''; |
|
if (!relative.hostname) relative.hostname = ''; |
|
if (relPath[0] !== '') relPath.unshift(''); |
|
if (relPath.length < 2) relPath.unshift(''); |
|
result.pathname = relPath.join('/'); |
|
} else { |
|
result.pathname = relative.pathname; |
|
} |
|
result.search = relative.search; |
|
result.query = relative.query; |
|
result.host = relative.host || ''; |
|
result.auth = relative.auth; |
|
result.hostname = relative.hostname || relative.host; |
|
result.port = relative.port; |
|
// to support http.request |
|
if (result.pathname || result.search) { |
|
var p = result.pathname || ''; |
|
var s = result.search || ''; |
|
result.path = p + s; |
|
} |
|
result.slashes = result.slashes || relative.slashes; |
|
result.href = result.format(); |
|
return result; |
|
} |
|
|
|
var isSourceAbs = (result.pathname && result.pathname.charAt(0) === '/'), |
|
isRelAbs = ( |
|
relative.host || |
|
relative.pathname && relative.pathname.charAt(0) === '/' |
|
), |
|
mustEndAbs = (isRelAbs || isSourceAbs || |
|
(result.host && relative.pathname)), |
|
removeAllDots = mustEndAbs, |
|
srcPath = result.pathname && result.pathname.split('/') || [], |
|
relPath = relative.pathname && relative.pathname.split('/') || [], |
|
psychotic = result.protocol && !slashedProtocol[result.protocol]; |
|
|
|
// if the url is a non-slashed url, then relative |
|
// links like ../.. should be able |
|
// to crawl up to the hostname, as well. This is strange. |
|
// result.protocol has already been set by now. |
|
// Later on, put the first path part into the host field. |
|
if (psychotic) { |
|
result.hostname = ''; |
|
result.port = null; |
|
if (result.host) { |
|
if (srcPath[0] === '') srcPath[0] = result.host; |
|
else srcPath.unshift(result.host); |
|
} |
|
result.host = ''; |
|
if (relative.protocol) { |
|
relative.hostname = null; |
|
relative.port = null; |
|
if (relative.host) { |
|
if (relPath[0] === '') relPath[0] = relative.host; |
|
else relPath.unshift(relative.host); |
|
} |
|
relative.host = null; |
|
} |
|
mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === ''); |
|
} |
|
|
|
if (isRelAbs) { |
|
// it's absolute. |
|
result.host = (relative.host || relative.host === '') ? |
|
relative.host : result.host; |
|
result.hostname = (relative.hostname || relative.hostname === '') ? |
|
relative.hostname : result.hostname; |
|
result.search = relative.search; |
|
result.query = relative.query; |
|
srcPath = relPath; |
|
// fall through to the dot-handling below. |
|
} else if (relPath.length) { |
|
// it's relative |
|
// throw away the existing file, and take the new path instead. |
|
if (!srcPath) srcPath = []; |
|
srcPath.pop(); |
|
srcPath = srcPath.concat(relPath); |
|
result.search = relative.search; |
|
result.query = relative.query; |
|
} else if (!util.isNullOrUndefined(relative.search)) { |
|
// just pull out the search. |
|
// like href='?foo'. |
|
// Put this after the other two cases because it simplifies the booleans |
|
if (psychotic) { |
|
result.hostname = result.host = srcPath.shift(); |
|
//occationaly the auth can get stuck only in host |
|
//this especially happens in cases like |
|
//url.resolveObject('mailto:local1@domain1', 'local2@domain2') |
|
var authInHost = result.host && result.host.indexOf('@') > 0 ? |
|
result.host.split('@') : false; |
|
if (authInHost) { |
|
result.auth = authInHost.shift(); |
|
result.host = result.hostname = authInHost.shift(); |
|
} |
|
} |
|
result.search = relative.search; |
|
result.query = relative.query; |
|
//to support http.request |
|
if (!util.isNull(result.pathname) || !util.isNull(result.search)) { |
|
result.path = (result.pathname ? result.pathname : '') + |
|
(result.search ? result.search : ''); |
|
} |
|
result.href = result.format(); |
|
return result; |
|
} |
|
|
|
if (!srcPath.length) { |
|
// no path at all. easy. |
|
// we've already handled the other stuff above. |
|
result.pathname = null; |
|
//to support http.request |
|
if (result.search) { |
|
result.path = '/' + result.search; |
|
} else { |
|
result.path = null; |
|
} |
|
result.href = result.format(); |
|
return result; |
|
} |
|
|
|
// if a url ENDs in . or .., then it must get a trailing slash. |
|
// however, if it ends in anything else non-slashy, |
|
// then it must NOT get a trailing slash. |
|
var last = srcPath.slice(-1)[0]; |
|
var hasTrailingSlash = ( |
|
(result.host || relative.host || srcPath.length > 1) && |
|
(last === '.' || last === '..') || last === ''); |
|
|
|
// strip single dots, resolve double dots to parent dir |
|
// if the path tries to go above the root, `up` ends up > 0 |
|
var up = 0; |
|
for (var i = srcPath.length; i >= 0; i--) { |
|
last = srcPath[i]; |
|
if (last === '.') { |
|
srcPath.splice(i, 1); |
|
} else if (last === '..') { |
|
srcPath.splice(i, 1); |
|
up++; |
|
} else if (up) { |
|
srcPath.splice(i, 1); |
|
up--; |
|
} |
|
} |
|
|
|
// if the path is allowed to go above the root, restore leading ..s |
|
if (!mustEndAbs && !removeAllDots) { |
|
for (; up--; up) { |
|
srcPath.unshift('..'); |
|
} |
|
} |
|
|
|
if (mustEndAbs && srcPath[0] !== '' && |
|
(!srcPath[0] || srcPath[0].charAt(0) !== '/')) { |
|
srcPath.unshift(''); |
|
} |
|
|
|
if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) { |
|
srcPath.push(''); |
|
} |
|
|
|
var isAbsolute = srcPath[0] === '' || |
|
(srcPath[0] && srcPath[0].charAt(0) === '/'); |
|
|
|
// put the host back |
|
if (psychotic) { |
|
result.hostname = result.host = isAbsolute ? '' : |
|
srcPath.length ? srcPath.shift() : ''; |
|
//occationaly the auth can get stuck only in host |
|
//this especially happens in cases like |
|
//url.resolveObject('mailto:local1@domain1', 'local2@domain2') |
|
var authInHost = result.host && result.host.indexOf('@') > 0 ? |
|
result.host.split('@') : false; |
|
if (authInHost) { |
|
result.auth = authInHost.shift(); |
|
result.host = result.hostname = authInHost.shift(); |
|
} |
|
} |
|
|
|
mustEndAbs = mustEndAbs || (result.host && srcPath.length); |
|
|
|
if (mustEndAbs && !isAbsolute) { |
|
srcPath.unshift(''); |
|
} |
|
|
|
if (!srcPath.length) { |
|
result.pathname = null; |
|
result.path = null; |
|
} else { |
|
result.pathname = srcPath.join('/'); |
|
} |
|
|
|
//to support request.http |
|
if (!util.isNull(result.pathname) || !util.isNull(result.search)) { |
|
result.path = (result.pathname ? result.pathname : '') + |
|
(result.search ? result.search : ''); |
|
} |
|
result.auth = relative.auth || result.auth; |
|
result.slashes = result.slashes || relative.slashes; |
|
result.href = result.format(); |
|
return result; |
|
}; |
|
|
|
Url.prototype.parseHost = function() { |
|
var host = this.host; |
|
var port = portPattern.exec(host); |
|
if (port) { |
|
port = port[0]; |
|
if (port !== ':') { |
|
this.port = port.substr(1); |
|
} |
|
host = host.substr(0, host.length - port.length); |
|
} |
|
if (host) this.hostname = host; |
|
}; |
|
|
|
},{"./util":49,"punycode":44,"querystring":47}],49:[function(require,module,exports){ |
|
'use strict'; |
|
|
|
module.exports = { |
|
isString: function(arg) { |
|
return typeof(arg) === 'string'; |
|
}, |
|
isObject: function(arg) { |
|
return typeof(arg) === 'object' && arg !== null; |
|
}, |
|
isNull: function(arg) { |
|
return arg === null; |
|
}, |
|
isNullOrUndefined: function(arg) { |
|
return arg == null; |
|
} |
|
}; |
|
|
|
},{}],"ajv":[function(require,module,exports){ |
|
'use strict'; |
|
|
|
var compileSchema = require('./compile') |
|
, resolve = require('./compile/resolve') |
|
, Cache = require('./cache') |
|
, SchemaObject = require('./compile/schema_obj') |
|
, stableStringify = require('fast-json-stable-stringify') |
|
, formats = require('./compile/formats') |
|
, rules = require('./compile/rules') |
|
, $dataMetaSchema = require('./$data') |
|
, patternGroups = require('./patternGroups') |
|
, util = require('./compile/util') |
|
, co = require('co'); |
|
|
|
module.exports = Ajv; |
|
|
|
Ajv.prototype.validate = validate; |
|
Ajv.prototype.compile = compile; |
|
Ajv.prototype.addSchema = addSchema; |
|
Ajv.prototype.addMetaSchema = addMetaSchema; |
|
Ajv.prototype.validateSchema = validateSchema; |
|
Ajv.prototype.getSchema = getSchema; |
|
Ajv.prototype.removeSchema = removeSchema; |
|
Ajv.prototype.addFormat = addFormat; |
|
Ajv.prototype.errorsText = errorsText; |
|
|
|
Ajv.prototype._addSchema = _addSchema; |
|
Ajv.prototype._compile = _compile; |
|
|
|
Ajv.prototype.compileAsync = require('./compile/async'); |
|
var customKeyword = require('./keyword'); |
|
Ajv.prototype.addKeyword = customKeyword.add; |
|
Ajv.prototype.getKeyword = customKeyword.get; |
|
Ajv.prototype.removeKeyword = customKeyword.remove; |
|
|
|
var errorClasses = require('./compile/error_classes'); |
|
Ajv.ValidationError = errorClasses.Validation; |
|
Ajv.MissingRefError = errorClasses.MissingRef; |
|
Ajv.$dataMetaSchema = $dataMetaSchema; |
|
|
|
var META_SCHEMA_ID = 'http://json-schema.org/draft-06/schema'; |
|
|
|
var META_IGNORE_OPTIONS = [ 'removeAdditional', 'useDefaults', 'coerceTypes' ]; |
|
var META_SUPPORT_DATA = ['/properties']; |
|
|
|
/** |
|
* Creates validator instance. |
|
* Usage: `Ajv(opts)` |
|
* @param {Object} opts optional options |
|
* @return {Object} ajv instance |
|
*/ |
|
function Ajv(opts) { |
|
if (!(this instanceof Ajv)) return new Ajv(opts); |
|
opts = this._opts = util.copy(opts) || {}; |
|
setLogger(this); |
|
this._schemas = {}; |
|
this._refs = {}; |
|
this._fragments = {}; |
|
this._formats = formats(opts.format); |
|
var schemaUriFormat = this._schemaUriFormat = this._formats['uri-reference']; |
|
this._schemaUriFormatFunc = function (str) { return schemaUriFormat.test(str); }; |
|
|
|
this._cache = opts.cache || new Cache; |
|
this._loadingSchemas = {}; |
|
this._compilations = []; |
|
this.RULES = rules(); |
|
this._getId = chooseGetId(opts); |
|
|
|
opts.loopRequired = opts.loopRequired || Infinity; |
|
if (opts.errorDataPath == 'property') opts._errorDataPathProperty = true; |
|
if (opts.serialize === undefined) opts.serialize = stableStringify; |
|
this._metaOpts = getMetaSchemaOptions(this); |
|
|
|
if (opts.formats) addInitialFormats(this); |
|
addDraft6MetaSchema(this); |
|
if (typeof opts.meta == 'object') this.addMetaSchema(opts.meta); |
|
addInitialSchemas(this); |
|
if (opts.patternGroups) patternGroups(this); |
|
} |
|
|
|
|
|
|
|
/** |
|
* Validate data using schema |
|
* Schema will be compiled and cached (using serialized JSON as key. [fast-json-stable-stringify](https://github.com/epoberezkin/fast-json-stable-stringify) is used to serialize. |
|
* @this Ajv |
|
* @param {String|Object} schemaKeyRef key, ref or schema object |
|
* @param {Any} data to be validated |
|
* @return {Boolean} validation result. Errors from the last validation will be available in `ajv.errors` (and also in compiled schema: `schema.errors`). |
|
*/ |
|
function validate(schemaKeyRef, data) { |
|
var v; |
|
if (typeof schemaKeyRef == 'string') { |
|
v = this.getSchema(schemaKeyRef); |
|
if (!v) throw new Error('no schema with key or ref "' + schemaKeyRef + '"'); |
|
} else { |
|
var schemaObj = this._addSchema(schemaKeyRef); |
|
v = schemaObj.validate || this._compile(schemaObj); |
|
} |
|
|
|
var valid = v(data); |
|
if (v.$async === true) |
|
return this._opts.async == '*' ? co(valid) : valid; |
|
this.errors = v.errors; |
|
return valid; |
|
} |
|
|
|
|
|
/** |
|
* Create validating function for passed schema. |
|
* @this Ajv |
|
* @param {Object} schema schema object |
|
* @param {Boolean} _meta true if schema is a meta-schema. Used internally to compile meta schemas of custom keywords. |
|
* @return {Function} validating function |
|
*/ |
|
function compile(schema, _meta) { |
|
var schemaObj = this._addSchema(schema, undefined, _meta); |
|
return schemaObj.validate || this._compile(schemaObj); |
|
} |
|
|
|
|
|
/** |
|
* Adds schema to the instance. |
|
* @this Ajv |
|
* @param {Object|Array} schema schema or array of schemas. If array is passed, `key` and other parameters will be ignored. |
|
* @param {String} key Optional schema key. Can be passed to `validate` method instead of schema object or id/ref. One schema per instance can have empty `id` and `key`. |
|
* @param {Boolean} _skipValidation true to skip schema validation. Used internally, option validateSchema should be used instead. |
|
* @param {Boolean} _meta true if schema is a meta-schema. Used internally, addMetaSchema should be used instead. |
|
* @return {Ajv} this for method chaining |
|
*/ |
|
function addSchema(schema, key, _skipValidation, _meta) { |
|
if (Array.isArray(schema)){ |
|
for (var i=0; i<schema.length; i++) this.addSchema(schema[i], undefined, _skipValidation, _meta); |
|
return this; |
|
} |
|
var id = this._getId(schema); |
|
if (id !== undefined && typeof id != 'string') |
|
throw new Error('schema id must be string'); |
|
key = resolve.normalizeId(key || id); |
|
checkUnique(this, key); |
|
this._schemas[key] = this._addSchema(schema, _skipValidation, _meta, true); |
|
return this; |
|
} |
|
|
|
|
|
/** |
|
* Add schema that will be used to validate other schemas |
|
* options in META_IGNORE_OPTIONS are alway set to false |
|
* @this Ajv |
|
* @param {Object} schema schema object |
|
* @param {String} key optional schema key |
|
* @param {Boolean} skipValidation true to skip schema validation, can be used to override validateSchema option for meta-schema |
|
* @return {Ajv} this for method chaining |
|
*/ |
|
function addMetaSchema(schema, key, skipValidation) { |
|
this.addSchema(schema, key, skipValidation, true); |
|
return this; |
|
} |
|
|
|
|
|
/** |
|
* Validate schema |
|
* @this Ajv |
|
* @param {Object} schema schema to validate |
|
* @param {Boolean} throwOrLogError pass true to throw (or log) an error if invalid |
|
* @return {Boolean} true if schema is valid |
|
*/ |
|
function validateSchema(schema, throwOrLogError) { |
|
var $schema = schema.$schema; |
|
if ($schema !== undefined && typeof $schema != 'string') |
|
throw new Error('$schema must be a string'); |
|
$schema = $schema || this._opts.defaultMeta || defaultMeta(this); |
|
if (!$schema) { |
|
this.logger.warn('meta-schema not available'); |
|
this.errors = null; |
|
return true; |
|
} |
|
var currentUriFormat = this._formats.uri; |
|
this._formats.uri = typeof currentUriFormat == 'function' |
|
? this._schemaUriFormatFunc |
|
: this._schemaUriFormat; |
|
var valid; |
|
try { valid = this.validate($schema, schema); } |
|
finally { this._formats.uri = currentUriFormat; } |
|
if (!valid && throwOrLogError) { |
|
var message = 'schema is invalid: ' + this.errorsText(); |
|
if (this._opts.validateSchema == 'log') this.logger.error(message); |
|
else throw new Error(message); |
|
} |
|
return valid; |
|
} |
|
|
|
|
|
function defaultMeta(self) { |
|
var meta = self._opts.meta; |
|
self._opts.defaultMeta = typeof meta == 'object' |
|
? self._getId(meta) || meta |
|
: self.getSchema(META_SCHEMA_ID) |
|
? META_SCHEMA_ID |
|
: undefined; |
|
return self._opts.defaultMeta; |
|
} |
|
|
|
|
|
/** |
|
* Get compiled schema from the instance by `key` or `ref`. |
|
* @this Ajv |
|
* @param {String} keyRef `key` that was passed to `addSchema` or full schema reference (`schema.id` or resolved id). |
|
* @return {Function} schema validating function (with property `schema`). |
|
*/ |
|
function getSchema(keyRef) { |
|
var schemaObj = _getSchemaObj(this, keyRef); |
|
switch (typeof schemaObj) { |
|
case 'object': return schemaObj.validate || this._compile(schemaObj); |
|
case 'string': return this.getSchema(schemaObj); |
|
case 'undefined': return _getSchemaFragment(this, keyRef); |
|
} |
|
} |
|
|
|
|
|
function _getSchemaFragment(self, ref) { |
|
var res = resolve.schema.call(self, { schema: {} }, ref); |
|
if (res) { |
|
var schema = res.schema |
|
, root = res.root |
|
, baseId = res.baseId; |
|
var v = compileSchema.call(self, schema, root, undefined, baseId); |
|
self._fragments[ref] = new SchemaObject({ |
|
ref: ref, |
|
fragment: true, |
|
schema: schema, |
|
root: root, |
|
baseId: baseId, |
|
validate: v |
|
}); |
|
return v; |
|
} |
|
} |
|
|
|
|
|
function _getSchemaObj(self, keyRef) { |
|
keyRef = resolve.normalizeId(keyRef); |
|
return self._schemas[keyRef] || self._refs[keyRef] || self._fragments[keyRef]; |
|
} |
|
|
|
|
|
/** |
|
* Remove cached schema(s). |
|
* If no parameter is passed all schemas but meta-schemas are removed. |
|
* If RegExp is passed all schemas with key/id matching pattern but meta-schemas are removed. |
|
* Even if schema is referenced by other schemas it still can be removed as other schemas have local references. |
|
* @this Ajv |
|
* @param {String|Object|RegExp} schemaKeyRef key, ref, pattern to match key/ref or schema object |
|
* @return {Ajv} this for method chaining |
|
*/ |
|
function removeSchema(schemaKeyRef) { |
|
if (schemaKeyRef instanceof RegExp) { |
|
_removeAllSchemas(this, this._schemas, schemaKeyRef); |
|
_removeAllSchemas(this, this._refs, schemaKeyRef); |
|
return this; |
|
} |
|
switch (typeof schemaKeyRef) { |
|
case 'undefined': |
|
_removeAllSchemas(this, this._schemas); |
|
_removeAllSchemas(this, this._refs); |
|
this._cache.clear(); |
|
return this; |
|
case 'string': |
|
var schemaObj = _getSchemaObj(this, schemaKeyRef); |
|
if (schemaObj) this._cache.del(schemaObj.cacheKey); |
|
delete this._schemas[schemaKeyRef]; |
|
delete this._refs[schemaKeyRef]; |
|
return this; |
|
case 'object': |
|
var serialize = this._opts.serialize; |
|
var cacheKey = serialize ? serialize(schemaKeyRef) : schemaKeyRef; |
|
this._cache.del(cacheKey); |
|
var id = this._getId(schemaKeyRef); |
|
if (id) { |
|
id = resolve.normalizeId(id); |
|
delete this._schemas[id]; |
|
delete this._refs[id]; |
|
} |
|
} |
|
return this; |
|
} |
|
|
|
|
|
function _removeAllSchemas(self, schemas, regex) { |
|
for (var keyRef in schemas) { |
|
var schemaObj = schemas[keyRef]; |
|
if (!schemaObj.meta && (!regex || regex.test(keyRef))) { |
|
self._cache.del(schemaObj.cacheKey); |
|
delete schemas[keyRef]; |
|
} |
|
} |
|
} |
|
|
|
|
|
/* @this Ajv */ |
|
function _addSchema(schema, skipValidation, meta, shouldAddSchema) { |
|
if (typeof schema != 'object' && typeof schema != 'boolean') |
|
throw new Error('schema should be object or boolean'); |
|
var serialize = this._opts.serialize; |
|
var cacheKey = serialize ? serialize(schema) : schema; |
|
var cached = this._cache.get(cacheKey); |
|
if (cached) return cached; |
|
|
|
shouldAddSchema = shouldAddSchema || this._opts.addUsedSchema !== false; |
|
|
|
var id = resolve.normalizeId(this._getId(schema)); |
|
if (id && shouldAddSchema) checkUnique(this, id); |
|
|
|
var willValidate = this._opts.validateSchema !== false && !skipValidation; |
|
var recursiveMeta; |
|
if (willValidate && !(recursiveMeta = id && id == resolve.normalizeId(schema.$schema))) |
|
this.validateSchema(schema, true); |
|
|
|
var localRefs = resolve.ids.call(this, schema); |
|
|
|
var schemaObj = new SchemaObject({ |
|
id: id, |
|
schema: schema, |
|
localRefs: localRefs, |
|
cacheKey: cacheKey, |
|
meta: meta |
|
}); |
|
|
|
if (id[0] != '#' && shouldAddSchema) this._refs[id] = schemaObj; |
|
this._cache.put(cacheKey, schemaObj); |
|
|
|
if (willValidate && recursiveMeta) this.validateSchema(schema, true); |
|
|
|
return schemaObj; |
|
} |
|
|
|
|
|
/* @this Ajv */ |
|
function _compile(schemaObj, root) { |
|
if (schemaObj.compiling) { |
|
schemaObj.validate = callValidate; |
|
callValidate.schema = schemaObj.schema; |
|
callValidate.errors = null; |
|
callValidate.root = root ? root : callValidate; |
|
if (schemaObj.schema.$async === true) |
|
callValidate.$async = true; |
|
return callValidate; |
|
} |
|
schemaObj.compiling = true; |
|
|
|
var currentOpts; |
|
if (schemaObj.meta) { |
|
currentOpts = this._opts; |
|
this._opts = this._metaOpts; |
|
} |
|
|
|
var v; |
|
try { v = compileSchema.call(this, schemaObj.schema, root, schemaObj.localRefs); } |
|
finally { |
|
schemaObj.compiling = false; |
|
if (schemaObj.meta) this._opts = currentOpts; |
|
} |
|
|
|
schemaObj.validate = v; |
|
schemaObj.refs = v.refs; |
|
schemaObj.refVal = v.refVal; |
|
schemaObj.root = v.root; |
|
return v; |
|
|
|
|
|
function callValidate() { |
|
var _validate = schemaObj.validate; |
|
var result = _validate.apply(null, arguments); |
|
callValidate.errors = _validate.errors; |
|
return result; |
|
} |
|
} |
|
|
|
|
|
function chooseGetId(opts) { |
|
switch (opts.schemaId) { |
|
case '$id': return _get$Id; |
|
case 'id': return _getId; |
|
default: return _get$IdOrId; |
|
} |
|
} |
|
|
|
/* @this Ajv */ |
|
function _getId(schema) { |
|
if (schema.$id) this.logger.warn('schema $id ignored', schema.$id); |
|
return schema.id; |
|
} |
|
|
|
/* @this Ajv */ |
|
function _get$Id(schema) { |
|
if (schema.id) this.logger.warn('schema id ignored', schema.id); |
|
return schema.$id; |
|
} |
|
|
|
|
|
function _get$IdOrId(schema) { |
|
if (schema.$id && schema.id && schema.$id != schema.id) |
|
throw new Error('schema $id is different from id'); |
|
return schema.$id || schema.id; |
|
} |
|
|
|
|
|
/** |
|
* Convert array of error message objects to string |
|
* @this Ajv |
|
* @param {Array<Object>} errors optional array of validation errors, if not passed errors from the instance are used. |
|
* @param {Object} options optional options with properties `separator` and `dataVar`. |
|
* @return {String} human readable string with all errors descriptions |
|
*/ |
|
function errorsText(errors, options) { |
|
errors = errors || this.errors; |
|
if (!errors) return 'No errors'; |
|
options = options || {}; |
|
var separator = options.separator === undefined ? ', ' : options.separator; |
|
var dataVar = options.dataVar === undefined ? 'data' : options.dataVar; |
|
|
|
var text = ''; |
|
for (var i=0; i<errors.length; i++) { |
|
var e = errors[i]; |
|
if (e) text += dataVar + e.dataPath + ' ' + e.message + separator; |
|
} |
|
return text.slice(0, -separator.length); |
|
} |
|
|
|
|
|
/** |
|
* Add custom format |
|
* @this Ajv |
|
* @param {String} name format name |
|
* @param {String|RegExp|Function} format string is converted to RegExp; function should return boolean (true when valid) |
|
* @return {Ajv} this for method chaining |
|
*/ |
|
function addFormat(name, format) { |
|
if (typeof format == 'string') format = new RegExp(format); |
|
this._formats[name] = format; |
|
return this; |
|
} |
|
|
|
|
|
function addDraft6MetaSchema(self) { |
|
var $dataSchema; |
|
if (self._opts.$data) { |
|
$dataSchema = require('./refs/$data.json'); |
|
self.addMetaSchema($dataSchema, $dataSchema.$id, true); |
|
} |
|
if (self._opts.meta === false) return; |
|
var metaSchema = require('./refs/json-schema-draft-06.json'); |
|
if (self._opts.$data) metaSchema = $dataMetaSchema(metaSchema, META_SUPPORT_DATA); |
|
self.addMetaSchema(metaSchema, META_SCHEMA_ID, true); |
|
self._refs['http://json-schema.org/schema'] = META_SCHEMA_ID; |
|
} |
|
|
|
|
|
function addInitialSchemas(self) { |
|
var optsSchemas = self._opts.schemas; |
|
if (!optsSchemas) return; |
|
if (Array.isArray(optsSchemas)) self.addSchema(optsSchemas); |
|
else for (var key in optsSchemas) self.addSchema(optsSchemas[key], key); |
|
} |
|
|
|
|
|
function addInitialFormats(self) { |
|
for (var name in self._opts.formats) { |
|
var format = self._opts.formats[name]; |
|
self.addFormat(name, format); |
|
} |
|
} |
|
|
|
|
|
function checkUnique(self, id) { |
|
if (self._schemas[id] || self._refs[id]) |
|
throw new Error('schema with key or id "' + id + '" already exists'); |
|
} |
|
|
|
|
|
function getMetaSchemaOptions(self) { |
|
var metaOpts = util.copy(self._opts); |
|
for (var i=0; i<META_IGNORE_OPTIONS.length; i++) |
|
delete metaOpts[META_IGNORE_OPTIONS[i]]; |
|
return metaOpts; |
|
} |
|
|
|
|
|
function setLogger(self) { |
|
var logger = self._opts.logger; |
|
if (logger === false) { |
|
self.logger = {log: noop, warn: noop, error: noop}; |
|
} else { |
|
if (logger === undefined) logger = console; |
|
if (!(typeof logger == 'object' && logger.log && logger.warn && logger.error)) |
|
throw new Error('logger must implement log, warn and error methods'); |
|
self.logger = logger; |
|
} |
|
} |
|
|
|
|
|
function noop() {} |
|
|
|
},{"./$data":1,"./cache":2,"./compile":7,"./compile/async":4,"./compile/error_classes":5,"./compile/formats":6,"./compile/resolve":8,"./compile/rules":9,"./compile/schema_obj":10,"./compile/util":12,"./keyword":36,"./patternGroups":37,"./refs/$data.json":38,"./refs/json-schema-draft-06.json":39,"co":40,"fast-json-stable-stringify":42}]},{},[])("ajv") |
|
}); |