| (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(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[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 = {}; |
| }; |
| |
| },{}],2:[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":3}],3:[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":6}],4:[function(require,module,exports){ |
| 'use strict'; |
| |
| var util = require('./util'); |
| |
| var DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/; |
| var DAYS = [0,31,28,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)*)*$/; |
| var JSON_POINTER_URI_FRAGMENT = /^#(?:\/(?:[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|23:59:60)(?:\.\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|23:59:60)(?:\.\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#][^\s#]*)?(?:#[^\\\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, |
| 'json-pointer-uri-fragment': JSON_POINTER_URI_FRAGMENT, |
| // 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, |
| 'json-pointer-uri-fragment': JSON_POINTER_URI_FRAGMENT, |
| 'relative-json-pointer': RELATIVE_JSON_POINTER |
| }; |
| |
| |
| function isLeapYear(year) { |
| // https://tools.ietf.org/html/rfc3339#appendix-C |
| return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0); |
| } |
| |
| |
| 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 year = +matches[1]; |
| var month = +matches[2]; |
| var day = +matches[3]; |
| |
| return month >= 1 && month <= 12 && day >= 1 && |
| day <= (month == 2 && isLeapYear(year) ? 29 : 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) || |
| (hour == 23 && minute == 59 && second == 60)) && |
| (!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":10}],5:[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 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); |
| } |
| |
| /* @this {*} - custom context, see passContext option */ |
| function callValidate() { |
| /* jshint validthis: true */ |
| var validate = compilation.validate; |
| var result = validate.apply(this, 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', |
| 'equal', |
| 'ucs2length', |
| 'ValidationError', |
| sourceCode |
| ); |
| |
| validate = makeValidate( |
| self, |
| RULES, |
| formats, |
| root, |
| refVal, |
| defaults, |
| customRules, |
| 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) { |
| if (self._opts.validateSchema !== false) { |
| var deps = rule.definition.dependencies; |
| if (deps && !deps.every(function(keyword) { |
| return Object.prototype.hasOwnProperty.call(parentSchema, keyword); |
| })) |
| throw new Error('parent schema must have all required keywords: ' + deps.join(',')); |
| |
| var validateSchema = rule.definition.validateSchema; |
| if (validateSchema) { |
| 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":38,"./error_classes":3,"./resolve":6,"./util":10,"fast-deep-equal":42,"fast-json-stable-stringify":43}],6:[function(require,module,exports){ |
| 'use strict'; |
| |
| var URI = require('uri-js') |
| , 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 = URI.parse(ref) |
| , refPath = _getFullPath(p) |
| , baseId = getFullPath(this._getId(root.schema)); |
| if (Object.keys(root.schema).length === 0 || 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.fragment = parsedRef.fragment || ''; |
| if (parsedRef.fragment.slice(0,1) != '/') return; |
| var parts = parsedRef.fragment.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 = URI.parse(id); |
| return _getFullPath(p); |
| } |
| |
| |
| function _getFullPath(p) { |
| return URI.serialize(p).split('#')[0] + '#'; |
| } |
| |
| |
| var TRAILING_SLASH_HASH = /#\/?$/; |
| function normalizeId(id) { |
| return id ? id.replace(TRAILING_SLASH_HASH, '') : ''; |
| } |
| |
| |
| function resolveUrl(baseId, id) { |
| id = normalizeId(id); |
| return URI.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 ? URI.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":8,"./util":10,"fast-deep-equal":42,"json-schema-traverse":44,"uri-js":45}],7:[function(require,module,exports){ |
| 'use strict'; |
| |
| var ruleModules = require('../dotjs') |
| , 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', 'items', 'contains', 'uniqueItems' ] }, |
| { type: 'object', |
| rules: [ 'maxProperties', 'minProperties', 'required', 'dependencies', 'propertyNames', |
| { 'properties': ['additionalProperties', 'patternProperties'] } ] }, |
| { rules: [ '$ref', 'const', 'enum', 'not', 'anyOf', 'oneOf', 'allOf', 'if' ] } |
| ]; |
| |
| var ALL = [ 'type', '$comment' ]; |
| var KEYWORDS = [ |
| '$schema', '$id', 'id', '$data', '$async', 'title', |
| 'description', 'default', 'definitions', |
| 'examples', 'readOnly', 'writeOnly', |
| 'contentMediaType', 'contentEncoding', |
| 'additionalItems', 'then', 'else' |
| ]; |
| 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; |
| }); |
| |
| RULES.all.$comment = { |
| keyword: '$comment', |
| code: ruleModules.$comment |
| }; |
| |
| if (group.type) RULES.types[group.type] = group; |
| }); |
| |
| RULES.keywords = toHash(ALL.concat(KEYWORDS)); |
| RULES.custom = {}; |
| |
| return RULES; |
| }; |
| |
| },{"../dotjs":27,"./util":10}],8:[function(require,module,exports){ |
| 'use strict'; |
| |
| var util = require('./util'); |
| |
| module.exports = SchemaObject; |
| |
| function SchemaObject(obj) { |
| util.copy(obj, this); |
| } |
| |
| },{"./util":10}],9:[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; |
| }; |
| |
| },{}],10:[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, |
| schemaUnknownRules: schemaUnknownRules, |
| 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 schemaUnknownRules(schema, rules) { |
| if (typeof schema == 'boolean') return; |
| for (var key in schema) if (!rules[key]) return key; |
| } |
| |
| |
| 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":9,"fast-deep-equal":42}],11:[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; |
| }; |
| |
| },{}],12:[function(require,module,exports){ |
| 'use strict'; |
| |
| var metaSchema = require('./refs/json-schema-draft-07.json'); |
| |
| module.exports = { |
| $id: 'https://github.com/epoberezkin/ajv/blob/master/lib/definition_schema.js', |
| definitions: { |
| simpleTypes: metaSchema.definitions.simpleTypes |
| }, |
| type: 'object', |
| dependencies: { |
| schema: ['validate'], |
| $data: ['validate'], |
| statements: ['inline'], |
| valid: {not: {required: ['macro']}} |
| }, |
| properties: { |
| type: metaSchema.properties.type, |
| schema: {type: 'boolean'}, |
| statements: {type: 'boolean'}, |
| dependencies: { |
| type: 'array', |
| items: {type: 'string'} |
| }, |
| metaSchema: {type: 'object'}, |
| modifying: {type: 'boolean'}, |
| valid: {type: 'boolean'}, |
| $data: {type: 'boolean'}, |
| async: {type: 'boolean'}, |
| errors: { |
| anyOf: [ |
| {type: 'boolean'}, |
| {const: 'full'} |
| ] |
| } |
| } |
| }; |
| |
| },{"./refs/json-schema-draft-07.json":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) + '=\'; '; |
| if ($schema === undefined) { |
| $errorKeyword = $exclusiveKeyword; |
| $errSchemaPath = it.errSchemaPath + '/' + $exclusiveKeyword; |
| $schemaValue = $schemaValueExcl; |
| $isData = $isDataExcl; |
| } |
| } 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 += 'fewer'; |
| } |
| 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 += 'fewer'; |
| } |
| 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.opts.strictKeywords ? typeof $sch == 'object' && Object.keys($sch).length > 0 : 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.opts.strictKeywords ? typeof $sch == 'object' && Object.keys($sch).length > 0 : 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_comment(it, $keyword, $ruleType) { |
| var out = ' '; |
| var $schema = it.schema[$keyword]; |
| var $errSchemaPath = it.errSchemaPath + '/' + $keyword; |
| var $breakOnError = !it.opts.allErrors; |
| var $comment = it.util.toQuotedString($schema); |
| if (it.opts.$comment === true) { |
| out += ' console.log(' + ($comment) + ');'; |
| } else if (typeof it.opts.$comment == 'function') { |
| out += ' self._opts.$comment(' + ($comment) + ', ' + (it.util.toQuotedString($errSchemaPath)) + ', validate.root.schema);'; |
| } |
| return out; |
| } |
| |
| },{}],20:[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: { allowedValue: schema' + ($lvl) + ' } '; |
| 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; |
| } |
| |
| },{}],21:[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.opts.strictKeywords ? typeof $schema == 'object' && Object.keys($schema).length > 0 : 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; |
| } |
| |
| },{}],22:[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 += 'await '; |
| } |
| out += '' + (def_callRuleValidate) + '; '; |
| } else { |
| if ($asyncKeyword) { |
| $ruleErrs = 'customErrors' + $lvl; |
| out += ' var ' + ($ruleErrs) + ' = null; try { ' + ($valid) + ' = await ' + (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; |
| } |
| |
| },{}],23:[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.opts.strictKeywords ? typeof $sch == 'object' && Object.keys($sch).length > 0 : 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; |
| } |
| |
| },{}],24:[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; |
| } |
| |
| },{}],25:[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) + ' ? await ' + ($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 (!(await ' + ($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; |
| } |
| |
| },{}],26:[function(require,module,exports){ |
| 'use strict'; |
| module.exports = function generate_if(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); |
| $it.level++; |
| var $nextValid = 'valid' + $it.level; |
| var $thenSch = it.schema['then'], |
| $elseSch = it.schema['else'], |
| $thenPresent = $thenSch !== undefined && (it.opts.strictKeywords ? typeof $thenSch == 'object' && Object.keys($thenSch).length > 0 : it.util.schemaHasRules($thenSch, it.RULES.all)), |
| $elsePresent = $elseSch !== undefined && (it.opts.strictKeywords ? typeof $elseSch == 'object' && Object.keys($elseSch).length > 0 : it.util.schemaHasRules($elseSch, it.RULES.all)), |
| $currentBaseId = $it.baseId; |
| if ($thenPresent || $elsePresent) { |
| var $ifClause; |
| $it.createErrors = false; |
| $it.schema = $schema; |
| $it.schemaPath = $schemaPath; |
| $it.errSchemaPath = $errSchemaPath; |
| out += ' var ' + ($errs) + ' = errors; var ' + ($valid) + ' = true; '; |
| var $wasComposite = it.compositeRule; |
| it.compositeRule = $it.compositeRule = true; |
| out += ' ' + (it.validate($it)) + ' '; |
| $it.baseId = $currentBaseId; |
| $it.createErrors = true; |
| out += ' errors = ' + ($errs) + '; if (vErrors !== null) { if (' + ($errs) + ') vErrors.length = ' + ($errs) + '; else vErrors = null; } '; |
| it.compositeRule = $it.compositeRule = $wasComposite; |
| if ($thenPresent) { |
| out += ' if (' + ($nextValid) + ') { '; |
| $it.schema = it.schema['then']; |
| $it.schemaPath = it.schemaPath + '.then'; |
| $it.errSchemaPath = it.errSchemaPath + '/then'; |
| out += ' ' + (it.validate($it)) + ' '; |
| $it.baseId = $currentBaseId; |
| out += ' ' + ($valid) + ' = ' + ($nextValid) + '; '; |
| if ($thenPresent && $elsePresent) { |
| $ifClause = 'ifClause' + $lvl; |
| out += ' var ' + ($ifClause) + ' = \'then\'; '; |
| } else { |
| $ifClause = '\'then\''; |
| } |
| out += ' } '; |
| if ($elsePresent) { |
| out += ' else { '; |
| } |
| } else { |
| out += ' if (!' + ($nextValid) + ') { '; |
| } |
| if ($elsePresent) { |
| $it.schema = it.schema['else']; |
| $it.schemaPath = it.schemaPath + '.else'; |
| $it.errSchemaPath = it.errSchemaPath + '/else'; |
| out += ' ' + (it.validate($it)) + ' '; |
| $it.baseId = $currentBaseId; |
| out += ' ' + ($valid) + ' = ' + ($nextValid) + '; '; |
| if ($thenPresent && $elsePresent) { |
| $ifClause = 'ifClause' + $lvl; |
| out += ' var ' + ($ifClause) + ' = \'else\'; '; |
| } else { |
| $ifClause = '\'else\''; |
| } |
| out += ' } '; |
| } |
| out += ' if (!' + ($valid) + ') { var err = '; /* istanbul ignore else */ |
| if (it.createErrors !== false) { |
| out += ' { keyword: \'' + ('if') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { failingKeyword: ' + ($ifClause) + ' } '; |
| if (it.opts.messages !== false) { |
| out += ' , message: \'should match "\' + ' + ($ifClause) + ' + \'" schema\' '; |
| } |
| 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 += ' } '; |
| if ($breakOnError) { |
| out += ' else { '; |
| } |
| out = it.util.cleanUpCode(out); |
| } else { |
| if ($breakOnError) { |
| out += ' if (true) { '; |
| } |
| } |
| return out; |
| } |
| |
| },{}],27:[function(require,module,exports){ |
| 'use strict'; |
| |
| //all requires must be explicit because browserify won't work with dynamic requires |
| module.exports = { |
| '$ref': require('./ref'), |
| allOf: require('./allOf'), |
| anyOf: require('./anyOf'), |
| '$comment': require('./comment'), |
| const: require('./const'), |
| contains: require('./contains'), |
| dependencies: require('./dependencies'), |
| 'enum': require('./enum'), |
| format: require('./format'), |
| 'if': require('./if'), |
| items: require('./items'), |
| maximum: require('./_limit'), |
| minimum: require('./_limit'), |
| maxItems: require('./_limitItems'), |
| minItems: require('./_limitItems'), |
| maxLength: require('./_limitLength'), |
| minLength: require('./_limitLength'), |
| maxProperties: require('./_limitProperties'), |
| minProperties: require('./_limitProperties'), |
| multipleOf: require('./multipleOf'), |
| not: require('./not'), |
| oneOf: require('./oneOf'), |
| pattern: require('./pattern'), |
| properties: require('./properties'), |
| propertyNames: require('./propertyNames'), |
| required: require('./required'), |
| uniqueItems: require('./uniqueItems'), |
| validate: require('./validate') |
| }; |
| |
| },{"./_limit":13,"./_limitItems":14,"./_limitLength":15,"./_limitProperties":16,"./allOf":17,"./anyOf":18,"./comment":19,"./const":20,"./contains":21,"./dependencies":23,"./enum":24,"./format":25,"./if":26,"./items":28,"./multipleOf":29,"./not":30,"./oneOf":31,"./pattern":32,"./properties":33,"./propertyNames":34,"./ref":35,"./required":36,"./uniqueItems":37,"./validate":38}],28:[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.opts.strictKeywords ? typeof $sch == 'object' && Object.keys($sch).length > 0 : 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.opts.strictKeywords ? typeof $additionalItems == 'object' && Object.keys($additionalItems).length > 0 : 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.opts.strictKeywords ? typeof $schema == 'object' && Object.keys($schema).length > 0 : 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; |
| } |
| |
| },{}],29:[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; |
| } |
| |
| },{}],30:[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.opts.strictKeywords ? typeof $schema == 'object' && Object.keys($schema).length > 0 : 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; |
| } |
| |
| },{}],31:[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; |
| var $currentBaseId = $it.baseId, |
| $prevValid = 'prevValid' + $lvl, |
| $passingSchemas = 'passingSchemas' + $lvl; |
| out += 'var ' + ($errs) + ' = errors , ' + ($prevValid) + ' = false , ' + ($valid) + ' = false , ' + ($passingSchemas) + ' = null; '; |
| 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.opts.strictKeywords ? typeof $sch == 'object' && Object.keys($sch).length > 0 : 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) + ') { ' + ($valid) + ' = false; ' + ($passingSchemas) + ' = [' + ($passingSchemas) + ', ' + ($i) + ']; } else { '; |
| $closingBraces += '}'; |
| } |
| out += ' if (' + ($nextValid) + ') { ' + ($valid) + ' = ' + ($prevValid) + ' = true; ' + ($passingSchemas) + ' = ' + ($i) + '; }'; |
| } |
| } |
| 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: { passingSchemas: ' + ($passingSchemas) + ' } '; |
| 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; |
| } |
| |
| },{}],32:[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; |
| } |
| |
| },{}],33:[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 $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.$data && $required.$data) && $required.length < it.opts.loopRequired) var $requiredHash = it.util.toHash($required); |
| 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 > 8) { |
| out += ' || validate.schema' + ($schemaPath) + '.hasOwnProperty(' + ($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) + ') '; |
| } |
| } |
| } |
| 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: \''; |
| if (it.opts._errorDataPathProperty) { |
| out += 'is an invalid additional property'; |
| } else { |
| out += 'should NOT have additional properties'; |
| } |
| out += '\' '; |
| } |
| 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 arr3 = $schemaKeys; |
| if (arr3) { |
| var $propertyKey, i3 = -1, |
| l3 = arr3.length - 1; |
| while (i3 < l3) { |
| $propertyKey = arr3[i3 += 1]; |
| var $sch = $schema[$propertyKey]; |
| if ((it.opts.strictKeywords ? typeof $sch == 'object' && Object.keys($sch).length > 0 : 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 arr4 = $pPropertyKeys; |
| if (arr4) { |
| var $pProperty, i4 = -1, |
| l4 = arr4.length - 1; |
| while (i4 < l4) { |
| $pProperty = arr4[i4 += 1]; |
| var $sch = $pProperties[$pProperty]; |
| if ((it.opts.strictKeywords ? typeof $sch == 'object' && Object.keys($sch).length > 0 : 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 ($breakOnError) { |
| out += ' ' + ($closingBraces) + ' if (' + ($errs) + ' == errors) {'; |
| } |
| out = it.util.cleanUpCode(out); |
| return out; |
| } |
| |
| },{}],34:[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; |
| out += 'var ' + ($errs) + ' = errors;'; |
| if ((it.opts.strictKeywords ? typeof $schema == 'object' && Object.keys($schema).length > 0 : 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; |
| 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; |
| } |
| |
| },{}],35:[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 || (it.async && $refVal.$async !== false); |
| $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 { await ' + (__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; |
| } |
| |
| },{}],36:[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.opts.strictKeywords ? typeof $propertySch == 'object' && Object.keys($propertySch).length > 0 : 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; |
| } |
| |
| },{}],37:[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 i = ' + ($data) + '.length , ' + ($valid) + ' = true , j; if (i > 1) { '; |
| var $itemType = it.schema.items && it.schema.items.type, |
| $typeIsArray = Array.isArray($itemType); |
| if (!$itemType || $itemType == 'object' || $itemType == 'array' || ($typeIsArray && ($itemType.indexOf('object') >= 0 || $itemType.indexOf('array') >= 0))) { |
| out += ' outer: for (;i--;) { for (j = i; j--;) { if (equal(' + ($data) + '[i], ' + ($data) + '[j])) { ' + ($valid) + ' = false; break outer; } } } '; |
| } else { |
| out += ' var itemIndices = {}, item; for (;i--;) { var item = ' + ($data) + '[i]; '; |
| var $method = 'checkDataType' + ($typeIsArray ? 's' : ''); |
| out += ' if (' + (it.util[$method]($itemType, 'item', true)) + ') continue; '; |
| if ($typeIsArray) { |
| out += ' if (typeof item == \'string\') item = \'"\' + item; '; |
| } |
| out += ' if (typeof itemIndices[item] == \'number\') { ' + ($valid) + ' = false; j = itemIndices[item]; break; } itemIndices[item] = i; } '; |
| } |
| out += ' } '; |
| 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; |
| } |
| |
| },{}],38:[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.opts.strictKeywords) { |
| var $unknownKwd = it.util.schemaUnknownRules(it.schema, it.RULES.keywords); |
| if ($unknownKwd) { |
| var $keywordsMsg = 'unknown keyword: ' + $unknownKwd; |
| if (it.opts.strictKeywords === 'log') it.logger.warn($keywordsMsg); |
| else throw new Error($keywordsMsg); |
| } |
| } |
| if (it.isTop) { |
| out += ' var validate = '; |
| if ($async) { |
| it.async = true; |
| out += 'async '; |
| } |
| out += 'function(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]; |
| if (it.schema.default !== undefined && it.opts.useDefaults && it.opts.strictDefaults) { |
| var $defaultMsg = 'default is ignored in the schema root'; |
| if (it.opts.strictDefaults === 'log') it.logger.warn($defaultMsg); |
| else throw new Error($defaultMsg); |
| } |
| 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 ($typeSchema && it.opts.nullable && it.schema.nullable === true) { |
| if ($typeIsArray) { |
| if ($typeSchema.indexOf('null') == -1) $typeSchema = $typeSchema.concat('null'); |
| } else if ($typeSchema != 'null') { |
| $typeSchema = [$typeSchema, 'null']; |
| $typeIsArray = true; |
| } |
| } |
| 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 (it.schema.$comment && it.opts.$comment) { |
| out += ' ' + (it.RULES.all.$comment.code(it, '$comment')); |
| } |
| 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 { |
| 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) { |
| 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); |
| if (it.compositeRule) { |
| if (it.opts.strictDefaults) { |
| var $defaultMsg = 'default is ignored for: ' + $passData; |
| if (it.opts.strictDefaults === 'log') it.logger.warn($defaultMsg); |
| else throw new Error($defaultMsg); |
| } |
| } else { |
| out += ' if (' + ($passData) + ' === undefined '; |
| if (it.opts.useDefaults == 'empty') { |
| out += ' || ' + ($passData) + ' === null || ' + ($passData) + ' === \'\' '; |
| } |
| out += ' ) ' + ($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 + ']'; |
| if (it.compositeRule) { |
| if (it.opts.strictDefaults) { |
| var $defaultMsg = 'default is ignored for: ' + $passData; |
| if (it.opts.strictDefaults === 'log') it.logger.warn($defaultMsg); |
| else throw new Error($defaultMsg); |
| } |
| } else { |
| out += ' if (' + ($passData) + ' === undefined '; |
| if (it.opts.useDefaults == 'empty') { |
| out += ' || ' + ($passData) + ' === null || ' + ($passData) + ' === \'\' '; |
| } |
| out += ' ) ' + ($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; |
| } |
| |
| },{}],39:[function(require,module,exports){ |
| 'use strict'; |
| |
| var IDENTIFIER = /^[a-z_$][a-z0-9_$-]*$/i; |
| var customRuleCode = require('./dotjs/custom'); |
| var definitionSchema = require('./definition_schema'); |
| |
| module.exports = { |
| add: addKeyword, |
| get: getKeyword, |
| remove: removeKeyword, |
| validate: validateKeyword |
| }; |
| |
| |
| /** |
| * 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) { |
| this.validateKeyword(definition, true); |
| |
| var dataType = definition.type; |
| if (Array.isArray(dataType)) { |
| for (var i=0; i<dataType.length; i++) |
| _addRule(keyword, dataType[i], definition); |
| } else { |
| _addRule(keyword, dataType, definition); |
| } |
| |
| var metaSchema = definition.metaSchema; |
| if (metaSchema) { |
| if (definition.$data && this._opts.$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; |
| } |
| |
| 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; |
| } |
| |
| |
| /** |
| * Validate keyword definition |
| * @this Ajv |
| * @param {Object} definition keyword definition object. |
| * @param {Boolean} throwError true to throw exception if definition is invalid |
| * @return {boolean} validation result |
| */ |
| function validateKeyword(definition, throwError) { |
| validateKeyword.errors = null; |
| var v = this._validateKeyword = this._validateKeyword |
| || this.compile(definitionSchema, true); |
| |
| if (v(definition)) return true; |
| validateKeyword.errors = v.errors; |
| if (throwError) |
| throw new Error('custom keyword definition is invalid: ' + this.errorsText(v.errors)); |
| else |
| return false; |
| } |
| |
| },{"./definition_schema":12,"./dotjs/custom":22}],40:[function(require,module,exports){ |
| module.exports={ |
| "$schema": "http://json-schema.org/draft-07/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 |
| } |
| |
| },{}],41:[function(require,module,exports){ |
| module.exports={ |
| "$schema": "http://json-schema.org/draft-07/schema#", |
| "$id": "http://json-schema.org/draft-07/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" |
| }, |
| "$comment": { |
| "type": "string" |
| }, |
| "title": { |
| "type": "string" |
| }, |
| "description": { |
| "type": "string" |
| }, |
| "default": true, |
| "readOnly": { |
| "type": "boolean", |
| "default": false |
| }, |
| "examples": { |
| "type": "array", |
| "items": true |
| }, |
| "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": true |
| }, |
| "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": "#" }, |
| "propertyNames": { "format": "regex" }, |
| "default": {} |
| }, |
| "dependencies": { |
| "type": "object", |
| "additionalProperties": { |
| "anyOf": [ |
| { "$ref": "#" }, |
| { "$ref": "#/definitions/stringArray" } |
| ] |
| } |
| }, |
| "propertyNames": { "$ref": "#" }, |
| "const": true, |
| "enum": { |
| "type": "array", |
| "items": true, |
| "minItems": 1, |
| "uniqueItems": true |
| }, |
| "type": { |
| "anyOf": [ |
| { "$ref": "#/definitions/simpleTypes" }, |
| { |
| "type": "array", |
| "items": { "$ref": "#/definitions/simpleTypes" }, |
| "minItems": 1, |
| "uniqueItems": true |
| } |
| ] |
| }, |
| "format": { "type": "string" }, |
| "contentMediaType": { "type": "string" }, |
| "contentEncoding": { "type": "string" }, |
| "if": {"$ref": "#"}, |
| "then": {"$ref": "#"}, |
| "else": {"$ref": "#"}, |
| "allOf": { "$ref": "#/definitions/schemaArray" }, |
| "anyOf": { "$ref": "#/definitions/schemaArray" }, |
| "oneOf": { "$ref": "#/definitions/schemaArray" }, |
| "not": { "$ref": "#" } |
| }, |
| "default": true |
| } |
| |
| },{}],42:[function(require,module,exports){ |
| 'use strict'; |
| |
| var isArray = Array.isArray; |
| var keyList = Object.keys; |
| var hasProp = Object.prototype.hasOwnProperty; |
| |
| module.exports = function equal(a, b) { |
| if (a === b) return true; |
| |
| if (a && b && typeof a == 'object' && typeof b == 'object') { |
| var arrA = isArray(a) |
| , arrB = isArray(b) |
| , i |
| , length |
| , key; |
| |
| if (arrA && arrB) { |
| length = a.length; |
| if (length != b.length) return false; |
| for (i = length; i-- !== 0;) |
| if (!equal(a[i], b[i])) return false; |
| return true; |
| } |
| |
| if (arrA != arrB) return false; |
| |
| var dateA = a instanceof Date |
| , dateB = b instanceof Date; |
| if (dateA != dateB) return false; |
| if (dateA && dateB) return a.getTime() == b.getTime(); |
| |
| var regexpA = a instanceof RegExp |
| , regexpB = b instanceof RegExp; |
| if (regexpA != regexpB) return false; |
| if (regexpA && regexpB) return a.toString() == b.toString(); |
| |
| var keys = keyList(a); |
| length = keys.length; |
| |
| if (length !== keyList(b).length) |
| return false; |
| |
| for (i = length; i-- !== 0;) |
| if (!hasProp.call(b, keys[i])) return false; |
| |
| for (i = length; i-- !== 0;) { |
| key = keys[i]; |
| if (!equal(a[key], b[key])) return false; |
| } |
| |
| return true; |
| } |
| |
| return a!==a && b!==b; |
| }; |
| |
| },{}],43:[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); |
| }; |
| |
| },{}],44:[function(require,module,exports){ |
| 'use strict'; |
| |
| var traverse = module.exports = function (schema, opts, cb) { |
| // Legacy support for v0.3.1 and earlier. |
| if (typeof opts == 'function') { |
| cb = opts; |
| opts = {}; |
| } |
| |
| cb = opts.cb || cb; |
| var pre = (typeof cb == 'function') ? cb : cb.pre || function() {}; |
| var post = cb.post || function() {}; |
| |
| _traverse(opts, pre, post, 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 = { |
| default: true, |
| 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, pre, post, schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) { |
| if (schema && typeof schema == 'object' && !Array.isArray(schema)) { |
| pre(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, pre, post, 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, pre, post, 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, pre, post, sch, jsonPtr + '/' + key, rootSchema, jsonPtr, key, schema); |
| } |
| } |
| post(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex); |
| } |
| } |
| |
| |
| function escapeJsonPtr(str) { |
| return str.replace(/~/g, '~0').replace(/\//g, '~1'); |
| } |
| |
| },{}],45:[function(require,module,exports){ |
| /** @license URI.js v4.2.1 (c) 2011 Gary Court. License: http://github.com/garycourt/uri-js */ |
| (function (global, factory) { |
| typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : |
| typeof define === 'function' && define.amd ? define(['exports'], factory) : |
| (factory((global.URI = global.URI || {}))); |
| }(this, (function (exports) { 'use strict'; |
| |
| function merge() { |
| for (var _len = arguments.length, sets = Array(_len), _key = 0; _key < _len; _key++) { |
| sets[_key] = arguments[_key]; |
| } |
| |
| if (sets.length > 1) { |
| sets[0] = sets[0].slice(0, -1); |
| var xl = sets.length - 1; |
| for (var x = 1; x < xl; ++x) { |
| sets[x] = sets[x].slice(1, -1); |
| } |
| sets[xl] = sets[xl].slice(1); |
| return sets.join(''); |
| } else { |
| return sets[0]; |
| } |
| } |
| function subexp(str) { |
| return "(?:" + str + ")"; |
| } |
| function typeOf(o) { |
| return o === undefined ? "undefined" : o === null ? "null" : Object.prototype.toString.call(o).split(" ").pop().split("]").shift().toLowerCase(); |
| } |
| function toUpperCase(str) { |
| return str.toUpperCase(); |
| } |
| function toArray(obj) { |
| return obj !== undefined && obj !== null ? obj instanceof Array ? obj : typeof obj.length !== "number" || obj.split || obj.setInterval || obj.call ? [obj] : Array.prototype.slice.call(obj) : []; |
| } |
| function assign(target, source) { |
| var obj = target; |
| if (source) { |
| for (var key in source) { |
| obj[key] = source[key]; |
| } |
| } |
| return obj; |
| } |
| |
| function buildExps(isIRI) { |
| var ALPHA$$ = "[A-Za-z]", |
| CR$ = "[\\x0D]", |
| DIGIT$$ = "[0-9]", |
| DQUOTE$$ = "[\\x22]", |
| HEXDIG$$ = merge(DIGIT$$, "[A-Fa-f]"), |
| //case-insensitive |
| LF$$ = "[\\x0A]", |
| SP$$ = "[\\x20]", |
| PCT_ENCODED$ = subexp(subexp("%[EFef]" + HEXDIG$$ + "%" + HEXDIG$$ + HEXDIG$$ + "%" + HEXDIG$$ + HEXDIG$$) + "|" + subexp("%[89A-Fa-f]" + HEXDIG$$ + "%" + HEXDIG$$ + HEXDIG$$) + "|" + subexp("%" + HEXDIG$$ + HEXDIG$$)), |
| //expanded |
| GEN_DELIMS$$ = "[\\:\\/\\?\\#\\[\\]\\@]", |
| SUB_DELIMS$$ = "[\\!\\$\\&\\'\\(\\)\\*\\+\\,\\;\\=]", |
| RESERVED$$ = merge(GEN_DELIMS$$, SUB_DELIMS$$), |
| UCSCHAR$$ = isIRI ? "[\\xA0-\\u200D\\u2010-\\u2029\\u202F-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF]" : "[]", |
| //subset, excludes bidi control characters |
| IPRIVATE$$ = isIRI ? "[\\uE000-\\uF8FF]" : "[]", |
| //subset |
| UNRESERVED$$ = merge(ALPHA$$, DIGIT$$, "[\\-\\.\\_\\~]", UCSCHAR$$), |
| SCHEME$ = subexp(ALPHA$$ + merge(ALPHA$$, DIGIT$$, "[\\+\\-\\.]") + "*"), |
| USERINFO$ = subexp(subexp(PCT_ENCODED$ + "|" + merge(UNRESERVED$$, SUB_DELIMS$$, "[\\:]")) + "*"), |
| DEC_OCTET$ = subexp(subexp("25[0-5]") + "|" + subexp("2[0-4]" + DIGIT$$) + "|" + subexp("1" + DIGIT$$ + DIGIT$$) + "|" + subexp("[1-9]" + DIGIT$$) + "|" + DIGIT$$), |
| DEC_OCTET_RELAXED$ = subexp(subexp("25[0-5]") + "|" + subexp("2[0-4]" + DIGIT$$) + "|" + subexp("1" + DIGIT$$ + DIGIT$$) + "|" + subexp("0?[1-9]" + DIGIT$$) + "|0?0?" + DIGIT$$), |
| //relaxed parsing rules |
| IPV4ADDRESS$ = subexp(DEC_OCTET_RELAXED$ + "\\." + DEC_OCTET_RELAXED$ + "\\." + DEC_OCTET_RELAXED$ + "\\." + DEC_OCTET_RELAXED$), |
| H16$ = subexp(HEXDIG$$ + "{1,4}"), |
| LS32$ = subexp(subexp(H16$ + "\\:" + H16$) + "|" + IPV4ADDRESS$), |
| IPV6ADDRESS1$ = subexp(subexp(H16$ + "\\:") + "{6}" + LS32$), |
| // 6( h16 ":" ) ls32 |
| IPV6ADDRESS2$ = subexp("\\:\\:" + subexp(H16$ + "\\:") + "{5}" + LS32$), |
| // "::" 5( h16 ":" ) ls32 |
| IPV6ADDRESS3$ = subexp(subexp(H16$) + "?\\:\\:" + subexp(H16$ + "\\:") + "{4}" + LS32$), |
| //[ h16 ] "::" 4( h16 ":" ) ls32 |
| IPV6ADDRESS4$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,1}" + H16$) + "?\\:\\:" + subexp(H16$ + "\\:") + "{3}" + LS32$), |
| //[ *1( h16 ":" ) h16 ] "::" 3( h16 ":" ) ls32 |
| IPV6ADDRESS5$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,2}" + H16$) + "?\\:\\:" + subexp(H16$ + "\\:") + "{2}" + LS32$), |
| //[ *2( h16 ":" ) h16 ] "::" 2( h16 ":" ) ls32 |
| IPV6ADDRESS6$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,3}" + H16$) + "?\\:\\:" + H16$ + "\\:" + LS32$), |
| //[ *3( h16 ":" ) h16 ] "::" h16 ":" ls32 |
| IPV6ADDRESS7$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,4}" + H16$) + "?\\:\\:" + LS32$), |
| //[ *4( h16 ":" ) h16 ] "::" ls32 |
| IPV6ADDRESS8$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,5}" + H16$) + "?\\:\\:" + H16$), |
| //[ *5( h16 ":" ) h16 ] "::" h16 |
| IPV6ADDRESS9$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,6}" + H16$) + "?\\:\\:"), |
| //[ *6( h16 ":" ) h16 ] "::" |
| IPV6ADDRESS$ = subexp([IPV6ADDRESS1$, IPV6ADDRESS2$, IPV6ADDRESS3$, IPV6ADDRESS4$, IPV6ADDRESS5$, IPV6ADDRESS6$, IPV6ADDRESS7$, IPV6ADDRESS8$, IPV6ADDRESS9$].join("|")), |
| ZONEID$ = subexp(subexp(UNRESERVED$$ + "|" + PCT_ENCODED$) + "+"), |
| //RFC 6874 |
| IPV6ADDRZ$ = subexp(IPV6ADDRESS$ + "\\%25" + ZONEID$), |
| //RFC 6874 |
| IPV6ADDRZ_RELAXED$ = subexp(IPV6ADDRESS$ + subexp("\\%25|\\%(?!" + HEXDIG$$ + "{2})") + ZONEID$), |
| //RFC 6874, with relaxed parsing rules |
| IPVFUTURE$ = subexp("[vV]" + HEXDIG$$ + "+\\." + merge(UNRESERVED$$, SUB_DELIMS$$, "[\\:]") + "+"), |
| IP_LITERAL$ = subexp("\\[" + subexp(IPV6ADDRZ_RELAXED$ + "|" + IPV6ADDRESS$ + "|" + IPVFUTURE$) + "\\]"), |
| //RFC 6874 |
| REG_NAME$ = subexp(subexp(PCT_ENCODED$ + "|" + merge(UNRESERVED$$, SUB_DELIMS$$)) + "*"), |
| HOST$ = subexp(IP_LITERAL$ + "|" + IPV4ADDRESS$ + "(?!" + REG_NAME$ + ")" + "|" + REG_NAME$), |
| PORT$ = subexp(DIGIT$$ + "*"), |
| AUTHORITY$ = subexp(subexp(USERINFO$ + "@") + "?" + HOST$ + subexp("\\:" + PORT$) + "?"), |
| PCHAR$ = subexp(PCT_ENCODED$ + "|" + merge(UNRESERVED$$, SUB_DELIMS$$, "[\\:\\@]")), |
| SEGMENT$ = subexp(PCHAR$ + "*"), |
| SEGMENT_NZ$ = subexp(PCHAR$ + "+"), |
| SEGMENT_NZ_NC$ = subexp(subexp(PCT_ENCODED$ + "|" + merge(UNRESERVED$$, SUB_DELIMS$$, "[\\@]")) + "+"), |
| PATH_ABEMPTY$ = subexp(subexp("\\/" + SEGMENT$) + "*"), |
| PATH_ABSOLUTE$ = subexp("\\/" + subexp(SEGMENT_NZ$ + PATH_ABEMPTY$) + "?"), |
| //simplified |
| PATH_NOSCHEME$ = subexp(SEGMENT_NZ_NC$ + PATH_ABEMPTY$), |
| //simplified |
| PATH_ROOTLESS$ = subexp(SEGMENT_NZ$ + PATH_ABEMPTY$), |
| //simplified |
| PATH_EMPTY$ = "(?!" + PCHAR$ + ")", |
| PATH$ = subexp(PATH_ABEMPTY$ + "|" + PATH_ABSOLUTE$ + "|" + PATH_NOSCHEME$ + "|" + PATH_ROOTLESS$ + "|" + PATH_EMPTY$), |
| QUERY$ = subexp(subexp(PCHAR$ + "|" + merge("[\\/\\?]", IPRIVATE$$)) + "*"), |
| FRAGMENT$ = subexp(subexp(PCHAR$ + "|[\\/\\?]") + "*"), |
| HIER_PART$ = subexp(subexp("\\/\\/" + AUTHORITY$ + PATH_ABEMPTY$) + "|" + PATH_ABSOLUTE$ + "|" + PATH_ROOTLESS$ + "|" + PATH_EMPTY$), |
| URI$ = subexp(SCHEME$ + "\\:" + HIER_PART$ + subexp("\\?" + QUERY$) + "?" + subexp("\\#" + FRAGMENT$) + "?"), |
| RELATIVE_PART$ = subexp(subexp("\\/\\/" + AUTHORITY$ + PATH_ABEMPTY$) + "|" + PATH_ABSOLUTE$ + "|" + PATH_NOSCHEME$ + "|" + PATH_EMPTY$), |
| RELATIVE$ = subexp(RELATIVE_PART$ + subexp("\\?" + QUERY$) + "?" + subexp("\\#" + FRAGMENT$) + "?"), |
| URI_REFERENCE$ = subexp(URI$ + "|" + RELATIVE$), |
| ABSOLUTE_URI$ = subexp(SCHEME$ + "\\:" + HIER_PART$ + subexp("\\?" + QUERY$) + "?"), |
| GENERIC_REF$ = "^(" + SCHEME$ + ")\\:" + subexp(subexp("\\/\\/(" + subexp("(" + USERINFO$ + ")@") + "?(" + HOST$ + ")" + subexp("\\:(" + PORT$ + ")") + "?)") + "?(" + PATH_ABEMPTY$ + "|" + PATH_ABSOLUTE$ + "|" + PATH_ROOTLESS$ + "|" + PATH_EMPTY$ + ")") + subexp("\\?(" + QUERY$ + ")") + "?" + subexp("\\#(" + FRAGMENT$ + ")") + "?$", |
| RELATIVE_REF$ = "^(){0}" + subexp(subexp("\\/\\/(" + subexp("(" + USERINFO$ + ")@") + "?(" + HOST$ + ")" + subexp("\\:(" + PORT$ + ")") + "?)") + "?(" + PATH_ABEMPTY$ + "|" + PATH_ABSOLUTE$ + "|" + PATH_NOSCHEME$ + "|" + PATH_EMPTY$ + ")") + subexp("\\?(" + QUERY$ + ")") + "?" + subexp("\\#(" + FRAGMENT$ + ")") + "?$", |
| ABSOLUTE_REF$ = "^(" + SCHEME$ + ")\\:" + subexp(subexp("\\/\\/(" + subexp("(" + USERINFO$ + ")@") + "?(" + HOST$ + ")" + subexp("\\:(" + PORT$ + ")") + "?)") + "?(" + PATH_ABEMPTY$ + "|" + PATH_ABSOLUTE$ + "|" + PATH_ROOTLESS$ + "|" + PATH_EMPTY$ + ")") + subexp("\\?(" + QUERY$ + ")") + "?$", |
| SAMEDOC_REF$ = "^" + subexp("\\#(" + FRAGMENT$ + ")") + "?$", |
| AUTHORITY_REF$ = "^" + subexp("(" + USERINFO$ + ")@") + "?(" + HOST$ + ")" + subexp("\\:(" + PORT$ + ")") + "?$"; |
| return { |
| NOT_SCHEME: new RegExp(merge("[^]", ALPHA$$, DIGIT$$, "[\\+\\-\\.]"), "g"), |
| NOT_USERINFO: new RegExp(merge("[^\\%\\:]", UNRESERVED$$, SUB_DELIMS$$), "g"), |
| NOT_HOST: new RegExp(merge("[^\\%\\[\\]\\:]", UNRESERVED$$, SUB_DELIMS$$), "g"), |
| NOT_PATH: new RegExp(merge("[^\\%\\/\\:\\@]", UNRESERVED$$, SUB_DELIMS$$), "g"), |
| NOT_PATH_NOSCHEME: new RegExp(merge("[^\\%\\/\\@]", UNRESERVED$$, SUB_DELIMS$$), "g"), |
| NOT_QUERY: new RegExp(merge("[^\\%]", UNRESERVED$$, SUB_DELIMS$$, "[\\:\\@\\/\\?]", IPRIVATE$$), "g"), |
| NOT_FRAGMENT: new RegExp(merge("[^\\%]", UNRESERVED$$, SUB_DELIMS$$, "[\\:\\@\\/\\?]"), "g"), |
| ESCAPE: new RegExp(merge("[^]", UNRESERVED$$, SUB_DELIMS$$), "g"), |
| UNRESERVED: new RegExp(UNRESERVED$$, "g"), |
| OTHER_CHARS: new RegExp(merge("[^\\%]", UNRESERVED$$, RESERVED$$), "g"), |
| PCT_ENCODED: new RegExp(PCT_ENCODED$, "g"), |
| IPV4ADDRESS: new RegExp("^(" + IPV4ADDRESS$ + ")$"), |
| IPV6ADDRESS: new RegExp("^\\[?(" + IPV6ADDRESS$ + ")" + subexp(subexp("\\%25|\\%(?!" + HEXDIG$$ + "{2})") + "(" + ZONEID$ + ")") + "?\\]?$") //RFC 6874, with relaxed parsing rules |
| }; |
| } |
| var URI_PROTOCOL = buildExps(false); |
| |
| var IRI_PROTOCOL = buildExps(true); |
| |
| var slicedToArray = function () { |
| function sliceIterator(arr, i) { |
| var _arr = []; |
| var _n = true; |
| var _d = false; |
| var _e = undefined; |
| |
| try { |
| for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { |
| _arr.push(_s.value); |
| |
| if (i && _arr.length === i) break; |
| } |
| } catch (err) { |
| _d = true; |
| _e = err; |
| } finally { |
| try { |
| if (!_n && _i["return"]) _i["return"](); |
| } finally { |
| if (_d) throw _e; |
| } |
| } |
| |
| return _arr; |
| } |
| |
| return function (arr, i) { |
| if (Array.isArray(arr)) { |
| return arr; |
| } else if (Symbol.iterator in Object(arr)) { |
| return sliceIterator(arr, i); |
| } else { |
| throw new TypeError("Invalid attempt to destructure non-iterable instance"); |
| } |
| }; |
| }(); |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| var toConsumableArray = function (arr) { |
| if (Array.isArray(arr)) { |
| for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; |
| |
| return arr2; |
| } else { |
| return Array.from(arr); |
| } |
| }; |
| |
| /** Highest positive signed 32-bit float value */ |
| |
| var maxInt = 2147483647; // aka. 0x7FFFFFFF or 2^31-1 |
| |
| /** Bootstring parameters */ |
| var base = 36; |
| var tMin = 1; |
| var tMax = 26; |
| var skew = 38; |
| var damp = 700; |
| var initialBias = 72; |
| var initialN = 128; // 0x80 |
| var delimiter = '-'; // '\x2D' |
| |
| /** Regular expressions */ |
| var regexPunycode = /^xn--/; |
| var regexNonASCII = /[^\0-\x7E]/; // non-ASCII chars |
| var regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g; // RFC 3490 separators |
| |
| /** Error messages */ |
| var 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 */ |
| var baseMinusTMin = base - tMin; |
| var floor = Math.floor; |
| var stringFromCharCode = String.fromCharCode; |
| |
| /*--------------------------------------------------------------------------*/ |
| |
| /** |
| * A generic error utility function. |
| * @private |
| * @param {String} type The error type. |
| * @returns {Error} Throws a `RangeError` with the applicable error message. |
| */ |
| function error$1(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 result = []; |
| var length = array.length; |
| 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 = []; |
| var counter = 0; |
| var length = string.length; |
| while (counter < length) { |
| var value = string.charCodeAt(counter++); |
| if (value >= 0xD800 && value <= 0xDBFF && counter < length) { |
| // It's a high surrogate, and there is a next character. |
| var extra = string.charCodeAt(counter++); |
| if ((extra & 0xFC00) == 0xDC00) { |
| // Low surrogate. |
| output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000); |
| } else { |
| // It's an 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). |
| */ |
| var ucs2encode = function ucs2encode(array) { |
| return String.fromCodePoint.apply(String, toConsumableArray(array)); |
| }; |
| |
| /** |
| * 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. |
| */ |
| var basicToDigit = function basicToDigit(codePoint) { |
| if (codePoint - 0x30 < 0x0A) { |
| return codePoint - 0x16; |
| } |
| if (codePoint - 0x41 < 0x1A) { |
| return codePoint - 0x41; |
| } |
| if (codePoint - 0x61 < 0x1A) { |
| return codePoint - 0x61; |
| } |
| 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. |
| */ |
| var digitToBasic = 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 |
| */ |
| var adapt = 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. |
| */ |
| var decode = function decode(input) { |
| // Don't use UCS-2. |
| var output = []; |
| var inputLength = input.length; |
| var i = 0; |
| var n = initialN; |
| var bias = initialBias; |
| |
| // 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. |
| |
| var basic = input.lastIndexOf(delimiter); |
| if (basic < 0) { |
| basic = 0; |
| } |
| |
| for (var j = 0; j < basic; ++j) { |
| // if it's not a basic code point |
| if (input.charCodeAt(j) >= 0x80) { |
| error$1('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 (var 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`. |
| var oldi = i; |
| for (var w = 1, k = base;; /* no condition */k += base) { |
| |
| if (index >= inputLength) { |
| error$1('invalid-input'); |
| } |
| |
| var digit = basicToDigit(input.charCodeAt(index++)); |
| |
| if (digit >= base || digit > floor((maxInt - i) / w)) { |
| error$1('overflow'); |
| } |
| |
| i += digit * w; |
| var t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias; |
| |
| if (digit < t) { |
| break; |
| } |
| |
| var baseMinusT = base - t; |
| if (w > floor(maxInt / baseMinusT)) { |
| error$1('overflow'); |
| } |
| |
| w *= baseMinusT; |
| } |
| |
| var 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$1('overflow'); |
| } |
| |
| n += floor(i / out); |
| i %= out; |
| |
| // Insert `n` at position `i` of the output. |
| output.splice(i++, 0, n); |
| } |
| |
| return String.fromCodePoint.apply(String, 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. |
| */ |
| var encode = function encode(input) { |
| var output = []; |
| |
| // Convert the input in UCS-2 to an array of Unicode code points. |
| input = ucs2decode(input); |
| |
| // Cache the length. |
| var inputLength = input.length; |
| |
| // Initialize the state. |
| var n = initialN; |
| var delta = 0; |
| var bias = initialBias; |
| |
| // Handle the basic code points. |
| var _iteratorNormalCompletion = true; |
| var _didIteratorError = false; |
| var _iteratorError = undefined; |
| |
| try { |
| for (var _iterator = input[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { |
| var _currentValue2 = _step.value; |
| |
| if (_currentValue2 < 0x80) { |
| output.push(stringFromCharCode(_currentValue2)); |
| } |
| } |
| } catch (err) { |
| _didIteratorError = true; |
| _iteratorError = err; |
| } finally { |
| try { |
| if (!_iteratorNormalCompletion && _iterator.return) { |
| _iterator.return(); |
| } |
| } finally { |
| if (_didIteratorError) { |
| throw _iteratorError; |
| } |
| } |
| } |
| |
| var basicLength = output.length; |
| var handledCPCount = basicLength; |
| |
| // `handledCPCount` is the number of code points that have been handled; |
| // `basicLength` is the number of basic code points. |
| |
| // Finish the basic string with a delimiter unless it's empty. |
| 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: |
| var m = maxInt; |
| var _iteratorNormalCompletion2 = true; |
| var _didIteratorError2 = false; |
| var _iteratorError2 = undefined; |
| |
| try { |
| for (var _iterator2 = input[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) { |
| var currentValue = _step2.value; |
| |
| 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. |
| } catch (err) { |
| _didIteratorError2 = true; |
| _iteratorError2 = err; |
| } finally { |
| try { |
| if (!_iteratorNormalCompletion2 && _iterator2.return) { |
| _iterator2.return(); |
| } |
| } finally { |
| if (_didIteratorError2) { |
| throw _iteratorError2; |
| } |
| } |
| } |
| |
| var handledCPCountPlusOne = handledCPCount + 1; |
| if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) { |
| error$1('overflow'); |
| } |
| |
| delta += (m - n) * handledCPCountPlusOne; |
| n = m; |
| |
| var _iteratorNormalCompletion3 = true; |
| var _didIteratorError3 = false; |
| var _iteratorError3 = undefined; |
| |
| try { |
| for (var _iterator3 = input[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) { |
| var _currentValue = _step3.value; |
| |
| if (_currentValue < n && ++delta > maxInt) { |
| error$1('overflow'); |
| } |
| if (_currentValue == n) { |
| // Represent delta as a generalized variable-length integer. |
| var q = delta; |
| for (var k = base;; /* no condition */k += base) { |
| var t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias; |
| if (q < t) { |
| break; |
| } |
| var qMinusT = q - t; |
| var 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; |
| } |
| } |
| } catch (err) { |
| _didIteratorError3 = true; |
| _iteratorError3 = err; |
| } finally { |
| try { |
| if (!_iteratorNormalCompletion3 && _iterator3.return) { |
| _iterator3.return(); |
| } |
| } finally { |
| if (_didIteratorError3) { |
| throw _iteratorError3; |
| } |
| } |
| } |
| |
| ++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. |
| */ |
| var toUnicode = 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. |
| */ |
| var toASCII = function toASCII(input) { |
| return mapDomain(input, function (string) { |
| return regexNonASCII.test(string) ? 'xn--' + encode(string) : string; |
| }); |
| }; |
| |
| /*--------------------------------------------------------------------------*/ |
| |
| /** Define the public API */ |
| var punycode = { |
| /** |
| * A string representing the current Punycode.js version number. |
| * @memberOf punycode |
| * @type String |
| */ |
| 'version': '2.1.0', |
| /** |
| * 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 |
| }; |
| |
| /** |
| * URI.js |
| * |
| * @fileoverview An RFC 3986 compliant, scheme extendable URI parsing/validating/resolving library for JavaScript. |
| * @author <a href="mailto:gary.court@gmail.com">Gary Court</a> |
| * @see http://github.com/garycourt/uri-js |
| */ |
| /** |
| * Copyright 2011 Gary Court. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without modification, are |
| * permitted provided that the following conditions are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright notice, this list of |
| * conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above copyright notice, this list |
| * of conditions and the following disclaimer in the documentation and/or other materials |
| * provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY GARY COURT ``AS IS'' AND ANY EXPRESS OR IMPLIED |
| * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND |
| * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GARY COURT OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR |
| * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON |
| * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING |
| * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
| * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| * The views and conclusions contained in the software and documentation are those of the |
| * authors and should not be interpreted as representing official policies, either expressed |
| * or implied, of Gary Court. |
| */ |
| var SCHEMES = {}; |
| function pctEncChar(chr) { |
| var c = chr.charCodeAt(0); |
| var e = void 0; |
| if (c < 16) e = "%0" + c.toString(16).toUpperCase();else if (c < 128) e = "%" + c.toString(16).toUpperCase();else if (c < 2048) e = "%" + (c >> 6 | 192).toString(16).toUpperCase() + "%" + (c & 63 | 128).toString(16).toUpperCase();else e = "%" + (c >> 12 | 224).toString(16).toUpperCase() + "%" + (c >> 6 & 63 | 128).toString(16).toUpperCase() + "%" + (c & 63 | 128).toString(16).toUpperCase(); |
| return e; |
| } |
| function pctDecChars(str) { |
| var newStr = ""; |
| var i = 0; |
| var il = str.length; |
| while (i < il) { |
| var c = parseInt(str.substr(i + 1, 2), 16); |
| if (c < 128) { |
| newStr += String.fromCharCode(c); |
| i += 3; |
| } else if (c >= 194 && c < 224) { |
| if (il - i >= 6) { |
| var c2 = parseInt(str.substr(i + 4, 2), 16); |
| newStr += String.fromCharCode((c & 31) << 6 | c2 & 63); |
| } else { |
| newStr += str.substr(i, 6); |
| } |
| i += 6; |
| } else if (c >= 224) { |
| if (il - i >= 9) { |
| var _c = parseInt(str.substr(i + 4, 2), 16); |
| var c3 = parseInt(str.substr(i + 7, 2), 16); |
| newStr += String.fromCharCode((c & 15) << 12 | (_c & 63) << 6 | c3 & 63); |
| } else { |
| newStr += str.substr(i, 9); |
| } |
| i += 9; |
| } else { |
| newStr += str.substr(i, 3); |
| i += 3; |
| } |
| } |
| return newStr; |
| } |
| function _normalizeComponentEncoding(components, protocol) { |
| function decodeUnreserved(str) { |
| var decStr = pctDecChars(str); |
| return !decStr.match(protocol.UNRESERVED) ? str : decStr; |
| } |
| if (components.scheme) components.scheme = String(components.scheme).replace(protocol.PCT_ENCODED, decodeUnreserved).toLowerCase().replace(protocol.NOT_SCHEME, ""); |
| if (components.userinfo !== undefined) components.userinfo = String(components.userinfo).replace(protocol.PCT_ENCODED, decodeUnreserved).replace(protocol.NOT_USERINFO, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase); |
| if (components.host !== undefined) components.host = String(components.host).replace(protocol.PCT_ENCODED, decodeUnreserved).toLowerCase().replace(protocol.NOT_HOST, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase); |
| if (components.path !== undefined) components.path = String(components.path).replace(protocol.PCT_ENCODED, decodeUnreserved).replace(components.scheme ? protocol.NOT_PATH : protocol.NOT_PATH_NOSCHEME, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase); |
| if (components.query !== undefined) components.query = String(components.query).replace(protocol.PCT_ENCODED, decodeUnreserved).replace(protocol.NOT_QUERY, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase); |
| if (components.fragment !== undefined) components.fragment = String(components.fragment).replace(protocol.PCT_ENCODED, decodeUnreserved).replace(protocol.NOT_FRAGMENT, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase); |
| return components; |
| } |
| |
| function _stripLeadingZeros(str) { |
| return str.replace(/^0*(.*)/, "$1") || "0"; |
| } |
| function _normalizeIPv4(host, protocol) { |
| var matches = host.match(protocol.IPV4ADDRESS) || []; |
| |
| var _matches = slicedToArray(matches, 2), |
| address = _matches[1]; |
| |
| if (address) { |
| return address.split(".").map(_stripLeadingZeros).join("."); |
| } else { |
| return host; |
| } |
| } |
| function _normalizeIPv6(host, protocol) { |
| var matches = host.match(protocol.IPV6ADDRESS) || []; |
| |
| var _matches2 = slicedToArray(matches, 3), |
| address = _matches2[1], |
| zone = _matches2[2]; |
| |
| if (address) { |
| var _address$toLowerCase$ = address.toLowerCase().split('::').reverse(), |
| _address$toLowerCase$2 = slicedToArray(_address$toLowerCase$, 2), |
| last = _address$toLowerCase$2[0], |
| first = _address$toLowerCase$2[1]; |
| |
| var firstFields = first ? first.split(":").map(_stripLeadingZeros) : []; |
| var lastFields = last.split(":").map(_stripLeadingZeros); |
| var isLastFieldIPv4Address = protocol.IPV4ADDRESS.test(lastFields[lastFields.length - 1]); |
| var fieldCount = isLastFieldIPv4Address ? 7 : 8; |
| var lastFieldsStart = lastFields.length - fieldCount; |
| var fields = Array(fieldCount); |
| for (var x = 0; x < fieldCount; ++x) { |
| fields[x] = firstFields[x] || lastFields[lastFieldsStart + x] || ''; |
| } |
| if (isLastFieldIPv4Address) { |
| fields[fieldCount - 1] = _normalizeIPv4(fields[fieldCount - 1], protocol); |
| } |
| var allZeroFields = fields.reduce(function (acc, field, index) { |
| if (!field || field === "0") { |
| var lastLongest = acc[acc.length - 1]; |
| if (lastLongest && lastLongest.index + lastLongest.length === index) { |
| lastLongest.length++; |
| } else { |
| acc.push({ index: index, length: 1 }); |
| } |
| } |
| return acc; |
| }, []); |
| var longestZeroFields = allZeroFields.sort(function (a, b) { |
| return b.length - a.length; |
| })[0]; |
| var newHost = void 0; |
| if (longestZeroFields && longestZeroFields.length > 1) { |
| var newFirst = fields.slice(0, longestZeroFields.index); |
| var newLast = fields.slice(longestZeroFields.index + longestZeroFields.length); |
| newHost = newFirst.join(":") + "::" + newLast.join(":"); |
| } else { |
| newHost = fields.join(":"); |
| } |
| if (zone) { |
| newHost += "%" + zone; |
| } |
| return newHost; |
| } else { |
| return host; |
| } |
| } |
| var URI_PARSE = /^(?:([^:\/?#]+):)?(?:\/\/((?:([^\/?#@]*)@)?(\[[^\/?#\]]+\]|[^\/?#:]*)(?:\:(\d*))?))?([^?#]*)(?:\?([^#]*))?(?:#((?:.|\n|\r)*))?/i; |
| var NO_MATCH_IS_UNDEFINED = "".match(/(){0}/)[1] === undefined; |
| function parse(uriString) { |
| var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; |
| |
| var components = {}; |
| var protocol = options.iri !== false ? IRI_PROTOCOL : URI_PROTOCOL; |
| if (options.reference === "suffix") uriString = (options.scheme ? options.scheme + ":" : "") + "//" + uriString; |
| var matches = uriString.match(URI_PARSE); |
| if (matches) { |
| if (NO_MATCH_IS_UNDEFINED) { |
| //store each component |
| components.scheme = matches[1]; |
| components.userinfo = matches[3]; |
| components.host = matches[4]; |
| components.port = parseInt(matches[5], 10); |
| components.path = matches[6] || ""; |
| components.query = matches[7]; |
| components.fragment = matches[8]; |
| //fix port number |
| if (isNaN(components.port)) { |
| components.port = matches[5]; |
| } |
| } else { |
| //IE FIX for improper RegExp matching |
| //store each component |
| components.scheme = matches[1] || undefined; |
| components.userinfo = uriString.indexOf("@") !== -1 ? matches[3] : undefined; |
| components.host = uriString.indexOf("//") !== -1 ? matches[4] : undefined; |
| components.port = parseInt(matches[5], 10); |
| components.path = matches[6] || ""; |
| components.query = uriString.indexOf("?") !== -1 ? matches[7] : undefined; |
| components.fragment = uriString.indexOf("#") !== -1 ? matches[8] : undefined; |
| //fix port number |
| if (isNaN(components.port)) { |
| components.port = uriString.match(/\/\/(?:.|\n)*\:(?:\/|\?|\#|$)/) ? matches[4] : undefined; |
| } |
| } |
| if (components.host) { |
| //normalize IP hosts |
| components.host = _normalizeIPv6(_normalizeIPv4(components.host, protocol), protocol); |
| } |
| //determine reference type |
| if (components.scheme === undefined && components.userinfo === undefined && components.host === undefined && components.port === undefined && !components.path && components.query === undefined) { |
| components.reference = "same-document"; |
| } else if (components.scheme === undefined) { |
| components.reference = "relative"; |
| } else if (components.fragment === undefined) { |
| components.reference = "absolute"; |
| } else { |
| components.reference = "uri"; |
| } |
| //check for reference errors |
| if (options.reference && options.reference !== "suffix" && options.reference !== components.reference) { |
| components.error = components.error || "URI is not a " + options.reference + " reference."; |
| } |
| //find scheme handler |
| var schemeHandler = SCHEMES[(options.scheme || components.scheme || "").toLowerCase()]; |
| //check if scheme can't handle IRIs |
| if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) { |
| //if host component is a domain name |
| if (components.host && (options.domainHost || schemeHandler && schemeHandler.domainHost)) { |
| //convert Unicode IDN -> ASCII IDN |
| try { |
| components.host = punycode.toASCII(components.host.replace(protocol.PCT_ENCODED, pctDecChars).toLowerCase()); |
| } catch (e) { |
| components.error = components.error || "Host's domain name can not be converted to ASCII via punycode: " + e; |
| } |
| } |
| //convert IRI -> URI |
| _normalizeComponentEncoding(components, URI_PROTOCOL); |
| } else { |
| //normalize encodings |
| _normalizeComponentEncoding(components, protocol); |
| } |
| //perform scheme specific parsing |
| if (schemeHandler && schemeHandler.parse) { |
| schemeHandler.parse(components, options); |
| } |
| } else { |
| components.error = components.error || "URI can not be parsed."; |
| } |
| return components; |
| } |
| |
| function _recomposeAuthority(components, options) { |
| var protocol = options.iri !== false ? IRI_PROTOCOL : URI_PROTOCOL; |
| var uriTokens = []; |
| if (components.userinfo !== undefined) { |
| uriTokens.push(components.userinfo); |
| uriTokens.push("@"); |
| } |
| if (components.host !== undefined) { |
| //normalize IP hosts, add brackets and escape zone separator for IPv6 |
| uriTokens.push(_normalizeIPv6(_normalizeIPv4(String(components.host), protocol), protocol).replace(protocol.IPV6ADDRESS, function (_, $1, $2) { |
| return "[" + $1 + ($2 ? "%25" + $2 : "") + "]"; |
| })); |
| } |
| if (typeof components.port === "number") { |
| uriTokens.push(":"); |
| uriTokens.push(components.port.toString(10)); |
| } |
| return uriTokens.length ? uriTokens.join("") : undefined; |
| } |
| |
| var RDS1 = /^\.\.?\//; |
| var RDS2 = /^\/\.(\/|$)/; |
| var RDS3 = /^\/\.\.(\/|$)/; |
| var RDS5 = /^\/?(?:.|\n)*?(?=\/|$)/; |
| function removeDotSegments(input) { |
| var output = []; |
| while (input.length) { |
| if (input.match(RDS1)) { |
| input = input.replace(RDS1, ""); |
| } else if (input.match(RDS2)) { |
| input = input.replace(RDS2, "/"); |
| } else if (input.match(RDS3)) { |
| input = input.replace(RDS3, "/"); |
| output.pop(); |
| } else if (input === "." || input === "..") { |
| input = ""; |
| } else { |
| var im = input.match(RDS5); |
| if (im) { |
| var s = im[0]; |
| input = input.slice(s.length); |
| output.push(s); |
| } else { |
| throw new Error("Unexpected dot segment condition"); |
| } |
| } |
| } |
| return output.join(""); |
| } |
| |
| function serialize(components) { |
| var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; |
| |
| var protocol = options.iri ? IRI_PROTOCOL : URI_PROTOCOL; |
| var uriTokens = []; |
| //find scheme handler |
| var schemeHandler = SCHEMES[(options.scheme || components.scheme || "").toLowerCase()]; |
| //perform scheme specific serialization |
| if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(components, options); |
| if (components.host) { |
| //if host component is an IPv6 address |
| if (protocol.IPV6ADDRESS.test(components.host)) {} |
| //TODO: normalize IPv6 address as per RFC 5952 |
| |
| //if host component is a domain name |
| else if (options.domainHost || schemeHandler && schemeHandler.domainHost) { |
| //convert IDN via punycode |
| try { |
| components.host = !options.iri ? punycode.toASCII(components.host.replace(protocol.PCT_ENCODED, pctDecChars).toLowerCase()) : punycode.toUnicode(components.host); |
| } catch (e) { |
| components.error = components.error || "Host's domain name can not be converted to " + (!options.iri ? "ASCII" : "Unicode") + " via punycode: " + e; |
| } |
| } |
| } |
| //normalize encoding |
| _normalizeComponentEncoding(components, protocol); |
| if (options.reference !== "suffix" && components.scheme) { |
| uriTokens.push(components.scheme); |
| uriTokens.push(":"); |
| } |
| var authority = _recomposeAuthority(components, options); |
| if (authority !== undefined) { |
| if (options.reference !== "suffix") { |
| uriTokens.push("//"); |
| } |
| uriTokens.push(authority); |
| if (components.path && components.path.charAt(0) !== "/") { |
| uriTokens.push("/"); |
| } |
| } |
| if (components.path !== undefined) { |
| var s = components.path; |
| if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) { |
| s = removeDotSegments(s); |
| } |
| if (authority === undefined) { |
| s = s.replace(/^\/\//, "/%2F"); //don't allow the path to start with "//" |
| } |
| uriTokens.push(s); |
| } |
| if (components.query !== undefined) { |
| uriTokens.push("?"); |
| uriTokens.push(components.query); |
| } |
| if (components.fragment !== undefined) { |
| uriTokens.push("#"); |
| uriTokens.push(components.fragment); |
| } |
| return uriTokens.join(""); //merge tokens into a string |
| } |
| |
| function resolveComponents(base, relative) { |
| var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; |
| var skipNormalization = arguments[3]; |
| |
| var target = {}; |
| if (!skipNormalization) { |
| base = parse(serialize(base, options), options); //normalize base components |
| relative = parse(serialize(relative, options), options); //normalize relative components |
| } |
| options = options || {}; |
| if (!options.tolerant && relative.scheme) { |
| target.scheme = relative.scheme; |
| //target.authority = relative.authority; |
| target.userinfo = relative.userinfo; |
| target.host = relative.host; |
| target.port = relative.port; |
| target.path = removeDotSegments(relative.path || ""); |
| target.query = relative.query; |
| } else { |
| if (relative.userinfo !== undefined || relative.host !== undefined || relative.port !== undefined) { |
| //target.authority = relative.authority; |
| target.userinfo = relative.userinfo; |
| target.host = relative.host; |
| target.port = relative.port; |
| target.path = removeDotSegments(relative.path || ""); |
| target.query = relative.query; |
| } else { |
| if (!relative.path) { |
| target.path = base.path; |
| if (relative.query !== undefined) { |
| target.query = relative.query; |
| } else { |
| target.query = base.query; |
| } |
| } else { |
| if (relative.path.charAt(0) === "/") { |
| target.path = removeDotSegments(relative.path); |
| } else { |
| if ((base.userinfo !== undefined || base.host !== undefined || base.port !== undefined) && !base.path) { |
| target.path = "/" + relative.path; |
| } else if (!base.path) { |
| target.path = relative.path; |
| } else { |
| target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative.path; |
| } |
| target.path = removeDotSegments(target.path); |
| } |
| target.query = relative.query; |
| } |
| //target.authority = base.authority; |
| target.userinfo = base.userinfo; |
| target.host = base.host; |
| target.port = base.port; |
| } |
| target.scheme = base.scheme; |
| } |
| target.fragment = relative.fragment; |
| return target; |
| } |
| |
| function resolve(baseURI, relativeURI, options) { |
| var schemelessOptions = assign({ scheme: 'null' }, options); |
| return serialize(resolveComponents(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true), schemelessOptions); |
| } |
| |
| function normalize(uri, options) { |
| if (typeof uri === "string") { |
| uri = serialize(parse(uri, options), options); |
| } else if (typeOf(uri) === "object") { |
| uri = parse(serialize(uri, options), options); |
| } |
| return uri; |
| } |
| |
| function equal(uriA, uriB, options) { |
| if (typeof uriA === "string") { |
| uriA = serialize(parse(uriA, options), options); |
| } else if (typeOf(uriA) === "object") { |
| uriA = serialize(uriA, options); |
| } |
| if (typeof uriB === "string") { |
| uriB = serialize(parse(uriB, options), options); |
| } else if (typeOf(uriB) === "object") { |
| uriB = serialize(uriB, options); |
| } |
| return uriA === uriB; |
| } |
| |
| function escapeComponent(str, options) { |
| return str && str.toString().replace(!options || !options.iri ? URI_PROTOCOL.ESCAPE : IRI_PROTOCOL.ESCAPE, pctEncChar); |
| } |
| |
| function unescapeComponent(str, options) { |
| return str && str.toString().replace(!options || !options.iri ? URI_PROTOCOL.PCT_ENCODED : IRI_PROTOCOL.PCT_ENCODED, pctDecChars); |
| } |
| |
| var handler = { |
| scheme: "http", |
| domainHost: true, |
| parse: function parse(components, options) { |
| //report missing host |
| if (!components.host) { |
| components.error = components.error || "HTTP URIs must have a host."; |
| } |
| return components; |
| }, |
| serialize: function serialize(components, options) { |
| //normalize the default port |
| if (components.port === (String(components.scheme).toLowerCase() !== "https" ? 80 : 443) || components.port === "") { |
| components.port = undefined; |
| } |
| //normalize the empty path |
| if (!components.path) { |
| components.path = "/"; |
| } |
| //NOTE: We do not parse query strings for HTTP URIs |
| //as WWW Form Url Encoded query strings are part of the HTML4+ spec, |
| //and not the HTTP spec. |
| return components; |
| } |
| }; |
| |
| var handler$1 = { |
| scheme: "https", |
| domainHost: handler.domainHost, |
| parse: handler.parse, |
| serialize: handler.serialize |
| }; |
| |
| var O = {}; |
| var isIRI = true; |
| //RFC 3986 |
| var UNRESERVED$$ = "[A-Za-z0-9\\-\\.\\_\\~" + (isIRI ? "\\xA0-\\u200D\\u2010-\\u2029\\u202F-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF" : "") + "]"; |
| var HEXDIG$$ = "[0-9A-Fa-f]"; //case-insensitive |
| var PCT_ENCODED$ = subexp(subexp("%[EFef]" + HEXDIG$$ + "%" + HEXDIG$$ + HEXDIG$$ + "%" + HEXDIG$$ + HEXDIG$$) + "|" + subexp("%[89A-Fa-f]" + HEXDIG$$ + "%" + HEXDIG$$ + HEXDIG$$) + "|" + subexp("%" + HEXDIG$$ + HEXDIG$$)); //expanded |
| //RFC 5322, except these symbols as per RFC 6068: @ : / ? # [ ] & ; = |
| //const ATEXT$$ = "[A-Za-z0-9\\!\\#\\$\\%\\&\\'\\*\\+\\-\\/\\=\\?\\^\\_\\`\\{\\|\\}\\~]"; |
| //const WSP$$ = "[\\x20\\x09]"; |
| //const OBS_QTEXT$$ = "[\\x01-\\x08\\x0B\\x0C\\x0E-\\x1F\\x7F]"; //(%d1-8 / %d11-12 / %d14-31 / %d127) |
| //const QTEXT$$ = merge("[\\x21\\x23-\\x5B\\x5D-\\x7E]", OBS_QTEXT$$); //%d33 / %d35-91 / %d93-126 / obs-qtext |
| //const VCHAR$$ = "[\\x21-\\x7E]"; |
| //const WSP$$ = "[\\x20\\x09]"; |
| //const OBS_QP$ = subexp("\\\\" + merge("[\\x00\\x0D\\x0A]", OBS_QTEXT$$)); //%d0 / CR / LF / obs-qtext |
| //const FWS$ = subexp(subexp(WSP$$ + "*" + "\\x0D\\x0A") + "?" + WSP$$ + "+"); |
| //const QUOTED_PAIR$ = subexp(subexp("\\\\" + subexp(VCHAR$$ + "|" + WSP$$)) + "|" + OBS_QP$); |
| //const QUOTED_STRING$ = subexp('\\"' + subexp(FWS$ + "?" + QCONTENT$) + "*" + FWS$ + "?" + '\\"'); |
| var ATEXT$$ = "[A-Za-z0-9\\!\\$\\%\\'\\*\\+\\-\\^\\_\\`\\{\\|\\}\\~]"; |
| var QTEXT$$ = "[\\!\\$\\%\\'\\(\\)\\*\\+\\,\\-\\.0-9\\<\\>A-Z\\x5E-\\x7E]"; |
| var VCHAR$$ = merge(QTEXT$$, "[\\\"\\\\]"); |
| var SOME_DELIMS$$ = "[\\!\\$\\'\\(\\)\\*\\+\\,\\;\\:\\@]"; |
| var UNRESERVED = new RegExp(UNRESERVED$$, "g"); |
| var PCT_ENCODED = new RegExp(PCT_ENCODED$, "g"); |
| var NOT_LOCAL_PART = new RegExp(merge("[^]", ATEXT$$, "[\\.]", '[\\"]', VCHAR$$), "g"); |
| var NOT_HFNAME = new RegExp(merge("[^]", UNRESERVED$$, SOME_DELIMS$$), "g"); |
| var NOT_HFVALUE = NOT_HFNAME; |
| function decodeUnreserved(str) { |
| var decStr = pctDecChars(str); |
| return !decStr.match(UNRESERVED) ? str : decStr; |
| } |
| var handler$2 = { |
| scheme: "mailto", |
| parse: function parse$$1(components, options) { |
| var mailtoComponents = components; |
| var to = mailtoComponents.to = mailtoComponents.path ? mailtoComponents.path.split(",") : []; |
| mailtoComponents.path = undefined; |
| if (mailtoComponents.query) { |
| var unknownHeaders = false; |
| var headers = {}; |
| var hfields = mailtoComponents.query.split("&"); |
| for (var x = 0, xl = hfields.length; x < xl; ++x) { |
| var hfield = hfields[x].split("="); |
| switch (hfield[0]) { |
| case "to": |
| var toAddrs = hfield[1].split(","); |
| for (var _x = 0, _xl = toAddrs.length; _x < _xl; ++_x) { |
| to.push(toAddrs[_x]); |
| } |
| break; |
| case "subject": |
| mailtoComponents.subject = unescapeComponent(hfield[1], options); |
| break; |
| case "body": |
| mailtoComponents.body = unescapeComponent(hfield[1], options); |
| break; |
| default: |
| unknownHeaders = true; |
| headers[unescapeComponent(hfield[0], options)] = unescapeComponent(hfield[1], options); |
| break; |
| } |
| } |
| if (unknownHeaders) mailtoComponents.headers = headers; |
| } |
| mailtoComponents.query = undefined; |
| for (var _x2 = 0, _xl2 = to.length; _x2 < _xl2; ++_x2) { |
| var addr = to[_x2].split("@"); |
| addr[0] = unescapeComponent(addr[0]); |
| if (!options.unicodeSupport) { |
| //convert Unicode IDN -> ASCII IDN |
| try { |
| addr[1] = punycode.toASCII(unescapeComponent(addr[1], options).toLowerCase()); |
| } catch (e) { |
| mailtoComponents.error = mailtoComponents.error || "Email address's domain name can not be converted to ASCII via punycode: " + e; |
| } |
| } else { |
| addr[1] = unescapeComponent(addr[1], options).toLowerCase(); |
| } |
| to[_x2] = addr.join("@"); |
| } |
| return mailtoComponents; |
| }, |
| serialize: function serialize$$1(mailtoComponents, options) { |
| var components = mailtoComponents; |
| var to = toArray(mailtoComponents.to); |
| if (to) { |
| for (var x = 0, xl = to.length; x < xl; ++x) { |
| var toAddr = String(to[x]); |
| var atIdx = toAddr.lastIndexOf("@"); |
| var localPart = toAddr.slice(0, atIdx).replace(PCT_ENCODED, decodeUnreserved).replace(PCT_ENCODED, toUpperCase).replace(NOT_LOCAL_PART, pctEncChar); |
| var domain = toAddr.slice(atIdx + 1); |
| //convert IDN via punycode |
| try { |
| domain = !options.iri ? punycode.toASCII(unescapeComponent(domain, options).toLowerCase()) : punycode.toUnicode(domain); |
| } catch (e) { |
| components.error = components.error || "Email address's domain name can not be converted to " + (!options.iri ? "ASCII" : "Unicode") + " via punycode: " + e; |
| } |
| to[x] = localPart + "@" + domain; |
| } |
| components.path = to.join(","); |
| } |
| var headers = mailtoComponents.headers = mailtoComponents.headers || {}; |
| if (mailtoComponents.subject) headers["subject"] = mailtoComponents.subject; |
| if (mailtoComponents.body) headers["body"] = mailtoComponents.body; |
| var fields = []; |
| for (var name in headers) { |
| if (headers[name] !== O[name]) { |
| fields.push(name.replace(PCT_ENCODED, decodeUnreserved).replace(PCT_ENCODED, toUpperCase).replace(NOT_HFNAME, pctEncChar) + "=" + headers[name].replace(PCT_ENCODED, decodeUnreserved).replace(PCT_ENCODED, toUpperCase).replace(NOT_HFVALUE, pctEncChar)); |
| } |
| } |
| if (fields.length) { |
| components.query = fields.join("&"); |
| } |
| return components; |
| } |
| }; |
| |
| var URN_PARSE = /^([^\:]+)\:(.*)/; |
| //RFC 2141 |
| var handler$3 = { |
| scheme: "urn", |
| parse: function parse$$1(components, options) { |
| var matches = components.path && components.path.match(URN_PARSE); |
| var urnComponents = components; |
| if (matches) { |
| var scheme = options.scheme || urnComponents.scheme || "urn"; |
| var nid = matches[1].toLowerCase(); |
| var nss = matches[2]; |
| var urnScheme = scheme + ":" + (options.nid || nid); |
| var schemeHandler = SCHEMES[urnScheme]; |
| urnComponents.nid = nid; |
| urnComponents.nss = nss; |
| urnComponents.path = undefined; |
| if (schemeHandler) { |
| urnComponents = schemeHandler.parse(urnComponents, options); |
| } |
| } else { |
| urnComponents.error = urnComponents.error || "URN can not be parsed."; |
| } |
| return urnComponents; |
| }, |
| serialize: function serialize$$1(urnComponents, options) { |
| var scheme = options.scheme || urnComponents.scheme || "urn"; |
| var nid = urnComponents.nid; |
| var urnScheme = scheme + ":" + (options.nid || nid); |
| var schemeHandler = SCHEMES[urnScheme]; |
| if (schemeHandler) { |
| urnComponents = schemeHandler.serialize(urnComponents, options); |
| } |
| var uriComponents = urnComponents; |
| var nss = urnComponents.nss; |
| uriComponents.path = (nid || options.nid) + ":" + nss; |
| return uriComponents; |
| } |
| }; |
| |
| var UUID = /^[0-9A-Fa-f]{8}(?:\-[0-9A-Fa-f]{4}){3}\-[0-9A-Fa-f]{12}$/; |
| //RFC 4122 |
| var handler$4 = { |
| scheme: "urn:uuid", |
| parse: function parse(urnComponents, options) { |
| var uuidComponents = urnComponents; |
| uuidComponents.uuid = uuidComponents.nss; |
| uuidComponents.nss = undefined; |
| if (!options.tolerant && (!uuidComponents.uuid || !uuidComponents.uuid.match(UUID))) { |
| uuidComponents.error = uuidComponents.error || "UUID is not valid."; |
| } |
| return uuidComponents; |
| }, |
| serialize: function serialize(uuidComponents, options) { |
| var urnComponents = uuidComponents; |
| //normalize UUID |
| urnComponents.nss = (uuidComponents.uuid || "").toLowerCase(); |
| return urnComponents; |
| } |
| }; |
| |
| SCHEMES[handler.scheme] = handler; |
| SCHEMES[handler$1.scheme] = handler$1; |
| SCHEMES[handler$2.scheme] = handler$2; |
| SCHEMES[handler$3.scheme] = handler$3; |
| SCHEMES[handler$4.scheme] = handler$4; |
| |
| exports.SCHEMES = SCHEMES; |
| exports.pctEncChar = pctEncChar; |
| exports.pctDecChars = pctDecChars; |
| exports.parse = parse; |
| exports.removeDotSegments = removeDotSegments; |
| exports.serialize = serialize; |
| exports.resolveComponents = resolveComponents; |
| exports.resolve = resolve; |
| exports.normalize = normalize; |
| exports.equal = equal; |
| exports.escapeComponent = escapeComponent; |
| exports.unescapeComponent = unescapeComponent; |
| |
| Object.defineProperty(exports, '__esModule', { value: true }); |
| |
| }))); |
| |
| |
| },{}],"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') |
| , util = require('./compile/util'); |
| |
| 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; |
| Ajv.prototype.validateKeyword = customKeyword.validate; |
| |
| 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-07/schema'; |
| |
| var META_IGNORE_OPTIONS = [ 'removeAdditional', 'useDefaults', 'coerceTypes', 'strictDefaults' ]; |
| 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); |
| |
| 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); |
| addDefaultMetaSchema(this); |
| if (typeof opts.meta == 'object') this.addMetaSchema(opts.meta); |
| if (opts.nullable) this.addKeyword('nullable', {metaSchema: {type: 'boolean'}}); |
| addInitialSchemas(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) 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 valid = this.validate($schema, schema); |
| 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); } |
| catch(e) { |
| delete schemaObj.validate; |
| throw e; |
| } |
| 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; |
| |
| |
| /* @this {*} - custom context, see passContext option */ |
| function callValidate() { |
| /* jshint validthis: true */ |
| var _validate = schemaObj.validate; |
| var result = _validate.apply(this, arguments); |
| callValidate.errors = _validate.errors; |
| return result; |
| } |
| } |
| |
| |
| function chooseGetId(opts) { |
| switch (opts.schemaId) { |
| case 'auto': return _get$IdOrId; |
| case 'id': return _getId; |
| default: return _get$Id; |
| } |
| } |
| |
| /* @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 addDefaultMetaSchema(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-07.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() {} |
| |
| },{"./cache":1,"./compile":5,"./compile/async":2,"./compile/error_classes":3,"./compile/formats":4,"./compile/resolve":6,"./compile/rules":7,"./compile/schema_obj":8,"./compile/util":10,"./data":11,"./keyword":39,"./refs/data.json":40,"./refs/json-schema-draft-07.json":41,"fast-json-stable-stringify":43}]},{},[])("ajv") |
| }); |
