twitst4tz

ajv.bundle.js (270979B)

---

 (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 = /^(?=.{1,253}\.?$)[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);
 }
 
 
 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';
 
 // do not edit .js files directly - edit src/index.jst
 
 
 
 module.exports = function equal(a, b) {
   if (a === b) return true;
 
   if (a && b && typeof a == 'object' && typeof b == 'object') {
     if (a.constructor !== b.constructor) return false;
 
     var length, i, keys;
     if (Array.isArray(a)) {
       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 (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
     if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
     if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
 
     keys = Object.keys(a);
     length = keys.length;
     if (length !== Object.keys(b).length) return false;
 
     for (i = length; i-- !== 0;)
       if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
 
     for (i = length; i-- !== 0;) {
       var key = keys[i];
 
       if (!equal(a[key], b[key])) return false;
     }
 
     return true;
   }
 
   // true if both NaN, false otherwise
   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);
   if (opts.keywords) addInitialKeywords(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 addInitialKeywords(self) {
   for (var name in self._opts.keywords) {
     var keyword = self._opts.keywords[name];
     self.addKeyword(name, keyword);
   }
 }
 
 
 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")
 });