{"version":3,"sources":["../node_modules/ajv/lib/ajv.js","../node_modules/ajv/lib/compile/util.js","../node_modules/ajv/lib/compile/resolve.js","../node_modules/fast-deep-equal/index.js","../node_modules/ajv/lib/compile/error_classes.js","../node_modules/ajv/lib/compile/schema_obj.js","../node_modules/fast-json-stable-stringify/index.js","../node_modules/ajv/lib/dotjs/validate.js","../node_modules/ajv/lib/dotjs/_limit.js","../node_modules/ajv/lib/dotjs/_limitItems.js","../node_modules/ajv/lib/dotjs/_limitLength.js","../node_modules/ajv/lib/dotjs/_limitProperties.js","../node_modules/ajv/lib/compile/index.js","../../../src/util.ts","../../../src/regexps-uri.ts","../../../src/regexps-iri.ts","../../../node_modules/punycode/punycode.es6.js","../../../src/uri.ts","../../../src/schemes/http.ts","../../../src/schemes/https.ts","../../../src/schemes/ws.ts","../../../src/schemes/wss.ts","../../../src/schemes/mailto.ts","../../../src/schemes/urn.ts","../../../src/schemes/urn-uuid.ts","../../../src/index.ts","../node_modules/ajv/lib/compile/ucs2length.js","../node_modules/json-schema-traverse/index.js","../node_modules/ajv/lib/cache.js","../node_modules/ajv/lib/compile/formats.js","../node_modules/ajv/lib/compile/rules.js","../node_modules/ajv/lib/dotjs/index.js","../node_modules/ajv/lib/dotjs/ref.js","../node_modules/ajv/lib/dotjs/allOf.js","../node_modules/ajv/lib/dotjs/anyOf.js","../node_modules/ajv/lib/dotjs/comment.js","../node_modules/ajv/lib/dotjs/const.js","../node_modules/ajv/lib/dotjs/contains.js","../node_modules/ajv/lib/dotjs/dependencies.js","../node_modules/ajv/lib/dotjs/enum.js","../node_modules/ajv/lib/dotjs/format.js","../node_modules/ajv/lib/dotjs/if.js","../node_modules/ajv/lib/dotjs/items.js","../node_modules/ajv/lib/dotjs/multipleOf.js","../node_modules/ajv/lib/dotjs/not.js","../node_modules/ajv/lib/dotjs/oneOf.js","../node_modules/ajv/lib/dotjs/pattern.js","../node_modules/ajv/lib/dotjs/properties.js","../node_modules/ajv/lib/dotjs/propertyNames.js","../node_modules/ajv/lib/dotjs/required.js","../node_modules/ajv/lib/dotjs/uniqueItems.js","../node_modules/ajv/lib/data.js","../node_modules/ajv/lib/compile/async.js","../node_modules/ajv/lib/keyword.js","../node_modules/ajv/lib/dotjs/custom.js","../node_modules/ajv/lib/definition_schema.js"],"names":["compileSchema","require","resolve","Cache","SchemaObject","stableStringify","formats","rules","$dataMetaSchema","util","module","exports","Ajv","prototype","validate","schemaKeyRef","data","v","this","getSchema","Error","schemaObj","_addSchema","_compile","valid","$async","errors","compile","schema","_meta","undefined","addSchema","key","_skipValidation","Array","isArray","i","length","id","_getId","checkUnique","normalizeId","_schemas","addMetaSchema","skipValidation","validateSchema","throwOrLogError","$schema","_opts","defaultMeta","self","meta","META_SCHEMA_ID","logger","warn","message","errorsText","error","keyRef","_getSchemaObj","ref","res","call","root","baseId","_fragments","fragment","_getSchemaFragment","removeSchema","RegExp","_removeAllSchemas","_refs","_cache","clear","del","cacheKey","serialize","addFormat","name","format","_formats","options","separator","dataVar","text","e","dataPath","slice","shouldAddSchema","cached","get","addUsedSchema","recursiveMeta","willValidate","localRefs","ids","put","compiling","callValidate","currentOpts","_metaOpts","refs","refVal","_validate","result","apply","arguments","compileAsync","customKeyword","addKeyword","add","getKeyword","removeKeyword","remove","validateKeyword","errorClasses","ValidationError","Validation","MissingRefError","MissingRef","META_IGNORE_OPTIONS","META_SUPPORT_DATA","opts","copy","log","noop","console","setLogger","cache","_loadingSchemas","_compilations","RULES","schemaId","_get$IdOrId","_get$Id","chooseGetId","loopRequired","Infinity","errorDataPath","_errorDataPathProperty","metaOpts","getMetaSchemaOptions","addInitialFormats","keywords","keyword","addInitialKeywords","$dataSchema","$data","$id","metaSchema","addDefaultMetaSchema","nullable","type","optsSchemas","schemas","addInitialSchemas","regex","test","checkDataType","dataType","strictNumbers","negate","EQUAL","AND","OK","NOT","o","to","checkDataTypes","dataTypes","code","types","toHash","t","array","object","null","number","integer","coerceToTypes","optionCoerceTypes","COERCE_TO_TYPES","getProperty","escapeQuotes","equal","ucs2length","varOccurences","str","matches","match","varReplace","expr","replace","schemaHasRules","schemaHasRulesExcept","exceptKeyword","schemaUnknownRules","toQuotedString","getPathExpr","currentPath","jsonPointers","isNumber","joinPaths","getPath","prop","path","escapeJsonPointer","getData","lvl","paths","up","jsonPointer","JSON_POINTER","RELATIVE_JSON_POINTER","segments","split","segment","unescapeJsonPointer","unescapeFragment","decodeURIComponent","escapeFragment","encodeURIComponent","arr","hash","IDENTIFIER","SINGLE_QUOTE","a","b","URI","traverse","inlineRef","inlineRefs","resolveSchema","p","parse","refPath","_getFullPath","getFullPath","Object","keys","resolveRecursive","getJsonPointer","parsedRef","resolveUrl","fullPath","url","baseIds","fullPaths","allKeys","sch","jsonPtr","rootSchema","parentJsonPtr","parentKeyword","parentSchema","keyIndex","PREVENT_SCOPE_CHANGE","parts","part","$ref","SIMPLE_INLINED","limit","checkNoRef","countKeys","item","count","normalize","TRAILING_SLASH_HASH","constructor","source","flags","valueOf","toString","hasOwnProperty","missingRef","missingSchema","errorSubclass","Subclass","create","ajv","validation","obj","cmp","f","cycles","node","aobj","value","bobj","seen","stringify","toJSON","isFinite","JSON","out","indexOf","TypeError","seenIndex","push","sort","splice","it","$keyword","$ruleType","$refKeywords","all","strictKeywords","$unknownKwd","$keywordsMsg","isTop","async","sourceCode","processCode","$lvl","level","$dataLvl","dataLevel","$schemaPath","schemaPath","$errSchemaPath","errSchemaPath","$breakOnError","allErrors","$valid","$$outStack","createErrors","errorPath","messages","verbose","__err","pop","compositeRule","$top","rootId","dataPathArr","default","useDefaults","strictDefaults","$defaultMsg","$closingBraces1","$closingBraces2","$typeSchema","$typeIsArray","concat","extendRefs","$comment","coerceTypes","$coerceToTypes","$rulesGroup","$shouldUseGroup","$method","$dataType","$coerced","arr1","$type","$i","l1","join","$parentData","arr2","i2","l2","properties","arr3","$propertyKey","i3","l3","$sch","$passData","useDefault","items","arr4","l4","arr5","$rule","i5","l5","$shouldUseRule","$code","implements","impl","$ruleImplementsSomeKeyword","$schemaValue","$isData","$isMax","$exclusiveKeyword","$schemaExcl","$isDataExcl","$op","$notOp","$errorKeyword","$schemaValueExcl","$exclusive","$exclType","$exclIsNumber","$opStr","$opExpr","Math","unicode","validateGenerator","checkCompiling","index","compIndex","endCompiling","c","patternCode","patterns","defaultCode","refValCode","customRuleCode","vars","statement","patternsHash","defaults","defaultsHash","customRules","compilation","localCompile","cv","_schema","_root","isRoot","resolveRef","usePattern","useCustomRule","Function","makeValidate","_refVal","refCode","refIndex","resolvedRef","rootRefId","addLocalRef","localSchema","refId","replaceLocalRef","removeLocalRef","inline","regexStr","valueStr","rule","deps","definition","dependencies","every","macro","sets","xl","x","ALPHA$$","DIGIT$$","HEXDIG$$","merge","PCT_ENCODED$","subexp","SUB_DELIMS$$","RESERVED$$","isIRI","SCHEME$","USERINFO$","DEC_OCTET_RELAXED$","H16$","LS32$","IPV6ADDRESS1$","IPV6ADDRESS2$","IPV6ADDRESS3$","IPV6ADDRESS4$","IPV6ADDRESS5$","IPV6ADDRESS6$","IPV6ADDRESS7$","IPV6ADDRESS8$","IPV6ADDRESS9$","ZONEID$","UNRESERVED$$","IPV6ADDRESS$","IP_LITERAL$","IPV6ADDRZ_RELAXED$","HOST$","PORT$","AUTHORITY$","PCHAR$","SEGMENT$","SEGMENT_NZ$","SEGMENT_NZ_NC$","PATH_ABEMPTY$","PATH_ABSOLUTE$","QUERY$","FRAGMENT$","HIER_PART$","URI$","RELATIVE_PART$","RELATIVE$","IPV4ADDRESS$","buildExps","maxInt","base","tMin","tMax","skew","damp","initialBias","initialN","delimiter","regexPunycode","regexNonASCII","regexSeparators","baseMinusTMin","floor","stringFromCharCode","String","RangeError","map","fn","mapDomain","string","ucs2decode","output","counter","extra","basicToDigit","codePoint","digitToBasic","digit","flag","adapt","k","firstTime","delta","decode","inputLength","input","n","bias","basic","j","oldi","w","baseMinusT","encode","currentValue","basicLength","handledCPCount","m","handledCPCountPlusOne","q","qMinusT","toUnicode","toASCII","punycode","SCHEMES","chr","newStr","il","parseInt","c2","c3","_normalizeComponentEncoding","components","decodeUnreserved","decStr","pctDecChars","protocol","_stripLeadingZeros","_normalizeIPv4","host","address","_normalizeIPv6","zone","last","first","firstFields","lastFields","isLastFieldIPv4Address","fieldCount","lastFieldsStart","fields","longestZeroFields","reduce","field","lastLongest","acc","newHost","newFirst","newLast","URI_PARSE","NO_MATCH_IS_UNDEFINED","uriString","isNaN","schemeHandler","_recomposeAuthority","uriTokens","$1","$2","RDS1","RDS2","RDS3","RDS5","im","s","authority","removeDotSegments","target","relative","schemelessOptions","assign","scheme","resolveComponents","uri","typeOf","uriA","uriB","IRI_PROTOCOL","URI_PROTOCOL","handler","secure","http","isSecure","wsComponents","query","ws","O","ATEXT$$","VCHAR$$","SOME_DELIMS$$","UNRESERVED","PCT_ENCODED","NOT_LOCAL_PART","NOT_HFNAME","NOT_HFVALUE","mailtoComponents","unknownHeaders","headers","hfields","hfield","toAddrs","unescapeComponent","addr","toArray","toAddr","atIdx","localPart","domain","URN_PARSE","urnComponents","nid","nss","urnScheme","uriComponents","UUID","uuidComponents","uuid","https","wss","mailto","urn","len","pos","charCodeAt","cb","_traverse","pre","post","arrayKeywords","propsKeywords","skipKeywords","additionalItems","contains","additionalProperties","propertyNames","not","allOf","anyOf","oneOf","definitions","patternProperties","enum","const","required","maximum","minimum","exclusiveMaximum","exclusiveMinimum","multipleOf","maxLength","minLength","pattern","maxItems","minItems","uniqueItems","maxProperties","minProperties","DATE","DAYS","TIME","HOSTNAME","URITEMPLATE","URL","JSON_POINTER_URI_FRAGMENT","mode","date","year","month","day","isLeapYear","time","full","hour","minute","second","timeZone","fast","email","hostname","ipv4","ipv6","dateTime","DATE_TIME_SEPARATOR","NOT_URI_FRAGMENT","Z_ANCHOR","ruleModules","ALL","forEach","group","implKeywords","custom","$refCode","$refVal","$message","missingRefs","$it","$nextValid","passContext","__callValidate","$closingBraces","$currentBaseId","$allSchemasEmpty","$errs","$noEmptySchema","$wasComposite","$idx","$dataNxt","$nextData","$nonEmptySchema","$schemaDeps","$propertyDeps","$ownProperties","ownProperties","$property","$deps","$currentErrorPath","$useData","$prop","$propertyPath","$missingProperty","$vSchema","$unknownFormats","unknownFormats","$allowUnknown","$format","$isObject","$formatType","$formatRef","$thenSch","$elseSch","$thenPresent","$elsePresent","$ifClause","$additionalItems","$currErrSchemaPath","multipleOfPrecision","$allErrorsOption","$prevValid","$passingSchemas","$key","$dataProperties","$schemaKeys","filter","notProto","$pProperties","$pPropertyKeys","$aProperties","$someProperties","$noAdditional","$additionalIsSchema","$removeAdditional","removeAdditional","$checkAdditional","$required","$requiredHash","i1","$pProperty","$additionalProperty","$useDefaults","$hasDefault","i4","$invalidName","$propertySch","$loopRequired","$itemType","KEYWORDS","keywordsJsonPointers","callback","loadSchema","loadMetaSchemaOf","then","_compileAsync","Promise","added","schemaPromise","removePromise","loadMissingSchema","definitionSchema","_addRule","ruleGroup","rg","throwError","_validateKeyword","$compile","$inline","$macro","$ruleValidate","$validateCode","$definition","$rDef","$validateSchema","$ruleErrs","$ruleErr","$asyncKeyword","statements","$parentDataProperty","def_callRuleValidate","modifying","def_customError","simpleTypes"],"mappings":"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","file":"static/js/1.9fafe191.chunk.js","sourcesContent":["'use strict';\n\nvar compileSchema = require('./compile')\n  , resolve = require('./compile/resolve')\n  , Cache = require('./cache')\n  , SchemaObject = require('./compile/schema_obj')\n  , stableStringify = require('fast-json-stable-stringify')\n  , formats = require('./compile/formats')\n  , rules = require('./compile/rules')\n  , $dataMetaSchema = require('./data')\n  , util = require('./compile/util');\n\nmodule.exports = Ajv;\n\nAjv.prototype.validate = validate;\nAjv.prototype.compile = compile;\nAjv.prototype.addSchema = addSchema;\nAjv.prototype.addMetaSchema = addMetaSchema;\nAjv.prototype.validateSchema = validateSchema;\nAjv.prototype.getSchema = getSchema;\nAjv.prototype.removeSchema = removeSchema;\nAjv.prototype.addFormat = addFormat;\nAjv.prototype.errorsText = errorsText;\n\nAjv.prototype._addSchema = _addSchema;\nAjv.prototype._compile = _compile;\n\nAjv.prototype.compileAsync = require('./compile/async');\nvar customKeyword = require('./keyword');\nAjv.prototype.addKeyword = customKeyword.add;\nAjv.prototype.getKeyword = customKeyword.get;\nAjv.prototype.removeKeyword = customKeyword.remove;\nAjv.prototype.validateKeyword = customKeyword.validate;\n\nvar errorClasses = require('./compile/error_classes');\nAjv.ValidationError = errorClasses.Validation;\nAjv.MissingRefError = errorClasses.MissingRef;\nAjv.$dataMetaSchema = $dataMetaSchema;\n\nvar META_SCHEMA_ID = 'http://json-schema.org/draft-07/schema';\n\nvar META_IGNORE_OPTIONS = [ 'removeAdditional', 'useDefaults', 'coerceTypes', 'strictDefaults' ];\nvar META_SUPPORT_DATA = ['/properties'];\n\n/**\n * Creates validator instance.\n * Usage: `Ajv(opts)`\n * @param {Object} opts optional options\n * @return {Object} ajv instance\n */\nfunction Ajv(opts) {\n  if (!(this instanceof Ajv)) return new Ajv(opts);\n  opts = this._opts = util.copy(opts) || {};\n  setLogger(this);\n  this._schemas = {};\n  this._refs = {};\n  this._fragments = {};\n  this._formats = formats(opts.format);\n\n  this._cache = opts.cache || new Cache;\n  this._loadingSchemas = {};\n  this._compilations = [];\n  this.RULES = rules();\n  this._getId = chooseGetId(opts);\n\n  opts.loopRequired = opts.loopRequired || Infinity;\n  if (opts.errorDataPath == 'property') opts._errorDataPathProperty = true;\n  if (opts.serialize === undefined) opts.serialize = stableStringify;\n  this._metaOpts = getMetaSchemaOptions(this);\n\n  if (opts.formats) addInitialFormats(this);\n  if (opts.keywords) addInitialKeywords(this);\n  addDefaultMetaSchema(this);\n  if (typeof opts.meta == 'object') this.addMetaSchema(opts.meta);\n  if (opts.nullable) this.addKeyword('nullable', {metaSchema: {type: 'boolean'}});\n  addInitialSchemas(this);\n}\n\n\n\n/**\n * Validate data using schema\n * 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.\n * @this   Ajv\n * @param  {String|Object} schemaKeyRef key, ref or schema object\n * @param  {Any} data to be validated\n * @return {Boolean} validation result. Errors from the last validation will be available in `ajv.errors` (and also in compiled schema: `schema.errors`).\n */\nfunction validate(schemaKeyRef, data) {\n  var v;\n  if (typeof schemaKeyRef == 'string') {\n    v = this.getSchema(schemaKeyRef);\n    if (!v) throw new Error('no schema with key or ref \"' + schemaKeyRef + '\"');\n  } else {\n    var schemaObj = this._addSchema(schemaKeyRef);\n    v = schemaObj.validate || this._compile(schemaObj);\n  }\n\n  var valid = v(data);\n  if (v.$async !== true) this.errors = v.errors;\n  return valid;\n}\n\n\n/**\n * Create validating function for passed schema.\n * @this   Ajv\n * @param  {Object} schema schema object\n * @param  {Boolean} _meta true if schema is a meta-schema. Used internally to compile meta schemas of custom keywords.\n * @return {Function} validating function\n */\nfunction compile(schema, _meta) {\n  var schemaObj = this._addSchema(schema, undefined, _meta);\n  return schemaObj.validate || this._compile(schemaObj);\n}\n\n\n/**\n * Adds schema to the instance.\n * @this   Ajv\n * @param {Object|Array} schema schema or array of schemas. If array is passed, `key` and other parameters will be ignored.\n * @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`.\n * @param {Boolean} _skipValidation true to skip schema validation. Used internally, option validateSchema should be used instead.\n * @param {Boolean} _meta true if schema is a meta-schema. Used internally, addMetaSchema should be used instead.\n * @return {Ajv} this for method chaining\n */\nfunction addSchema(schema, key, _skipValidation, _meta) {\n  if (Array.isArray(schema)){\n    for (var i=0; i<schema.length; i++) this.addSchema(schema[i], undefined, _skipValidation, _meta);\n    return this;\n  }\n  var id = this._getId(schema);\n  if (id !== undefined && typeof id != 'string')\n    throw new Error('schema id must be string');\n  key = resolve.normalizeId(key || id);\n  checkUnique(this, key);\n  this._schemas[key] = this._addSchema(schema, _skipValidation, _meta, true);\n  return this;\n}\n\n\n/**\n * Add schema that will be used to validate other schemas\n * options in META_IGNORE_OPTIONS are alway set to false\n * @this   Ajv\n * @param {Object} schema schema object\n * @param {String} key optional schema key\n * @param {Boolean} skipValidation true to skip schema validation, can be used to override validateSchema option for meta-schema\n * @return {Ajv} this for method chaining\n */\nfunction addMetaSchema(schema, key, skipValidation) {\n  this.addSchema(schema, key, skipValidation, true);\n  return this;\n}\n\n\n/**\n * Validate schema\n * @this   Ajv\n * @param {Object} schema schema to validate\n * @param {Boolean} throwOrLogError pass true to throw (or log) an error if invalid\n * @return {Boolean} true if schema is valid\n */\nfunction validateSchema(schema, throwOrLogError) {\n  var $schema = schema.$schema;\n  if ($schema !== undefined && typeof $schema != 'string')\n    throw new Error('$schema must be a string');\n  $schema = $schema || this._opts.defaultMeta || defaultMeta(this);\n  if (!$schema) {\n    this.logger.warn('meta-schema not available');\n    this.errors = null;\n    return true;\n  }\n  var valid = this.validate($schema, schema);\n  if (!valid && throwOrLogError) {\n    var message = 'schema is invalid: ' + this.errorsText();\n    if (this._opts.validateSchema == 'log') this.logger.error(message);\n    else throw new Error(message);\n  }\n  return valid;\n}\n\n\nfunction defaultMeta(self) {\n  var meta = self._opts.meta;\n  self._opts.defaultMeta = typeof meta == 'object'\n                            ? self._getId(meta) || meta\n                            : self.getSchema(META_SCHEMA_ID)\n                              ? META_SCHEMA_ID\n                              : undefined;\n  return self._opts.defaultMeta;\n}\n\n\n/**\n * Get compiled schema from the instance by `key` or `ref`.\n * @this   Ajv\n * @param  {String} keyRef `key` that was passed to `addSchema` or full schema reference (`schema.id` or resolved id).\n * @return {Function} schema validating function (with property `schema`).\n */\nfunction getSchema(keyRef) {\n  var schemaObj = _getSchemaObj(this, keyRef);\n  switch (typeof schemaObj) {\n    case 'object': return schemaObj.validate || this._compile(schemaObj);\n    case 'string': return this.getSchema(schemaObj);\n    case 'undefined': return _getSchemaFragment(this, keyRef);\n  }\n}\n\n\nfunction _getSchemaFragment(self, ref) {\n  var res = resolve.schema.call(self, { schema: {} }, ref);\n  if (res) {\n    var schema = res.schema\n      , root = res.root\n      , baseId = res.baseId;\n    var v = compileSchema.call(self, schema, root, undefined, baseId);\n    self._fragments[ref] = new SchemaObject({\n      ref: ref,\n      fragment: true,\n      schema: schema,\n      root: root,\n      baseId: baseId,\n      validate: v\n    });\n    return v;\n  }\n}\n\n\nfunction _getSchemaObj(self, keyRef) {\n  keyRef = resolve.normalizeId(keyRef);\n  return self._schemas[keyRef] || self._refs[keyRef] || self._fragments[keyRef];\n}\n\n\n/**\n * Remove cached schema(s).\n * If no parameter is passed all schemas but meta-schemas are removed.\n * If RegExp is passed all schemas with key/id matching pattern but meta-schemas are removed.\n * Even if schema is referenced by other schemas it still can be removed as other schemas have local references.\n * @this   Ajv\n * @param  {String|Object|RegExp} schemaKeyRef key, ref, pattern to match key/ref or schema object\n * @return {Ajv} this for method chaining\n */\nfunction removeSchema(schemaKeyRef) {\n  if (schemaKeyRef instanceof RegExp) {\n    _removeAllSchemas(this, this._schemas, schemaKeyRef);\n    _removeAllSchemas(this, this._refs, schemaKeyRef);\n    return this;\n  }\n  switch (typeof schemaKeyRef) {\n    case 'undefined':\n      _removeAllSchemas(this, this._schemas);\n      _removeAllSchemas(this, this._refs);\n      this._cache.clear();\n      return this;\n    case 'string':\n      var schemaObj = _getSchemaObj(this, schemaKeyRef);\n      if (schemaObj) this._cache.del(schemaObj.cacheKey);\n      delete this._schemas[schemaKeyRef];\n      delete this._refs[schemaKeyRef];\n      return this;\n    case 'object':\n      var serialize = this._opts.serialize;\n      var cacheKey = serialize ? serialize(schemaKeyRef) : schemaKeyRef;\n      this._cache.del(cacheKey);\n      var id = this._getId(schemaKeyRef);\n      if (id) {\n        id = resolve.normalizeId(id);\n        delete this._schemas[id];\n        delete this._refs[id];\n      }\n  }\n  return this;\n}\n\n\nfunction _removeAllSchemas(self, schemas, regex) {\n  for (var keyRef in schemas) {\n    var schemaObj = schemas[keyRef];\n    if (!schemaObj.meta && (!regex || regex.test(keyRef))) {\n      self._cache.del(schemaObj.cacheKey);\n      delete schemas[keyRef];\n    }\n  }\n}\n\n\n/* @this   Ajv */\nfunction _addSchema(schema, skipValidation, meta, shouldAddSchema) {\n  if (typeof schema != 'object' && typeof schema != 'boolean')\n    throw new Error('schema should be object or boolean');\n  var serialize = this._opts.serialize;\n  var cacheKey = serialize ? serialize(schema) : schema;\n  var cached = this._cache.get(cacheKey);\n  if (cached) return cached;\n\n  shouldAddSchema = shouldAddSchema || this._opts.addUsedSchema !== false;\n\n  var id = resolve.normalizeId(this._getId(schema));\n  if (id && shouldAddSchema) checkUnique(this, id);\n\n  var willValidate = this._opts.validateSchema !== false && !skipValidation;\n  var recursiveMeta;\n  if (willValidate && !(recursiveMeta = id && id == resolve.normalizeId(schema.$schema)))\n    this.validateSchema(schema, true);\n\n  var localRefs = resolve.ids.call(this, schema);\n\n  var schemaObj = new SchemaObject({\n    id: id,\n    schema: schema,\n    localRefs: localRefs,\n    cacheKey: cacheKey,\n    meta: meta\n  });\n\n  if (id[0] != '#' && shouldAddSchema) this._refs[id] = schemaObj;\n  this._cache.put(cacheKey, schemaObj);\n\n  if (willValidate && recursiveMeta) this.validateSchema(schema, true);\n\n  return schemaObj;\n}\n\n\n/* @this   Ajv */\nfunction _compile(schemaObj, root) {\n  if (schemaObj.compiling) {\n    schemaObj.validate = callValidate;\n    callValidate.schema = schemaObj.schema;\n    callValidate.errors = null;\n    callValidate.root = root ? root : callValidate;\n    if (schemaObj.schema.$async === true)\n      callValidate.$async = true;\n    return callValidate;\n  }\n  schemaObj.compiling = true;\n\n  var currentOpts;\n  if (schemaObj.meta) {\n    currentOpts = this._opts;\n    this._opts = this._metaOpts;\n  }\n\n  var v;\n  try { v = compileSchema.call(this, schemaObj.schema, root, schemaObj.localRefs); }\n  catch(e) {\n    delete schemaObj.validate;\n    throw e;\n  }\n  finally {\n    schemaObj.compiling = false;\n    if (schemaObj.meta) this._opts = currentOpts;\n  }\n\n  schemaObj.validate = v;\n  schemaObj.refs = v.refs;\n  schemaObj.refVal = v.refVal;\n  schemaObj.root = v.root;\n  return v;\n\n\n  /* @this   {*} - custom context, see passContext option */\n  function callValidate() {\n    /* jshint validthis: true */\n    var _validate = schemaObj.validate;\n    var result = _validate.apply(this, arguments);\n    callValidate.errors = _validate.errors;\n    return result;\n  }\n}\n\n\nfunction chooseGetId(opts) {\n  switch (opts.schemaId) {\n    case 'auto': return _get$IdOrId;\n    case 'id': return _getId;\n    default: return _get$Id;\n  }\n}\n\n/* @this   Ajv */\nfunction _getId(schema) {\n  if (schema.$id) this.logger.warn('schema $id ignored', schema.$id);\n  return schema.id;\n}\n\n/* @this   Ajv */\nfunction _get$Id(schema) {\n  if (schema.id) this.logger.warn('schema id ignored', schema.id);\n  return schema.$id;\n}\n\n\nfunction _get$IdOrId(schema) {\n  if (schema.$id && schema.id && schema.$id != schema.id)\n    throw new Error('schema $id is different from id');\n  return schema.$id || schema.id;\n}\n\n\n/**\n * Convert array of error message objects to string\n * @this   Ajv\n * @param  {Array<Object>} errors optional array of validation errors, if not passed errors from the instance are used.\n * @param  {Object} options optional options with properties `separator` and `dataVar`.\n * @return {String} human readable string with all errors descriptions\n */\nfunction errorsText(errors, options) {\n  errors = errors || this.errors;\n  if (!errors) return 'No errors';\n  options = options || {};\n  var separator = options.separator === undefined ? ', ' : options.separator;\n  var dataVar = options.dataVar === undefined ? 'data' : options.dataVar;\n\n  var text = '';\n  for (var i=0; i<errors.length; i++) {\n    var e = errors[i];\n    if (e) text += dataVar + e.dataPath + ' ' + e.message + separator;\n  }\n  return text.slice(0, -separator.length);\n}\n\n\n/**\n * Add custom format\n * @this   Ajv\n * @param {String} name format name\n * @param {String|RegExp|Function} format string is converted to RegExp; function should return boolean (true when valid)\n * @return {Ajv} this for method chaining\n */\nfunction addFormat(name, format) {\n  if (typeof format == 'string') format = new RegExp(format);\n  this._formats[name] = format;\n  return this;\n}\n\n\nfunction addDefaultMetaSchema(self) {\n  var $dataSchema;\n  if (self._opts.$data) {\n    $dataSchema = require('./refs/data.json');\n    self.addMetaSchema($dataSchema, $dataSchema.$id, true);\n  }\n  if (self._opts.meta === false) return;\n  var metaSchema = require('./refs/json-schema-draft-07.json');\n  if (self._opts.$data) metaSchema = $dataMetaSchema(metaSchema, META_SUPPORT_DATA);\n  self.addMetaSchema(metaSchema, META_SCHEMA_ID, true);\n  self._refs['http://json-schema.org/schema'] = META_SCHEMA_ID;\n}\n\n\nfunction addInitialSchemas(self) {\n  var optsSchemas = self._opts.schemas;\n  if (!optsSchemas) return;\n  if (Array.isArray(optsSchemas)) self.addSchema(optsSchemas);\n  else for (var key in optsSchemas) self.addSchema(optsSchemas[key], key);\n}\n\n\nfunction addInitialFormats(self) {\n  for (var name in self._opts.formats) {\n    var format = self._opts.formats[name];\n    self.addFormat(name, format);\n  }\n}\n\n\nfunction addInitialKeywords(self) {\n  for (var name in self._opts.keywords) {\n    var keyword = self._opts.keywords[name];\n    self.addKeyword(name, keyword);\n  }\n}\n\n\nfunction checkUnique(self, id) {\n  if (self._schemas[id] || self._refs[id])\n    throw new Error('schema with key or id \"' + id + '\" already exists');\n}\n\n\nfunction getMetaSchemaOptions(self) {\n  var metaOpts = util.copy(self._opts);\n  for (var i=0; i<META_IGNORE_OPTIONS.length; i++)\n    delete metaOpts[META_IGNORE_OPTIONS[i]];\n  return metaOpts;\n}\n\n\nfunction setLogger(self) {\n  var logger = self._opts.logger;\n  if (logger === false) {\n    self.logger = {log: noop, warn: noop, error: noop};\n  } else {\n    if (logger === undefined) logger = console;\n    if (!(typeof logger == 'object' && logger.log && logger.warn && logger.error))\n      throw new Error('logger must implement log, warn and error methods');\n    self.logger = logger;\n  }\n}\n\n\nfunction noop() {}\n","'use strict';\n\n\nmodule.exports = {\n  copy: copy,\n  checkDataType: checkDataType,\n  checkDataTypes: checkDataTypes,\n  coerceToTypes: coerceToTypes,\n  toHash: toHash,\n  getProperty: getProperty,\n  escapeQuotes: escapeQuotes,\n  equal: require('fast-deep-equal'),\n  ucs2length: require('./ucs2length'),\n  varOccurences: varOccurences,\n  varReplace: varReplace,\n  schemaHasRules: schemaHasRules,\n  schemaHasRulesExcept: schemaHasRulesExcept,\n  schemaUnknownRules: schemaUnknownRules,\n  toQuotedString: toQuotedString,\n  getPathExpr: getPathExpr,\n  getPath: getPath,\n  getData: getData,\n  unescapeFragment: unescapeFragment,\n  unescapeJsonPointer: unescapeJsonPointer,\n  escapeFragment: escapeFragment,\n  escapeJsonPointer: escapeJsonPointer\n};\n\n\nfunction copy(o, to) {\n  to = to || {};\n  for (var key in o) to[key] = o[key];\n  return to;\n}\n\n\nfunction checkDataType(dataType, data, strictNumbers, negate) {\n  var EQUAL = negate ? ' !== ' : ' === '\n    , AND = negate ? ' || ' : ' && '\n    , OK = negate ? '!' : ''\n    , NOT = negate ? '' : '!';\n  switch (dataType) {\n    case 'null': return data + EQUAL + 'null';\n    case 'array': return OK + 'Array.isArray(' + data + ')';\n    case 'object': return '(' + OK + data + AND +\n                          'typeof ' + data + EQUAL + '\"object\"' + AND +\n                          NOT + 'Array.isArray(' + data + '))';\n    case 'integer': return '(typeof ' + data + EQUAL + '\"number\"' + AND +\n                           NOT + '(' + data + ' % 1)' +\n                           AND + data + EQUAL + data +\n                           (strictNumbers ? (AND + OK + 'isFinite(' + data + ')') : '') + ')';\n    case 'number': return '(typeof ' + data + EQUAL + '\"' + dataType + '\"' +\n                          (strictNumbers ? (AND + OK + 'isFinite(' + data + ')') : '') + ')';\n    default: return 'typeof ' + data + EQUAL + '\"' + dataType + '\"';\n  }\n}\n\n\nfunction checkDataTypes(dataTypes, data, strictNumbers) {\n  switch (dataTypes.length) {\n    case 1: return checkDataType(dataTypes[0], data, strictNumbers, true);\n    default:\n      var code = '';\n      var types = toHash(dataTypes);\n      if (types.array && types.object) {\n        code = types.null ? '(': '(!' + data + ' || ';\n        code += 'typeof ' + data + ' !== \"object\")';\n        delete types.null;\n        delete types.array;\n        delete types.object;\n      }\n      if (types.number) delete types.integer;\n      for (var t in types)\n        code += (code ? ' && ' : '' ) + checkDataType(t, data, strictNumbers, true);\n\n      return code;\n  }\n}\n\n\nvar COERCE_TO_TYPES = toHash([ 'string', 'number', 'integer', 'boolean', 'null' ]);\nfunction coerceToTypes(optionCoerceTypes, dataTypes) {\n  if (Array.isArray(dataTypes)) {\n    var types = [];\n    for (var i=0; i<dataTypes.length; i++) {\n      var t = dataTypes[i];\n      if (COERCE_TO_TYPES[t]) types[types.length] = t;\n      else if (optionCoerceTypes === 'array' && t === 'array') types[types.length] = t;\n    }\n    if (types.length) return types;\n  } else if (COERCE_TO_TYPES[dataTypes]) {\n    return [dataTypes];\n  } else if (optionCoerceTypes === 'array' && dataTypes === 'array') {\n    return ['array'];\n  }\n}\n\n\nfunction toHash(arr) {\n  var hash = {};\n  for (var i=0; i<arr.length; i++) hash[arr[i]] = true;\n  return hash;\n}\n\n\nvar IDENTIFIER = /^[a-z$_][a-z$_0-9]*$/i;\nvar SINGLE_QUOTE = /'|\\\\/g;\nfunction getProperty(key) {\n  return typeof key == 'number'\n          ? '[' + key + ']'\n          : IDENTIFIER.test(key)\n            ? '.' + key\n            : \"['\" + escapeQuotes(key) + \"']\";\n}\n\n\nfunction escapeQuotes(str) {\n  return str.replace(SINGLE_QUOTE, '\\\\$&')\n            .replace(/\\n/g, '\\\\n')\n            .replace(/\\r/g, '\\\\r')\n            .replace(/\\f/g, '\\\\f')\n            .replace(/\\t/g, '\\\\t');\n}\n\n\nfunction varOccurences(str, dataVar) {\n  dataVar += '[^0-9]';\n  var matches = str.match(new RegExp(dataVar, 'g'));\n  return matches ? matches.length : 0;\n}\n\n\nfunction varReplace(str, dataVar, expr) {\n  dataVar += '([^0-9])';\n  expr = expr.replace(/\\$/g, '$$$$');\n  return str.replace(new RegExp(dataVar, 'g'), expr + '$1');\n}\n\n\nfunction schemaHasRules(schema, rules) {\n  if (typeof schema == 'boolean') return !schema;\n  for (var key in schema) if (rules[key]) return true;\n}\n\n\nfunction schemaHasRulesExcept(schema, rules, exceptKeyword) {\n  if (typeof schema == 'boolean') return !schema && exceptKeyword != 'not';\n  for (var key in schema) if (key != exceptKeyword && rules[key]) return true;\n}\n\n\nfunction schemaUnknownRules(schema, rules) {\n  if (typeof schema == 'boolean') return;\n  for (var key in schema) if (!rules[key]) return key;\n}\n\n\nfunction toQuotedString(str) {\n  return '\\'' + escapeQuotes(str) + '\\'';\n}\n\n\nfunction getPathExpr(currentPath, expr, jsonPointers, isNumber) {\n  var path = jsonPointers // false by default\n              ? '\\'/\\' + ' + expr + (isNumber ? '' : '.replace(/~/g, \\'~0\\').replace(/\\\\//g, \\'~1\\')')\n              : (isNumber ? '\\'[\\' + ' + expr + ' + \\']\\'' : '\\'[\\\\\\'\\' + ' + expr + ' + \\'\\\\\\']\\'');\n  return joinPaths(currentPath, path);\n}\n\n\nfunction getPath(currentPath, prop, jsonPointers) {\n  var path = jsonPointers // false by default\n              ? toQuotedString('/' + escapeJsonPointer(prop))\n              : toQuotedString(getProperty(prop));\n  return joinPaths(currentPath, path);\n}\n\n\nvar JSON_POINTER = /^\\/(?:[^~]|~0|~1)*$/;\nvar RELATIVE_JSON_POINTER = /^([0-9]+)(#|\\/(?:[^~]|~0|~1)*)?$/;\nfunction getData($data, lvl, paths) {\n  var up, jsonPointer, data, matches;\n  if ($data === '') return 'rootData';\n  if ($data[0] == '/') {\n    if (!JSON_POINTER.test($data)) throw new Error('Invalid JSON-pointer: ' + $data);\n    jsonPointer = $data;\n    data = 'rootData';\n  } else {\n    matches = $data.match(RELATIVE_JSON_POINTER);\n    if (!matches) throw new Error('Invalid JSON-pointer: ' + $data);\n    up = +matches[1];\n    jsonPointer = matches[2];\n    if (jsonPointer == '#') {\n      if (up >= lvl) throw new Error('Cannot access property/index ' + up + ' levels up, current level is ' + lvl);\n      return paths[lvl - up];\n    }\n\n    if (up > lvl) throw new Error('Cannot access data ' + up + ' levels up, current level is ' + lvl);\n    data = 'data' + ((lvl - up) || '');\n    if (!jsonPointer) return data;\n  }\n\n  var expr = data;\n  var segments = jsonPointer.split('/');\n  for (var i=0; i<segments.length; i++) {\n    var segment = segments[i];\n    if (segment) {\n      data += getProperty(unescapeJsonPointer(segment));\n      expr += ' && ' + data;\n    }\n  }\n  return expr;\n}\n\n\nfunction joinPaths (a, b) {\n  if (a == '\"\"') return b;\n  return (a + ' + ' + b).replace(/([^\\\\])' \\+ '/g, '$1');\n}\n\n\nfunction unescapeFragment(str) {\n  return unescapeJsonPointer(decodeURIComponent(str));\n}\n\n\nfunction escapeFragment(str) {\n  return encodeURIComponent(escapeJsonPointer(str));\n}\n\n\nfunction escapeJsonPointer(str) {\n  return str.replace(/~/g, '~0').replace(/\\//g, '~1');\n}\n\n\nfunction unescapeJsonPointer(str) {\n  return str.replace(/~1/g, '/').replace(/~0/g, '~');\n}\n","'use strict';\n\nvar URI = require('uri-js')\n  , equal = require('fast-deep-equal')\n  , util = require('./util')\n  , SchemaObject = require('./schema_obj')\n  , traverse = require('json-schema-traverse');\n\nmodule.exports = resolve;\n\nresolve.normalizeId = normalizeId;\nresolve.fullPath = getFullPath;\nresolve.url = resolveUrl;\nresolve.ids = resolveIds;\nresolve.inlineRef = inlineRef;\nresolve.schema = resolveSchema;\n\n/**\n * [resolve and compile the references ($ref)]\n * @this   Ajv\n * @param  {Function} compile reference to schema compilation funciton (localCompile)\n * @param  {Object} root object with information about the root schema for the current schema\n * @param  {String} ref reference to resolve\n * @return {Object|Function} schema object (if the schema can be inlined) or validation function\n */\nfunction resolve(compile, root, ref) {\n  /* jshint validthis: true */\n  var refVal = this._refs[ref];\n  if (typeof refVal == 'string') {\n    if (this._refs[refVal]) refVal = this._refs[refVal];\n    else return resolve.call(this, compile, root, refVal);\n  }\n\n  refVal = refVal || this._schemas[ref];\n  if (refVal instanceof SchemaObject) {\n    return inlineRef(refVal.schema, this._opts.inlineRefs)\n            ? refVal.schema\n            : refVal.validate || this._compile(refVal);\n  }\n\n  var res = resolveSchema.call(this, root, ref);\n  var schema, v, baseId;\n  if (res) {\n    schema = res.schema;\n    root = res.root;\n    baseId = res.baseId;\n  }\n\n  if (schema instanceof SchemaObject) {\n    v = schema.validate || compile.call(this, schema.schema, root, undefined, baseId);\n  } else if (schema !== undefined) {\n    v = inlineRef(schema, this._opts.inlineRefs)\n        ? schema\n        : compile.call(this, schema, root, undefined, baseId);\n  }\n\n  return v;\n}\n\n\n/**\n * Resolve schema, its root and baseId\n * @this Ajv\n * @param  {Object} root root object with properties schema, refVal, refs\n * @param  {String} ref  reference to resolve\n * @return {Object} object with properties schema, root, baseId\n */\nfunction resolveSchema(root, ref) {\n  /* jshint validthis: true */\n  var p = URI.parse(ref)\n    , refPath = _getFullPath(p)\n    , baseId = getFullPath(this._getId(root.schema));\n  if (Object.keys(root.schema).length === 0 || refPath !== baseId) {\n    var id = normalizeId(refPath);\n    var refVal = this._refs[id];\n    if (typeof refVal == 'string') {\n      return resolveRecursive.call(this, root, refVal, p);\n    } else if (refVal instanceof SchemaObject) {\n      if (!refVal.validate) this._compile(refVal);\n      root = refVal;\n    } else {\n      refVal = this._schemas[id];\n      if (refVal instanceof SchemaObject) {\n        if (!refVal.validate) this._compile(refVal);\n        if (id == normalizeId(ref))\n          return { schema: refVal, root: root, baseId: baseId };\n        root = refVal;\n      } else {\n        return;\n      }\n    }\n    if (!root.schema) return;\n    baseId = getFullPath(this._getId(root.schema));\n  }\n  return getJsonPointer.call(this, p, baseId, root.schema, root);\n}\n\n\n/* @this Ajv */\nfunction resolveRecursive(root, ref, parsedRef) {\n  /* jshint validthis: true */\n  var res = resolveSchema.call(this, root, ref);\n  if (res) {\n    var schema = res.schema;\n    var baseId = res.baseId;\n    root = res.root;\n    var id = this._getId(schema);\n    if (id) baseId = resolveUrl(baseId, id);\n    return getJsonPointer.call(this, parsedRef, baseId, schema, root);\n  }\n}\n\n\nvar PREVENT_SCOPE_CHANGE = util.toHash(['properties', 'patternProperties', 'enum', 'dependencies', 'definitions']);\n/* @this Ajv */\nfunction getJsonPointer(parsedRef, baseId, schema, root) {\n  /* jshint validthis: true */\n  parsedRef.fragment = parsedRef.fragment || '';\n  if (parsedRef.fragment.slice(0,1) != '/') return;\n  var parts = parsedRef.fragment.split('/');\n\n  for (var i = 1; i < parts.length; i++) {\n    var part = parts[i];\n    if (part) {\n      part = util.unescapeFragment(part);\n      schema = schema[part];\n      if (schema === undefined) break;\n      var id;\n      if (!PREVENT_SCOPE_CHANGE[part]) {\n        id = this._getId(schema);\n        if (id) baseId = resolveUrl(baseId, id);\n        if (schema.$ref) {\n          var $ref = resolveUrl(baseId, schema.$ref);\n          var res = resolveSchema.call(this, root, $ref);\n          if (res) {\n            schema = res.schema;\n            root = res.root;\n            baseId = res.baseId;\n          }\n        }\n      }\n    }\n  }\n  if (schema !== undefined && schema !== root.schema)\n    return { schema: schema, root: root, baseId: baseId };\n}\n\n\nvar SIMPLE_INLINED = util.toHash([\n  'type', 'format', 'pattern',\n  'maxLength', 'minLength',\n  'maxProperties', 'minProperties',\n  'maxItems', 'minItems',\n  'maximum', 'minimum',\n  'uniqueItems', 'multipleOf',\n  'required', 'enum'\n]);\nfunction inlineRef(schema, limit) {\n  if (limit === false) return false;\n  if (limit === undefined || limit === true) return checkNoRef(schema);\n  else if (limit) return countKeys(schema) <= limit;\n}\n\n\nfunction checkNoRef(schema) {\n  var item;\n  if (Array.isArray(schema)) {\n    for (var i=0; i<schema.length; i++) {\n      item = schema[i];\n      if (typeof item == 'object' && !checkNoRef(item)) return false;\n    }\n  } else {\n    for (var key in schema) {\n      if (key == '$ref') return false;\n      item = schema[key];\n      if (typeof item == 'object' && !checkNoRef(item)) return false;\n    }\n  }\n  return true;\n}\n\n\nfunction countKeys(schema) {\n  var count = 0, item;\n  if (Array.isArray(schema)) {\n    for (var i=0; i<schema.length; i++) {\n      item = schema[i];\n      if (typeof item == 'object') count += countKeys(item);\n      if (count == Infinity) return Infinity;\n    }\n  } else {\n    for (var key in schema) {\n      if (key == '$ref') return Infinity;\n      if (SIMPLE_INLINED[key]) {\n        count++;\n      } else {\n        item = schema[key];\n        if (typeof item == 'object') count += countKeys(item) + 1;\n        if (count == Infinity) return Infinity;\n      }\n    }\n  }\n  return count;\n}\n\n\nfunction getFullPath(id, normalize) {\n  if (normalize !== false) id = normalizeId(id);\n  var p = URI.parse(id);\n  return _getFullPath(p);\n}\n\n\nfunction _getFullPath(p) {\n  return URI.serialize(p).split('#')[0] + '#';\n}\n\n\nvar TRAILING_SLASH_HASH = /#\\/?$/;\nfunction normalizeId(id) {\n  return id ? id.replace(TRAILING_SLASH_HASH, '') : '';\n}\n\n\nfunction resolveUrl(baseId, id) {\n  id = normalizeId(id);\n  return URI.resolve(baseId, id);\n}\n\n\n/* @this Ajv */\nfunction resolveIds(schema) {\n  var schemaId = normalizeId(this._getId(schema));\n  var baseIds = {'': schemaId};\n  var fullPaths = {'': getFullPath(schemaId, false)};\n  var localRefs = {};\n  var self = this;\n\n  traverse(schema, {allKeys: true}, function(sch, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) {\n    if (jsonPtr === '') return;\n    var id = self._getId(sch);\n    var baseId = baseIds[parentJsonPtr];\n    var fullPath = fullPaths[parentJsonPtr] + '/' + parentKeyword;\n    if (keyIndex !== undefined)\n      fullPath += '/' + (typeof keyIndex == 'number' ? keyIndex : util.escapeFragment(keyIndex));\n\n    if (typeof id == 'string') {\n      id = baseId = normalizeId(baseId ? URI.resolve(baseId, id) : id);\n\n      var refVal = self._refs[id];\n      if (typeof refVal == 'string') refVal = self._refs[refVal];\n      if (refVal && refVal.schema) {\n        if (!equal(sch, refVal.schema))\n          throw new Error('id \"' + id + '\" resolves to more than one schema');\n      } else if (id != normalizeId(fullPath)) {\n        if (id[0] == '#') {\n          if (localRefs[id] && !equal(sch, localRefs[id]))\n            throw new Error('id \"' + id + '\" resolves to more than one schema');\n          localRefs[id] = sch;\n        } else {\n          self._refs[id] = fullPath;\n        }\n      }\n    }\n    baseIds[jsonPtr] = baseId;\n    fullPaths[jsonPtr] = fullPath;\n  });\n\n  return localRefs;\n}\n","'use strict';\n\n// do not edit .js files directly - edit src/index.jst\n\n\n\nmodule.exports = function equal(a, b) {\n  if (a === b) return true;\n\n  if (a && b && typeof a == 'object' && typeof b == 'object') {\n    if (a.constructor !== b.constructor) return false;\n\n    var length, i, keys;\n    if (Array.isArray(a)) {\n      length = a.length;\n      if (length != b.length) return false;\n      for (i = length; i-- !== 0;)\n        if (!equal(a[i], b[i])) return false;\n      return true;\n    }\n\n\n\n    if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;\n    if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();\n    if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();\n\n    keys = Object.keys(a);\n    length = keys.length;\n    if (length !== Object.keys(b).length) return false;\n\n    for (i = length; i-- !== 0;)\n      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;\n\n    for (i = length; i-- !== 0;) {\n      var key = keys[i];\n\n      if (!equal(a[key], b[key])) return false;\n    }\n\n    return true;\n  }\n\n  // true if both NaN, false otherwise\n  return a!==a && b!==b;\n};\n","'use strict';\n\nvar resolve = require('./resolve');\n\nmodule.exports = {\n  Validation: errorSubclass(ValidationError),\n  MissingRef: errorSubclass(MissingRefError)\n};\n\n\nfunction ValidationError(errors) {\n  this.message = 'validation failed';\n  this.errors = errors;\n  this.ajv = this.validation = true;\n}\n\n\nMissingRefError.message = function (baseId, ref) {\n  return 'can\\'t resolve reference ' + ref + ' from id ' + baseId;\n};\n\n\nfunction MissingRefError(baseId, ref, message) {\n  this.message = message || MissingRefError.message(baseId, ref);\n  this.missingRef = resolve.url(baseId, ref);\n  this.missingSchema = resolve.normalizeId(resolve.fullPath(this.missingRef));\n}\n\n\nfunction errorSubclass(Subclass) {\n  Subclass.prototype = Object.create(Error.prototype);\n  Subclass.prototype.constructor = Subclass;\n  return Subclass;\n}\n","'use strict';\n\nvar util = require('./util');\n\nmodule.exports = SchemaObject;\n\nfunction SchemaObject(obj) {\n  util.copy(obj, this);\n}\n","'use strict';\n\nmodule.exports = function (data, opts) {\n    if (!opts) opts = {};\n    if (typeof opts === 'function') opts = { cmp: opts };\n    var cycles = (typeof opts.cycles === 'boolean') ? opts.cycles : false;\n\n    var cmp = opts.cmp && (function (f) {\n        return function (node) {\n            return function (a, b) {\n                var aobj = { key: a, value: node[a] };\n                var bobj = { key: b, value: node[b] };\n                return f(aobj, bobj);\n            };\n        };\n    })(opts.cmp);\n\n    var seen = [];\n    return (function stringify (node) {\n        if (node && node.toJSON && typeof node.toJSON === 'function') {\n            node = node.toJSON();\n        }\n\n        if (node === undefined) return;\n        if (typeof node == 'number') return isFinite(node) ? '' + node : 'null';\n        if (typeof node !== 'object') return JSON.stringify(node);\n\n        var i, out;\n        if (Array.isArray(node)) {\n            out = '[';\n            for (i = 0; i < node.length; i++) {\n                if (i) out += ',';\n                out += stringify(node[i]) || 'null';\n            }\n            return out + ']';\n        }\n\n        if (node === null) return 'null';\n\n        if (seen.indexOf(node) !== -1) {\n            if (cycles) return JSON.stringify('__cycle__');\n            throw new TypeError('Converting circular structure to JSON');\n        }\n\n        var seenIndex = seen.push(node) - 1;\n        var keys = Object.keys(node).sort(cmp && cmp(node));\n        out = '';\n        for (i = 0; i < keys.length; i++) {\n            var key = keys[i];\n            var value = stringify(node[key]);\n\n            if (!value) continue;\n            if (out) out += ',';\n            out += JSON.stringify(key) + ':' + value;\n        }\n        seen.splice(seenIndex, 1);\n        return '{' + out + '}';\n    })(data);\n};\n","'use strict';\nmodule.exports = function generate_validate(it, $keyword, $ruleType) {\n  var out = '';\n  var $async = it.schema.$async === true,\n    $refKeywords = it.util.schemaHasRulesExcept(it.schema, it.RULES.all, '$ref'),\n    $id = it.self._getId(it.schema);\n  if (it.opts.strictKeywords) {\n    var $unknownKwd = it.util.schemaUnknownRules(it.schema, it.RULES.keywords);\n    if ($unknownKwd) {\n      var $keywordsMsg = 'unknown keyword: ' + $unknownKwd;\n      if (it.opts.strictKeywords === 'log') it.logger.warn($keywordsMsg);\n      else throw new Error($keywordsMsg);\n    }\n  }\n  if (it.isTop) {\n    out += ' var validate = ';\n    if ($async) {\n      it.async = true;\n      out += 'async ';\n    }\n    out += 'function(data, dataPath, parentData, parentDataProperty, rootData) { \\'use strict\\'; ';\n    if ($id && (it.opts.sourceCode || it.opts.processCode)) {\n      out += ' ' + ('/\\*# sourceURL=' + $id + ' */') + ' ';\n    }\n  }\n  if (typeof it.schema == 'boolean' || !($refKeywords || it.schema.$ref)) {\n    var $keyword = 'false schema';\n    var $lvl = it.level;\n    var $dataLvl = it.dataLevel;\n    var $schema = it.schema[$keyword];\n    var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n    var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n    var $breakOnError = !it.opts.allErrors;\n    var $errorKeyword;\n    var $data = 'data' + ($dataLvl || '');\n    var $valid = 'valid' + $lvl;\n    if (it.schema === false) {\n      if (it.isTop) {\n        $breakOnError = true;\n      } else {\n        out += ' var ' + ($valid) + ' = false; ';\n      }\n      var $$outStack = $$outStack || [];\n      $$outStack.push(out);\n      out = ''; /* istanbul ignore else */\n      if (it.createErrors !== false) {\n        out += ' { keyword: \\'' + ($errorKeyword || 'false schema') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: {} ';\n        if (it.opts.messages !== false) {\n          out += ' , message: \\'boolean schema is false\\' ';\n        }\n        if (it.opts.verbose) {\n          out += ' , schema: false , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n        }\n        out += ' } ';\n      } else {\n        out += ' {} ';\n      }\n      var __err = out;\n      out = $$outStack.pop();\n      if (!it.compositeRule && $breakOnError) {\n        /* istanbul ignore if */\n        if (it.async) {\n          out += ' throw new ValidationError([' + (__err) + ']); ';\n        } else {\n          out += ' validate.errors = [' + (__err) + ']; return false; ';\n        }\n      } else {\n        out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n      }\n    } else {\n      if (it.isTop) {\n        if ($async) {\n          out += ' return data; ';\n        } else {\n          out += ' validate.errors = null; return true; ';\n        }\n      } else {\n        out += ' var ' + ($valid) + ' = true; ';\n      }\n    }\n    if (it.isTop) {\n      out += ' }; return validate; ';\n    }\n    return out;\n  }\n  if (it.isTop) {\n    var $top = it.isTop,\n      $lvl = it.level = 0,\n      $dataLvl = it.dataLevel = 0,\n      $data = 'data';\n    it.rootId = it.resolve.fullPath(it.self._getId(it.root.schema));\n    it.baseId = it.baseId || it.rootId;\n    delete it.isTop;\n    it.dataPathArr = [\"\"];\n    if (it.schema.default !== undefined && it.opts.useDefaults && it.opts.strictDefaults) {\n      var $defaultMsg = 'default is ignored in the schema root';\n      if (it.opts.strictDefaults === 'log') it.logger.warn($defaultMsg);\n      else throw new Error($defaultMsg);\n    }\n    out += ' var vErrors = null; ';\n    out += ' var errors = 0;     ';\n    out += ' if (rootData === undefined) rootData = data; ';\n  } else {\n    var $lvl = it.level,\n      $dataLvl = it.dataLevel,\n      $data = 'data' + ($dataLvl || '');\n    if ($id) it.baseId = it.resolve.url(it.baseId, $id);\n    if ($async && !it.async) throw new Error('async schema in sync schema');\n    out += ' var errs_' + ($lvl) + ' = errors;';\n  }\n  var $valid = 'valid' + $lvl,\n    $breakOnError = !it.opts.allErrors,\n    $closingBraces1 = '',\n    $closingBraces2 = '';\n  var $errorKeyword;\n  var $typeSchema = it.schema.type,\n    $typeIsArray = Array.isArray($typeSchema);\n  if ($typeSchema && it.opts.nullable && it.schema.nullable === true) {\n    if ($typeIsArray) {\n      if ($typeSchema.indexOf('null') == -1) $typeSchema = $typeSchema.concat('null');\n    } else if ($typeSchema != 'null') {\n      $typeSchema = [$typeSchema, 'null'];\n      $typeIsArray = true;\n    }\n  }\n  if ($typeIsArray && $typeSchema.length == 1) {\n    $typeSchema = $typeSchema[0];\n    $typeIsArray = false;\n  }\n  if (it.schema.$ref && $refKeywords) {\n    if (it.opts.extendRefs == 'fail') {\n      throw new Error('$ref: validation keywords used in schema at path \"' + it.errSchemaPath + '\" (see option extendRefs)');\n    } else if (it.opts.extendRefs !== true) {\n      $refKeywords = false;\n      it.logger.warn('$ref: keywords ignored in schema at path \"' + it.errSchemaPath + '\"');\n    }\n  }\n  if (it.schema.$comment && it.opts.$comment) {\n    out += ' ' + (it.RULES.all.$comment.code(it, '$comment'));\n  }\n  if ($typeSchema) {\n    if (it.opts.coerceTypes) {\n      var $coerceToTypes = it.util.coerceToTypes(it.opts.coerceTypes, $typeSchema);\n    }\n    var $rulesGroup = it.RULES.types[$typeSchema];\n    if ($coerceToTypes || $typeIsArray || $rulesGroup === true || ($rulesGroup && !$shouldUseGroup($rulesGroup))) {\n      var $schemaPath = it.schemaPath + '.type',\n        $errSchemaPath = it.errSchemaPath + '/type';\n      var $schemaPath = it.schemaPath + '.type',\n        $errSchemaPath = it.errSchemaPath + '/type',\n        $method = $typeIsArray ? 'checkDataTypes' : 'checkDataType';\n      out += ' if (' + (it.util[$method]($typeSchema, $data, it.opts.strictNumbers, true)) + ') { ';\n      if ($coerceToTypes) {\n        var $dataType = 'dataType' + $lvl,\n          $coerced = 'coerced' + $lvl;\n        out += ' var ' + ($dataType) + ' = typeof ' + ($data) + '; var ' + ($coerced) + ' = undefined; ';\n        if (it.opts.coerceTypes == 'array') {\n          out += ' if (' + ($dataType) + ' == \\'object\\' && Array.isArray(' + ($data) + ') && ' + ($data) + '.length == 1) { ' + ($data) + ' = ' + ($data) + '[0]; ' + ($dataType) + ' = typeof ' + ($data) + '; if (' + (it.util.checkDataType(it.schema.type, $data, it.opts.strictNumbers)) + ') ' + ($coerced) + ' = ' + ($data) + '; } ';\n        }\n        out += ' if (' + ($coerced) + ' !== undefined) ; ';\n        var arr1 = $coerceToTypes;\n        if (arr1) {\n          var $type, $i = -1,\n            l1 = arr1.length - 1;\n          while ($i < l1) {\n            $type = arr1[$i += 1];\n            if ($type == 'string') {\n              out += ' else if (' + ($dataType) + ' == \\'number\\' || ' + ($dataType) + ' == \\'boolean\\') ' + ($coerced) + ' = \\'\\' + ' + ($data) + '; else if (' + ($data) + ' === null) ' + ($coerced) + ' = \\'\\'; ';\n            } else if ($type == 'number' || $type == 'integer') {\n              out += ' else if (' + ($dataType) + ' == \\'boolean\\' || ' + ($data) + ' === null || (' + ($dataType) + ' == \\'string\\' && ' + ($data) + ' && ' + ($data) + ' == +' + ($data) + ' ';\n              if ($type == 'integer') {\n                out += ' && !(' + ($data) + ' % 1)';\n              }\n              out += ')) ' + ($coerced) + ' = +' + ($data) + '; ';\n            } else if ($type == 'boolean') {\n              out += ' else if (' + ($data) + ' === \\'false\\' || ' + ($data) + ' === 0 || ' + ($data) + ' === null) ' + ($coerced) + ' = false; else if (' + ($data) + ' === \\'true\\' || ' + ($data) + ' === 1) ' + ($coerced) + ' = true; ';\n            } else if ($type == 'null') {\n              out += ' else if (' + ($data) + ' === \\'\\' || ' + ($data) + ' === 0 || ' + ($data) + ' === false) ' + ($coerced) + ' = null; ';\n            } else if (it.opts.coerceTypes == 'array' && $type == 'array') {\n              out += ' else if (' + ($dataType) + ' == \\'string\\' || ' + ($dataType) + ' == \\'number\\' || ' + ($dataType) + ' == \\'boolean\\' || ' + ($data) + ' == null) ' + ($coerced) + ' = [' + ($data) + ']; ';\n            }\n          }\n        }\n        out += ' else {   ';\n        var $$outStack = $$outStack || [];\n        $$outStack.push(out);\n        out = ''; /* istanbul ignore else */\n        if (it.createErrors !== false) {\n          out += ' { keyword: \\'' + ($errorKeyword || 'type') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { type: \\'';\n          if ($typeIsArray) {\n            out += '' + ($typeSchema.join(\",\"));\n          } else {\n            out += '' + ($typeSchema);\n          }\n          out += '\\' } ';\n          if (it.opts.messages !== false) {\n            out += ' , message: \\'should be ';\n            if ($typeIsArray) {\n              out += '' + ($typeSchema.join(\",\"));\n            } else {\n              out += '' + ($typeSchema);\n            }\n            out += '\\' ';\n          }\n          if (it.opts.verbose) {\n            out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n          }\n          out += ' } ';\n        } else {\n          out += ' {} ';\n        }\n        var __err = out;\n        out = $$outStack.pop();\n        if (!it.compositeRule && $breakOnError) {\n          /* istanbul ignore if */\n          if (it.async) {\n            out += ' throw new ValidationError([' + (__err) + ']); ';\n          } else {\n            out += ' validate.errors = [' + (__err) + ']; return false; ';\n          }\n        } else {\n          out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n        }\n        out += ' } if (' + ($coerced) + ' !== undefined) {  ';\n        var $parentData = $dataLvl ? 'data' + (($dataLvl - 1) || '') : 'parentData',\n          $parentDataProperty = $dataLvl ? it.dataPathArr[$dataLvl] : 'parentDataProperty';\n        out += ' ' + ($data) + ' = ' + ($coerced) + '; ';\n        if (!$dataLvl) {\n          out += 'if (' + ($parentData) + ' !== undefined)';\n        }\n        out += ' ' + ($parentData) + '[' + ($parentDataProperty) + '] = ' + ($coerced) + '; } ';\n      } else {\n        var $$outStack = $$outStack || [];\n        $$outStack.push(out);\n        out = ''; /* istanbul ignore else */\n        if (it.createErrors !== false) {\n          out += ' { keyword: \\'' + ($errorKeyword || 'type') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { type: \\'';\n          if ($typeIsArray) {\n            out += '' + ($typeSchema.join(\",\"));\n          } else {\n            out += '' + ($typeSchema);\n          }\n          out += '\\' } ';\n          if (it.opts.messages !== false) {\n            out += ' , message: \\'should be ';\n            if ($typeIsArray) {\n              out += '' + ($typeSchema.join(\",\"));\n            } else {\n              out += '' + ($typeSchema);\n            }\n            out += '\\' ';\n          }\n          if (it.opts.verbose) {\n            out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n          }\n          out += ' } ';\n        } else {\n          out += ' {} ';\n        }\n        var __err = out;\n        out = $$outStack.pop();\n        if (!it.compositeRule && $breakOnError) {\n          /* istanbul ignore if */\n          if (it.async) {\n            out += ' throw new ValidationError([' + (__err) + ']); ';\n          } else {\n            out += ' validate.errors = [' + (__err) + ']; return false; ';\n          }\n        } else {\n          out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n        }\n      }\n      out += ' } ';\n    }\n  }\n  if (it.schema.$ref && !$refKeywords) {\n    out += ' ' + (it.RULES.all.$ref.code(it, '$ref')) + ' ';\n    if ($breakOnError) {\n      out += ' } if (errors === ';\n      if ($top) {\n        out += '0';\n      } else {\n        out += 'errs_' + ($lvl);\n      }\n      out += ') { ';\n      $closingBraces2 += '}';\n    }\n  } else {\n    var arr2 = it.RULES;\n    if (arr2) {\n      var $rulesGroup, i2 = -1,\n        l2 = arr2.length - 1;\n      while (i2 < l2) {\n        $rulesGroup = arr2[i2 += 1];\n        if ($shouldUseGroup($rulesGroup)) {\n          if ($rulesGroup.type) {\n            out += ' if (' + (it.util.checkDataType($rulesGroup.type, $data, it.opts.strictNumbers)) + ') { ';\n          }\n          if (it.opts.useDefaults) {\n            if ($rulesGroup.type == 'object' && it.schema.properties) {\n              var $schema = it.schema.properties,\n                $schemaKeys = Object.keys($schema);\n              var arr3 = $schemaKeys;\n              if (arr3) {\n                var $propertyKey, i3 = -1,\n                  l3 = arr3.length - 1;\n                while (i3 < l3) {\n                  $propertyKey = arr3[i3 += 1];\n                  var $sch = $schema[$propertyKey];\n                  if ($sch.default !== undefined) {\n                    var $passData = $data + it.util.getProperty($propertyKey);\n                    if (it.compositeRule) {\n                      if (it.opts.strictDefaults) {\n                        var $defaultMsg = 'default is ignored for: ' + $passData;\n                        if (it.opts.strictDefaults === 'log') it.logger.warn($defaultMsg);\n                        else throw new Error($defaultMsg);\n                      }\n                    } else {\n                      out += ' if (' + ($passData) + ' === undefined ';\n                      if (it.opts.useDefaults == 'empty') {\n                        out += ' || ' + ($passData) + ' === null || ' + ($passData) + ' === \\'\\' ';\n                      }\n                      out += ' ) ' + ($passData) + ' = ';\n                      if (it.opts.useDefaults == 'shared') {\n                        out += ' ' + (it.useDefault($sch.default)) + ' ';\n                      } else {\n                        out += ' ' + (JSON.stringify($sch.default)) + ' ';\n                      }\n                      out += '; ';\n                    }\n                  }\n                }\n              }\n            } else if ($rulesGroup.type == 'array' && Array.isArray(it.schema.items)) {\n              var arr4 = it.schema.items;\n              if (arr4) {\n                var $sch, $i = -1,\n                  l4 = arr4.length - 1;\n                while ($i < l4) {\n                  $sch = arr4[$i += 1];\n                  if ($sch.default !== undefined) {\n                    var $passData = $data + '[' + $i + ']';\n                    if (it.compositeRule) {\n                      if (it.opts.strictDefaults) {\n                        var $defaultMsg = 'default is ignored for: ' + $passData;\n                        if (it.opts.strictDefaults === 'log') it.logger.warn($defaultMsg);\n                        else throw new Error($defaultMsg);\n                      }\n                    } else {\n                      out += ' if (' + ($passData) + ' === undefined ';\n                      if (it.opts.useDefaults == 'empty') {\n                        out += ' || ' + ($passData) + ' === null || ' + ($passData) + ' === \\'\\' ';\n                      }\n                      out += ' ) ' + ($passData) + ' = ';\n                      if (it.opts.useDefaults == 'shared') {\n                        out += ' ' + (it.useDefault($sch.default)) + ' ';\n                      } else {\n                        out += ' ' + (JSON.stringify($sch.default)) + ' ';\n                      }\n                      out += '; ';\n                    }\n                  }\n                }\n              }\n            }\n          }\n          var arr5 = $rulesGroup.rules;\n          if (arr5) {\n            var $rule, i5 = -1,\n              l5 = arr5.length - 1;\n            while (i5 < l5) {\n              $rule = arr5[i5 += 1];\n              if ($shouldUseRule($rule)) {\n                var $code = $rule.code(it, $rule.keyword, $rulesGroup.type);\n                if ($code) {\n                  out += ' ' + ($code) + ' ';\n                  if ($breakOnError) {\n                    $closingBraces1 += '}';\n                  }\n                }\n              }\n            }\n          }\n          if ($breakOnError) {\n            out += ' ' + ($closingBraces1) + ' ';\n            $closingBraces1 = '';\n          }\n          if ($rulesGroup.type) {\n            out += ' } ';\n            if ($typeSchema && $typeSchema === $rulesGroup.type && !$coerceToTypes) {\n              out += ' else { ';\n              var $schemaPath = it.schemaPath + '.type',\n                $errSchemaPath = it.errSchemaPath + '/type';\n              var $$outStack = $$outStack || [];\n              $$outStack.push(out);\n              out = ''; /* istanbul ignore else */\n              if (it.createErrors !== false) {\n                out += ' { keyword: \\'' + ($errorKeyword || 'type') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { type: \\'';\n                if ($typeIsArray) {\n                  out += '' + ($typeSchema.join(\",\"));\n                } else {\n                  out += '' + ($typeSchema);\n                }\n                out += '\\' } ';\n                if (it.opts.messages !== false) {\n                  out += ' , message: \\'should be ';\n                  if ($typeIsArray) {\n                    out += '' + ($typeSchema.join(\",\"));\n                  } else {\n                    out += '' + ($typeSchema);\n                  }\n                  out += '\\' ';\n                }\n                if (it.opts.verbose) {\n                  out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n                }\n                out += ' } ';\n              } else {\n                out += ' {} ';\n              }\n              var __err = out;\n              out = $$outStack.pop();\n              if (!it.compositeRule && $breakOnError) {\n                /* istanbul ignore if */\n                if (it.async) {\n                  out += ' throw new ValidationError([' + (__err) + ']); ';\n                } else {\n                  out += ' validate.errors = [' + (__err) + ']; return false; ';\n                }\n              } else {\n                out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n              }\n              out += ' } ';\n            }\n          }\n          if ($breakOnError) {\n            out += ' if (errors === ';\n            if ($top) {\n              out += '0';\n            } else {\n              out += 'errs_' + ($lvl);\n            }\n            out += ') { ';\n            $closingBraces2 += '}';\n          }\n        }\n      }\n    }\n  }\n  if ($breakOnError) {\n    out += ' ' + ($closingBraces2) + ' ';\n  }\n  if ($top) {\n    if ($async) {\n      out += ' if (errors === 0) return data;           ';\n      out += ' else throw new ValidationError(vErrors); ';\n    } else {\n      out += ' validate.errors = vErrors; ';\n      out += ' return errors === 0;       ';\n    }\n    out += ' }; return validate;';\n  } else {\n    out += ' var ' + ($valid) + ' = errors === errs_' + ($lvl) + ';';\n  }\n\n  function $shouldUseGroup($rulesGroup) {\n    var rules = $rulesGroup.rules;\n    for (var i = 0; i < rules.length; i++)\n      if ($shouldUseRule(rules[i])) return true;\n  }\n\n  function $shouldUseRule($rule) {\n    return it.schema[$rule.keyword] !== undefined || ($rule.implements && $ruleImplementsSomeKeyword($rule));\n  }\n\n  function $ruleImplementsSomeKeyword($rule) {\n    var impl = $rule.implements;\n    for (var i = 0; i < impl.length; i++)\n      if (it.schema[impl[i]] !== undefined) return true;\n  }\n  return out;\n}\n","'use strict';\nmodule.exports = function generate__limit(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $errorKeyword;\n  var $data = 'data' + ($dataLvl || '');\n  var $isData = it.opts.$data && $schema && $schema.$data,\n    $schemaValue;\n  if ($isData) {\n    out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; ';\n    $schemaValue = 'schema' + $lvl;\n  } else {\n    $schemaValue = $schema;\n  }\n  var $isMax = $keyword == 'maximum',\n    $exclusiveKeyword = $isMax ? 'exclusiveMaximum' : 'exclusiveMinimum',\n    $schemaExcl = it.schema[$exclusiveKeyword],\n    $isDataExcl = it.opts.$data && $schemaExcl && $schemaExcl.$data,\n    $op = $isMax ? '<' : '>',\n    $notOp = $isMax ? '>' : '<',\n    $errorKeyword = undefined;\n  if (!($isData || typeof $schema == 'number' || $schema === undefined)) {\n    throw new Error($keyword + ' must be number');\n  }\n  if (!($isDataExcl || $schemaExcl === undefined || typeof $schemaExcl == 'number' || typeof $schemaExcl == 'boolean')) {\n    throw new Error($exclusiveKeyword + ' must be number or boolean');\n  }\n  if ($isDataExcl) {\n    var $schemaValueExcl = it.util.getData($schemaExcl.$data, $dataLvl, it.dataPathArr),\n      $exclusive = 'exclusive' + $lvl,\n      $exclType = 'exclType' + $lvl,\n      $exclIsNumber = 'exclIsNumber' + $lvl,\n      $opExpr = 'op' + $lvl,\n      $opStr = '\\' + ' + $opExpr + ' + \\'';\n    out += ' var schemaExcl' + ($lvl) + ' = ' + ($schemaValueExcl) + '; ';\n    $schemaValueExcl = 'schemaExcl' + $lvl;\n    out += ' var ' + ($exclusive) + '; var ' + ($exclType) + ' = typeof ' + ($schemaValueExcl) + '; if (' + ($exclType) + ' != \\'boolean\\' && ' + ($exclType) + ' != \\'undefined\\' && ' + ($exclType) + ' != \\'number\\') { ';\n    var $errorKeyword = $exclusiveKeyword;\n    var $$outStack = $$outStack || [];\n    $$outStack.push(out);\n    out = ''; /* istanbul ignore else */\n    if (it.createErrors !== false) {\n      out += ' { keyword: \\'' + ($errorKeyword || '_exclusiveLimit') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: {} ';\n      if (it.opts.messages !== false) {\n        out += ' , message: \\'' + ($exclusiveKeyword) + ' should be boolean\\' ';\n      }\n      if (it.opts.verbose) {\n        out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n      }\n      out += ' } ';\n    } else {\n      out += ' {} ';\n    }\n    var __err = out;\n    out = $$outStack.pop();\n    if (!it.compositeRule && $breakOnError) {\n      /* istanbul ignore if */\n      if (it.async) {\n        out += ' throw new ValidationError([' + (__err) + ']); ';\n      } else {\n        out += ' validate.errors = [' + (__err) + ']; return false; ';\n      }\n    } else {\n      out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n    }\n    out += ' } else if ( ';\n    if ($isData) {\n      out += ' (' + ($schemaValue) + ' !== undefined && typeof ' + ($schemaValue) + ' != \\'number\\') || ';\n    }\n    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) + '=\\'; ';\n    if ($schema === undefined) {\n      $errorKeyword = $exclusiveKeyword;\n      $errSchemaPath = it.errSchemaPath + '/' + $exclusiveKeyword;\n      $schemaValue = $schemaValueExcl;\n      $isData = $isDataExcl;\n    }\n  } else {\n    var $exclIsNumber = typeof $schemaExcl == 'number',\n      $opStr = $op;\n    if ($exclIsNumber && $isData) {\n      var $opExpr = '\\'' + $opStr + '\\'';\n      out += ' if ( ';\n      if ($isData) {\n        out += ' (' + ($schemaValue) + ' !== undefined && typeof ' + ($schemaValue) + ' != \\'number\\') || ';\n      }\n      out += ' ( ' + ($schemaValue) + ' === undefined || ' + ($schemaExcl) + ' ' + ($op) + '= ' + ($schemaValue) + ' ? ' + ($data) + ' ' + ($notOp) + '= ' + ($schemaExcl) + ' : ' + ($data) + ' ' + ($notOp) + ' ' + ($schemaValue) + ' ) || ' + ($data) + ' !== ' + ($data) + ') { ';\n    } else {\n      if ($exclIsNumber && $schema === undefined) {\n        $exclusive = true;\n        $errorKeyword = $exclusiveKeyword;\n        $errSchemaPath = it.errSchemaPath + '/' + $exclusiveKeyword;\n        $schemaValue = $schemaExcl;\n        $notOp += '=';\n      } else {\n        if ($exclIsNumber) $schemaValue = Math[$isMax ? 'min' : 'max']($schemaExcl, $schema);\n        if ($schemaExcl === ($exclIsNumber ? $schemaValue : true)) {\n          $exclusive = true;\n          $errorKeyword = $exclusiveKeyword;\n          $errSchemaPath = it.errSchemaPath + '/' + $exclusiveKeyword;\n          $notOp += '=';\n        } else {\n          $exclusive = false;\n          $opStr += '=';\n        }\n      }\n      var $opExpr = '\\'' + $opStr + '\\'';\n      out += ' if ( ';\n      if ($isData) {\n        out += ' (' + ($schemaValue) + ' !== undefined && typeof ' + ($schemaValue) + ' != \\'number\\') || ';\n      }\n      out += ' ' + ($data) + ' ' + ($notOp) + ' ' + ($schemaValue) + ' || ' + ($data) + ' !== ' + ($data) + ') { ';\n    }\n  }\n  $errorKeyword = $errorKeyword || $keyword;\n  var $$outStack = $$outStack || [];\n  $$outStack.push(out);\n  out = ''; /* istanbul ignore else */\n  if (it.createErrors !== false) {\n    out += ' { keyword: \\'' + ($errorKeyword || '_limit') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { comparison: ' + ($opExpr) + ', limit: ' + ($schemaValue) + ', exclusive: ' + ($exclusive) + ' } ';\n    if (it.opts.messages !== false) {\n      out += ' , message: \\'should be ' + ($opStr) + ' ';\n      if ($isData) {\n        out += '\\' + ' + ($schemaValue);\n      } else {\n        out += '' + ($schemaValue) + '\\'';\n      }\n    }\n    if (it.opts.verbose) {\n      out += ' , schema:  ';\n      if ($isData) {\n        out += 'validate.schema' + ($schemaPath);\n      } else {\n        out += '' + ($schema);\n      }\n      out += '         , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n    }\n    out += ' } ';\n  } else {\n    out += ' {} ';\n  }\n  var __err = out;\n  out = $$outStack.pop();\n  if (!it.compositeRule && $breakOnError) {\n    /* istanbul ignore if */\n    if (it.async) {\n      out += ' throw new ValidationError([' + (__err) + ']); ';\n    } else {\n      out += ' validate.errors = [' + (__err) + ']; return false; ';\n    }\n  } else {\n    out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n  }\n  out += ' } ';\n  if ($breakOnError) {\n    out += ' else { ';\n  }\n  return out;\n}\n","'use strict';\nmodule.exports = function generate__limitItems(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $errorKeyword;\n  var $data = 'data' + ($dataLvl || '');\n  var $isData = it.opts.$data && $schema && $schema.$data,\n    $schemaValue;\n  if ($isData) {\n    out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; ';\n    $schemaValue = 'schema' + $lvl;\n  } else {\n    $schemaValue = $schema;\n  }\n  if (!($isData || typeof $schema == 'number')) {\n    throw new Error($keyword + ' must be number');\n  }\n  var $op = $keyword == 'maxItems' ? '>' : '<';\n  out += 'if ( ';\n  if ($isData) {\n    out += ' (' + ($schemaValue) + ' !== undefined && typeof ' + ($schemaValue) + ' != \\'number\\') || ';\n  }\n  out += ' ' + ($data) + '.length ' + ($op) + ' ' + ($schemaValue) + ') { ';\n  var $errorKeyword = $keyword;\n  var $$outStack = $$outStack || [];\n  $$outStack.push(out);\n  out = ''; /* istanbul ignore else */\n  if (it.createErrors !== false) {\n    out += ' { keyword: \\'' + ($errorKeyword || '_limitItems') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { limit: ' + ($schemaValue) + ' } ';\n    if (it.opts.messages !== false) {\n      out += ' , message: \\'should NOT have ';\n      if ($keyword == 'maxItems') {\n        out += 'more';\n      } else {\n        out += 'fewer';\n      }\n      out += ' than ';\n      if ($isData) {\n        out += '\\' + ' + ($schemaValue) + ' + \\'';\n      } else {\n        out += '' + ($schema);\n      }\n      out += ' items\\' ';\n    }\n    if (it.opts.verbose) {\n      out += ' , schema:  ';\n      if ($isData) {\n        out += 'validate.schema' + ($schemaPath);\n      } else {\n        out += '' + ($schema);\n      }\n      out += '         , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n    }\n    out += ' } ';\n  } else {\n    out += ' {} ';\n  }\n  var __err = out;\n  out = $$outStack.pop();\n  if (!it.compositeRule && $breakOnError) {\n    /* istanbul ignore if */\n    if (it.async) {\n      out += ' throw new ValidationError([' + (__err) + ']); ';\n    } else {\n      out += ' validate.errors = [' + (__err) + ']; return false; ';\n    }\n  } else {\n    out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n  }\n  out += '} ';\n  if ($breakOnError) {\n    out += ' else { ';\n  }\n  return out;\n}\n","'use strict';\nmodule.exports = function generate__limitLength(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $errorKeyword;\n  var $data = 'data' + ($dataLvl || '');\n  var $isData = it.opts.$data && $schema && $schema.$data,\n    $schemaValue;\n  if ($isData) {\n    out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; ';\n    $schemaValue = 'schema' + $lvl;\n  } else {\n    $schemaValue = $schema;\n  }\n  if (!($isData || typeof $schema == 'number')) {\n    throw new Error($keyword + ' must be number');\n  }\n  var $op = $keyword == 'maxLength' ? '>' : '<';\n  out += 'if ( ';\n  if ($isData) {\n    out += ' (' + ($schemaValue) + ' !== undefined && typeof ' + ($schemaValue) + ' != \\'number\\') || ';\n  }\n  if (it.opts.unicode === false) {\n    out += ' ' + ($data) + '.length ';\n  } else {\n    out += ' ucs2length(' + ($data) + ') ';\n  }\n  out += ' ' + ($op) + ' ' + ($schemaValue) + ') { ';\n  var $errorKeyword = $keyword;\n  var $$outStack = $$outStack || [];\n  $$outStack.push(out);\n  out = ''; /* istanbul ignore else */\n  if (it.createErrors !== false) {\n    out += ' { keyword: \\'' + ($errorKeyword || '_limitLength') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { limit: ' + ($schemaValue) + ' } ';\n    if (it.opts.messages !== false) {\n      out += ' , message: \\'should NOT be ';\n      if ($keyword == 'maxLength') {\n        out += 'longer';\n      } else {\n        out += 'shorter';\n      }\n      out += ' than ';\n      if ($isData) {\n        out += '\\' + ' + ($schemaValue) + ' + \\'';\n      } else {\n        out += '' + ($schema);\n      }\n      out += ' characters\\' ';\n    }\n    if (it.opts.verbose) {\n      out += ' , schema:  ';\n      if ($isData) {\n        out += 'validate.schema' + ($schemaPath);\n      } else {\n        out += '' + ($schema);\n      }\n      out += '         , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n    }\n    out += ' } ';\n  } else {\n    out += ' {} ';\n  }\n  var __err = out;\n  out = $$outStack.pop();\n  if (!it.compositeRule && $breakOnError) {\n    /* istanbul ignore if */\n    if (it.async) {\n      out += ' throw new ValidationError([' + (__err) + ']); ';\n    } else {\n      out += ' validate.errors = [' + (__err) + ']; return false; ';\n    }\n  } else {\n    out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n  }\n  out += '} ';\n  if ($breakOnError) {\n    out += ' else { ';\n  }\n  return out;\n}\n","'use strict';\nmodule.exports = function generate__limitProperties(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $errorKeyword;\n  var $data = 'data' + ($dataLvl || '');\n  var $isData = it.opts.$data && $schema && $schema.$data,\n    $schemaValue;\n  if ($isData) {\n    out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; ';\n    $schemaValue = 'schema' + $lvl;\n  } else {\n    $schemaValue = $schema;\n  }\n  if (!($isData || typeof $schema == 'number')) {\n    throw new Error($keyword + ' must be number');\n  }\n  var $op = $keyword == 'maxProperties' ? '>' : '<';\n  out += 'if ( ';\n  if ($isData) {\n    out += ' (' + ($schemaValue) + ' !== undefined && typeof ' + ($schemaValue) + ' != \\'number\\') || ';\n  }\n  out += ' Object.keys(' + ($data) + ').length ' + ($op) + ' ' + ($schemaValue) + ') { ';\n  var $errorKeyword = $keyword;\n  var $$outStack = $$outStack || [];\n  $$outStack.push(out);\n  out = ''; /* istanbul ignore else */\n  if (it.createErrors !== false) {\n    out += ' { keyword: \\'' + ($errorKeyword || '_limitProperties') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { limit: ' + ($schemaValue) + ' } ';\n    if (it.opts.messages !== false) {\n      out += ' , message: \\'should NOT have ';\n      if ($keyword == 'maxProperties') {\n        out += 'more';\n      } else {\n        out += 'fewer';\n      }\n      out += ' than ';\n      if ($isData) {\n        out += '\\' + ' + ($schemaValue) + ' + \\'';\n      } else {\n        out += '' + ($schema);\n      }\n      out += ' properties\\' ';\n    }\n    if (it.opts.verbose) {\n      out += ' , schema:  ';\n      if ($isData) {\n        out += 'validate.schema' + ($schemaPath);\n      } else {\n        out += '' + ($schema);\n      }\n      out += '         , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n    }\n    out += ' } ';\n  } else {\n    out += ' {} ';\n  }\n  var __err = out;\n  out = $$outStack.pop();\n  if (!it.compositeRule && $breakOnError) {\n    /* istanbul ignore if */\n    if (it.async) {\n      out += ' throw new ValidationError([' + (__err) + ']); ';\n    } else {\n      out += ' validate.errors = [' + (__err) + ']; return false; ';\n    }\n  } else {\n    out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n  }\n  out += '} ';\n  if ($breakOnError) {\n    out += ' else { ';\n  }\n  return out;\n}\n","'use strict';\n\nvar resolve = require('./resolve')\n  , util = require('./util')\n  , errorClasses = require('./error_classes')\n  , stableStringify = require('fast-json-stable-stringify');\n\nvar validateGenerator = require('../dotjs/validate');\n\n/**\n * Functions below are used inside compiled validations function\n */\n\nvar ucs2length = util.ucs2length;\nvar equal = require('fast-deep-equal');\n\n// this error is thrown by async schemas to return validation errors via exception\nvar ValidationError = errorClasses.Validation;\n\nmodule.exports = compile;\n\n\n/**\n * Compiles schema to validation function\n * @this   Ajv\n * @param  {Object} schema schema object\n * @param  {Object} root object with information about the root schema for this schema\n * @param  {Object} localRefs the hash of local references inside the schema (created by resolve.id), used for inline resolution\n * @param  {String} baseId base ID for IDs in the schema\n * @return {Function} validation function\n */\nfunction compile(schema, root, localRefs, baseId) {\n  /* jshint validthis: true, evil: true */\n  /* eslint no-shadow: 0 */\n  var self = this\n    , opts = this._opts\n    , refVal = [ undefined ]\n    , refs = {}\n    , patterns = []\n    , patternsHash = {}\n    , defaults = []\n    , defaultsHash = {}\n    , customRules = [];\n\n  root = root || { schema: schema, refVal: refVal, refs: refs };\n\n  var c = checkCompiling.call(this, schema, root, baseId);\n  var compilation = this._compilations[c.index];\n  if (c.compiling) return (compilation.callValidate = callValidate);\n\n  var formats = this._formats;\n  var RULES = this.RULES;\n\n  try {\n    var v = localCompile(schema, root, localRefs, baseId);\n    compilation.validate = v;\n    var cv = compilation.callValidate;\n    if (cv) {\n      cv.schema = v.schema;\n      cv.errors = null;\n      cv.refs = v.refs;\n      cv.refVal = v.refVal;\n      cv.root = v.root;\n      cv.$async = v.$async;\n      if (opts.sourceCode) cv.source = v.source;\n    }\n    return v;\n  } finally {\n    endCompiling.call(this, schema, root, baseId);\n  }\n\n  /* @this   {*} - custom context, see passContext option */\n  function callValidate() {\n    /* jshint validthis: true */\n    var validate = compilation.validate;\n    var result = validate.apply(this, arguments);\n    callValidate.errors = validate.errors;\n    return result;\n  }\n\n  function localCompile(_schema, _root, localRefs, baseId) {\n    var isRoot = !_root || (_root && _root.schema == _schema);\n    if (_root.schema != root.schema)\n      return compile.call(self, _schema, _root, localRefs, baseId);\n\n    var $async = _schema.$async === true;\n\n    var sourceCode = validateGenerator({\n      isTop: true,\n      schema: _schema,\n      isRoot: isRoot,\n      baseId: baseId,\n      root: _root,\n      schemaPath: '',\n      errSchemaPath: '#',\n      errorPath: '\"\"',\n      MissingRefError: errorClasses.MissingRef,\n      RULES: RULES,\n      validate: validateGenerator,\n      util: util,\n      resolve: resolve,\n      resolveRef: resolveRef,\n      usePattern: usePattern,\n      useDefault: useDefault,\n      useCustomRule: useCustomRule,\n      opts: opts,\n      formats: formats,\n      logger: self.logger,\n      self: self\n    });\n\n    sourceCode = vars(refVal, refValCode) + vars(patterns, patternCode)\n                   + vars(defaults, defaultCode) + vars(customRules, customRuleCode)\n                   + sourceCode;\n\n    if (opts.processCode) sourceCode = opts.processCode(sourceCode, _schema);\n    // console.log('\\n\\n\\n *** \\n', JSON.stringify(sourceCode));\n    var validate;\n    try {\n      var makeValidate = new Function(\n        'self',\n        'RULES',\n        'formats',\n        'root',\n        'refVal',\n        'defaults',\n        'customRules',\n        'equal',\n        'ucs2length',\n        'ValidationError',\n        sourceCode\n      );\n\n      validate = makeValidate(\n        self,\n        RULES,\n        formats,\n        root,\n        refVal,\n        defaults,\n        customRules,\n        equal,\n        ucs2length,\n        ValidationError\n      );\n\n      refVal[0] = validate;\n    } catch(e) {\n      self.logger.error('Error compiling schema, function code:', sourceCode);\n      throw e;\n    }\n\n    validate.schema = _schema;\n    validate.errors = null;\n    validate.refs = refs;\n    validate.refVal = refVal;\n    validate.root = isRoot ? validate : _root;\n    if ($async) validate.$async = true;\n    if (opts.sourceCode === true) {\n      validate.source = {\n        code: sourceCode,\n        patterns: patterns,\n        defaults: defaults\n      };\n    }\n\n    return validate;\n  }\n\n  function resolveRef(baseId, ref, isRoot) {\n    ref = resolve.url(baseId, ref);\n    var refIndex = refs[ref];\n    var _refVal, refCode;\n    if (refIndex !== undefined) {\n      _refVal = refVal[refIndex];\n      refCode = 'refVal[' + refIndex + ']';\n      return resolvedRef(_refVal, refCode);\n    }\n    if (!isRoot && root.refs) {\n      var rootRefId = root.refs[ref];\n      if (rootRefId !== undefined) {\n        _refVal = root.refVal[rootRefId];\n        refCode = addLocalRef(ref, _refVal);\n        return resolvedRef(_refVal, refCode);\n      }\n    }\n\n    refCode = addLocalRef(ref);\n    var v = resolve.call(self, localCompile, root, ref);\n    if (v === undefined) {\n      var localSchema = localRefs && localRefs[ref];\n      if (localSchema) {\n        v = resolve.inlineRef(localSchema, opts.inlineRefs)\n            ? localSchema\n            : compile.call(self, localSchema, root, localRefs, baseId);\n      }\n    }\n\n    if (v === undefined) {\n      removeLocalRef(ref);\n    } else {\n      replaceLocalRef(ref, v);\n      return resolvedRef(v, refCode);\n    }\n  }\n\n  function addLocalRef(ref, v) {\n    var refId = refVal.length;\n    refVal[refId] = v;\n    refs[ref] = refId;\n    return 'refVal' + refId;\n  }\n\n  function removeLocalRef(ref) {\n    delete refs[ref];\n  }\n\n  function replaceLocalRef(ref, v) {\n    var refId = refs[ref];\n    refVal[refId] = v;\n  }\n\n  function resolvedRef(refVal, code) {\n    return typeof refVal == 'object' || typeof refVal == 'boolean'\n            ? { code: code, schema: refVal, inline: true }\n            : { code: code, $async: refVal && !!refVal.$async };\n  }\n\n  function usePattern(regexStr) {\n    var index = patternsHash[regexStr];\n    if (index === undefined) {\n      index = patternsHash[regexStr] = patterns.length;\n      patterns[index] = regexStr;\n    }\n    return 'pattern' + index;\n  }\n\n  function useDefault(value) {\n    switch (typeof value) {\n      case 'boolean':\n      case 'number':\n        return '' + value;\n      case 'string':\n        return util.toQuotedString(value);\n      case 'object':\n        if (value === null) return 'null';\n        var valueStr = stableStringify(value);\n        var index = defaultsHash[valueStr];\n        if (index === undefined) {\n          index = defaultsHash[valueStr] = defaults.length;\n          defaults[index] = value;\n        }\n        return 'default' + index;\n    }\n  }\n\n  function useCustomRule(rule, schema, parentSchema, it) {\n    if (self._opts.validateSchema !== false) {\n      var deps = rule.definition.dependencies;\n      if (deps && !deps.every(function(keyword) {\n        return Object.prototype.hasOwnProperty.call(parentSchema, keyword);\n      }))\n        throw new Error('parent schema must have all required keywords: ' + deps.join(','));\n\n      var validateSchema = rule.definition.validateSchema;\n      if (validateSchema) {\n        var valid = validateSchema(schema);\n        if (!valid) {\n          var message = 'keyword schema is invalid: ' + self.errorsText(validateSchema.errors);\n          if (self._opts.validateSchema == 'log') self.logger.error(message);\n          else throw new Error(message);\n        }\n      }\n    }\n\n    var compile = rule.definition.compile\n      , inline = rule.definition.inline\n      , macro = rule.definition.macro;\n\n    var validate;\n    if (compile) {\n      validate = compile.call(self, schema, parentSchema, it);\n    } else if (macro) {\n      validate = macro.call(self, schema, parentSchema, it);\n      if (opts.validateSchema !== false) self.validateSchema(validate, true);\n    } else if (inline) {\n      validate = inline.call(self, it, rule.keyword, schema, parentSchema);\n    } else {\n      validate = rule.definition.validate;\n      if (!validate) return;\n    }\n\n    if (validate === undefined)\n      throw new Error('custom keyword \"' + rule.keyword + '\"failed to compile');\n\n    var index = customRules.length;\n    customRules[index] = validate;\n\n    return {\n      code: 'customRule' + index,\n      validate: validate\n    };\n  }\n}\n\n\n/**\n * Checks if the schema is currently compiled\n * @this   Ajv\n * @param  {Object} schema schema to compile\n * @param  {Object} root root object\n * @param  {String} baseId base schema ID\n * @return {Object} object with properties \"index\" (compilation index) and \"compiling\" (boolean)\n */\nfunction checkCompiling(schema, root, baseId) {\n  /* jshint validthis: true */\n  var index = compIndex.call(this, schema, root, baseId);\n  if (index >= 0) return { index: index, compiling: true };\n  index = this._compilations.length;\n  this._compilations[index] = {\n    schema: schema,\n    root: root,\n    baseId: baseId\n  };\n  return { index: index, compiling: false };\n}\n\n\n/**\n * Removes the schema from the currently compiled list\n * @this   Ajv\n * @param  {Object} schema schema to compile\n * @param  {Object} root root object\n * @param  {String} baseId base schema ID\n */\nfunction endCompiling(schema, root, baseId) {\n  /* jshint validthis: true */\n  var i = compIndex.call(this, schema, root, baseId);\n  if (i >= 0) this._compilations.splice(i, 1);\n}\n\n\n/**\n * Index of schema compilation in the currently compiled list\n * @this   Ajv\n * @param  {Object} schema schema to compile\n * @param  {Object} root root object\n * @param  {String} baseId base schema ID\n * @return {Integer} compilation index\n */\nfunction compIndex(schema, root, baseId) {\n  /* jshint validthis: true */\n  for (var i=0; i<this._compilations.length; i++) {\n    var c = this._compilations[i];\n    if (c.schema == schema && c.root == root && c.baseId == baseId) return i;\n  }\n  return -1;\n}\n\n\nfunction patternCode(i, patterns) {\n  return 'var pattern' + i + ' = new RegExp(' + util.toQuotedString(patterns[i]) + ');';\n}\n\n\nfunction defaultCode(i) {\n  return 'var default' + i + ' = defaults[' + i + '];';\n}\n\n\nfunction refValCode(i, refVal) {\n  return refVal[i] === undefined ? '' : 'var refVal' + i + ' = refVal[' + i + '];';\n}\n\n\nfunction customRuleCode(i) {\n  return 'var customRule' + i + ' = customRules[' + i + '];';\n}\n\n\nfunction vars(arr, statement) {\n  if (!arr.length) return '';\n  var code = '';\n  for (var i=0; i<arr.length; i++)\n    code += statement(i, arr);\n  return code;\n}\n","export function merge(...sets:Array<string>):string {\n\tif (sets.length > 1) {\n\t\tsets[0] = sets[0].slice(0, -1);\n\t\tconst xl = sets.length - 1;\n\t\tfor (let x = 1; x < xl; ++x) {\n\t\t\tsets[x] = sets[x].slice(1, -1);\n\t\t}\n\t\tsets[xl] = sets[xl].slice(1);\n\t\treturn sets.join('');\n\t} else {\n\t\treturn sets[0];\n\t}\n}\n\nexport function subexp(str:string):string {\n\treturn \"(?:\" + str + \")\";\n}\n\nexport function typeOf(o:any):string {\n\treturn o === undefined ? \"undefined\" : (o === null ? \"null\" : Object.prototype.toString.call(o).split(\" \").pop().split(\"]\").shift().toLowerCase());\n}\n\nexport function toUpperCase(str:string):string {\n\treturn str.toUpperCase();\n}\n\nexport function toArray(obj:any):Array<any> {\n\treturn obj !== undefined && obj !== null ? (obj instanceof Array ? obj : (typeof obj.length !== \"number\" || obj.split || obj.setInterval || obj.call ? [obj] : Array.prototype.slice.call(obj))) : [];\n}\n\n\nexport function assign(target: object, source: any): any {\n\tconst obj = target as any;\n\tif (source) {\n\t\tfor (const key in source) {\n\t\t\tobj[key] = source[key];\n\t\t}\n\t}\n\treturn obj;\n}","import { URIRegExps } from \"./uri\";\nimport { merge, subexp } from \"./util\";\n\nexport function buildExps(isIRI:boolean):URIRegExps {\n\tconst\n\t\tALPHA$$ = \"[A-Za-z]\",\n\t\tCR$ = \"[\\\\x0D]\",\n\t\tDIGIT$$ = \"[0-9]\",\n\t\tDQUOTE$$ = \"[\\\\x22]\",\n\t\tHEXDIG$$ = merge(DIGIT$$, \"[A-Fa-f]\"),  //case-insensitive\n\t\tLF$$ = \"[\\\\x0A]\",\n\t\tSP$$ = \"[\\\\x20]\",\n\t\tPCT_ENCODED$ = subexp(subexp(\"%[EFef]\" + HEXDIG$$ + \"%\" + HEXDIG$$ + HEXDIG$$ + \"%\" + HEXDIG$$ + HEXDIG$$) + \"|\" + subexp(\"%[89A-Fa-f]\" + HEXDIG$$ + \"%\" + HEXDIG$$ + HEXDIG$$) + \"|\" + subexp(\"%\" + HEXDIG$$ + HEXDIG$$)),  //expanded\n\t\tGEN_DELIMS$$ = \"[\\\\:\\\\/\\\\?\\\\#\\\\[\\\\]\\\\@]\",\n\t\tSUB_DELIMS$$ = \"[\\\\!\\\\$\\\\&\\\\'\\\\(\\\\)\\\\*\\\\+\\\\,\\\\;\\\\=]\",\n\t\tRESERVED$$ = merge(GEN_DELIMS$$, SUB_DELIMS$$),\n\t\tUCSCHAR$$ = isIRI ? \"[\\\\xA0-\\\\u200D\\\\u2010-\\\\u2029\\\\u202F-\\\\uD7FF\\\\uF900-\\\\uFDCF\\\\uFDF0-\\\\uFFEF]\" : \"[]\",  //subset, excludes bidi control characters\n\t\tIPRIVATE$$ = isIRI ? \"[\\\\uE000-\\\\uF8FF]\" : \"[]\",  //subset\n\t\tUNRESERVED$$ = merge(ALPHA$$, DIGIT$$, \"[\\\\-\\\\.\\\\_\\\\~]\", UCSCHAR$$),\n\t\tSCHEME$ = subexp(ALPHA$$ + merge(ALPHA$$, DIGIT$$, \"[\\\\+\\\\-\\\\.]\") + \"*\"),\n\t\tUSERINFO$ = subexp(subexp(PCT_ENCODED$ + \"|\" + merge(UNRESERVED$$, SUB_DELIMS$$, \"[\\\\:]\")) + \"*\"),\n\t\tDEC_OCTET$ = subexp(subexp(\"25[0-5]\") + \"|\" + subexp(\"2[0-4]\" + DIGIT$$) + \"|\" + subexp(\"1\" + DIGIT$$ + DIGIT$$) + \"|\" + subexp(\"[1-9]\" + DIGIT$$) + \"|\" + DIGIT$$),\n\t\tDEC_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\n\t\tIPV4ADDRESS$ = subexp(DEC_OCTET_RELAXED$ + \"\\\\.\" + DEC_OCTET_RELAXED$ + \"\\\\.\" + DEC_OCTET_RELAXED$ + \"\\\\.\" + DEC_OCTET_RELAXED$),\n\t\tH16$ = subexp(HEXDIG$$ + \"{1,4}\"),\n\t\tLS32$ = subexp(subexp(H16$ + \"\\\\:\" + H16$) + \"|\" + IPV4ADDRESS$),\n\t\tIPV6ADDRESS1$ = subexp(                                                            subexp(H16$ + \"\\\\:\") + \"{6}\" + LS32$), //                           6( h16 \":\" ) ls32\n\t\tIPV6ADDRESS2$ = subexp(                                                 \"\\\\:\\\\:\" + subexp(H16$ + \"\\\\:\") + \"{5}\" + LS32$), //                      \"::\" 5( h16 \":\" ) ls32\n\t\tIPV6ADDRESS3$ = subexp(subexp(                                 H16$) + \"?\\\\:\\\\:\" + subexp(H16$ + \"\\\\:\") + \"{4}\" + LS32$), //[               h16 ] \"::\" 4( h16 \":\" ) ls32\n\t\tIPV6ADDRESS4$ = subexp(subexp(subexp(H16$ + \"\\\\:\") + \"{0,1}\" + H16$) + \"?\\\\:\\\\:\" + subexp(H16$ + \"\\\\:\") + \"{3}\" + LS32$), //[ *1( h16 \":\" ) h16 ] \"::\" 3( h16 \":\" ) ls32\n\t\tIPV6ADDRESS5$ = subexp(subexp(subexp(H16$ + \"\\\\:\") + \"{0,2}\" + H16$) + \"?\\\\:\\\\:\" + subexp(H16$ + \"\\\\:\") + \"{2}\" + LS32$), //[ *2( h16 \":\" ) h16 ] \"::\" 2( h16 \":\" ) ls32\n\t\tIPV6ADDRESS6$ = subexp(subexp(subexp(H16$ + \"\\\\:\") + \"{0,3}\" + H16$) + \"?\\\\:\\\\:\" +        H16$ + \"\\\\:\"          + LS32$), //[ *3( h16 \":\" ) h16 ] \"::\"    h16 \":\"   ls32\n\t\tIPV6ADDRESS7$ = subexp(subexp(subexp(H16$ + \"\\\\:\") + \"{0,4}\" + H16$) + \"?\\\\:\\\\:\"                                + LS32$), //[ *4( h16 \":\" ) h16 ] \"::\"              ls32\n\t\tIPV6ADDRESS8$ = subexp(subexp(subexp(H16$ + \"\\\\:\") + \"{0,5}\" + H16$) + \"?\\\\:\\\\:\"                                + H16$ ), //[ *5( h16 \":\" ) h16 ] \"::\"              h16\n\t\tIPV6ADDRESS9$ = subexp(subexp(subexp(H16$ + \"\\\\:\") + \"{0,6}\" + H16$) + \"?\\\\:\\\\:\"                                       ), //[ *6( h16 \":\" ) h16 ] \"::\"\n\t\tIPV6ADDRESS$ = subexp([IPV6ADDRESS1$, IPV6ADDRESS2$, IPV6ADDRESS3$, IPV6ADDRESS4$, IPV6ADDRESS5$, IPV6ADDRESS6$, IPV6ADDRESS7$, IPV6ADDRESS8$, IPV6ADDRESS9$].join(\"|\")),\n\t\tZONEID$ = subexp(subexp(UNRESERVED$$ + \"|\" + PCT_ENCODED$) + \"+\"),  //RFC 6874\n\t\tIPV6ADDRZ$ = subexp(IPV6ADDRESS$ + \"\\\\%25\" + ZONEID$),  //RFC 6874\n\t\tIPV6ADDRZ_RELAXED$ = subexp(IPV6ADDRESS$ + subexp(\"\\\\%25|\\\\%(?!\" + HEXDIG$$ + \"{2})\") + ZONEID$),  //RFC 6874, with relaxed parsing rules\n\t\tIPVFUTURE$ = subexp(\"[vV]\" + HEXDIG$$ + \"+\\\\.\" + merge(UNRESERVED$$, SUB_DELIMS$$, \"[\\\\:]\") + \"+\"),\n\t\tIP_LITERAL$ = subexp(\"\\\\[\" + subexp(IPV6ADDRZ_RELAXED$ + \"|\" + IPV6ADDRESS$ + \"|\" + IPVFUTURE$) + \"\\\\]\"),  //RFC 6874\n\t\tREG_NAME$ = subexp(subexp(PCT_ENCODED$ + \"|\" + merge(UNRESERVED$$, SUB_DELIMS$$)) + \"*\"),\n\t\tHOST$ = subexp(IP_LITERAL$ + \"|\" + IPV4ADDRESS$ + \"(?!\" + REG_NAME$ + \")\" + \"|\" + REG_NAME$),\n\t\tPORT$ = subexp(DIGIT$$ + \"*\"),\n\t\tAUTHORITY$ = subexp(subexp(USERINFO$ + \"@\") + \"?\" + HOST$ + subexp(\"\\\\:\" + PORT$) + \"?\"),\n\t\tPCHAR$ = subexp(PCT_ENCODED$ + \"|\" + merge(UNRESERVED$$, SUB_DELIMS$$, \"[\\\\:\\\\@]\")),\n\t\tSEGMENT$ = subexp(PCHAR$ + \"*\"),\n\t\tSEGMENT_NZ$ = subexp(PCHAR$ + \"+\"),\n\t\tSEGMENT_NZ_NC$ = subexp(subexp(PCT_ENCODED$ + \"|\" + merge(UNRESERVED$$, SUB_DELIMS$$, \"[\\\\@]\")) + \"+\"),\n\t\tPATH_ABEMPTY$ = subexp(subexp(\"\\\\/\" + SEGMENT$) + \"*\"),\n\t\tPATH_ABSOLUTE$ = subexp(\"\\\\/\" + subexp(SEGMENT_NZ$ + PATH_ABEMPTY$) + \"?\"),  //simplified\n\t\tPATH_NOSCHEME$ = subexp(SEGMENT_NZ_NC$ + PATH_ABEMPTY$),  //simplified\n\t\tPATH_ROOTLESS$ = subexp(SEGMENT_NZ$ + PATH_ABEMPTY$),  //simplified\n\t\tPATH_EMPTY$ = \"(?!\" + PCHAR$ + \")\",\n\t\tPATH$ = subexp(PATH_ABEMPTY$ + \"|\" + PATH_ABSOLUTE$ + \"|\" + PATH_NOSCHEME$ + \"|\" + PATH_ROOTLESS$ + \"|\" + PATH_EMPTY$),\n\t\tQUERY$ = subexp(subexp(PCHAR$ + \"|\" + merge(\"[\\\\/\\\\?]\", IPRIVATE$$)) + \"*\"),\n\t\tFRAGMENT$ = subexp(subexp(PCHAR$ + \"|[\\\\/\\\\?]\") + \"*\"),\n\t\tHIER_PART$ = subexp(subexp(\"\\\\/\\\\/\" + AUTHORITY$ + PATH_ABEMPTY$) + \"|\" + PATH_ABSOLUTE$ + \"|\" + PATH_ROOTLESS$ + \"|\" + PATH_EMPTY$),\n\t\tURI$ = subexp(SCHEME$ + \"\\\\:\" + HIER_PART$ + subexp(\"\\\\?\" + QUERY$) + \"?\" + subexp(\"\\\\#\" + FRAGMENT$) + \"?\"),\n\t\tRELATIVE_PART$ = subexp(subexp(\"\\\\/\\\\/\" + AUTHORITY$ + PATH_ABEMPTY$) + \"|\" + PATH_ABSOLUTE$ + \"|\" + PATH_NOSCHEME$ + \"|\" + PATH_EMPTY$),\n\t\tRELATIVE$ = subexp(RELATIVE_PART$ + subexp(\"\\\\?\" + QUERY$) + \"?\" + subexp(\"\\\\#\" + FRAGMENT$) + \"?\"),\n\t\tURI_REFERENCE$ = subexp(URI$ + \"|\" + RELATIVE$),\n\t\tABSOLUTE_URI$ = subexp(SCHEME$ + \"\\\\:\" + HIER_PART$ + subexp(\"\\\\?\" + QUERY$) + \"?\"),\n\n\t\tGENERIC_REF$ = \"^(\" + SCHEME$ + \")\\\\:\" + subexp(subexp(\"\\\\/\\\\/(\" + subexp(\"(\" + USERINFO$ + \")@\") + \"?(\" + HOST$ + \")\" + subexp(\"\\\\:(\" + PORT$ + \")\") + \"?)\") + \"?(\" + PATH_ABEMPTY$ + \"|\" + PATH_ABSOLUTE$ + \"|\" + PATH_ROOTLESS$ + \"|\" + PATH_EMPTY$ + \")\") + subexp(\"\\\\?(\" + QUERY$ + \")\") + \"?\" + subexp(\"\\\\#(\" + FRAGMENT$ + \")\") + \"?$\",\n\t\tRELATIVE_REF$ = \"^(){0}\" + subexp(subexp(\"\\\\/\\\\/(\" + subexp(\"(\" + USERINFO$ + \")@\") + \"?(\" + HOST$ + \")\" + subexp(\"\\\\:(\" + PORT$ + \")\") + \"?)\") + \"?(\" + PATH_ABEMPTY$ + \"|\" + PATH_ABSOLUTE$ + \"|\" + PATH_NOSCHEME$ + \"|\" + PATH_EMPTY$ + \")\") + subexp(\"\\\\?(\" + QUERY$ + \")\") + \"?\" + subexp(\"\\\\#(\" + FRAGMENT$ + \")\") + \"?$\",\n\t\tABSOLUTE_REF$ = \"^(\" + SCHEME$ + \")\\\\:\" + subexp(subexp(\"\\\\/\\\\/(\" + subexp(\"(\" + USERINFO$ + \")@\") + \"?(\" + HOST$ + \")\" + subexp(\"\\\\:(\" + PORT$ + \")\") + \"?)\") + \"?(\" + PATH_ABEMPTY$ + \"|\" + PATH_ABSOLUTE$ + \"|\" + PATH_ROOTLESS$ + \"|\" + PATH_EMPTY$ + \")\") + subexp(\"\\\\?(\" + QUERY$ + \")\") + \"?$\",\n\t\tSAMEDOC_REF$ = \"^\" + subexp(\"\\\\#(\" + FRAGMENT$ + \")\") + \"?$\",\n\t\tAUTHORITY_REF$ = \"^\" + subexp(\"(\" + USERINFO$ + \")@\") + \"?(\" + HOST$ + \")\" + subexp(\"\\\\:(\" + PORT$ + \")\") + \"?$\"\n\t;\n\n\treturn {\n\t\tNOT_SCHEME : new RegExp(merge(\"[^]\", ALPHA$$, DIGIT$$, \"[\\\\+\\\\-\\\\.]\"), \"g\"),\n\t\tNOT_USERINFO : new RegExp(merge(\"[^\\\\%\\\\:]\", UNRESERVED$$, SUB_DELIMS$$), \"g\"),\n\t\tNOT_HOST : new RegExp(merge(\"[^\\\\%\\\\[\\\\]\\\\:]\", UNRESERVED$$, SUB_DELIMS$$), \"g\"),\n\t\tNOT_PATH : new RegExp(merge(\"[^\\\\%\\\\/\\\\:\\\\@]\", UNRESERVED$$, SUB_DELIMS$$), \"g\"),\n\t\tNOT_PATH_NOSCHEME : new RegExp(merge(\"[^\\\\%\\\\/\\\\@]\", UNRESERVED$$, SUB_DELIMS$$), \"g\"),\n\t\tNOT_QUERY : new RegExp(merge(\"[^\\\\%]\", UNRESERVED$$, SUB_DELIMS$$, \"[\\\\:\\\\@\\\\/\\\\?]\", IPRIVATE$$), \"g\"),\n\t\tNOT_FRAGMENT : new RegExp(merge(\"[^\\\\%]\", UNRESERVED$$, SUB_DELIMS$$, \"[\\\\:\\\\@\\\\/\\\\?]\"), \"g\"),\n\t\tESCAPE : new RegExp(merge(\"[^]\", UNRESERVED$$, SUB_DELIMS$$), \"g\"),\n\t\tUNRESERVED : new RegExp(UNRESERVED$$, \"g\"),\n\t\tOTHER_CHARS : new RegExp(merge(\"[^\\\\%]\", UNRESERVED$$, RESERVED$$), \"g\"),\n\t\tPCT_ENCODED : new RegExp(PCT_ENCODED$, \"g\"),\n\t\tIPV4ADDRESS : new RegExp(\"^(\" + IPV4ADDRESS$ + \")$\"),\n\t\tIPV6ADDRESS : new RegExp(\"^\\\\[?(\" + IPV6ADDRESS$ + \")\" + subexp(subexp(\"\\\\%25|\\\\%(?!\" + HEXDIG$$ + \"{2})\") + \"(\" + ZONEID$ + \")\") + \"?\\\\]?$\")  //RFC 6874, with relaxed parsing rules\n\t};\n}\n\nexport default buildExps(false);\n","import { URIRegExps } from \"./uri\";\nimport { buildExps } from \"./regexps-uri\";\n\nexport default buildExps(true);\n","'use strict';\n\n/** Highest positive signed 32-bit float value */\nconst maxInt = 2147483647; // aka. 0x7FFFFFFF or 2^31-1\n\n/** Bootstring parameters */\nconst base = 36;\nconst tMin = 1;\nconst tMax = 26;\nconst skew = 38;\nconst damp = 700;\nconst initialBias = 72;\nconst initialN = 128; // 0x80\nconst delimiter = '-'; // '\\x2D'\n\n/** Regular expressions */\nconst regexPunycode = /^xn--/;\nconst regexNonASCII = /[^\\0-\\x7E]/; // non-ASCII chars\nconst regexSeparators = /[\\x2E\\u3002\\uFF0E\\uFF61]/g; // RFC 3490 separators\n\n/** Error messages */\nconst errors = {\n\t'overflow': 'Overflow: input needs wider integers to process',\n\t'not-basic': 'Illegal input >= 0x80 (not a basic code point)',\n\t'invalid-input': 'Invalid input'\n};\n\n/** Convenience shortcuts */\nconst baseMinusTMin = base - tMin;\nconst floor = Math.floor;\nconst stringFromCharCode = String.fromCharCode;\n\n/*--------------------------------------------------------------------------*/\n\n/**\n * A generic error utility function.\n * @private\n * @param {String} type The error type.\n * @returns {Error} Throws a `RangeError` with the applicable error message.\n */\nfunction error(type) {\n\tthrow new RangeError(errors[type]);\n}\n\n/**\n * A generic `Array#map` utility function.\n * @private\n * @param {Array} array The array to iterate over.\n * @param {Function} callback The function that gets called for every array\n * item.\n * @returns {Array} A new array of values returned by the callback function.\n */\nfunction map(array, fn) {\n\tconst result = [];\n\tlet length = array.length;\n\twhile (length--) {\n\t\tresult[length] = fn(array[length]);\n\t}\n\treturn result;\n}\n\n/**\n * A simple `Array#map`-like wrapper to work with domain name strings or email\n * addresses.\n * @private\n * @param {String} domain The domain name or email address.\n * @param {Function} callback The function that gets called for every\n * character.\n * @returns {Array} A new string of characters returned by the callback\n * function.\n */\nfunction mapDomain(string, fn) {\n\tconst parts = string.split('@');\n\tlet result = '';\n\tif (parts.length > 1) {\n\t\t// In email addresses, only the domain name should be punycoded. Leave\n\t\t// the local part (i.e. everything up to `@`) intact.\n\t\tresult = parts[0] + '@';\n\t\tstring = parts[1];\n\t}\n\t// Avoid `split(regex)` for IE8 compatibility. See #17.\n\tstring = string.replace(regexSeparators, '\\x2E');\n\tconst labels = string.split('.');\n\tconst encoded = map(labels, fn).join('.');\n\treturn result + encoded;\n}\n\n/**\n * Creates an array containing the numeric code points of each Unicode\n * character in the string. While JavaScript uses UCS-2 internally,\n * this function will convert a pair of surrogate halves (each of which\n * UCS-2 exposes as separate characters) into a single code point,\n * matching UTF-16.\n * @see `punycode.ucs2.encode`\n * @see <https://mathiasbynens.be/notes/javascript-encoding>\n * @memberOf punycode.ucs2\n * @name decode\n * @param {String} string The Unicode input string (UCS-2).\n * @returns {Array} The new array of code points.\n */\nfunction ucs2decode(string) {\n\tconst output = [];\n\tlet counter = 0;\n\tconst length = string.length;\n\twhile (counter < length) {\n\t\tconst value = string.charCodeAt(counter++);\n\t\tif (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n\t\t\t// It's a high surrogate, and there is a next character.\n\t\t\tconst extra = string.charCodeAt(counter++);\n\t\t\tif ((extra & 0xFC00) == 0xDC00) { // Low surrogate.\n\t\t\t\toutput.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n\t\t\t} else {\n\t\t\t\t// It's an unmatched surrogate; only append this code unit, in case the\n\t\t\t\t// next code unit is the high surrogate of a surrogate pair.\n\t\t\t\toutput.push(value);\n\t\t\t\tcounter--;\n\t\t\t}\n\t\t} else {\n\t\t\toutput.push(value);\n\t\t}\n\t}\n\treturn output;\n}\n\n/**\n * Creates a string based on an array of numeric code points.\n * @see `punycode.ucs2.decode`\n * @memberOf punycode.ucs2\n * @name encode\n * @param {Array} codePoints The array of numeric code points.\n * @returns {String} The new Unicode string (UCS-2).\n */\nconst ucs2encode = array => String.fromCodePoint(...array);\n\n/**\n * Converts a basic code point into a digit/integer.\n * @see `digitToBasic()`\n * @private\n * @param {Number} codePoint The basic numeric code point value.\n * @returns {Number} The numeric value of a basic code point (for use in\n * representing integers) in the range `0` to `base - 1`, or `base` if\n * the code point does not represent a value.\n */\nconst basicToDigit = function(codePoint) {\n\tif (codePoint - 0x30 < 0x0A) {\n\t\treturn codePoint - 0x16;\n\t}\n\tif (codePoint - 0x41 < 0x1A) {\n\t\treturn codePoint - 0x41;\n\t}\n\tif (codePoint - 0x61 < 0x1A) {\n\t\treturn codePoint - 0x61;\n\t}\n\treturn base;\n};\n\n/**\n * Converts a digit/integer into a basic code point.\n * @see `basicToDigit()`\n * @private\n * @param {Number} digit The numeric value of a basic code point.\n * @returns {Number} The basic code point whose value (when used for\n * representing integers) is `digit`, which needs to be in the range\n * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is\n * used; else, the lowercase form is used. The behavior is undefined\n * if `flag` is non-zero and `digit` has no uppercase form.\n */\nconst digitToBasic = function(digit, flag) {\n\t//  0..25 map to ASCII a..z or A..Z\n\t// 26..35 map to ASCII 0..9\n\treturn digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);\n};\n\n/**\n * Bias adaptation function as per section 3.4 of RFC 3492.\n * https://tools.ietf.org/html/rfc3492#section-3.4\n * @private\n */\nconst adapt = function(delta, numPoints, firstTime) {\n\tlet k = 0;\n\tdelta = firstTime ? floor(delta / damp) : delta >> 1;\n\tdelta += floor(delta / numPoints);\n\tfor (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {\n\t\tdelta = floor(delta / baseMinusTMin);\n\t}\n\treturn floor(k + (baseMinusTMin + 1) * delta / (delta + skew));\n};\n\n/**\n * Converts a Punycode string of ASCII-only symbols to a string of Unicode\n * symbols.\n * @memberOf punycode\n * @param {String} input The Punycode string of ASCII-only symbols.\n * @returns {String} The resulting string of Unicode symbols.\n */\nconst decode = function(input) {\n\t// Don't use UCS-2.\n\tconst output = [];\n\tconst inputLength = input.length;\n\tlet i = 0;\n\tlet n = initialN;\n\tlet bias = initialBias;\n\n\t// Handle the basic code points: let `basic` be the number of input code\n\t// points before the last delimiter, or `0` if there is none, then copy\n\t// the first basic code points to the output.\n\n\tlet basic = input.lastIndexOf(delimiter);\n\tif (basic < 0) {\n\t\tbasic = 0;\n\t}\n\n\tfor (let j = 0; j < basic; ++j) {\n\t\t// if it's not a basic code point\n\t\tif (input.charCodeAt(j) >= 0x80) {\n\t\t\terror('not-basic');\n\t\t}\n\t\toutput.push(input.charCodeAt(j));\n\t}\n\n\t// Main decoding loop: start just after the last delimiter if any basic code\n\t// points were copied; start at the beginning otherwise.\n\n\tfor (let index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {\n\n\t\t// `index` is the index of the next character to be consumed.\n\t\t// Decode a generalized variable-length integer into `delta`,\n\t\t// which gets added to `i`. The overflow checking is easier\n\t\t// if we increase `i` as we go, then subtract off its starting\n\t\t// value at the end to obtain `delta`.\n\t\tlet oldi = i;\n\t\tfor (let w = 1, k = base; /* no condition */; k += base) {\n\n\t\t\tif (index >= inputLength) {\n\t\t\t\terror('invalid-input');\n\t\t\t}\n\n\t\t\tconst digit = basicToDigit(input.charCodeAt(index++));\n\n\t\t\tif (digit >= base || digit > floor((maxInt - i) / w)) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\n\t\t\ti += digit * w;\n\t\t\tconst t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\n\t\t\tif (digit < t) {\n\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\tconst baseMinusT = base - t;\n\t\t\tif (w > floor(maxInt / baseMinusT)) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\n\t\t\tw *= baseMinusT;\n\n\t\t}\n\n\t\tconst out = output.length + 1;\n\t\tbias = adapt(i - oldi, out, oldi == 0);\n\n\t\t// `i` was supposed to wrap around from `out` to `0`,\n\t\t// incrementing `n` each time, so we'll fix that now:\n\t\tif (floor(i / out) > maxInt - n) {\n\t\t\terror('overflow');\n\t\t}\n\n\t\tn += floor(i / out);\n\t\ti %= out;\n\n\t\t// Insert `n` at position `i` of the output.\n\t\toutput.splice(i++, 0, n);\n\n\t}\n\n\treturn String.fromCodePoint(...output);\n};\n\n/**\n * Converts a string of Unicode symbols (e.g. a domain name label) to a\n * Punycode string of ASCII-only symbols.\n * @memberOf punycode\n * @param {String} input The string of Unicode symbols.\n * @returns {String} The resulting Punycode string of ASCII-only symbols.\n */\nconst encode = function(input) {\n\tconst output = [];\n\n\t// Convert the input in UCS-2 to an array of Unicode code points.\n\tinput = ucs2decode(input);\n\n\t// Cache the length.\n\tlet inputLength = input.length;\n\n\t// Initialize the state.\n\tlet n = initialN;\n\tlet delta = 0;\n\tlet bias = initialBias;\n\n\t// Handle the basic code points.\n\tfor (const currentValue of input) {\n\t\tif (currentValue < 0x80) {\n\t\t\toutput.push(stringFromCharCode(currentValue));\n\t\t}\n\t}\n\n\tlet basicLength = output.length;\n\tlet handledCPCount = basicLength;\n\n\t// `handledCPCount` is the number of code points that have been handled;\n\t// `basicLength` is the number of basic code points.\n\n\t// Finish the basic string with a delimiter unless it's empty.\n\tif (basicLength) {\n\t\toutput.push(delimiter);\n\t}\n\n\t// Main encoding loop:\n\twhile (handledCPCount < inputLength) {\n\n\t\t// All non-basic code points < n have been handled already. Find the next\n\t\t// larger one:\n\t\tlet m = maxInt;\n\t\tfor (const currentValue of input) {\n\t\t\tif (currentValue >= n && currentValue < m) {\n\t\t\t\tm = currentValue;\n\t\t\t}\n\t\t}\n\n\t\t// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,\n\t\t// but guard against overflow.\n\t\tconst handledCPCountPlusOne = handledCPCount + 1;\n\t\tif (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {\n\t\t\terror('overflow');\n\t\t}\n\n\t\tdelta += (m - n) * handledCPCountPlusOne;\n\t\tn = m;\n\n\t\tfor (const currentValue of input) {\n\t\t\tif (currentValue < n && ++delta > maxInt) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\t\t\tif (currentValue == n) {\n\t\t\t\t// Represent delta as a generalized variable-length integer.\n\t\t\t\tlet q = delta;\n\t\t\t\tfor (let k = base; /* no condition */; k += base) {\n\t\t\t\t\tconst t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\t\t\t\t\tif (q < t) {\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t\tconst qMinusT = q - t;\n\t\t\t\t\tconst baseMinusT = base - t;\n\t\t\t\t\toutput.push(\n\t\t\t\t\t\tstringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))\n\t\t\t\t\t);\n\t\t\t\t\tq = floor(qMinusT / baseMinusT);\n\t\t\t\t}\n\n\t\t\t\toutput.push(stringFromCharCode(digitToBasic(q, 0)));\n\t\t\t\tbias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);\n\t\t\t\tdelta = 0;\n\t\t\t\t++handledCPCount;\n\t\t\t}\n\t\t}\n\n\t\t++delta;\n\t\t++n;\n\n\t}\n\treturn output.join('');\n};\n\n/**\n * Converts a Punycode string representing a domain name or an email address\n * to Unicode. Only the Punycoded parts of the input will be converted, i.e.\n * it doesn't matter if you call it on a string that has already been\n * converted to Unicode.\n * @memberOf punycode\n * @param {String} input The Punycoded domain name or email address to\n * convert to Unicode.\n * @returns {String} The Unicode representation of the given Punycode\n * string.\n */\nconst toUnicode = function(input) {\n\treturn mapDomain(input, function(string) {\n\t\treturn regexPunycode.test(string)\n\t\t\t? decode(string.slice(4).toLowerCase())\n\t\t\t: string;\n\t});\n};\n\n/**\n * Converts a Unicode string representing a domain name or an email address to\n * Punycode. Only the non-ASCII parts of the domain name will be converted,\n * i.e. it doesn't matter if you call it with a domain that's already in\n * ASCII.\n * @memberOf punycode\n * @param {String} input The domain name or email address to convert, as a\n * Unicode string.\n * @returns {String} The Punycode representation of the given domain name or\n * email address.\n */\nconst toASCII = function(input) {\n\treturn mapDomain(input, function(string) {\n\t\treturn regexNonASCII.test(string)\n\t\t\t? 'xn--' + encode(string)\n\t\t\t: string;\n\t});\n};\n\n/*--------------------------------------------------------------------------*/\n\n/** Define the public API */\nconst punycode = {\n\t/**\n\t * A string representing the current Punycode.js version number.\n\t * @memberOf punycode\n\t * @type String\n\t */\n\t'version': '2.1.0',\n\t/**\n\t * An object of methods to convert from JavaScript's internal character\n\t * representation (UCS-2) to Unicode code points, and back.\n\t * @see <https://mathiasbynens.be/notes/javascript-encoding>\n\t * @memberOf punycode\n\t * @type Object\n\t */\n\t'ucs2': {\n\t\t'decode': ucs2decode,\n\t\t'encode': ucs2encode\n\t},\n\t'decode': decode,\n\t'encode': encode,\n\t'toASCII': toASCII,\n\t'toUnicode': toUnicode\n};\n\nexport default punycode;\n","/**\n * URI.js\n *\n * @fileoverview An RFC 3986 compliant, scheme extendable URI parsing/validating/resolving library for JavaScript.\n * @author <a href=\"mailto:gary.court@gmail.com\">Gary Court</a>\n * @see http://github.com/garycourt/uri-js\n */\n\n/**\n * Copyright 2011 Gary Court. All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without modification, are\n * permitted provided that the following conditions are met:\n *\n *    1. Redistributions of source code must retain the above copyright notice, this list of\n *       conditions and the following disclaimer.\n *\n *    2. Redistributions in binary form must reproduce the above copyright notice, this list\n *       of conditions and the following disclaimer in the documentation and/or other materials\n *       provided with the distribution.\n *\n * THIS SOFTWARE IS PROVIDED BY GARY COURT ``AS IS'' AND ANY EXPRESS OR IMPLIED\n * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND\n * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GARY COURT OR\n * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\n * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON\n * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING\n * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF\n * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n *\n * The views and conclusions contained in the software and documentation are those of the\n * authors and should not be interpreted as representing official policies, either expressed\n * or implied, of Gary Court.\n */\n\nimport URI_PROTOCOL from \"./regexps-uri\";\nimport IRI_PROTOCOL from \"./regexps-iri\";\nimport punycode from \"punycode\";\nimport { toUpperCase, typeOf, assign } from \"./util\";\n\nexport interface URIComponents {\n\tscheme?:string;\n\tuserinfo?:string;\n\thost?:string;\n\tport?:number|string;\n\tpath?:string;\n\tquery?:string;\n\tfragment?:string;\n\treference?:string;\n\terror?:string;\n}\n\nexport interface URIOptions {\n\tscheme?:string;\n\treference?:string;\n\ttolerant?:boolean;\n\tabsolutePath?:boolean;\n\tiri?:boolean;\n\tunicodeSupport?:boolean;\n\tdomainHost?:boolean;\n}\n\nexport interface URISchemeHandler<Components extends URIComponents = URIComponents, Options extends URIOptions = URIOptions, ParentComponents extends URIComponents = URIComponents> {\n\tscheme:string;\n\tparse(components:ParentComponents, options:Options):Components;\n\tserialize(components:Components, options:Options):ParentComponents;\n\tunicodeSupport?:boolean;\n\tdomainHost?:boolean;\n\tabsolutePath?:boolean;\n}\n\nexport interface URIRegExps {\n\tNOT_SCHEME : RegExp,\n\tNOT_USERINFO : RegExp,\n\tNOT_HOST : RegExp,\n\tNOT_PATH : RegExp,\n\tNOT_PATH_NOSCHEME : RegExp,\n\tNOT_QUERY : RegExp,\n\tNOT_FRAGMENT : RegExp,\n\tESCAPE : RegExp,\n\tUNRESERVED : RegExp,\n\tOTHER_CHARS : RegExp,\n\tPCT_ENCODED : RegExp,\n\tIPV4ADDRESS : RegExp,\n\tIPV6ADDRESS : RegExp,\n}\n\nexport const SCHEMES:{[scheme:string]:URISchemeHandler} = {};\n\nexport function pctEncChar(chr:string):string {\n\tconst c = chr.charCodeAt(0);\n\tlet e:string;\n\n\tif (c < 16) e = \"%0\" + c.toString(16).toUpperCase();\n\telse if (c < 128) e = \"%\" + c.toString(16).toUpperCase();\n\telse if (c < 2048) e = \"%\" + ((c >> 6) | 192).toString(16).toUpperCase() + \"%\" + ((c & 63) | 128).toString(16).toUpperCase();\n\telse e = \"%\" + ((c >> 12) | 224).toString(16).toUpperCase() + \"%\" + (((c >> 6) & 63) | 128).toString(16).toUpperCase() + \"%\" + ((c & 63) | 128).toString(16).toUpperCase();\n\n\treturn e;\n}\n\nexport function pctDecChars(str:string):string {\n\tlet newStr = \"\";\n\tlet i = 0;\n\tconst il = str.length;\n\n\twhile (i < il) {\n\t\tconst c = parseInt(str.substr(i + 1, 2), 16);\n\n\t\tif (c < 128) {\n\t\t\tnewStr += String.fromCharCode(c);\n\t\t\ti += 3;\n\t\t}\n\t\telse if (c >= 194 && c < 224) {\n\t\t\tif ((il - i) >= 6) {\n\t\t\t\tconst c2 = parseInt(str.substr(i + 4, 2), 16);\n\t\t\t\tnewStr += String.fromCharCode(((c & 31) << 6) | (c2 & 63));\n\t\t\t} else {\n\t\t\t\tnewStr += str.substr(i, 6);\n\t\t\t}\n\t\t\ti += 6;\n\t\t}\n\t\telse if (c >= 224) {\n\t\t\tif ((il - i) >= 9) {\n\t\t\t\tconst c2 = parseInt(str.substr(i + 4, 2), 16);\n\t\t\t\tconst c3 = parseInt(str.substr(i + 7, 2), 16);\n\t\t\t\tnewStr += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));\n\t\t\t} else {\n\t\t\t\tnewStr += str.substr(i, 9);\n\t\t\t}\n\t\t\ti += 9;\n\t\t}\n\t\telse {\n\t\t\tnewStr += str.substr(i, 3);\n\t\t\ti += 3;\n\t\t}\n\t}\n\n\treturn newStr;\n}\n\nfunction _normalizeComponentEncoding(components:URIComponents, protocol:URIRegExps) {\n\tfunction decodeUnreserved(str:string):string {\n\t\tconst decStr = pctDecChars(str);\n\t\treturn (!decStr.match(protocol.UNRESERVED) ? str : decStr);\n\t}\n\n\tif (components.scheme) components.scheme = String(components.scheme).replace(protocol.PCT_ENCODED, decodeUnreserved).toLowerCase().replace(protocol.NOT_SCHEME, \"\");\n\tif (components.userinfo !== undefined) components.userinfo = String(components.userinfo).replace(protocol.PCT_ENCODED, decodeUnreserved).replace(protocol.NOT_USERINFO, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);\n\tif (components.host !== undefined) components.host = String(components.host).replace(protocol.PCT_ENCODED, decodeUnreserved).toLowerCase().replace(protocol.NOT_HOST, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);\n\tif (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);\n\tif (components.query !== undefined) components.query = String(components.query).replace(protocol.PCT_ENCODED, decodeUnreserved).replace(protocol.NOT_QUERY, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);\n\tif (components.fragment !== undefined) components.fragment = String(components.fragment).replace(protocol.PCT_ENCODED, decodeUnreserved).replace(protocol.NOT_FRAGMENT, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);\n\n\treturn components;\n};\n\nfunction _stripLeadingZeros(str:string):string {\n\treturn str.replace(/^0*(.*)/, \"$1\") || \"0\";\n}\n\nfunction _normalizeIPv4(host:string, protocol:URIRegExps):string {\n\tconst matches = host.match(protocol.IPV4ADDRESS) || [];\n\tconst [, address] = matches;\n\t\n\tif (address) {\n\t\treturn address.split(\".\").map(_stripLeadingZeros).join(\".\");\n\t} else {\n\t\treturn host;\n\t}\n}\n\nfunction _normalizeIPv6(host:string, protocol:URIRegExps):string {\n\tconst matches = host.match(protocol.IPV6ADDRESS) || [];\n\tconst [, address, zone] = matches;\n\n\tif (address) {\n\t\tconst [last, first] = address.toLowerCase().split('::').reverse();\n\t\tconst firstFields = first ? first.split(\":\").map(_stripLeadingZeros) : [];\n\t\tconst lastFields = last.split(\":\").map(_stripLeadingZeros);\n\t\tconst isLastFieldIPv4Address = protocol.IPV4ADDRESS.test(lastFields[lastFields.length - 1]);\n\t\tconst fieldCount = isLastFieldIPv4Address ? 7 : 8;\n\t\tconst lastFieldsStart = lastFields.length - fieldCount;\n\t\tconst fields = Array<string>(fieldCount);\n\n\t\tfor (let x = 0; x < fieldCount; ++x) {\n\t\t\tfields[x] = firstFields[x] || lastFields[lastFieldsStart + x] || '';\n\t\t}\n\n\t\tif (isLastFieldIPv4Address) {\n\t\t\tfields[fieldCount - 1] = _normalizeIPv4(fields[fieldCount - 1], protocol);\n\t\t}\n\n\t\tconst allZeroFields = fields.reduce<Array<{index:number,length:number}>>((acc, field, index) => {\n\t\t\tif (!field || field === \"0\") {\n\t\t\t\tconst lastLongest = acc[acc.length - 1];\n\t\t\t\tif (lastLongest && lastLongest.index + lastLongest.length === index) {\n\t\t\t\t\tlastLongest.length++;\n\t\t\t\t} else {\n\t\t\t\t\tacc.push({ index, length : 1 });\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn acc;\n\t\t}, []);\n\n\t\tconst longestZeroFields = allZeroFields.sort((a, b) => b.length - a.length)[0];\n\n\t\tlet newHost:string;\n\t\tif (longestZeroFields && longestZeroFields.length > 1) {\n\t\t\tconst newFirst = fields.slice(0, longestZeroFields.index) ;\n\t\t\tconst newLast = fields.slice(longestZeroFields.index + longestZeroFields.length);\n\t\t\tnewHost = newFirst.join(\":\") + \"::\" + newLast.join(\":\");\n\t\t} else {\n\t\t\tnewHost = fields.join(\":\");\n\t\t}\n\n\t\tif (zone) {\n\t\t\tnewHost += \"%\" + zone;\n\t\t}\n\n\t\treturn newHost;\n\t} else {\n\t\treturn host;\n\t}\n}\n\nconst URI_PARSE = /^(?:([^:\\/?#]+):)?(?:\\/\\/((?:([^\\/?#@]*)@)?(\\[[^\\/?#\\]]+\\]|[^\\/?#:]*)(?:\\:(\\d*))?))?([^?#]*)(?:\\?([^#]*))?(?:#((?:.|\\n|\\r)*))?/i;\nconst NO_MATCH_IS_UNDEFINED = (<RegExpMatchArray>(\"\").match(/(){0}/))[1] === undefined;\n\nexport function parse(uriString:string, options:URIOptions = {}):URIComponents {\n\tconst components:URIComponents = {};\n\tconst protocol = (options.iri !== false ? IRI_PROTOCOL : URI_PROTOCOL);\n\n\tif (options.reference === \"suffix\") uriString = (options.scheme ? options.scheme + \":\" : \"\") + \"//\" + uriString;\n\n\tconst matches = uriString.match(URI_PARSE);\n\n\tif (matches) {\n\t\tif (NO_MATCH_IS_UNDEFINED) {\n\t\t\t//store each component\n\t\t\tcomponents.scheme = matches[1];\n\t\t\tcomponents.userinfo = matches[3];\n\t\t\tcomponents.host = matches[4];\n\t\t\tcomponents.port = parseInt(matches[5], 10);\n\t\t\tcomponents.path = matches[6] || \"\";\n\t\t\tcomponents.query = matches[7];\n\t\t\tcomponents.fragment = matches[8];\n\n\t\t\t//fix port number\n\t\t\tif (isNaN(components.port)) {\n\t\t\t\tcomponents.port = matches[5];\n\t\t\t}\n\t\t} else {  //IE FIX for improper RegExp matching\n\t\t\t//store each component\n\t\t\tcomponents.scheme = matches[1] || undefined;\n\t\t\tcomponents.userinfo = (uriString.indexOf(\"@\") !== -1 ? matches[3] : undefined);\n\t\t\tcomponents.host = (uriString.indexOf(\"//\") !== -1 ? matches[4] : undefined);\n\t\t\tcomponents.port = parseInt(matches[5], 10);\n\t\t\tcomponents.path = matches[6] || \"\";\n\t\t\tcomponents.query = (uriString.indexOf(\"?\") !== -1 ? matches[7] : undefined);\n\t\t\tcomponents.fragment = (uriString.indexOf(\"#\") !== -1 ? matches[8] : undefined);\n\n\t\t\t//fix port number\n\t\t\tif (isNaN(components.port)) {\n\t\t\t\tcomponents.port = (uriString.match(/\\/\\/(?:.|\\n)*\\:(?:\\/|\\?|\\#|$)/) ? matches[4] : undefined);\n\t\t\t}\n\t\t}\n\n\t\tif (components.host) {\n\t\t\t//normalize IP hosts\n\t\t\tcomponents.host = _normalizeIPv6(_normalizeIPv4(components.host, protocol), protocol);\n\t\t}\n\n\t\t//determine reference type\n\t\tif (components.scheme === undefined && components.userinfo === undefined && components.host === undefined && components.port === undefined && !components.path && components.query === undefined) {\n\t\t\tcomponents.reference = \"same-document\";\n\t\t} else if (components.scheme === undefined) {\n\t\t\tcomponents.reference = \"relative\";\n\t\t} else if (components.fragment === undefined) {\n\t\t\tcomponents.reference = \"absolute\";\n\t\t} else {\n\t\t\tcomponents.reference = \"uri\";\n\t\t}\n\n\t\t//check for reference errors\n\t\tif (options.reference && options.reference !== \"suffix\" && options.reference !== components.reference) {\n\t\t\tcomponents.error = components.error || \"URI is not a \" + options.reference + \" reference.\";\n\t\t}\n\n\t\t//find scheme handler\n\t\tconst schemeHandler = SCHEMES[(options.scheme || components.scheme || \"\").toLowerCase()];\n\n\t\t//check if scheme can't handle IRIs\n\t\tif (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {\n\t\t\t//if host component is a domain name\n\t\t\tif (components.host && (options.domainHost || (schemeHandler && schemeHandler.domainHost))) {\n\t\t\t\t//convert Unicode IDN -> ASCII IDN\n\t\t\t\ttry {\n\t\t\t\t\tcomponents.host = punycode.toASCII(components.host.replace(protocol.PCT_ENCODED, pctDecChars).toLowerCase());\n\t\t\t\t} catch (e) {\n\t\t\t\t\tcomponents.error = components.error || \"Host's domain name can not be converted to ASCII via punycode: \" + e;\n\t\t\t\t}\n\t\t\t}\n\t\t\t//convert IRI -> URI\n\t\t\t_normalizeComponentEncoding(components, URI_PROTOCOL);\n\t\t} else {\n\t\t\t//normalize encodings\n\t\t\t_normalizeComponentEncoding(components, protocol);\n\t\t}\n\n\t\t//perform scheme specific parsing\n\t\tif (schemeHandler && schemeHandler.parse) {\n\t\t\tschemeHandler.parse(components, options);\n\t\t}\n\t} else {\n\t\tcomponents.error = components.error || \"URI can not be parsed.\";\n\t}\n\n\treturn components;\n};\n\nfunction _recomposeAuthority(components:URIComponents, options:URIOptions):string|undefined {\n\tconst protocol = (options.iri !== false ? IRI_PROTOCOL : URI_PROTOCOL);\n\tconst uriTokens:Array<string> = [];\n\n\tif (components.userinfo !== undefined) {\n\t\turiTokens.push(components.userinfo);\n\t\turiTokens.push(\"@\");\n\t}\n\n\tif (components.host !== undefined) {\n\t\t//normalize IP hosts, add brackets and escape zone separator for IPv6\n\t\turiTokens.push(_normalizeIPv6(_normalizeIPv4(String(components.host), protocol), protocol).replace(protocol.IPV6ADDRESS, (_, $1, $2) => \"[\" + $1 + ($2 ? \"%25\" + $2 : \"\") + \"]\"));\n\t}\n\n\tif (typeof components.port === \"number\" || typeof components.port === \"string\") {\n\t\turiTokens.push(\":\");\n\t\turiTokens.push(String(components.port));\n\t}\n\n\treturn uriTokens.length ? uriTokens.join(\"\") : undefined;\n};\n\nconst RDS1 = /^\\.\\.?\\//;\nconst RDS2 = /^\\/\\.(\\/|$)/;\nconst RDS3 = /^\\/\\.\\.(\\/|$)/;\nconst RDS4 = /^\\.\\.?$/;\nconst RDS5 = /^\\/?(?:.|\\n)*?(?=\\/|$)/;\n\nexport function removeDotSegments(input:string):string {\n\tconst output:Array<string> = [];\n\n\twhile (input.length) {\n\t\tif (input.match(RDS1)) {\n\t\t\tinput = input.replace(RDS1, \"\");\n\t\t} else if (input.match(RDS2)) {\n\t\t\tinput = input.replace(RDS2, \"/\");\n\t\t} else if (input.match(RDS3)) {\n\t\t\tinput = input.replace(RDS3, \"/\");\n\t\t\toutput.pop();\n\t\t} else if (input === \".\" || input === \"..\") {\n\t\t\tinput = \"\";\n\t\t} else {\n\t\t\tconst im = input.match(RDS5);\n\t\t\tif (im) {\n\t\t\t\tconst s = im[0];\n\t\t\t\tinput = input.slice(s.length);\n\t\t\t\toutput.push(s);\n\t\t\t} else {\n\t\t\t\tthrow new Error(\"Unexpected dot segment condition\");\n\t\t\t}\n\t\t}\n\t}\n\n\treturn output.join(\"\");\n};\n\nexport function serialize(components:URIComponents, options:URIOptions = {}):string {\n\tconst protocol = (options.iri ? IRI_PROTOCOL : URI_PROTOCOL);\n\tconst uriTokens:Array<string> = [];\n\n\t//find scheme handler\n\tconst schemeHandler = SCHEMES[(options.scheme || components.scheme || \"\").toLowerCase()];\n\n\t//perform scheme specific serialization\n\tif (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(components, options);\n\n\tif (components.host) {\n\t\t//if host component is an IPv6 address\n\t\tif (protocol.IPV6ADDRESS.test(components.host)) {\n\t\t\t//TODO: normalize IPv6 address as per RFC 5952\n\t\t}\n\n\t\t//if host component is a domain name\n\t\telse if (options.domainHost || (schemeHandler && schemeHandler.domainHost)) {\n\t\t\t//convert IDN via punycode\n\t\t\ttry {\n\t\t\t\tcomponents.host = (!options.iri ? punycode.toASCII(components.host.replace(protocol.PCT_ENCODED, pctDecChars).toLowerCase()) : punycode.toUnicode(components.host));\n\t\t\t} catch (e) {\n\t\t\t\tcomponents.error = components.error || \"Host's domain name can not be converted to \" + (!options.iri ? \"ASCII\" : \"Unicode\") + \" via punycode: \" + e;\n\t\t\t}\n\t\t}\n\t}\n\n\t//normalize encoding\n\t_normalizeComponentEncoding(components, protocol);\n\n\tif (options.reference !== \"suffix\" && components.scheme) {\n\t\turiTokens.push(components.scheme);\n\t\turiTokens.push(\":\");\n\t}\n\n\tconst authority = _recomposeAuthority(components, options);\n\tif (authority !== undefined) {\n\t\tif (options.reference !== \"suffix\") {\n\t\t\turiTokens.push(\"//\");\n\t\t}\n\n\t\turiTokens.push(authority);\n\n\t\tif (components.path && components.path.charAt(0) !== \"/\") {\n\t\t\turiTokens.push(\"/\");\n\t\t}\n\t}\n\n\tif (components.path !== undefined) {\n\t\tlet s = components.path;\n\n\t\tif (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {\n\t\t\ts = removeDotSegments(s);\n\t\t}\n\n\t\tif (authority === undefined) {\n\t\t\ts = s.replace(/^\\/\\//, \"/%2F\");  //don't allow the path to start with \"//\"\n\t\t}\n\n\t\turiTokens.push(s);\n\t}\n\n\tif (components.query !== undefined) {\n\t\turiTokens.push(\"?\");\n\t\turiTokens.push(components.query);\n\t}\n\n\tif (components.fragment !== undefined) {\n\t\turiTokens.push(\"#\");\n\t\turiTokens.push(components.fragment);\n\t}\n\n\treturn uriTokens.join(\"\");  //merge tokens into a string\n};\n\nexport function resolveComponents(base:URIComponents, relative:URIComponents, options:URIOptions = {}, skipNormalization?:boolean):URIComponents {\n\tconst target:URIComponents = {};\n\n\tif (!skipNormalization) {\n\t\tbase = parse(serialize(base, options), options);  //normalize base components\n\t\trelative = parse(serialize(relative, options), options);  //normalize relative components\n\t}\n\toptions = options || {};\n\n\tif (!options.tolerant && relative.scheme) {\n\t\ttarget.scheme = relative.scheme;\n\t\t//target.authority = relative.authority;\n\t\ttarget.userinfo = relative.userinfo;\n\t\ttarget.host = relative.host;\n\t\ttarget.port = relative.port;\n\t\ttarget.path = removeDotSegments(relative.path || \"\");\n\t\ttarget.query = relative.query;\n\t} else {\n\t\tif (relative.userinfo !== undefined || relative.host !== undefined || relative.port !== undefined) {\n\t\t\t//target.authority = relative.authority;\n\t\t\ttarget.userinfo = relative.userinfo;\n\t\t\ttarget.host = relative.host;\n\t\t\ttarget.port = relative.port;\n\t\t\ttarget.path = removeDotSegments(relative.path || \"\");\n\t\t\ttarget.query = relative.query;\n\t\t} else {\n\t\t\tif (!relative.path) {\n\t\t\t\ttarget.path = base.path;\n\t\t\t\tif (relative.query !== undefined) {\n\t\t\t\t\ttarget.query = relative.query;\n\t\t\t\t} else {\n\t\t\t\t\ttarget.query = base.query;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tif (relative.path.charAt(0) === \"/\") {\n\t\t\t\t\ttarget.path = removeDotSegments(relative.path);\n\t\t\t\t} else {\n\t\t\t\t\tif ((base.userinfo !== undefined || base.host !== undefined || base.port !== undefined) && !base.path) {\n\t\t\t\t\t\ttarget.path = \"/\" + relative.path;\n\t\t\t\t\t} else if (!base.path) {\n\t\t\t\t\t\ttarget.path = relative.path;\n\t\t\t\t\t} else {\n\t\t\t\t\t\ttarget.path = base.path.slice(0, base.path.lastIndexOf(\"/\") + 1) + relative.path;\n\t\t\t\t\t}\n\t\t\t\t\ttarget.path = removeDotSegments(target.path);\n\t\t\t\t}\n\t\t\t\ttarget.query = relative.query;\n\t\t\t}\n\t\t\t//target.authority = base.authority;\n\t\t\ttarget.userinfo = base.userinfo;\n\t\t\ttarget.host = base.host;\n\t\t\ttarget.port = base.port;\n\t\t}\n\t\ttarget.scheme = base.scheme;\n\t}\n\n\ttarget.fragment = relative.fragment;\n\n\treturn target;\n};\n\nexport function resolve(baseURI:string, relativeURI:string, options?:URIOptions):string {\n\tconst schemelessOptions = assign({ scheme : 'null' }, options);\n\treturn serialize(resolveComponents(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true), schemelessOptions);\n};\n\nexport function normalize(uri:string, options?:URIOptions):string;\nexport function normalize(uri:URIComponents, options?:URIOptions):URIComponents;\nexport function normalize(uri:any, options?:URIOptions):any {\n\tif (typeof uri === \"string\") {\n\t\turi = serialize(parse(uri, options), options);\n\t} else if (typeOf(uri) === \"object\") {\n\t\turi = parse(serialize(<URIComponents>uri, options), options);\n\t}\n\n\treturn uri;\n};\n\nexport function equal(uriA:string, uriB:string, options?: URIOptions):boolean;\nexport function equal(uriA:URIComponents, uriB:URIComponents, options?:URIOptions):boolean;\nexport function equal(uriA:any, uriB:any, options?:URIOptions):boolean {\n\tif (typeof uriA === \"string\") {\n\t\turiA = serialize(parse(uriA, options), options);\n\t} else if (typeOf(uriA) === \"object\") {\n\t\turiA = serialize(<URIComponents>uriA, options);\n\t}\n\n\tif (typeof uriB === \"string\") {\n\t\turiB = serialize(parse(uriB, options), options);\n\t} else if (typeOf(uriB) === \"object\") {\n\t\turiB = serialize(<URIComponents>uriB, options);\n\t}\n\n\treturn uriA === uriB;\n};\n\nexport function escapeComponent(str:string, options?:URIOptions):string {\n\treturn str && str.toString().replace((!options || !options.iri ? URI_PROTOCOL.ESCAPE : IRI_PROTOCOL.ESCAPE), pctEncChar);\n};\n\nexport function unescapeComponent(str:string, options?:URIOptions):string {\n\treturn str && str.toString().replace((!options || !options.iri ? URI_PROTOCOL.PCT_ENCODED : IRI_PROTOCOL.PCT_ENCODED), pctDecChars);\n};\n","import { URISchemeHandler, URIComponents, URIOptions } from \"../uri\";\n\nconst handler:URISchemeHandler = {\n\tscheme : \"http\",\n\n\tdomainHost : true,\n\n\tparse : function (components:URIComponents, options:URIOptions):URIComponents {\n\t\t//report missing host\n\t\tif (!components.host) {\n\t\t\tcomponents.error = components.error || \"HTTP URIs must have a host.\";\n\t\t}\n\n\t\treturn components;\n\t},\n\n\tserialize : function (components:URIComponents, options:URIOptions):URIComponents {\n\t\tconst secure = String(components.scheme).toLowerCase() === \"https\";\n\n\t\t//normalize the default port\n\t\tif (components.port === (secure ? 443 : 80) || components.port === \"\") {\n\t\t\tcomponents.port = undefined;\n\t\t}\n\t\t\n\t\t//normalize the empty path\n\t\tif (!components.path) {\n\t\t\tcomponents.path = \"/\";\n\t\t}\n\n\t\t//NOTE: We do not parse query strings for HTTP URIs\n\t\t//as WWW Form Url Encoded query strings are part of the HTML4+ spec,\n\t\t//and not the HTTP spec.\n\n\t\treturn components;\n\t}\n};\n\nexport default handler;","import { URISchemeHandler, URIComponents, URIOptions } from \"../uri\";\nimport http from \"./http\";\n\nconst handler:URISchemeHandler = {\n\tscheme : \"https\",\n\tdomainHost : http.domainHost,\n\tparse : http.parse,\n\tserialize : http.serialize\n}\n\nexport default handler;","import { URISchemeHandler, URIComponents, URIOptions } from \"../uri\";\n\nexport interface WSComponents extends URIComponents {\n\tresourceName?: string;\n\tsecure?: boolean;\n}\n\nfunction isSecure(wsComponents:WSComponents):boolean {\n\treturn typeof wsComponents.secure === 'boolean' ? wsComponents.secure : String(wsComponents.scheme).toLowerCase() === \"wss\";\n}\n\n//RFC 6455\nconst handler:URISchemeHandler = {\n\tscheme : \"ws\",\n\n\tdomainHost : true,\n\n\tparse : function (components:URIComponents, options:URIOptions):WSComponents {\n\t\tconst wsComponents = components as WSComponents;\n\n\t\t//indicate if the secure flag is set\n\t\twsComponents.secure = isSecure(wsComponents);\n\n\t\t//construct resouce name\n\t\twsComponents.resourceName = (wsComponents.path || '/') + (wsComponents.query ? '?' + wsComponents.query : '');\n\t\twsComponents.path = undefined;\n\t\twsComponents.query = undefined;\n\n\t\treturn wsComponents;\n\t},\n\n\tserialize : function (wsComponents:WSComponents, options:URIOptions):URIComponents {\n\t\t//normalize the default port\n\t\tif (wsComponents.port === (isSecure(wsComponents) ? 443 : 80) || wsComponents.port === \"\") {\n\t\t\twsComponents.port = undefined;\n\t\t}\n\n\t\t//ensure scheme matches secure flag\n\t\tif (typeof wsComponents.secure === 'boolean') {\n\t\t\twsComponents.scheme = (wsComponents.secure ? 'wss' : 'ws');\n\t\t\twsComponents.secure = undefined;\n\t\t}\n\n\t\t//reconstruct path from resource name\n\t\tif (wsComponents.resourceName) {\n\t\t\tconst [path, query] = wsComponents.resourceName.split('?');\n\t\t\twsComponents.path = (path && path !== '/' ? path : undefined);\n\t\t\twsComponents.query = query;\n\t\t\twsComponents.resourceName = undefined;\n\t\t}\n\n\t\t//forbid fragment component\n\t\twsComponents.fragment = undefined;\n\n\t\treturn wsComponents;\n\t}\n};\n\nexport default handler;","import { URISchemeHandler, URIComponents, URIOptions } from \"../uri\";\nimport ws from \"./ws\";\n\nconst handler:URISchemeHandler = {\n\tscheme : \"wss\",\n\tdomainHost : ws.domainHost,\n\tparse : ws.parse,\n\tserialize : ws.serialize\n}\n\nexport default handler;","import { URISchemeHandler, URIComponents, URIOptions } from \"../uri\";\nimport { pctEncChar, pctDecChars, unescapeComponent } from \"../uri\";\nimport punycode from \"punycode\";\nimport { merge, subexp, toUpperCase, toArray } from \"../util\";\n\nexport interface MailtoHeaders {\n\t[hfname:string]:string\n}\n\nexport interface MailtoComponents extends URIComponents {\n\tto:Array<string>,\n\theaders?:MailtoHeaders,\n\tsubject?:string,\n\tbody?:string\n}\n\nconst O:MailtoHeaders = {};\nconst isIRI = true;\n\n//RFC 3986\nconst UNRESERVED$$ = \"[A-Za-z0-9\\\\-\\\\.\\\\_\\\\~\" + (isIRI ? \"\\\\xA0-\\\\u200D\\\\u2010-\\\\u2029\\\\u202F-\\\\uD7FF\\\\uF900-\\\\uFDCF\\\\uFDF0-\\\\uFFEF\" : \"\") + \"]\";\nconst HEXDIG$$ = \"[0-9A-Fa-f]\";  //case-insensitive\nconst PCT_ENCODED$ = subexp(subexp(\"%[EFef]\" + HEXDIG$$ + \"%\" + HEXDIG$$ + HEXDIG$$ + \"%\" + HEXDIG$$ + HEXDIG$$) + \"|\" + subexp(\"%[89A-Fa-f]\" + HEXDIG$$ + \"%\" + HEXDIG$$ + HEXDIG$$) + \"|\" + subexp(\"%\" + HEXDIG$$ + HEXDIG$$));  //expanded\n\n//RFC 5322, except these symbols as per RFC 6068: @ : / ? # [ ] & ; =\n//const ATEXT$$ = \"[A-Za-z0-9\\\\!\\\\#\\\\$\\\\%\\\\&\\\\'\\\\*\\\\+\\\\-\\\\/\\\\=\\\\?\\\\^\\\\_\\\\`\\\\{\\\\|\\\\}\\\\~]\";\n//const WSP$$ = \"[\\\\x20\\\\x09]\";\n//const OBS_QTEXT$$ = \"[\\\\x01-\\\\x08\\\\x0B\\\\x0C\\\\x0E-\\\\x1F\\\\x7F]\";  //(%d1-8 / %d11-12 / %d14-31 / %d127)\n//const QTEXT$$ = merge(\"[\\\\x21\\\\x23-\\\\x5B\\\\x5D-\\\\x7E]\", OBS_QTEXT$$);  //%d33 / %d35-91 / %d93-126 / obs-qtext\n//const VCHAR$$ = \"[\\\\x21-\\\\x7E]\";\n//const WSP$$ = \"[\\\\x20\\\\x09]\";\n//const OBS_QP$ = subexp(\"\\\\\\\\\" + merge(\"[\\\\x00\\\\x0D\\\\x0A]\", OBS_QTEXT$$));  //%d0 / CR / LF / obs-qtext\n//const FWS$ = subexp(subexp(WSP$$ + \"*\" + \"\\\\x0D\\\\x0A\") + \"?\" + WSP$$ + \"+\");\n//const QUOTED_PAIR$ = subexp(subexp(\"\\\\\\\\\" + subexp(VCHAR$$ + \"|\" + WSP$$)) + \"|\" + OBS_QP$);\n//const QUOTED_STRING$ = subexp('\\\\\"' + subexp(FWS$ + \"?\" + QCONTENT$) + \"*\" + FWS$ + \"?\" + '\\\\\"');\nconst ATEXT$$ = \"[A-Za-z0-9\\\\!\\\\$\\\\%\\\\'\\\\*\\\\+\\\\-\\\\^\\\\_\\\\`\\\\{\\\\|\\\\}\\\\~]\";\nconst QTEXT$$ = \"[\\\\!\\\\$\\\\%\\\\'\\\\(\\\\)\\\\*\\\\+\\\\,\\\\-\\\\.0-9\\\\<\\\\>A-Z\\\\x5E-\\\\x7E]\";\nconst VCHAR$$ = merge(QTEXT$$, \"[\\\\\\\"\\\\\\\\]\");\nconst DOT_ATOM_TEXT$ = subexp(ATEXT$$ + \"+\" + subexp(\"\\\\.\" + ATEXT$$ + \"+\") + \"*\");\nconst QUOTED_PAIR$ = subexp(\"\\\\\\\\\" + VCHAR$$);\nconst QCONTENT$ = subexp(QTEXT$$ + \"|\" + QUOTED_PAIR$);\nconst QUOTED_STRING$ = subexp('\\\\\"' + QCONTENT$ + \"*\" + '\\\\\"');\n\n//RFC 6068\nconst DTEXT_NO_OBS$$ = \"[\\\\x21-\\\\x5A\\\\x5E-\\\\x7E]\";  //%d33-90 / %d94-126\nconst SOME_DELIMS$$ = \"[\\\\!\\\\$\\\\'\\\\(\\\\)\\\\*\\\\+\\\\,\\\\;\\\\:\\\\@]\";\nconst QCHAR$ = subexp(UNRESERVED$$ + \"|\" + PCT_ENCODED$ + \"|\" + SOME_DELIMS$$);\nconst DOMAIN$ = subexp(DOT_ATOM_TEXT$ + \"|\" + \"\\\\[\" + DTEXT_NO_OBS$$ + \"*\" + \"\\\\]\");\nconst LOCAL_PART$ = subexp(DOT_ATOM_TEXT$ + \"|\" + QUOTED_STRING$);\nconst ADDR_SPEC$ = subexp(LOCAL_PART$ + \"\\\\@\" + DOMAIN$);\nconst TO$ = subexp(ADDR_SPEC$ + subexp(\"\\\\,\" + ADDR_SPEC$) + \"*\");\nconst HFNAME$ = subexp(QCHAR$ + \"*\");\nconst HFVALUE$ = HFNAME$;\nconst HFIELD$ = subexp(HFNAME$ + \"\\\\=\" + HFVALUE$);\nconst HFIELDS2$ = subexp(HFIELD$ + subexp(\"\\\\&\" + HFIELD$) + \"*\");\nconst HFIELDS$ = subexp(\"\\\\?\" + HFIELDS2$);\nconst MAILTO_URI = new RegExp(\"^mailto\\\\:\" + TO$ + \"?\" + HFIELDS$ + \"?$\");\n\nconst UNRESERVED = new RegExp(UNRESERVED$$, \"g\");\nconst PCT_ENCODED = new RegExp(PCT_ENCODED$, \"g\");\nconst NOT_LOCAL_PART = new RegExp(merge(\"[^]\", ATEXT$$, \"[\\\\.]\", '[\\\\\"]', VCHAR$$), \"g\");\nconst NOT_DOMAIN = new RegExp(merge(\"[^]\", ATEXT$$, \"[\\\\.]\", \"[\\\\[]\", DTEXT_NO_OBS$$, \"[\\\\]]\"), \"g\");\nconst NOT_HFNAME = new RegExp(merge(\"[^]\", UNRESERVED$$, SOME_DELIMS$$), \"g\");\nconst NOT_HFVALUE = NOT_HFNAME;\nconst TO = new RegExp(\"^\" + TO$ + \"$\");\nconst HFIELDS = new RegExp(\"^\" + HFIELDS2$ + \"$\");\n\nfunction decodeUnreserved(str:string):string {\n\tconst decStr = pctDecChars(str);\n\treturn (!decStr.match(UNRESERVED) ? str : decStr);\n}\n\nconst handler:URISchemeHandler<MailtoComponents> =  {\n\tscheme : \"mailto\",\n\n\tparse : function (components:URIComponents, options:URIOptions):MailtoComponents {\n\t\tconst mailtoComponents = components as MailtoComponents;\n\t\tconst to = mailtoComponents.to = (mailtoComponents.path ? mailtoComponents.path.split(\",\") : []);\n\t\tmailtoComponents.path = undefined;\n\n\t\tif (mailtoComponents.query) {\n\t\t\tlet unknownHeaders = false\n\t\t\tconst headers:MailtoHeaders = {};\n\t\t\tconst hfields = mailtoComponents.query.split(\"&\");\n\n\t\t\tfor (let x = 0, xl = hfields.length; x < xl; ++x) {\n\t\t\t\tconst hfield = hfields[x].split(\"=\");\n\n\t\t\t\tswitch (hfield[0]) {\n\t\t\t\t\tcase \"to\":\n\t\t\t\t\t\tconst toAddrs = hfield[1].split(\",\");\n\t\t\t\t\t\tfor (let x = 0, xl = toAddrs.length; x < xl; ++x) {\n\t\t\t\t\t\t\tto.push(toAddrs[x]);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase \"subject\":\n\t\t\t\t\t\tmailtoComponents.subject = unescapeComponent(hfield[1], options);\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase \"body\":\n\t\t\t\t\t\tmailtoComponents.body = unescapeComponent(hfield[1], options);\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tdefault:\n\t\t\t\t\t\tunknownHeaders = true;\n\t\t\t\t\t\theaders[unescapeComponent(hfield[0], options)] = unescapeComponent(hfield[1], options);\n\t\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (unknownHeaders) mailtoComponents.headers = headers;\n\t\t}\n\n\t\tmailtoComponents.query = undefined;\n\n\t\tfor (let x = 0, xl = to.length; x < xl; ++x) {\n\t\t\tconst addr = to[x].split(\"@\");\n\n\t\t\taddr[0] = unescapeComponent(addr[0]);\n\n\t\t\tif (!options.unicodeSupport) {\n\t\t\t\t//convert Unicode IDN -> ASCII IDN\n\t\t\t\ttry {\n\t\t\t\t\taddr[1] = punycode.toASCII(unescapeComponent(addr[1], options).toLowerCase());\n\t\t\t\t} catch (e) {\n\t\t\t\t\tmailtoComponents.error = mailtoComponents.error || \"Email address's domain name can not be converted to ASCII via punycode: \" + e;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\taddr[1] = unescapeComponent(addr[1], options).toLowerCase();\n\t\t\t}\n\n\t\t\tto[x] = addr.join(\"@\");\n\t\t}\n\n\t\treturn mailtoComponents;\n\t},\n\n\tserialize : function (mailtoComponents:MailtoComponents, options:URIOptions):URIComponents {\n\t\tconst components = mailtoComponents as URIComponents;\n\t\tconst to = toArray(mailtoComponents.to);\n\t\tif (to) {\n\t\t\tfor (let x = 0, xl = to.length; x < xl; ++x) {\n\t\t\t\tconst toAddr = String(to[x]);\n\t\t\t\tconst atIdx = toAddr.lastIndexOf(\"@\");\n\t\t\t\tconst localPart = (toAddr.slice(0, atIdx)).replace(PCT_ENCODED, decodeUnreserved).replace(PCT_ENCODED, toUpperCase).replace(NOT_LOCAL_PART, pctEncChar);\n\t\t\t\tlet domain = toAddr.slice(atIdx + 1);\n\n\t\t\t\t//convert IDN via punycode\n\t\t\t\ttry {\n\t\t\t\t\tdomain = (!options.iri ? punycode.toASCII(unescapeComponent(domain, options).toLowerCase()) : punycode.toUnicode(domain));\n\t\t\t\t} catch (e) {\n\t\t\t\t\tcomponents.error = components.error || \"Email address's domain name can not be converted to \" + (!options.iri ? \"ASCII\" : \"Unicode\") + \" via punycode: \" + e;\n\t\t\t\t}\n\n\t\t\t\tto[x] = localPart + \"@\" + domain;\n\t\t\t}\n\n\t\t\tcomponents.path = to.join(\",\");\n\t\t}\n\n\t\tconst headers = mailtoComponents.headers = mailtoComponents.headers || {};\n\n\t\tif (mailtoComponents.subject) headers[\"subject\"] = mailtoComponents.subject;\n\t\tif (mailtoComponents.body) headers[\"body\"] = mailtoComponents.body;\n\n\t\tconst fields = [];\n\t\tfor (const name in headers) {\n\t\t\tif (headers[name] !== O[name]) {\n\t\t\t\tfields.push(\n\t\t\t\t\tname.replace(PCT_ENCODED, decodeUnreserved).replace(PCT_ENCODED, toUpperCase).replace(NOT_HFNAME, pctEncChar) +\n\t\t\t\t\t\"=\" +\n\t\t\t\t\theaders[name].replace(PCT_ENCODED, decodeUnreserved).replace(PCT_ENCODED, toUpperCase).replace(NOT_HFVALUE, pctEncChar)\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\t\tif (fields.length) {\n\t\t\tcomponents.query = fields.join(\"&\");\n\t\t}\n\n\t\treturn components;\n\t}\n}\n\nexport default handler;","import { URISchemeHandler, URIComponents, URIOptions } from \"../uri\";\nimport { pctEncChar, SCHEMES } from \"../uri\";\n\nexport interface URNComponents extends URIComponents {\n\tnid?:string;\n\tnss?:string;\n}\n\nexport interface URNOptions extends URIOptions {\n\tnid?:string;\n}\n\nconst NID$ = \"(?:[0-9A-Za-z][0-9A-Za-z\\\\-]{1,31})\";\nconst PCT_ENCODED$ = \"(?:\\\\%[0-9A-Fa-f]{2})\";\nconst TRANS$$ = \"[0-9A-Za-z\\\\(\\\\)\\\\+\\\\,\\\\-\\\\.\\\\:\\\\=\\\\@\\\\;\\\\$\\\\_\\\\!\\\\*\\\\'\\\\/\\\\?\\\\#]\";\nconst NSS$ = \"(?:(?:\" + PCT_ENCODED$ + \"|\" + TRANS$$ + \")+)\";\nconst URN_SCHEME = new RegExp(\"^urn\\\\:(\" + NID$ + \")$\");\nconst URN_PATH = new RegExp(\"^(\" + NID$ + \")\\\\:(\" + NSS$ + \")$\");\nconst URN_PARSE = /^([^\\:]+)\\:(.*)/;\nconst URN_EXCLUDED = /[\\x00-\\x20\\\\\\\"\\&\\<\\>\\[\\]\\^\\`\\{\\|\\}\\~\\x7F-\\xFF]/g;\n\n//RFC 2141\nconst handler:URISchemeHandler<URNComponents,URNOptions> = {\n\tscheme : \"urn\",\n\n\tparse : function (components:URIComponents, options:URNOptions):URNComponents {\n\t\tconst matches = components.path && components.path.match(URN_PARSE);\n\t\tlet urnComponents = components as URNComponents;\n\n\t\tif (matches) {\n\t\t\tconst scheme = options.scheme || urnComponents.scheme || \"urn\";\n\t\t\tconst nid = matches[1].toLowerCase();\n\t\t\tconst nss = matches[2];\n\t\t\tconst urnScheme = `${scheme}:${options.nid || nid}`;\n\t\t\tconst schemeHandler = SCHEMES[urnScheme];\n\n\t\t\turnComponents.nid = nid;\n\t\t\turnComponents.nss = nss;\n\t\t\turnComponents.path = undefined;\n\n\t\t\tif (schemeHandler) {\n\t\t\t\turnComponents = schemeHandler.parse(urnComponents, options) as URNComponents;\n\t\t\t}\n\t\t} else {\n\t\t\turnComponents.error = urnComponents.error || \"URN can not be parsed.\";\n\t\t}\n\n\t\treturn urnComponents;\n\t},\n\n\tserialize : function (urnComponents:URNComponents, options:URNOptions):URIComponents {\n\t\tconst scheme = options.scheme || urnComponents.scheme || \"urn\";\n\t\tconst nid = urnComponents.nid;\n\t\tconst urnScheme = `${scheme}:${options.nid || nid}`;\n\t\tconst schemeHandler = SCHEMES[urnScheme];\n\n\t\tif (schemeHandler) {\n\t\t\turnComponents = schemeHandler.serialize(urnComponents, options) as URNComponents;\n\t\t}\n\n\t\tconst uriComponents = urnComponents as URIComponents;\n\t\tconst nss = urnComponents.nss;\n\t\turiComponents.path = `${nid || options.nid}:${nss}`;\n\n\t\treturn uriComponents;\n\t},\n};\n\nexport default handler;","import { URISchemeHandler, URIComponents, URIOptions } from \"../uri\";\nimport { URNComponents } from \"./urn\";\nimport { SCHEMES } from \"../uri\";\n\nexport interface UUIDComponents extends URNComponents {\n\tuuid?: string;\n}\n\nconst UUID = /^[0-9A-Fa-f]{8}(?:\\-[0-9A-Fa-f]{4}){3}\\-[0-9A-Fa-f]{12}$/;\nconst UUID_PARSE = /^[0-9A-Fa-f\\-]{36}/;\n\n//RFC 4122\nconst handler:URISchemeHandler<UUIDComponents, URIOptions, URNComponents> = {\n\tscheme : \"urn:uuid\",\n\n\tparse : function (urnComponents:URNComponents, options:URIOptions):UUIDComponents {\n\t\tconst uuidComponents = urnComponents as UUIDComponents;\n\t\tuuidComponents.uuid = uuidComponents.nss;\n\t\tuuidComponents.nss = undefined;\n\n\t\tif (!options.tolerant && (!uuidComponents.uuid || !uuidComponents.uuid.match(UUID))) {\n\t\t\tuuidComponents.error = uuidComponents.error || \"UUID is not valid.\";\n\t\t}\n\n\t\treturn uuidComponents;\n\t},\n\n\tserialize : function (uuidComponents:UUIDComponents, options:URIOptions):URNComponents {\n\t\tconst urnComponents = uuidComponents as URNComponents;\n\t\t//normalize UUID\n\t\turnComponents.nss = (uuidComponents.uuid || \"\").toLowerCase();\n\t\treturn urnComponents;\n\t},\n};\n\nexport default handler;","import { SCHEMES } from \"./uri\";\n\nimport http from \"./schemes/http\";\nSCHEMES[http.scheme] = http;\n\nimport https from \"./schemes/https\";\nSCHEMES[https.scheme] = https;\n\nimport ws from \"./schemes/ws\";\nSCHEMES[ws.scheme] = ws;\n\nimport wss from \"./schemes/wss\";\nSCHEMES[wss.scheme] = wss;\n\nimport mailto from \"./schemes/mailto\";\nSCHEMES[mailto.scheme] = mailto;\n\nimport urn from \"./schemes/urn\";\nSCHEMES[urn.scheme] = urn;\n\nimport uuid from \"./schemes/urn-uuid\";\nSCHEMES[uuid.scheme] = uuid;\n\nexport * from \"./uri\";\n","'use strict';\n\n// https://mathiasbynens.be/notes/javascript-encoding\n// https://github.com/bestiejs/punycode.js - punycode.ucs2.decode\nmodule.exports = function ucs2length(str) {\n  var length = 0\n    , len = str.length\n    , pos = 0\n    , value;\n  while (pos < len) {\n    length++;\n    value = str.charCodeAt(pos++);\n    if (value >= 0xD800 && value <= 0xDBFF && pos < len) {\n      // high surrogate, and there is a next character\n      value = str.charCodeAt(pos);\n      if ((value & 0xFC00) == 0xDC00) pos++; // low surrogate\n    }\n  }\n  return length;\n};\n","'use strict';\n\nvar traverse = module.exports = function (schema, opts, cb) {\n  // Legacy support for v0.3.1 and earlier.\n  if (typeof opts == 'function') {\n    cb = opts;\n    opts = {};\n  }\n\n  cb = opts.cb || cb;\n  var pre = (typeof cb == 'function') ? cb : cb.pre || function() {};\n  var post = cb.post || function() {};\n\n  _traverse(opts, pre, post, schema, '', schema);\n};\n\n\ntraverse.keywords = {\n  additionalItems: true,\n  items: true,\n  contains: true,\n  additionalProperties: true,\n  propertyNames: true,\n  not: true\n};\n\ntraverse.arrayKeywords = {\n  items: true,\n  allOf: true,\n  anyOf: true,\n  oneOf: true\n};\n\ntraverse.propsKeywords = {\n  definitions: true,\n  properties: true,\n  patternProperties: true,\n  dependencies: true\n};\n\ntraverse.skipKeywords = {\n  default: true,\n  enum: true,\n  const: true,\n  required: true,\n  maximum: true,\n  minimum: true,\n  exclusiveMaximum: true,\n  exclusiveMinimum: true,\n  multipleOf: true,\n  maxLength: true,\n  minLength: true,\n  pattern: true,\n  format: true,\n  maxItems: true,\n  minItems: true,\n  uniqueItems: true,\n  maxProperties: true,\n  minProperties: true\n};\n\n\nfunction _traverse(opts, pre, post, schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) {\n  if (schema && typeof schema == 'object' && !Array.isArray(schema)) {\n    pre(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);\n    for (var key in schema) {\n      var sch = schema[key];\n      if (Array.isArray(sch)) {\n        if (key in traverse.arrayKeywords) {\n          for (var i=0; i<sch.length; i++)\n            _traverse(opts, pre, post, sch[i], jsonPtr + '/' + key + '/' + i, rootSchema, jsonPtr, key, schema, i);\n        }\n      } else if (key in traverse.propsKeywords) {\n        if (sch && typeof sch == 'object') {\n          for (var prop in sch)\n            _traverse(opts, pre, post, sch[prop], jsonPtr + '/' + key + '/' + escapeJsonPtr(prop), rootSchema, jsonPtr, key, schema, prop);\n        }\n      } else if (key in traverse.keywords || (opts.allKeys && !(key in traverse.skipKeywords))) {\n        _traverse(opts, pre, post, sch, jsonPtr + '/' + key, rootSchema, jsonPtr, key, schema);\n      }\n    }\n    post(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);\n  }\n}\n\n\nfunction escapeJsonPtr(str) {\n  return str.replace(/~/g, '~0').replace(/\\//g, '~1');\n}\n","'use strict';\n\n\nvar Cache = module.exports = function Cache() {\n  this._cache = {};\n};\n\n\nCache.prototype.put = function Cache_put(key, value) {\n  this._cache[key] = value;\n};\n\n\nCache.prototype.get = function Cache_get(key) {\n  return this._cache[key];\n};\n\n\nCache.prototype.del = function Cache_del(key) {\n  delete this._cache[key];\n};\n\n\nCache.prototype.clear = function Cache_clear() {\n  this._cache = {};\n};\n","'use strict';\n\nvar util = require('./util');\n\nvar DATE = /^(\\d\\d\\d\\d)-(\\d\\d)-(\\d\\d)$/;\nvar DAYS = [0,31,28,31,30,31,30,31,31,30,31,30,31];\nvar TIME = /^(\\d\\d):(\\d\\d):(\\d\\d)(\\.\\d+)?(z|[+-]\\d\\d(?::?\\d\\d)?)?$/i;\nvar 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;\nvar 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;\nvar 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;\n// uri-template: https://tools.ietf.org/html/rfc6570\nvar 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;\n// For the source: https://gist.github.com/dperini/729294\n// For test cases: https://mathiasbynens.be/demo/url-regex\n// @todo Delete current URL in favour of the commented out URL rule when this issue is fixed https://github.com/eslint/eslint/issues/7983.\n// 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;\nvar 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-9a-z\\xA1-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF])+-)*(?:[0-9a-z\\xA1-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF])+)(?:\\.(?:(?:[0-9a-z\\xA1-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF])+-)*(?:[0-9a-z\\xA1-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF])+)*(?:\\.(?:(?:[a-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;\nvar UUID = /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i;\nvar JSON_POINTER = /^(?:\\/(?:[^~/]|~0|~1)*)*$/;\nvar JSON_POINTER_URI_FRAGMENT = /^#(?:\\/(?:[a-z0-9_\\-.!$&'()*+,;:=@]|%[0-9a-f]{2}|~0|~1)*)*$/i;\nvar RELATIVE_JSON_POINTER = /^(?:0|[1-9][0-9]*)(?:#|(?:\\/(?:[^~/]|~0|~1)*)*)$/;\n\n\nmodule.exports = formats;\n\nfunction formats(mode) {\n  mode = mode == 'full' ? 'full' : 'fast';\n  return util.copy(formats[mode]);\n}\n\n\nformats.fast = {\n  // date: http://tools.ietf.org/html/rfc3339#section-5.6\n  date: /^\\d\\d\\d\\d-[0-1]\\d-[0-3]\\d$/,\n  // date-time: http://tools.ietf.org/html/rfc3339#section-5.6\n  time: /^(?:[0-2]\\d:[0-5]\\d:[0-5]\\d|23:59:60)(?:\\.\\d+)?(?:z|[+-]\\d\\d(?::?\\d\\d)?)?$/i,\n  '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,\n  // uri: https://github.com/mafintosh/is-my-json-valid/blob/master/formats.js\n  uri: /^(?:[a-z][a-z0-9+\\-.]*:)(?:\\/?\\/)?[^\\s]*$/i,\n  'uri-reference': /^(?:(?:[a-z][a-z0-9+\\-.]*:)?\\/?\\/)?(?:[^\\\\\\s#][^\\s#]*)?(?:#[^\\\\\\s]*)?$/i,\n  'uri-template': URITEMPLATE,\n  url: URL,\n  // email (sources from jsen validator):\n  // http://stackoverflow.com/questions/201323/using-a-regular-expression-to-validate-an-email-address#answer-8829363\n  // http://www.w3.org/TR/html5/forms.html#valid-e-mail-address (search for 'willful violation')\n  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,\n  hostname: HOSTNAME,\n  // optimized https://www.safaribooksonline.com/library/view/regular-expressions-cookbook/9780596802837/ch07s16.html\n  ipv4: /^(?:(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)$/,\n  // optimized http://stackoverflow.com/questions/53497/regular-expression-that-matches-valid-ipv6-addresses\n  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,\n  regex: regex,\n  // uuid: http://tools.ietf.org/html/rfc4122\n  uuid: UUID,\n  // JSON-pointer: https://tools.ietf.org/html/rfc6901\n  // uri fragment: https://tools.ietf.org/html/rfc3986#appendix-A\n  'json-pointer': JSON_POINTER,\n  'json-pointer-uri-fragment': JSON_POINTER_URI_FRAGMENT,\n  // relative JSON-pointer: http://tools.ietf.org/html/draft-luff-relative-json-pointer-00\n  'relative-json-pointer': RELATIVE_JSON_POINTER\n};\n\n\nformats.full = {\n  date: date,\n  time: time,\n  'date-time': date_time,\n  uri: uri,\n  'uri-reference': URIREF,\n  'uri-template': URITEMPLATE,\n  url: URL,\n  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,\n  hostname: HOSTNAME,\n  ipv4: /^(?:(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)$/,\n  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,\n  regex: regex,\n  uuid: UUID,\n  'json-pointer': JSON_POINTER,\n  'json-pointer-uri-fragment': JSON_POINTER_URI_FRAGMENT,\n  'relative-json-pointer': RELATIVE_JSON_POINTER\n};\n\n\nfunction isLeapYear(year) {\n  // https://tools.ietf.org/html/rfc3339#appendix-C\n  return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);\n}\n\n\nfunction date(str) {\n  // full-date from http://tools.ietf.org/html/rfc3339#section-5.6\n  var matches = str.match(DATE);\n  if (!matches) return false;\n\n  var year = +matches[1];\n  var month = +matches[2];\n  var day = +matches[3];\n\n  return month >= 1 && month <= 12 && day >= 1 &&\n          day <= (month == 2 && isLeapYear(year) ? 29 : DAYS[month]);\n}\n\n\nfunction time(str, full) {\n  var matches = str.match(TIME);\n  if (!matches) return false;\n\n  var hour = matches[1];\n  var minute = matches[2];\n  var second = matches[3];\n  var timeZone = matches[5];\n  return ((hour <= 23 && minute <= 59 && second <= 59) ||\n          (hour == 23 && minute == 59 && second == 60)) &&\n         (!full || timeZone);\n}\n\n\nvar DATE_TIME_SEPARATOR = /t|\\s/i;\nfunction date_time(str) {\n  // http://tools.ietf.org/html/rfc3339#section-5.6\n  var dateTime = str.split(DATE_TIME_SEPARATOR);\n  return dateTime.length == 2 && date(dateTime[0]) && time(dateTime[1], true);\n}\n\n\nvar NOT_URI_FRAGMENT = /\\/|:/;\nfunction uri(str) {\n  // http://jmrware.com/articles/2009/uri_regexp/URI_regex.html + optional protocol + required \".\"\n  return NOT_URI_FRAGMENT.test(str) && URI.test(str);\n}\n\n\nvar Z_ANCHOR = /[^\\\\]\\\\Z/;\nfunction regex(str) {\n  if (Z_ANCHOR.test(str)) return false;\n  try {\n    new RegExp(str);\n    return true;\n  } catch(e) {\n    return false;\n  }\n}\n","'use strict';\n\nvar ruleModules = require('../dotjs')\n  , toHash = require('./util').toHash;\n\nmodule.exports = function rules() {\n  var RULES = [\n    { type: 'number',\n      rules: [ { 'maximum': ['exclusiveMaximum'] },\n               { 'minimum': ['exclusiveMinimum'] }, 'multipleOf', 'format'] },\n    { type: 'string',\n      rules: [ 'maxLength', 'minLength', 'pattern', 'format' ] },\n    { type: 'array',\n      rules: [ 'maxItems', 'minItems', 'items', 'contains', 'uniqueItems' ] },\n    { type: 'object',\n      rules: [ 'maxProperties', 'minProperties', 'required', 'dependencies', 'propertyNames',\n               { 'properties': ['additionalProperties', 'patternProperties'] } ] },\n    { rules: [ '$ref', 'const', 'enum', 'not', 'anyOf', 'oneOf', 'allOf', 'if' ] }\n  ];\n\n  var ALL = [ 'type', '$comment' ];\n  var KEYWORDS = [\n    '$schema', '$id', 'id', '$data', '$async', 'title',\n    'description', 'default', 'definitions',\n    'examples', 'readOnly', 'writeOnly',\n    'contentMediaType', 'contentEncoding',\n    'additionalItems', 'then', 'else'\n  ];\n  var TYPES = [ 'number', 'integer', 'string', 'array', 'object', 'boolean', 'null' ];\n  RULES.all = toHash(ALL);\n  RULES.types = toHash(TYPES);\n\n  RULES.forEach(function (group) {\n    group.rules = group.rules.map(function (keyword) {\n      var implKeywords;\n      if (typeof keyword == 'object') {\n        var key = Object.keys(keyword)[0];\n        implKeywords = keyword[key];\n        keyword = key;\n        implKeywords.forEach(function (k) {\n          ALL.push(k);\n          RULES.all[k] = true;\n        });\n      }\n      ALL.push(keyword);\n      var rule = RULES.all[keyword] = {\n        keyword: keyword,\n        code: ruleModules[keyword],\n        implements: implKeywords\n      };\n      return rule;\n    });\n\n    RULES.all.$comment = {\n      keyword: '$comment',\n      code: ruleModules.$comment\n    };\n\n    if (group.type) RULES.types[group.type] = group;\n  });\n\n  RULES.keywords = toHash(ALL.concat(KEYWORDS));\n  RULES.custom = {};\n\n  return RULES;\n};\n","'use strict';\n\n//all requires must be explicit because browserify won't work with dynamic requires\nmodule.exports = {\n  '$ref': require('./ref'),\n  allOf: require('./allOf'),\n  anyOf: require('./anyOf'),\n  '$comment': require('./comment'),\n  const: require('./const'),\n  contains: require('./contains'),\n  dependencies: require('./dependencies'),\n  'enum': require('./enum'),\n  format: require('./format'),\n  'if': require('./if'),\n  items: require('./items'),\n  maximum: require('./_limit'),\n  minimum: require('./_limit'),\n  maxItems: require('./_limitItems'),\n  minItems: require('./_limitItems'),\n  maxLength: require('./_limitLength'),\n  minLength: require('./_limitLength'),\n  maxProperties: require('./_limitProperties'),\n  minProperties: require('./_limitProperties'),\n  multipleOf: require('./multipleOf'),\n  not: require('./not'),\n  oneOf: require('./oneOf'),\n  pattern: require('./pattern'),\n  properties: require('./properties'),\n  propertyNames: require('./propertyNames'),\n  required: require('./required'),\n  uniqueItems: require('./uniqueItems'),\n  validate: require('./validate')\n};\n","'use strict';\nmodule.exports = function generate_ref(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $valid = 'valid' + $lvl;\n  var $async, $refCode;\n  if ($schema == '#' || $schema == '#/') {\n    if (it.isRoot) {\n      $async = it.async;\n      $refCode = 'validate';\n    } else {\n      $async = it.root.schema.$async === true;\n      $refCode = 'root.refVal[0]';\n    }\n  } else {\n    var $refVal = it.resolveRef(it.baseId, $schema, it.isRoot);\n    if ($refVal === undefined) {\n      var $message = it.MissingRefError.message(it.baseId, $schema);\n      if (it.opts.missingRefs == 'fail') {\n        it.logger.error($message);\n        var $$outStack = $$outStack || [];\n        $$outStack.push(out);\n        out = ''; /* istanbul ignore else */\n        if (it.createErrors !== false) {\n          out += ' { keyword: \\'' + ('$ref') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { ref: \\'' + (it.util.escapeQuotes($schema)) + '\\' } ';\n          if (it.opts.messages !== false) {\n            out += ' , message: \\'can\\\\\\'t resolve reference ' + (it.util.escapeQuotes($schema)) + '\\' ';\n          }\n          if (it.opts.verbose) {\n            out += ' , schema: ' + (it.util.toQuotedString($schema)) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n          }\n          out += ' } ';\n        } else {\n          out += ' {} ';\n        }\n        var __err = out;\n        out = $$outStack.pop();\n        if (!it.compositeRule && $breakOnError) {\n          /* istanbul ignore if */\n          if (it.async) {\n            out += ' throw new ValidationError([' + (__err) + ']); ';\n          } else {\n            out += ' validate.errors = [' + (__err) + ']; return false; ';\n          }\n        } else {\n          out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n        }\n        if ($breakOnError) {\n          out += ' if (false) { ';\n        }\n      } else if (it.opts.missingRefs == 'ignore') {\n        it.logger.warn($message);\n        if ($breakOnError) {\n          out += ' if (true) { ';\n        }\n      } else {\n        throw new it.MissingRefError(it.baseId, $schema, $message);\n      }\n    } else if ($refVal.inline) {\n      var $it = it.util.copy(it);\n      $it.level++;\n      var $nextValid = 'valid' + $it.level;\n      $it.schema = $refVal.schema;\n      $it.schemaPath = '';\n      $it.errSchemaPath = $schema;\n      var $code = it.validate($it).replace(/validate\\.schema/g, $refVal.code);\n      out += ' ' + ($code) + ' ';\n      if ($breakOnError) {\n        out += ' if (' + ($nextValid) + ') { ';\n      }\n    } else {\n      $async = $refVal.$async === true || (it.async && $refVal.$async !== false);\n      $refCode = $refVal.code;\n    }\n  }\n  if ($refCode) {\n    var $$outStack = $$outStack || [];\n    $$outStack.push(out);\n    out = '';\n    if (it.opts.passContext) {\n      out += ' ' + ($refCode) + '.call(this, ';\n    } else {\n      out += ' ' + ($refCode) + '( ';\n    }\n    out += ' ' + ($data) + ', (dataPath || \\'\\')';\n    if (it.errorPath != '\"\"') {\n      out += ' + ' + (it.errorPath);\n    }\n    var $parentData = $dataLvl ? 'data' + (($dataLvl - 1) || '') : 'parentData',\n      $parentDataProperty = $dataLvl ? it.dataPathArr[$dataLvl] : 'parentDataProperty';\n    out += ' , ' + ($parentData) + ' , ' + ($parentDataProperty) + ', rootData)  ';\n    var __callValidate = out;\n    out = $$outStack.pop();\n    if ($async) {\n      if (!it.async) throw new Error('async schema referenced by sync schema');\n      if ($breakOnError) {\n        out += ' var ' + ($valid) + '; ';\n      }\n      out += ' try { await ' + (__callValidate) + '; ';\n      if ($breakOnError) {\n        out += ' ' + ($valid) + ' = true; ';\n      }\n      out += ' } catch (e) { if (!(e instanceof ValidationError)) throw e; if (vErrors === null) vErrors = e.errors; else vErrors = vErrors.concat(e.errors); errors = vErrors.length; ';\n      if ($breakOnError) {\n        out += ' ' + ($valid) + ' = false; ';\n      }\n      out += ' } ';\n      if ($breakOnError) {\n        out += ' if (' + ($valid) + ') { ';\n      }\n    } else {\n      out += ' if (!' + (__callValidate) + ') { if (vErrors === null) vErrors = ' + ($refCode) + '.errors; else vErrors = vErrors.concat(' + ($refCode) + '.errors); errors = vErrors.length; } ';\n      if ($breakOnError) {\n        out += ' else { ';\n      }\n    }\n  }\n  return out;\n}\n","'use strict';\nmodule.exports = function generate_allOf(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $it = it.util.copy(it);\n  var $closingBraces = '';\n  $it.level++;\n  var $nextValid = 'valid' + $it.level;\n  var $currentBaseId = $it.baseId,\n    $allSchemasEmpty = true;\n  var arr1 = $schema;\n  if (arr1) {\n    var $sch, $i = -1,\n      l1 = arr1.length - 1;\n    while ($i < l1) {\n      $sch = arr1[$i += 1];\n      if ((it.opts.strictKeywords ? (typeof $sch == 'object' && Object.keys($sch).length > 0) || $sch === false : it.util.schemaHasRules($sch, it.RULES.all))) {\n        $allSchemasEmpty = false;\n        $it.schema = $sch;\n        $it.schemaPath = $schemaPath + '[' + $i + ']';\n        $it.errSchemaPath = $errSchemaPath + '/' + $i;\n        out += '  ' + (it.validate($it)) + ' ';\n        $it.baseId = $currentBaseId;\n        if ($breakOnError) {\n          out += ' if (' + ($nextValid) + ') { ';\n          $closingBraces += '}';\n        }\n      }\n    }\n  }\n  if ($breakOnError) {\n    if ($allSchemasEmpty) {\n      out += ' if (true) { ';\n    } else {\n      out += ' ' + ($closingBraces.slice(0, -1)) + ' ';\n    }\n  }\n  return out;\n}\n","'use strict';\nmodule.exports = function generate_anyOf(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $valid = 'valid' + $lvl;\n  var $errs = 'errs__' + $lvl;\n  var $it = it.util.copy(it);\n  var $closingBraces = '';\n  $it.level++;\n  var $nextValid = 'valid' + $it.level;\n  var $noEmptySchema = $schema.every(function($sch) {\n    return (it.opts.strictKeywords ? (typeof $sch == 'object' && Object.keys($sch).length > 0) || $sch === false : it.util.schemaHasRules($sch, it.RULES.all));\n  });\n  if ($noEmptySchema) {\n    var $currentBaseId = $it.baseId;\n    out += ' var ' + ($errs) + ' = errors; var ' + ($valid) + ' = false;  ';\n    var $wasComposite = it.compositeRule;\n    it.compositeRule = $it.compositeRule = true;\n    var arr1 = $schema;\n    if (arr1) {\n      var $sch, $i = -1,\n        l1 = arr1.length - 1;\n      while ($i < l1) {\n        $sch = arr1[$i += 1];\n        $it.schema = $sch;\n        $it.schemaPath = $schemaPath + '[' + $i + ']';\n        $it.errSchemaPath = $errSchemaPath + '/' + $i;\n        out += '  ' + (it.validate($it)) + ' ';\n        $it.baseId = $currentBaseId;\n        out += ' ' + ($valid) + ' = ' + ($valid) + ' || ' + ($nextValid) + '; if (!' + ($valid) + ') { ';\n        $closingBraces += '}';\n      }\n    }\n    it.compositeRule = $it.compositeRule = $wasComposite;\n    out += ' ' + ($closingBraces) + ' if (!' + ($valid) + ') {   var err =   '; /* istanbul ignore else */\n    if (it.createErrors !== false) {\n      out += ' { keyword: \\'' + ('anyOf') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: {} ';\n      if (it.opts.messages !== false) {\n        out += ' , message: \\'should match some schema in anyOf\\' ';\n      }\n      if (it.opts.verbose) {\n        out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n      }\n      out += ' } ';\n    } else {\n      out += ' {} ';\n    }\n    out += ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n    if (!it.compositeRule && $breakOnError) {\n      /* istanbul ignore if */\n      if (it.async) {\n        out += ' throw new ValidationError(vErrors); ';\n      } else {\n        out += ' validate.errors = vErrors; return false; ';\n      }\n    }\n    out += ' } else {  errors = ' + ($errs) + '; if (vErrors !== null) { if (' + ($errs) + ') vErrors.length = ' + ($errs) + '; else vErrors = null; } ';\n    if (it.opts.allErrors) {\n      out += ' } ';\n    }\n  } else {\n    if ($breakOnError) {\n      out += ' if (true) { ';\n    }\n  }\n  return out;\n}\n","'use strict';\nmodule.exports = function generate_comment(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $schema = it.schema[$keyword];\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $comment = it.util.toQuotedString($schema);\n  if (it.opts.$comment === true) {\n    out += ' console.log(' + ($comment) + ');';\n  } else if (typeof it.opts.$comment == 'function') {\n    out += ' self._opts.$comment(' + ($comment) + ', ' + (it.util.toQuotedString($errSchemaPath)) + ', validate.root.schema);';\n  }\n  return out;\n}\n","'use strict';\nmodule.exports = function generate_const(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $valid = 'valid' + $lvl;\n  var $isData = it.opts.$data && $schema && $schema.$data,\n    $schemaValue;\n  if ($isData) {\n    out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; ';\n    $schemaValue = 'schema' + $lvl;\n  } else {\n    $schemaValue = $schema;\n  }\n  if (!$isData) {\n    out += ' var schema' + ($lvl) + ' = validate.schema' + ($schemaPath) + ';';\n  }\n  out += 'var ' + ($valid) + ' = equal(' + ($data) + ', schema' + ($lvl) + '); if (!' + ($valid) + ') {   ';\n  var $$outStack = $$outStack || [];\n  $$outStack.push(out);\n  out = ''; /* istanbul ignore else */\n  if (it.createErrors !== false) {\n    out += ' { keyword: \\'' + ('const') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { allowedValue: schema' + ($lvl) + ' } ';\n    if (it.opts.messages !== false) {\n      out += ' , message: \\'should be equal to constant\\' ';\n    }\n    if (it.opts.verbose) {\n      out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n    }\n    out += ' } ';\n  } else {\n    out += ' {} ';\n  }\n  var __err = out;\n  out = $$outStack.pop();\n  if (!it.compositeRule && $breakOnError) {\n    /* istanbul ignore if */\n    if (it.async) {\n      out += ' throw new ValidationError([' + (__err) + ']); ';\n    } else {\n      out += ' validate.errors = [' + (__err) + ']; return false; ';\n    }\n  } else {\n    out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n  }\n  out += ' }';\n  if ($breakOnError) {\n    out += ' else { ';\n  }\n  return out;\n}\n","'use strict';\nmodule.exports = function generate_contains(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $valid = 'valid' + $lvl;\n  var $errs = 'errs__' + $lvl;\n  var $it = it.util.copy(it);\n  var $closingBraces = '';\n  $it.level++;\n  var $nextValid = 'valid' + $it.level;\n  var $idx = 'i' + $lvl,\n    $dataNxt = $it.dataLevel = it.dataLevel + 1,\n    $nextData = 'data' + $dataNxt,\n    $currentBaseId = it.baseId,\n    $nonEmptySchema = (it.opts.strictKeywords ? (typeof $schema == 'object' && Object.keys($schema).length > 0) || $schema === false : it.util.schemaHasRules($schema, it.RULES.all));\n  out += 'var ' + ($errs) + ' = errors;var ' + ($valid) + ';';\n  if ($nonEmptySchema) {\n    var $wasComposite = it.compositeRule;\n    it.compositeRule = $it.compositeRule = true;\n    $it.schema = $schema;\n    $it.schemaPath = $schemaPath;\n    $it.errSchemaPath = $errSchemaPath;\n    out += ' var ' + ($nextValid) + ' = false; for (var ' + ($idx) + ' = 0; ' + ($idx) + ' < ' + ($data) + '.length; ' + ($idx) + '++) { ';\n    $it.errorPath = it.util.getPathExpr(it.errorPath, $idx, it.opts.jsonPointers, true);\n    var $passData = $data + '[' + $idx + ']';\n    $it.dataPathArr[$dataNxt] = $idx;\n    var $code = it.validate($it);\n    $it.baseId = $currentBaseId;\n    if (it.util.varOccurences($code, $nextData) < 2) {\n      out += ' ' + (it.util.varReplace($code, $nextData, $passData)) + ' ';\n    } else {\n      out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ' + ($code) + ' ';\n    }\n    out += ' if (' + ($nextValid) + ') break; }  ';\n    it.compositeRule = $it.compositeRule = $wasComposite;\n    out += ' ' + ($closingBraces) + ' if (!' + ($nextValid) + ') {';\n  } else {\n    out += ' if (' + ($data) + '.length == 0) {';\n  }\n  var $$outStack = $$outStack || [];\n  $$outStack.push(out);\n  out = ''; /* istanbul ignore else */\n  if (it.createErrors !== false) {\n    out += ' { keyword: \\'' + ('contains') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: {} ';\n    if (it.opts.messages !== false) {\n      out += ' , message: \\'should contain a valid item\\' ';\n    }\n    if (it.opts.verbose) {\n      out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n    }\n    out += ' } ';\n  } else {\n    out += ' {} ';\n  }\n  var __err = out;\n  out = $$outStack.pop();\n  if (!it.compositeRule && $breakOnError) {\n    /* istanbul ignore if */\n    if (it.async) {\n      out += ' throw new ValidationError([' + (__err) + ']); ';\n    } else {\n      out += ' validate.errors = [' + (__err) + ']; return false; ';\n    }\n  } else {\n    out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n  }\n  out += ' } else { ';\n  if ($nonEmptySchema) {\n    out += '  errors = ' + ($errs) + '; if (vErrors !== null) { if (' + ($errs) + ') vErrors.length = ' + ($errs) + '; else vErrors = null; } ';\n  }\n  if (it.opts.allErrors) {\n    out += ' } ';\n  }\n  return out;\n}\n","'use strict';\nmodule.exports = function generate_dependencies(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $errs = 'errs__' + $lvl;\n  var $it = it.util.copy(it);\n  var $closingBraces = '';\n  $it.level++;\n  var $nextValid = 'valid' + $it.level;\n  var $schemaDeps = {},\n    $propertyDeps = {},\n    $ownProperties = it.opts.ownProperties;\n  for ($property in $schema) {\n    if ($property == '__proto__') continue;\n    var $sch = $schema[$property];\n    var $deps = Array.isArray($sch) ? $propertyDeps : $schemaDeps;\n    $deps[$property] = $sch;\n  }\n  out += 'var ' + ($errs) + ' = errors;';\n  var $currentErrorPath = it.errorPath;\n  out += 'var missing' + ($lvl) + ';';\n  for (var $property in $propertyDeps) {\n    $deps = $propertyDeps[$property];\n    if ($deps.length) {\n      out += ' if ( ' + ($data) + (it.util.getProperty($property)) + ' !== undefined ';\n      if ($ownProperties) {\n        out += ' && Object.prototype.hasOwnProperty.call(' + ($data) + ', \\'' + (it.util.escapeQuotes($property)) + '\\') ';\n      }\n      if ($breakOnError) {\n        out += ' && ( ';\n        var arr1 = $deps;\n        if (arr1) {\n          var $propertyKey, $i = -1,\n            l1 = arr1.length - 1;\n          while ($i < l1) {\n            $propertyKey = arr1[$i += 1];\n            if ($i) {\n              out += ' || ';\n            }\n            var $prop = it.util.getProperty($propertyKey),\n              $useData = $data + $prop;\n            out += ' ( ( ' + ($useData) + ' === undefined ';\n            if ($ownProperties) {\n              out += ' || ! Object.prototype.hasOwnProperty.call(' + ($data) + ', \\'' + (it.util.escapeQuotes($propertyKey)) + '\\') ';\n            }\n            out += ') && (missing' + ($lvl) + ' = ' + (it.util.toQuotedString(it.opts.jsonPointers ? $propertyKey : $prop)) + ') ) ';\n          }\n        }\n        out += ')) {  ';\n        var $propertyPath = 'missing' + $lvl,\n          $missingProperty = '\\' + ' + $propertyPath + ' + \\'';\n        if (it.opts._errorDataPathProperty) {\n          it.errorPath = it.opts.jsonPointers ? it.util.getPathExpr($currentErrorPath, $propertyPath, true) : $currentErrorPath + ' + ' + $propertyPath;\n        }\n        var $$outStack = $$outStack || [];\n        $$outStack.push(out);\n        out = ''; /* istanbul ignore else */\n        if (it.createErrors !== false) {\n          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(\", \"))) + '\\' } ';\n          if (it.opts.messages !== false) {\n            out += ' , message: \\'should have ';\n            if ($deps.length == 1) {\n              out += 'property ' + (it.util.escapeQuotes($deps[0]));\n            } else {\n              out += 'properties ' + (it.util.escapeQuotes($deps.join(\", \")));\n            }\n            out += ' when property ' + (it.util.escapeQuotes($property)) + ' is present\\' ';\n          }\n          if (it.opts.verbose) {\n            out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n          }\n          out += ' } ';\n        } else {\n          out += ' {} ';\n        }\n        var __err = out;\n        out = $$outStack.pop();\n        if (!it.compositeRule && $breakOnError) {\n          /* istanbul ignore if */\n          if (it.async) {\n            out += ' throw new ValidationError([' + (__err) + ']); ';\n          } else {\n            out += ' validate.errors = [' + (__err) + ']; return false; ';\n          }\n        } else {\n          out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n        }\n      } else {\n        out += ' ) { ';\n        var arr2 = $deps;\n        if (arr2) {\n          var $propertyKey, i2 = -1,\n            l2 = arr2.length - 1;\n          while (i2 < l2) {\n            $propertyKey = arr2[i2 += 1];\n            var $prop = it.util.getProperty($propertyKey),\n              $missingProperty = it.util.escapeQuotes($propertyKey),\n              $useData = $data + $prop;\n            if (it.opts._errorDataPathProperty) {\n              it.errorPath = it.util.getPath($currentErrorPath, $propertyKey, it.opts.jsonPointers);\n            }\n            out += ' if ( ' + ($useData) + ' === undefined ';\n            if ($ownProperties) {\n              out += ' || ! Object.prototype.hasOwnProperty.call(' + ($data) + ', \\'' + (it.util.escapeQuotes($propertyKey)) + '\\') ';\n            }\n            out += ') {  var err =   '; /* istanbul ignore else */\n            if (it.createErrors !== false) {\n              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(\", \"))) + '\\' } ';\n              if (it.opts.messages !== false) {\n                out += ' , message: \\'should have ';\n                if ($deps.length == 1) {\n                  out += 'property ' + (it.util.escapeQuotes($deps[0]));\n                } else {\n                  out += 'properties ' + (it.util.escapeQuotes($deps.join(\", \")));\n                }\n                out += ' when property ' + (it.util.escapeQuotes($property)) + ' is present\\' ';\n              }\n              if (it.opts.verbose) {\n                out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n              }\n              out += ' } ';\n            } else {\n              out += ' {} ';\n            }\n            out += ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; } ';\n          }\n        }\n      }\n      out += ' }   ';\n      if ($breakOnError) {\n        $closingBraces += '}';\n        out += ' else { ';\n      }\n    }\n  }\n  it.errorPath = $currentErrorPath;\n  var $currentBaseId = $it.baseId;\n  for (var $property in $schemaDeps) {\n    var $sch = $schemaDeps[$property];\n    if ((it.opts.strictKeywords ? (typeof $sch == 'object' && Object.keys($sch).length > 0) || $sch === false : it.util.schemaHasRules($sch, it.RULES.all))) {\n      out += ' ' + ($nextValid) + ' = true; if ( ' + ($data) + (it.util.getProperty($property)) + ' !== undefined ';\n      if ($ownProperties) {\n        out += ' && Object.prototype.hasOwnProperty.call(' + ($data) + ', \\'' + (it.util.escapeQuotes($property)) + '\\') ';\n      }\n      out += ') { ';\n      $it.schema = $sch;\n      $it.schemaPath = $schemaPath + it.util.getProperty($property);\n      $it.errSchemaPath = $errSchemaPath + '/' + it.util.escapeFragment($property);\n      out += '  ' + (it.validate($it)) + ' ';\n      $it.baseId = $currentBaseId;\n      out += ' }  ';\n      if ($breakOnError) {\n        out += ' if (' + ($nextValid) + ') { ';\n        $closingBraces += '}';\n      }\n    }\n  }\n  if ($breakOnError) {\n    out += '   ' + ($closingBraces) + ' if (' + ($errs) + ' == errors) {';\n  }\n  return out;\n}\n","'use strict';\nmodule.exports = function generate_enum(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $valid = 'valid' + $lvl;\n  var $isData = it.opts.$data && $schema && $schema.$data,\n    $schemaValue;\n  if ($isData) {\n    out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; ';\n    $schemaValue = 'schema' + $lvl;\n  } else {\n    $schemaValue = $schema;\n  }\n  var $i = 'i' + $lvl,\n    $vSchema = 'schema' + $lvl;\n  if (!$isData) {\n    out += ' var ' + ($vSchema) + ' = validate.schema' + ($schemaPath) + ';';\n  }\n  out += 'var ' + ($valid) + ';';\n  if ($isData) {\n    out += ' if (schema' + ($lvl) + ' === undefined) ' + ($valid) + ' = true; else if (!Array.isArray(schema' + ($lvl) + ')) ' + ($valid) + ' = false; else {';\n  }\n  out += '' + ($valid) + ' = false;for (var ' + ($i) + '=0; ' + ($i) + '<' + ($vSchema) + '.length; ' + ($i) + '++) if (equal(' + ($data) + ', ' + ($vSchema) + '[' + ($i) + '])) { ' + ($valid) + ' = true; break; }';\n  if ($isData) {\n    out += '  }  ';\n  }\n  out += ' if (!' + ($valid) + ') {   ';\n  var $$outStack = $$outStack || [];\n  $$outStack.push(out);\n  out = ''; /* istanbul ignore else */\n  if (it.createErrors !== false) {\n    out += ' { keyword: \\'' + ('enum') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { allowedValues: schema' + ($lvl) + ' } ';\n    if (it.opts.messages !== false) {\n      out += ' , message: \\'should be equal to one of the allowed values\\' ';\n    }\n    if (it.opts.verbose) {\n      out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n    }\n    out += ' } ';\n  } else {\n    out += ' {} ';\n  }\n  var __err = out;\n  out = $$outStack.pop();\n  if (!it.compositeRule && $breakOnError) {\n    /* istanbul ignore if */\n    if (it.async) {\n      out += ' throw new ValidationError([' + (__err) + ']); ';\n    } else {\n      out += ' validate.errors = [' + (__err) + ']; return false; ';\n    }\n  } else {\n    out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n  }\n  out += ' }';\n  if ($breakOnError) {\n    out += ' else { ';\n  }\n  return out;\n}\n","'use strict';\nmodule.exports = function generate_format(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  if (it.opts.format === false) {\n    if ($breakOnError) {\n      out += ' if (true) { ';\n    }\n    return out;\n  }\n  var $isData = it.opts.$data && $schema && $schema.$data,\n    $schemaValue;\n  if ($isData) {\n    out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; ';\n    $schemaValue = 'schema' + $lvl;\n  } else {\n    $schemaValue = $schema;\n  }\n  var $unknownFormats = it.opts.unknownFormats,\n    $allowUnknown = Array.isArray($unknownFormats);\n  if ($isData) {\n    var $format = 'format' + $lvl,\n      $isObject = 'isObject' + $lvl,\n      $formatType = 'formatType' + $lvl;\n    out += ' var ' + ($format) + ' = formats[' + ($schemaValue) + ']; var ' + ($isObject) + ' = typeof ' + ($format) + ' == \\'object\\' && !(' + ($format) + ' instanceof RegExp) && ' + ($format) + '.validate; var ' + ($formatType) + ' = ' + ($isObject) + ' && ' + ($format) + '.type || \\'string\\'; if (' + ($isObject) + ') { ';\n    if (it.async) {\n      out += ' var async' + ($lvl) + ' = ' + ($format) + '.async; ';\n    }\n    out += ' ' + ($format) + ' = ' + ($format) + '.validate; } if (  ';\n    if ($isData) {\n      out += ' (' + ($schemaValue) + ' !== undefined && typeof ' + ($schemaValue) + ' != \\'string\\') || ';\n    }\n    out += ' (';\n    if ($unknownFormats != 'ignore') {\n      out += ' (' + ($schemaValue) + ' && !' + ($format) + ' ';\n      if ($allowUnknown) {\n        out += ' && self._opts.unknownFormats.indexOf(' + ($schemaValue) + ') == -1 ';\n      }\n      out += ') || ';\n    }\n    out += ' (' + ($format) + ' && ' + ($formatType) + ' == \\'' + ($ruleType) + '\\' && !(typeof ' + ($format) + ' == \\'function\\' ? ';\n    if (it.async) {\n      out += ' (async' + ($lvl) + ' ? await ' + ($format) + '(' + ($data) + ') : ' + ($format) + '(' + ($data) + ')) ';\n    } else {\n      out += ' ' + ($format) + '(' + ($data) + ') ';\n    }\n    out += ' : ' + ($format) + '.test(' + ($data) + '))))) {';\n  } else {\n    var $format = it.formats[$schema];\n    if (!$format) {\n      if ($unknownFormats == 'ignore') {\n        it.logger.warn('unknown format \"' + $schema + '\" ignored in schema at path \"' + it.errSchemaPath + '\"');\n        if ($breakOnError) {\n          out += ' if (true) { ';\n        }\n        return out;\n      } else if ($allowUnknown && $unknownFormats.indexOf($schema) >= 0) {\n        if ($breakOnError) {\n          out += ' if (true) { ';\n        }\n        return out;\n      } else {\n        throw new Error('unknown format \"' + $schema + '\" is used in schema at path \"' + it.errSchemaPath + '\"');\n      }\n    }\n    var $isObject = typeof $format == 'object' && !($format instanceof RegExp) && $format.validate;\n    var $formatType = $isObject && $format.type || 'string';\n    if ($isObject) {\n      var $async = $format.async === true;\n      $format = $format.validate;\n    }\n    if ($formatType != $ruleType) {\n      if ($breakOnError) {\n        out += ' if (true) { ';\n      }\n      return out;\n    }\n    if ($async) {\n      if (!it.async) throw new Error('async format in sync schema');\n      var $formatRef = 'formats' + it.util.getProperty($schema) + '.validate';\n      out += ' if (!(await ' + ($formatRef) + '(' + ($data) + '))) { ';\n    } else {\n      out += ' if (! ';\n      var $formatRef = 'formats' + it.util.getProperty($schema);\n      if ($isObject) $formatRef += '.validate';\n      if (typeof $format == 'function') {\n        out += ' ' + ($formatRef) + '(' + ($data) + ') ';\n      } else {\n        out += ' ' + ($formatRef) + '.test(' + ($data) + ') ';\n      }\n      out += ') { ';\n    }\n  }\n  var $$outStack = $$outStack || [];\n  $$outStack.push(out);\n  out = ''; /* istanbul ignore else */\n  if (it.createErrors !== false) {\n    out += ' { keyword: \\'' + ('format') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { format:  ';\n    if ($isData) {\n      out += '' + ($schemaValue);\n    } else {\n      out += '' + (it.util.toQuotedString($schema));\n    }\n    out += '  } ';\n    if (it.opts.messages !== false) {\n      out += ' , message: \\'should match format \"';\n      if ($isData) {\n        out += '\\' + ' + ($schemaValue) + ' + \\'';\n      } else {\n        out += '' + (it.util.escapeQuotes($schema));\n      }\n      out += '\"\\' ';\n    }\n    if (it.opts.verbose) {\n      out += ' , schema:  ';\n      if ($isData) {\n        out += 'validate.schema' + ($schemaPath);\n      } else {\n        out += '' + (it.util.toQuotedString($schema));\n      }\n      out += '         , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n    }\n    out += ' } ';\n  } else {\n    out += ' {} ';\n  }\n  var __err = out;\n  out = $$outStack.pop();\n  if (!it.compositeRule && $breakOnError) {\n    /* istanbul ignore if */\n    if (it.async) {\n      out += ' throw new ValidationError([' + (__err) + ']); ';\n    } else {\n      out += ' validate.errors = [' + (__err) + ']; return false; ';\n    }\n  } else {\n    out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n  }\n  out += ' } ';\n  if ($breakOnError) {\n    out += ' else { ';\n  }\n  return out;\n}\n","'use strict';\nmodule.exports = function generate_if(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $valid = 'valid' + $lvl;\n  var $errs = 'errs__' + $lvl;\n  var $it = it.util.copy(it);\n  $it.level++;\n  var $nextValid = 'valid' + $it.level;\n  var $thenSch = it.schema['then'],\n    $elseSch = it.schema['else'],\n    $thenPresent = $thenSch !== undefined && (it.opts.strictKeywords ? (typeof $thenSch == 'object' && Object.keys($thenSch).length > 0) || $thenSch === false : it.util.schemaHasRules($thenSch, it.RULES.all)),\n    $elsePresent = $elseSch !== undefined && (it.opts.strictKeywords ? (typeof $elseSch == 'object' && Object.keys($elseSch).length > 0) || $elseSch === false : it.util.schemaHasRules($elseSch, it.RULES.all)),\n    $currentBaseId = $it.baseId;\n  if ($thenPresent || $elsePresent) {\n    var $ifClause;\n    $it.createErrors = false;\n    $it.schema = $schema;\n    $it.schemaPath = $schemaPath;\n    $it.errSchemaPath = $errSchemaPath;\n    out += ' var ' + ($errs) + ' = errors; var ' + ($valid) + ' = true;  ';\n    var $wasComposite = it.compositeRule;\n    it.compositeRule = $it.compositeRule = true;\n    out += '  ' + (it.validate($it)) + ' ';\n    $it.baseId = $currentBaseId;\n    $it.createErrors = true;\n    out += '  errors = ' + ($errs) + '; if (vErrors !== null) { if (' + ($errs) + ') vErrors.length = ' + ($errs) + '; else vErrors = null; }  ';\n    it.compositeRule = $it.compositeRule = $wasComposite;\n    if ($thenPresent) {\n      out += ' if (' + ($nextValid) + ') {  ';\n      $it.schema = it.schema['then'];\n      $it.schemaPath = it.schemaPath + '.then';\n      $it.errSchemaPath = it.errSchemaPath + '/then';\n      out += '  ' + (it.validate($it)) + ' ';\n      $it.baseId = $currentBaseId;\n      out += ' ' + ($valid) + ' = ' + ($nextValid) + '; ';\n      if ($thenPresent && $elsePresent) {\n        $ifClause = 'ifClause' + $lvl;\n        out += ' var ' + ($ifClause) + ' = \\'then\\'; ';\n      } else {\n        $ifClause = '\\'then\\'';\n      }\n      out += ' } ';\n      if ($elsePresent) {\n        out += ' else { ';\n      }\n    } else {\n      out += ' if (!' + ($nextValid) + ') { ';\n    }\n    if ($elsePresent) {\n      $it.schema = it.schema['else'];\n      $it.schemaPath = it.schemaPath + '.else';\n      $it.errSchemaPath = it.errSchemaPath + '/else';\n      out += '  ' + (it.validate($it)) + ' ';\n      $it.baseId = $currentBaseId;\n      out += ' ' + ($valid) + ' = ' + ($nextValid) + '; ';\n      if ($thenPresent && $elsePresent) {\n        $ifClause = 'ifClause' + $lvl;\n        out += ' var ' + ($ifClause) + ' = \\'else\\'; ';\n      } else {\n        $ifClause = '\\'else\\'';\n      }\n      out += ' } ';\n    }\n    out += ' if (!' + ($valid) + ') {   var err =   '; /* istanbul ignore else */\n    if (it.createErrors !== false) {\n      out += ' { keyword: \\'' + ('if') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { failingKeyword: ' + ($ifClause) + ' } ';\n      if (it.opts.messages !== false) {\n        out += ' , message: \\'should match \"\\' + ' + ($ifClause) + ' + \\'\" schema\\' ';\n      }\n      if (it.opts.verbose) {\n        out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n      }\n      out += ' } ';\n    } else {\n      out += ' {} ';\n    }\n    out += ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n    if (!it.compositeRule && $breakOnError) {\n      /* istanbul ignore if */\n      if (it.async) {\n        out += ' throw new ValidationError(vErrors); ';\n      } else {\n        out += ' validate.errors = vErrors; return false; ';\n      }\n    }\n    out += ' }   ';\n    if ($breakOnError) {\n      out += ' else { ';\n    }\n  } else {\n    if ($breakOnError) {\n      out += ' if (true) { ';\n    }\n  }\n  return out;\n}\n","'use strict';\nmodule.exports = function generate_items(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $valid = 'valid' + $lvl;\n  var $errs = 'errs__' + $lvl;\n  var $it = it.util.copy(it);\n  var $closingBraces = '';\n  $it.level++;\n  var $nextValid = 'valid' + $it.level;\n  var $idx = 'i' + $lvl,\n    $dataNxt = $it.dataLevel = it.dataLevel + 1,\n    $nextData = 'data' + $dataNxt,\n    $currentBaseId = it.baseId;\n  out += 'var ' + ($errs) + ' = errors;var ' + ($valid) + ';';\n  if (Array.isArray($schema)) {\n    var $additionalItems = it.schema.additionalItems;\n    if ($additionalItems === false) {\n      out += ' ' + ($valid) + ' = ' + ($data) + '.length <= ' + ($schema.length) + '; ';\n      var $currErrSchemaPath = $errSchemaPath;\n      $errSchemaPath = it.errSchemaPath + '/additionalItems';\n      out += '  if (!' + ($valid) + ') {   ';\n      var $$outStack = $$outStack || [];\n      $$outStack.push(out);\n      out = ''; /* istanbul ignore else */\n      if (it.createErrors !== false) {\n        out += ' { keyword: \\'' + ('additionalItems') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { limit: ' + ($schema.length) + ' } ';\n        if (it.opts.messages !== false) {\n          out += ' , message: \\'should NOT have more than ' + ($schema.length) + ' items\\' ';\n        }\n        if (it.opts.verbose) {\n          out += ' , schema: false , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n        }\n        out += ' } ';\n      } else {\n        out += ' {} ';\n      }\n      var __err = out;\n      out = $$outStack.pop();\n      if (!it.compositeRule && $breakOnError) {\n        /* istanbul ignore if */\n        if (it.async) {\n          out += ' throw new ValidationError([' + (__err) + ']); ';\n        } else {\n          out += ' validate.errors = [' + (__err) + ']; return false; ';\n        }\n      } else {\n        out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n      }\n      out += ' } ';\n      $errSchemaPath = $currErrSchemaPath;\n      if ($breakOnError) {\n        $closingBraces += '}';\n        out += ' else { ';\n      }\n    }\n    var arr1 = $schema;\n    if (arr1) {\n      var $sch, $i = -1,\n        l1 = arr1.length - 1;\n      while ($i < l1) {\n        $sch = arr1[$i += 1];\n        if ((it.opts.strictKeywords ? (typeof $sch == 'object' && Object.keys($sch).length > 0) || $sch === false : it.util.schemaHasRules($sch, it.RULES.all))) {\n          out += ' ' + ($nextValid) + ' = true; if (' + ($data) + '.length > ' + ($i) + ') { ';\n          var $passData = $data + '[' + $i + ']';\n          $it.schema = $sch;\n          $it.schemaPath = $schemaPath + '[' + $i + ']';\n          $it.errSchemaPath = $errSchemaPath + '/' + $i;\n          $it.errorPath = it.util.getPathExpr(it.errorPath, $i, it.opts.jsonPointers, true);\n          $it.dataPathArr[$dataNxt] = $i;\n          var $code = it.validate($it);\n          $it.baseId = $currentBaseId;\n          if (it.util.varOccurences($code, $nextData) < 2) {\n            out += ' ' + (it.util.varReplace($code, $nextData, $passData)) + ' ';\n          } else {\n            out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ' + ($code) + ' ';\n          }\n          out += ' }  ';\n          if ($breakOnError) {\n            out += ' if (' + ($nextValid) + ') { ';\n            $closingBraces += '}';\n          }\n        }\n      }\n    }\n    if (typeof $additionalItems == 'object' && (it.opts.strictKeywords ? (typeof $additionalItems == 'object' && Object.keys($additionalItems).length > 0) || $additionalItems === false : it.util.schemaHasRules($additionalItems, it.RULES.all))) {\n      $it.schema = $additionalItems;\n      $it.schemaPath = it.schemaPath + '.additionalItems';\n      $it.errSchemaPath = it.errSchemaPath + '/additionalItems';\n      out += ' ' + ($nextValid) + ' = true; if (' + ($data) + '.length > ' + ($schema.length) + ') {  for (var ' + ($idx) + ' = ' + ($schema.length) + '; ' + ($idx) + ' < ' + ($data) + '.length; ' + ($idx) + '++) { ';\n      $it.errorPath = it.util.getPathExpr(it.errorPath, $idx, it.opts.jsonPointers, true);\n      var $passData = $data + '[' + $idx + ']';\n      $it.dataPathArr[$dataNxt] = $idx;\n      var $code = it.validate($it);\n      $it.baseId = $currentBaseId;\n      if (it.util.varOccurences($code, $nextData) < 2) {\n        out += ' ' + (it.util.varReplace($code, $nextData, $passData)) + ' ';\n      } else {\n        out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ' + ($code) + ' ';\n      }\n      if ($breakOnError) {\n        out += ' if (!' + ($nextValid) + ') break; ';\n      }\n      out += ' } }  ';\n      if ($breakOnError) {\n        out += ' if (' + ($nextValid) + ') { ';\n        $closingBraces += '}';\n      }\n    }\n  } else if ((it.opts.strictKeywords ? (typeof $schema == 'object' && Object.keys($schema).length > 0) || $schema === false : it.util.schemaHasRules($schema, it.RULES.all))) {\n    $it.schema = $schema;\n    $it.schemaPath = $schemaPath;\n    $it.errSchemaPath = $errSchemaPath;\n    out += '  for (var ' + ($idx) + ' = ' + (0) + '; ' + ($idx) + ' < ' + ($data) + '.length; ' + ($idx) + '++) { ';\n    $it.errorPath = it.util.getPathExpr(it.errorPath, $idx, it.opts.jsonPointers, true);\n    var $passData = $data + '[' + $idx + ']';\n    $it.dataPathArr[$dataNxt] = $idx;\n    var $code = it.validate($it);\n    $it.baseId = $currentBaseId;\n    if (it.util.varOccurences($code, $nextData) < 2) {\n      out += ' ' + (it.util.varReplace($code, $nextData, $passData)) + ' ';\n    } else {\n      out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ' + ($code) + ' ';\n    }\n    if ($breakOnError) {\n      out += ' if (!' + ($nextValid) + ') break; ';\n    }\n    out += ' }';\n  }\n  if ($breakOnError) {\n    out += ' ' + ($closingBraces) + ' if (' + ($errs) + ' == errors) {';\n  }\n  return out;\n}\n","'use strict';\nmodule.exports = function generate_multipleOf(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $isData = it.opts.$data && $schema && $schema.$data,\n    $schemaValue;\n  if ($isData) {\n    out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; ';\n    $schemaValue = 'schema' + $lvl;\n  } else {\n    $schemaValue = $schema;\n  }\n  if (!($isData || typeof $schema == 'number')) {\n    throw new Error($keyword + ' must be number');\n  }\n  out += 'var division' + ($lvl) + ';if (';\n  if ($isData) {\n    out += ' ' + ($schemaValue) + ' !== undefined && ( typeof ' + ($schemaValue) + ' != \\'number\\' || ';\n  }\n  out += ' (division' + ($lvl) + ' = ' + ($data) + ' / ' + ($schemaValue) + ', ';\n  if (it.opts.multipleOfPrecision) {\n    out += ' Math.abs(Math.round(division' + ($lvl) + ') - division' + ($lvl) + ') > 1e-' + (it.opts.multipleOfPrecision) + ' ';\n  } else {\n    out += ' division' + ($lvl) + ' !== parseInt(division' + ($lvl) + ') ';\n  }\n  out += ' ) ';\n  if ($isData) {\n    out += '  )  ';\n  }\n  out += ' ) {   ';\n  var $$outStack = $$outStack || [];\n  $$outStack.push(out);\n  out = ''; /* istanbul ignore else */\n  if (it.createErrors !== false) {\n    out += ' { keyword: \\'' + ('multipleOf') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { multipleOf: ' + ($schemaValue) + ' } ';\n    if (it.opts.messages !== false) {\n      out += ' , message: \\'should be multiple of ';\n      if ($isData) {\n        out += '\\' + ' + ($schemaValue);\n      } else {\n        out += '' + ($schemaValue) + '\\'';\n      }\n    }\n    if (it.opts.verbose) {\n      out += ' , schema:  ';\n      if ($isData) {\n        out += 'validate.schema' + ($schemaPath);\n      } else {\n        out += '' + ($schema);\n      }\n      out += '         , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n    }\n    out += ' } ';\n  } else {\n    out += ' {} ';\n  }\n  var __err = out;\n  out = $$outStack.pop();\n  if (!it.compositeRule && $breakOnError) {\n    /* istanbul ignore if */\n    if (it.async) {\n      out += ' throw new ValidationError([' + (__err) + ']); ';\n    } else {\n      out += ' validate.errors = [' + (__err) + ']; return false; ';\n    }\n  } else {\n    out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n  }\n  out += '} ';\n  if ($breakOnError) {\n    out += ' else { ';\n  }\n  return out;\n}\n","'use strict';\nmodule.exports = function generate_not(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $errs = 'errs__' + $lvl;\n  var $it = it.util.copy(it);\n  $it.level++;\n  var $nextValid = 'valid' + $it.level;\n  if ((it.opts.strictKeywords ? (typeof $schema == 'object' && Object.keys($schema).length > 0) || $schema === false : it.util.schemaHasRules($schema, it.RULES.all))) {\n    $it.schema = $schema;\n    $it.schemaPath = $schemaPath;\n    $it.errSchemaPath = $errSchemaPath;\n    out += ' var ' + ($errs) + ' = errors;  ';\n    var $wasComposite = it.compositeRule;\n    it.compositeRule = $it.compositeRule = true;\n    $it.createErrors = false;\n    var $allErrorsOption;\n    if ($it.opts.allErrors) {\n      $allErrorsOption = $it.opts.allErrors;\n      $it.opts.allErrors = false;\n    }\n    out += ' ' + (it.validate($it)) + ' ';\n    $it.createErrors = true;\n    if ($allErrorsOption) $it.opts.allErrors = $allErrorsOption;\n    it.compositeRule = $it.compositeRule = $wasComposite;\n    out += ' if (' + ($nextValid) + ') {   ';\n    var $$outStack = $$outStack || [];\n    $$outStack.push(out);\n    out = ''; /* istanbul ignore else */\n    if (it.createErrors !== false) {\n      out += ' { keyword: \\'' + ('not') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: {} ';\n      if (it.opts.messages !== false) {\n        out += ' , message: \\'should NOT be valid\\' ';\n      }\n      if (it.opts.verbose) {\n        out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n      }\n      out += ' } ';\n    } else {\n      out += ' {} ';\n    }\n    var __err = out;\n    out = $$outStack.pop();\n    if (!it.compositeRule && $breakOnError) {\n      /* istanbul ignore if */\n      if (it.async) {\n        out += ' throw new ValidationError([' + (__err) + ']); ';\n      } else {\n        out += ' validate.errors = [' + (__err) + ']; return false; ';\n      }\n    } else {\n      out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n    }\n    out += ' } else {  errors = ' + ($errs) + '; if (vErrors !== null) { if (' + ($errs) + ') vErrors.length = ' + ($errs) + '; else vErrors = null; } ';\n    if (it.opts.allErrors) {\n      out += ' } ';\n    }\n  } else {\n    out += '  var err =   '; /* istanbul ignore else */\n    if (it.createErrors !== false) {\n      out += ' { keyword: \\'' + ('not') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: {} ';\n      if (it.opts.messages !== false) {\n        out += ' , message: \\'should NOT be valid\\' ';\n      }\n      if (it.opts.verbose) {\n        out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n      }\n      out += ' } ';\n    } else {\n      out += ' {} ';\n    }\n    out += ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n    if ($breakOnError) {\n      out += ' if (false) { ';\n    }\n  }\n  return out;\n}\n","'use strict';\nmodule.exports = function generate_oneOf(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $valid = 'valid' + $lvl;\n  var $errs = 'errs__' + $lvl;\n  var $it = it.util.copy(it);\n  var $closingBraces = '';\n  $it.level++;\n  var $nextValid = 'valid' + $it.level;\n  var $currentBaseId = $it.baseId,\n    $prevValid = 'prevValid' + $lvl,\n    $passingSchemas = 'passingSchemas' + $lvl;\n  out += 'var ' + ($errs) + ' = errors , ' + ($prevValid) + ' = false , ' + ($valid) + ' = false , ' + ($passingSchemas) + ' = null; ';\n  var $wasComposite = it.compositeRule;\n  it.compositeRule = $it.compositeRule = true;\n  var arr1 = $schema;\n  if (arr1) {\n    var $sch, $i = -1,\n      l1 = arr1.length - 1;\n    while ($i < l1) {\n      $sch = arr1[$i += 1];\n      if ((it.opts.strictKeywords ? (typeof $sch == 'object' && Object.keys($sch).length > 0) || $sch === false : it.util.schemaHasRules($sch, it.RULES.all))) {\n        $it.schema = $sch;\n        $it.schemaPath = $schemaPath + '[' + $i + ']';\n        $it.errSchemaPath = $errSchemaPath + '/' + $i;\n        out += '  ' + (it.validate($it)) + ' ';\n        $it.baseId = $currentBaseId;\n      } else {\n        out += ' var ' + ($nextValid) + ' = true; ';\n      }\n      if ($i) {\n        out += ' if (' + ($nextValid) + ' && ' + ($prevValid) + ') { ' + ($valid) + ' = false; ' + ($passingSchemas) + ' = [' + ($passingSchemas) + ', ' + ($i) + ']; } else { ';\n        $closingBraces += '}';\n      }\n      out += ' if (' + ($nextValid) + ') { ' + ($valid) + ' = ' + ($prevValid) + ' = true; ' + ($passingSchemas) + ' = ' + ($i) + '; }';\n    }\n  }\n  it.compositeRule = $it.compositeRule = $wasComposite;\n  out += '' + ($closingBraces) + 'if (!' + ($valid) + ') {   var err =   '; /* istanbul ignore else */\n  if (it.createErrors !== false) {\n    out += ' { keyword: \\'' + ('oneOf') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { passingSchemas: ' + ($passingSchemas) + ' } ';\n    if (it.opts.messages !== false) {\n      out += ' , message: \\'should match exactly one schema in oneOf\\' ';\n    }\n    if (it.opts.verbose) {\n      out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n    }\n    out += ' } ';\n  } else {\n    out += ' {} ';\n  }\n  out += ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n  if (!it.compositeRule && $breakOnError) {\n    /* istanbul ignore if */\n    if (it.async) {\n      out += ' throw new ValidationError(vErrors); ';\n    } else {\n      out += ' validate.errors = vErrors; return false; ';\n    }\n  }\n  out += '} else {  errors = ' + ($errs) + '; if (vErrors !== null) { if (' + ($errs) + ') vErrors.length = ' + ($errs) + '; else vErrors = null; }';\n  if (it.opts.allErrors) {\n    out += ' } ';\n  }\n  return out;\n}\n","'use strict';\nmodule.exports = function generate_pattern(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $isData = it.opts.$data && $schema && $schema.$data,\n    $schemaValue;\n  if ($isData) {\n    out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; ';\n    $schemaValue = 'schema' + $lvl;\n  } else {\n    $schemaValue = $schema;\n  }\n  var $regexp = $isData ? '(new RegExp(' + $schemaValue + '))' : it.usePattern($schema);\n  out += 'if ( ';\n  if ($isData) {\n    out += ' (' + ($schemaValue) + ' !== undefined && typeof ' + ($schemaValue) + ' != \\'string\\') || ';\n  }\n  out += ' !' + ($regexp) + '.test(' + ($data) + ') ) {   ';\n  var $$outStack = $$outStack || [];\n  $$outStack.push(out);\n  out = ''; /* istanbul ignore else */\n  if (it.createErrors !== false) {\n    out += ' { keyword: \\'' + ('pattern') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { pattern:  ';\n    if ($isData) {\n      out += '' + ($schemaValue);\n    } else {\n      out += '' + (it.util.toQuotedString($schema));\n    }\n    out += '  } ';\n    if (it.opts.messages !== false) {\n      out += ' , message: \\'should match pattern \"';\n      if ($isData) {\n        out += '\\' + ' + ($schemaValue) + ' + \\'';\n      } else {\n        out += '' + (it.util.escapeQuotes($schema));\n      }\n      out += '\"\\' ';\n    }\n    if (it.opts.verbose) {\n      out += ' , schema:  ';\n      if ($isData) {\n        out += 'validate.schema' + ($schemaPath);\n      } else {\n        out += '' + (it.util.toQuotedString($schema));\n      }\n      out += '         , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n    }\n    out += ' } ';\n  } else {\n    out += ' {} ';\n  }\n  var __err = out;\n  out = $$outStack.pop();\n  if (!it.compositeRule && $breakOnError) {\n    /* istanbul ignore if */\n    if (it.async) {\n      out += ' throw new ValidationError([' + (__err) + ']); ';\n    } else {\n      out += ' validate.errors = [' + (__err) + ']; return false; ';\n    }\n  } else {\n    out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n  }\n  out += '} ';\n  if ($breakOnError) {\n    out += ' else { ';\n  }\n  return out;\n}\n","'use strict';\nmodule.exports = function generate_properties(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $errs = 'errs__' + $lvl;\n  var $it = it.util.copy(it);\n  var $closingBraces = '';\n  $it.level++;\n  var $nextValid = 'valid' + $it.level;\n  var $key = 'key' + $lvl,\n    $idx = 'idx' + $lvl,\n    $dataNxt = $it.dataLevel = it.dataLevel + 1,\n    $nextData = 'data' + $dataNxt,\n    $dataProperties = 'dataProperties' + $lvl;\n  var $schemaKeys = Object.keys($schema || {}).filter(notProto),\n    $pProperties = it.schema.patternProperties || {},\n    $pPropertyKeys = Object.keys($pProperties).filter(notProto),\n    $aProperties = it.schema.additionalProperties,\n    $someProperties = $schemaKeys.length || $pPropertyKeys.length,\n    $noAdditional = $aProperties === false,\n    $additionalIsSchema = typeof $aProperties == 'object' && Object.keys($aProperties).length,\n    $removeAdditional = it.opts.removeAdditional,\n    $checkAdditional = $noAdditional || $additionalIsSchema || $removeAdditional,\n    $ownProperties = it.opts.ownProperties,\n    $currentBaseId = it.baseId;\n  var $required = it.schema.required;\n  if ($required && !(it.opts.$data && $required.$data) && $required.length < it.opts.loopRequired) {\n    var $requiredHash = it.util.toHash($required);\n  }\n\n  function notProto(p) {\n    return p !== '__proto__';\n  }\n  out += 'var ' + ($errs) + ' = errors;var ' + ($nextValid) + ' = true;';\n  if ($ownProperties) {\n    out += ' var ' + ($dataProperties) + ' = undefined;';\n  }\n  if ($checkAdditional) {\n    if ($ownProperties) {\n      out += ' ' + ($dataProperties) + ' = ' + ($dataProperties) + ' || Object.keys(' + ($data) + '); for (var ' + ($idx) + '=0; ' + ($idx) + '<' + ($dataProperties) + '.length; ' + ($idx) + '++) { var ' + ($key) + ' = ' + ($dataProperties) + '[' + ($idx) + ']; ';\n    } else {\n      out += ' for (var ' + ($key) + ' in ' + ($data) + ') { ';\n    }\n    if ($someProperties) {\n      out += ' var isAdditional' + ($lvl) + ' = !(false ';\n      if ($schemaKeys.length) {\n        if ($schemaKeys.length > 8) {\n          out += ' || validate.schema' + ($schemaPath) + '.hasOwnProperty(' + ($key) + ') ';\n        } else {\n          var arr1 = $schemaKeys;\n          if (arr1) {\n            var $propertyKey, i1 = -1,\n              l1 = arr1.length - 1;\n            while (i1 < l1) {\n              $propertyKey = arr1[i1 += 1];\n              out += ' || ' + ($key) + ' == ' + (it.util.toQuotedString($propertyKey)) + ' ';\n            }\n          }\n        }\n      }\n      if ($pPropertyKeys.length) {\n        var arr2 = $pPropertyKeys;\n        if (arr2) {\n          var $pProperty, $i = -1,\n            l2 = arr2.length - 1;\n          while ($i < l2) {\n            $pProperty = arr2[$i += 1];\n            out += ' || ' + (it.usePattern($pProperty)) + '.test(' + ($key) + ') ';\n          }\n        }\n      }\n      out += ' ); if (isAdditional' + ($lvl) + ') { ';\n    }\n    if ($removeAdditional == 'all') {\n      out += ' delete ' + ($data) + '[' + ($key) + ']; ';\n    } else {\n      var $currentErrorPath = it.errorPath;\n      var $additionalProperty = '\\' + ' + $key + ' + \\'';\n      if (it.opts._errorDataPathProperty) {\n        it.errorPath = it.util.getPathExpr(it.errorPath, $key, it.opts.jsonPointers);\n      }\n      if ($noAdditional) {\n        if ($removeAdditional) {\n          out += ' delete ' + ($data) + '[' + ($key) + ']; ';\n        } else {\n          out += ' ' + ($nextValid) + ' = false; ';\n          var $currErrSchemaPath = $errSchemaPath;\n          $errSchemaPath = it.errSchemaPath + '/additionalProperties';\n          var $$outStack = $$outStack || [];\n          $$outStack.push(out);\n          out = ''; /* istanbul ignore else */\n          if (it.createErrors !== false) {\n            out += ' { keyword: \\'' + ('additionalProperties') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { additionalProperty: \\'' + ($additionalProperty) + '\\' } ';\n            if (it.opts.messages !== false) {\n              out += ' , message: \\'';\n              if (it.opts._errorDataPathProperty) {\n                out += 'is an invalid additional property';\n              } else {\n                out += 'should NOT have additional properties';\n              }\n              out += '\\' ';\n            }\n            if (it.opts.verbose) {\n              out += ' , schema: false , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n            }\n            out += ' } ';\n          } else {\n            out += ' {} ';\n          }\n          var __err = out;\n          out = $$outStack.pop();\n          if (!it.compositeRule && $breakOnError) {\n            /* istanbul ignore if */\n            if (it.async) {\n              out += ' throw new ValidationError([' + (__err) + ']); ';\n            } else {\n              out += ' validate.errors = [' + (__err) + ']; return false; ';\n            }\n          } else {\n            out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n          }\n          $errSchemaPath = $currErrSchemaPath;\n          if ($breakOnError) {\n            out += ' break; ';\n          }\n        }\n      } else if ($additionalIsSchema) {\n        if ($removeAdditional == 'failing') {\n          out += ' var ' + ($errs) + ' = errors;  ';\n          var $wasComposite = it.compositeRule;\n          it.compositeRule = $it.compositeRule = true;\n          $it.schema = $aProperties;\n          $it.schemaPath = it.schemaPath + '.additionalProperties';\n          $it.errSchemaPath = it.errSchemaPath + '/additionalProperties';\n          $it.errorPath = it.opts._errorDataPathProperty ? it.errorPath : it.util.getPathExpr(it.errorPath, $key, it.opts.jsonPointers);\n          var $passData = $data + '[' + $key + ']';\n          $it.dataPathArr[$dataNxt] = $key;\n          var $code = it.validate($it);\n          $it.baseId = $currentBaseId;\n          if (it.util.varOccurences($code, $nextData) < 2) {\n            out += ' ' + (it.util.varReplace($code, $nextData, $passData)) + ' ';\n          } else {\n            out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ' + ($code) + ' ';\n          }\n          out += ' if (!' + ($nextValid) + ') { errors = ' + ($errs) + '; if (validate.errors !== null) { if (errors) validate.errors.length = errors; else validate.errors = null; } delete ' + ($data) + '[' + ($key) + ']; }  ';\n          it.compositeRule = $it.compositeRule = $wasComposite;\n        } else {\n          $it.schema = $aProperties;\n          $it.schemaPath = it.schemaPath + '.additionalProperties';\n          $it.errSchemaPath = it.errSchemaPath + '/additionalProperties';\n          $it.errorPath = it.opts._errorDataPathProperty ? it.errorPath : it.util.getPathExpr(it.errorPath, $key, it.opts.jsonPointers);\n          var $passData = $data + '[' + $key + ']';\n          $it.dataPathArr[$dataNxt] = $key;\n          var $code = it.validate($it);\n          $it.baseId = $currentBaseId;\n          if (it.util.varOccurences($code, $nextData) < 2) {\n            out += ' ' + (it.util.varReplace($code, $nextData, $passData)) + ' ';\n          } else {\n            out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ' + ($code) + ' ';\n          }\n          if ($breakOnError) {\n            out += ' if (!' + ($nextValid) + ') break; ';\n          }\n        }\n      }\n      it.errorPath = $currentErrorPath;\n    }\n    if ($someProperties) {\n      out += ' } ';\n    }\n    out += ' }  ';\n    if ($breakOnError) {\n      out += ' if (' + ($nextValid) + ') { ';\n      $closingBraces += '}';\n    }\n  }\n  var $useDefaults = it.opts.useDefaults && !it.compositeRule;\n  if ($schemaKeys.length) {\n    var arr3 = $schemaKeys;\n    if (arr3) {\n      var $propertyKey, i3 = -1,\n        l3 = arr3.length - 1;\n      while (i3 < l3) {\n        $propertyKey = arr3[i3 += 1];\n        var $sch = $schema[$propertyKey];\n        if ((it.opts.strictKeywords ? (typeof $sch == 'object' && Object.keys($sch).length > 0) || $sch === false : it.util.schemaHasRules($sch, it.RULES.all))) {\n          var $prop = it.util.getProperty($propertyKey),\n            $passData = $data + $prop,\n            $hasDefault = $useDefaults && $sch.default !== undefined;\n          $it.schema = $sch;\n          $it.schemaPath = $schemaPath + $prop;\n          $it.errSchemaPath = $errSchemaPath + '/' + it.util.escapeFragment($propertyKey);\n          $it.errorPath = it.util.getPath(it.errorPath, $propertyKey, it.opts.jsonPointers);\n          $it.dataPathArr[$dataNxt] = it.util.toQuotedString($propertyKey);\n          var $code = it.validate($it);\n          $it.baseId = $currentBaseId;\n          if (it.util.varOccurences($code, $nextData) < 2) {\n            $code = it.util.varReplace($code, $nextData, $passData);\n            var $useData = $passData;\n          } else {\n            var $useData = $nextData;\n            out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ';\n          }\n          if ($hasDefault) {\n            out += ' ' + ($code) + ' ';\n          } else {\n            if ($requiredHash && $requiredHash[$propertyKey]) {\n              out += ' if ( ' + ($useData) + ' === undefined ';\n              if ($ownProperties) {\n                out += ' || ! Object.prototype.hasOwnProperty.call(' + ($data) + ', \\'' + (it.util.escapeQuotes($propertyKey)) + '\\') ';\n              }\n              out += ') { ' + ($nextValid) + ' = false; ';\n              var $currentErrorPath = it.errorPath,\n                $currErrSchemaPath = $errSchemaPath,\n                $missingProperty = it.util.escapeQuotes($propertyKey);\n              if (it.opts._errorDataPathProperty) {\n                it.errorPath = it.util.getPath($currentErrorPath, $propertyKey, it.opts.jsonPointers);\n              }\n              $errSchemaPath = it.errSchemaPath + '/required';\n              var $$outStack = $$outStack || [];\n              $$outStack.push(out);\n              out = ''; /* istanbul ignore else */\n              if (it.createErrors !== false) {\n                out += ' { keyword: \\'' + ('required') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { missingProperty: \\'' + ($missingProperty) + '\\' } ';\n                if (it.opts.messages !== false) {\n                  out += ' , message: \\'';\n                  if (it.opts._errorDataPathProperty) {\n                    out += 'is a required property';\n                  } else {\n                    out += 'should have required property \\\\\\'' + ($missingProperty) + '\\\\\\'';\n                  }\n                  out += '\\' ';\n                }\n                if (it.opts.verbose) {\n                  out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n                }\n                out += ' } ';\n              } else {\n                out += ' {} ';\n              }\n              var __err = out;\n              out = $$outStack.pop();\n              if (!it.compositeRule && $breakOnError) {\n                /* istanbul ignore if */\n                if (it.async) {\n                  out += ' throw new ValidationError([' + (__err) + ']); ';\n                } else {\n                  out += ' validate.errors = [' + (__err) + ']; return false; ';\n                }\n              } else {\n                out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n              }\n              $errSchemaPath = $currErrSchemaPath;\n              it.errorPath = $currentErrorPath;\n              out += ' } else { ';\n            } else {\n              if ($breakOnError) {\n                out += ' if ( ' + ($useData) + ' === undefined ';\n                if ($ownProperties) {\n                  out += ' || ! Object.prototype.hasOwnProperty.call(' + ($data) + ', \\'' + (it.util.escapeQuotes($propertyKey)) + '\\') ';\n                }\n                out += ') { ' + ($nextValid) + ' = true; } else { ';\n              } else {\n                out += ' if (' + ($useData) + ' !== undefined ';\n                if ($ownProperties) {\n                  out += ' &&   Object.prototype.hasOwnProperty.call(' + ($data) + ', \\'' + (it.util.escapeQuotes($propertyKey)) + '\\') ';\n                }\n                out += ' ) { ';\n              }\n            }\n            out += ' ' + ($code) + ' } ';\n          }\n        }\n        if ($breakOnError) {\n          out += ' if (' + ($nextValid) + ') { ';\n          $closingBraces += '}';\n        }\n      }\n    }\n  }\n  if ($pPropertyKeys.length) {\n    var arr4 = $pPropertyKeys;\n    if (arr4) {\n      var $pProperty, i4 = -1,\n        l4 = arr4.length - 1;\n      while (i4 < l4) {\n        $pProperty = arr4[i4 += 1];\n        var $sch = $pProperties[$pProperty];\n        if ((it.opts.strictKeywords ? (typeof $sch == 'object' && Object.keys($sch).length > 0) || $sch === false : it.util.schemaHasRules($sch, it.RULES.all))) {\n          $it.schema = $sch;\n          $it.schemaPath = it.schemaPath + '.patternProperties' + it.util.getProperty($pProperty);\n          $it.errSchemaPath = it.errSchemaPath + '/patternProperties/' + it.util.escapeFragment($pProperty);\n          if ($ownProperties) {\n            out += ' ' + ($dataProperties) + ' = ' + ($dataProperties) + ' || Object.keys(' + ($data) + '); for (var ' + ($idx) + '=0; ' + ($idx) + '<' + ($dataProperties) + '.length; ' + ($idx) + '++) { var ' + ($key) + ' = ' + ($dataProperties) + '[' + ($idx) + ']; ';\n          } else {\n            out += ' for (var ' + ($key) + ' in ' + ($data) + ') { ';\n          }\n          out += ' if (' + (it.usePattern($pProperty)) + '.test(' + ($key) + ')) { ';\n          $it.errorPath = it.util.getPathExpr(it.errorPath, $key, it.opts.jsonPointers);\n          var $passData = $data + '[' + $key + ']';\n          $it.dataPathArr[$dataNxt] = $key;\n          var $code = it.validate($it);\n          $it.baseId = $currentBaseId;\n          if (it.util.varOccurences($code, $nextData) < 2) {\n            out += ' ' + (it.util.varReplace($code, $nextData, $passData)) + ' ';\n          } else {\n            out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ' + ($code) + ' ';\n          }\n          if ($breakOnError) {\n            out += ' if (!' + ($nextValid) + ') break; ';\n          }\n          out += ' } ';\n          if ($breakOnError) {\n            out += ' else ' + ($nextValid) + ' = true; ';\n          }\n          out += ' }  ';\n          if ($breakOnError) {\n            out += ' if (' + ($nextValid) + ') { ';\n            $closingBraces += '}';\n          }\n        }\n      }\n    }\n  }\n  if ($breakOnError) {\n    out += ' ' + ($closingBraces) + ' if (' + ($errs) + ' == errors) {';\n  }\n  return out;\n}\n","'use strict';\nmodule.exports = function generate_propertyNames(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $errs = 'errs__' + $lvl;\n  var $it = it.util.copy(it);\n  var $closingBraces = '';\n  $it.level++;\n  var $nextValid = 'valid' + $it.level;\n  out += 'var ' + ($errs) + ' = errors;';\n  if ((it.opts.strictKeywords ? (typeof $schema == 'object' && Object.keys($schema).length > 0) || $schema === false : it.util.schemaHasRules($schema, it.RULES.all))) {\n    $it.schema = $schema;\n    $it.schemaPath = $schemaPath;\n    $it.errSchemaPath = $errSchemaPath;\n    var $key = 'key' + $lvl,\n      $idx = 'idx' + $lvl,\n      $i = 'i' + $lvl,\n      $invalidName = '\\' + ' + $key + ' + \\'',\n      $dataNxt = $it.dataLevel = it.dataLevel + 1,\n      $nextData = 'data' + $dataNxt,\n      $dataProperties = 'dataProperties' + $lvl,\n      $ownProperties = it.opts.ownProperties,\n      $currentBaseId = it.baseId;\n    if ($ownProperties) {\n      out += ' var ' + ($dataProperties) + ' = undefined; ';\n    }\n    if ($ownProperties) {\n      out += ' ' + ($dataProperties) + ' = ' + ($dataProperties) + ' || Object.keys(' + ($data) + '); for (var ' + ($idx) + '=0; ' + ($idx) + '<' + ($dataProperties) + '.length; ' + ($idx) + '++) { var ' + ($key) + ' = ' + ($dataProperties) + '[' + ($idx) + ']; ';\n    } else {\n      out += ' for (var ' + ($key) + ' in ' + ($data) + ') { ';\n    }\n    out += ' var startErrs' + ($lvl) + ' = errors; ';\n    var $passData = $key;\n    var $wasComposite = it.compositeRule;\n    it.compositeRule = $it.compositeRule = true;\n    var $code = it.validate($it);\n    $it.baseId = $currentBaseId;\n    if (it.util.varOccurences($code, $nextData) < 2) {\n      out += ' ' + (it.util.varReplace($code, $nextData, $passData)) + ' ';\n    } else {\n      out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ' + ($code) + ' ';\n    }\n    it.compositeRule = $it.compositeRule = $wasComposite;\n    out += ' if (!' + ($nextValid) + ') { for (var ' + ($i) + '=startErrs' + ($lvl) + '; ' + ($i) + '<errors; ' + ($i) + '++) { vErrors[' + ($i) + '].propertyName = ' + ($key) + '; }   var err =   '; /* istanbul ignore else */\n    if (it.createErrors !== false) {\n      out += ' { keyword: \\'' + ('propertyNames') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { propertyName: \\'' + ($invalidName) + '\\' } ';\n      if (it.opts.messages !== false) {\n        out += ' , message: \\'property name \\\\\\'' + ($invalidName) + '\\\\\\' is invalid\\' ';\n      }\n      if (it.opts.verbose) {\n        out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n      }\n      out += ' } ';\n    } else {\n      out += ' {} ';\n    }\n    out += ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n    if (!it.compositeRule && $breakOnError) {\n      /* istanbul ignore if */\n      if (it.async) {\n        out += ' throw new ValidationError(vErrors); ';\n      } else {\n        out += ' validate.errors = vErrors; return false; ';\n      }\n    }\n    if ($breakOnError) {\n      out += ' break; ';\n    }\n    out += ' } }';\n  }\n  if ($breakOnError) {\n    out += ' ' + ($closingBraces) + ' if (' + ($errs) + ' == errors) {';\n  }\n  return out;\n}\n","'use strict';\nmodule.exports = function generate_required(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $valid = 'valid' + $lvl;\n  var $isData = it.opts.$data && $schema && $schema.$data,\n    $schemaValue;\n  if ($isData) {\n    out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; ';\n    $schemaValue = 'schema' + $lvl;\n  } else {\n    $schemaValue = $schema;\n  }\n  var $vSchema = 'schema' + $lvl;\n  if (!$isData) {\n    if ($schema.length < it.opts.loopRequired && it.schema.properties && Object.keys(it.schema.properties).length) {\n      var $required = [];\n      var arr1 = $schema;\n      if (arr1) {\n        var $property, i1 = -1,\n          l1 = arr1.length - 1;\n        while (i1 < l1) {\n          $property = arr1[i1 += 1];\n          var $propertySch = it.schema.properties[$property];\n          if (!($propertySch && (it.opts.strictKeywords ? (typeof $propertySch == 'object' && Object.keys($propertySch).length > 0) || $propertySch === false : it.util.schemaHasRules($propertySch, it.RULES.all)))) {\n            $required[$required.length] = $property;\n          }\n        }\n      }\n    } else {\n      var $required = $schema;\n    }\n  }\n  if ($isData || $required.length) {\n    var $currentErrorPath = it.errorPath,\n      $loopRequired = $isData || $required.length >= it.opts.loopRequired,\n      $ownProperties = it.opts.ownProperties;\n    if ($breakOnError) {\n      out += ' var missing' + ($lvl) + '; ';\n      if ($loopRequired) {\n        if (!$isData) {\n          out += ' var ' + ($vSchema) + ' = validate.schema' + ($schemaPath) + '; ';\n        }\n        var $i = 'i' + $lvl,\n          $propertyPath = 'schema' + $lvl + '[' + $i + ']',\n          $missingProperty = '\\' + ' + $propertyPath + ' + \\'';\n        if (it.opts._errorDataPathProperty) {\n          it.errorPath = it.util.getPathExpr($currentErrorPath, $propertyPath, it.opts.jsonPointers);\n        }\n        out += ' var ' + ($valid) + ' = true; ';\n        if ($isData) {\n          out += ' if (schema' + ($lvl) + ' === undefined) ' + ($valid) + ' = true; else if (!Array.isArray(schema' + ($lvl) + ')) ' + ($valid) + ' = false; else {';\n        }\n        out += ' for (var ' + ($i) + ' = 0; ' + ($i) + ' < ' + ($vSchema) + '.length; ' + ($i) + '++) { ' + ($valid) + ' = ' + ($data) + '[' + ($vSchema) + '[' + ($i) + ']] !== undefined ';\n        if ($ownProperties) {\n          out += ' &&   Object.prototype.hasOwnProperty.call(' + ($data) + ', ' + ($vSchema) + '[' + ($i) + ']) ';\n        }\n        out += '; if (!' + ($valid) + ') break; } ';\n        if ($isData) {\n          out += '  }  ';\n        }\n        out += '  if (!' + ($valid) + ') {   ';\n        var $$outStack = $$outStack || [];\n        $$outStack.push(out);\n        out = ''; /* istanbul ignore else */\n        if (it.createErrors !== false) {\n          out += ' { keyword: \\'' + ('required') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { missingProperty: \\'' + ($missingProperty) + '\\' } ';\n          if (it.opts.messages !== false) {\n            out += ' , message: \\'';\n            if (it.opts._errorDataPathProperty) {\n              out += 'is a required property';\n            } else {\n              out += 'should have required property \\\\\\'' + ($missingProperty) + '\\\\\\'';\n            }\n            out += '\\' ';\n          }\n          if (it.opts.verbose) {\n            out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n          }\n          out += ' } ';\n        } else {\n          out += ' {} ';\n        }\n        var __err = out;\n        out = $$outStack.pop();\n        if (!it.compositeRule && $breakOnError) {\n          /* istanbul ignore if */\n          if (it.async) {\n            out += ' throw new ValidationError([' + (__err) + ']); ';\n          } else {\n            out += ' validate.errors = [' + (__err) + ']; return false; ';\n          }\n        } else {\n          out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n        }\n        out += ' } else { ';\n      } else {\n        out += ' if ( ';\n        var arr2 = $required;\n        if (arr2) {\n          var $propertyKey, $i = -1,\n            l2 = arr2.length - 1;\n          while ($i < l2) {\n            $propertyKey = arr2[$i += 1];\n            if ($i) {\n              out += ' || ';\n            }\n            var $prop = it.util.getProperty($propertyKey),\n              $useData = $data + $prop;\n            out += ' ( ( ' + ($useData) + ' === undefined ';\n            if ($ownProperties) {\n              out += ' || ! Object.prototype.hasOwnProperty.call(' + ($data) + ', \\'' + (it.util.escapeQuotes($propertyKey)) + '\\') ';\n            }\n            out += ') && (missing' + ($lvl) + ' = ' + (it.util.toQuotedString(it.opts.jsonPointers ? $propertyKey : $prop)) + ') ) ';\n          }\n        }\n        out += ') {  ';\n        var $propertyPath = 'missing' + $lvl,\n          $missingProperty = '\\' + ' + $propertyPath + ' + \\'';\n        if (it.opts._errorDataPathProperty) {\n          it.errorPath = it.opts.jsonPointers ? it.util.getPathExpr($currentErrorPath, $propertyPath, true) : $currentErrorPath + ' + ' + $propertyPath;\n        }\n        var $$outStack = $$outStack || [];\n        $$outStack.push(out);\n        out = ''; /* istanbul ignore else */\n        if (it.createErrors !== false) {\n          out += ' { keyword: \\'' + ('required') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { missingProperty: \\'' + ($missingProperty) + '\\' } ';\n          if (it.opts.messages !== false) {\n            out += ' , message: \\'';\n            if (it.opts._errorDataPathProperty) {\n              out += 'is a required property';\n            } else {\n              out += 'should have required property \\\\\\'' + ($missingProperty) + '\\\\\\'';\n            }\n            out += '\\' ';\n          }\n          if (it.opts.verbose) {\n            out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n          }\n          out += ' } ';\n        } else {\n          out += ' {} ';\n        }\n        var __err = out;\n        out = $$outStack.pop();\n        if (!it.compositeRule && $breakOnError) {\n          /* istanbul ignore if */\n          if (it.async) {\n            out += ' throw new ValidationError([' + (__err) + ']); ';\n          } else {\n            out += ' validate.errors = [' + (__err) + ']; return false; ';\n          }\n        } else {\n          out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n        }\n        out += ' } else { ';\n      }\n    } else {\n      if ($loopRequired) {\n        if (!$isData) {\n          out += ' var ' + ($vSchema) + ' = validate.schema' + ($schemaPath) + '; ';\n        }\n        var $i = 'i' + $lvl,\n          $propertyPath = 'schema' + $lvl + '[' + $i + ']',\n          $missingProperty = '\\' + ' + $propertyPath + ' + \\'';\n        if (it.opts._errorDataPathProperty) {\n          it.errorPath = it.util.getPathExpr($currentErrorPath, $propertyPath, it.opts.jsonPointers);\n        }\n        if ($isData) {\n          out += ' if (' + ($vSchema) + ' && !Array.isArray(' + ($vSchema) + ')) {  var err =   '; /* istanbul ignore else */\n          if (it.createErrors !== false) {\n            out += ' { keyword: \\'' + ('required') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { missingProperty: \\'' + ($missingProperty) + '\\' } ';\n            if (it.opts.messages !== false) {\n              out += ' , message: \\'';\n              if (it.opts._errorDataPathProperty) {\n                out += 'is a required property';\n              } else {\n                out += 'should have required property \\\\\\'' + ($missingProperty) + '\\\\\\'';\n              }\n              out += '\\' ';\n            }\n            if (it.opts.verbose) {\n              out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n            }\n            out += ' } ';\n          } else {\n            out += ' {} ';\n          }\n          out += ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; } else if (' + ($vSchema) + ' !== undefined) { ';\n        }\n        out += ' for (var ' + ($i) + ' = 0; ' + ($i) + ' < ' + ($vSchema) + '.length; ' + ($i) + '++) { if (' + ($data) + '[' + ($vSchema) + '[' + ($i) + ']] === undefined ';\n        if ($ownProperties) {\n          out += ' || ! Object.prototype.hasOwnProperty.call(' + ($data) + ', ' + ($vSchema) + '[' + ($i) + ']) ';\n        }\n        out += ') {  var err =   '; /* istanbul ignore else */\n        if (it.createErrors !== false) {\n          out += ' { keyword: \\'' + ('required') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { missingProperty: \\'' + ($missingProperty) + '\\' } ';\n          if (it.opts.messages !== false) {\n            out += ' , message: \\'';\n            if (it.opts._errorDataPathProperty) {\n              out += 'is a required property';\n            } else {\n              out += 'should have required property \\\\\\'' + ($missingProperty) + '\\\\\\'';\n            }\n            out += '\\' ';\n          }\n          if (it.opts.verbose) {\n            out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n          }\n          out += ' } ';\n        } else {\n          out += ' {} ';\n        }\n        out += ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; } } ';\n        if ($isData) {\n          out += '  }  ';\n        }\n      } else {\n        var arr3 = $required;\n        if (arr3) {\n          var $propertyKey, i3 = -1,\n            l3 = arr3.length - 1;\n          while (i3 < l3) {\n            $propertyKey = arr3[i3 += 1];\n            var $prop = it.util.getProperty($propertyKey),\n              $missingProperty = it.util.escapeQuotes($propertyKey),\n              $useData = $data + $prop;\n            if (it.opts._errorDataPathProperty) {\n              it.errorPath = it.util.getPath($currentErrorPath, $propertyKey, it.opts.jsonPointers);\n            }\n            out += ' if ( ' + ($useData) + ' === undefined ';\n            if ($ownProperties) {\n              out += ' || ! Object.prototype.hasOwnProperty.call(' + ($data) + ', \\'' + (it.util.escapeQuotes($propertyKey)) + '\\') ';\n            }\n            out += ') {  var err =   '; /* istanbul ignore else */\n            if (it.createErrors !== false) {\n              out += ' { keyword: \\'' + ('required') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { missingProperty: \\'' + ($missingProperty) + '\\' } ';\n              if (it.opts.messages !== false) {\n                out += ' , message: \\'';\n                if (it.opts._errorDataPathProperty) {\n                  out += 'is a required property';\n                } else {\n                  out += 'should have required property \\\\\\'' + ($missingProperty) + '\\\\\\'';\n                }\n                out += '\\' ';\n              }\n              if (it.opts.verbose) {\n                out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n              }\n              out += ' } ';\n            } else {\n              out += ' {} ';\n            }\n            out += ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; } ';\n          }\n        }\n      }\n    }\n    it.errorPath = $currentErrorPath;\n  } else if ($breakOnError) {\n    out += ' if (true) {';\n  }\n  return out;\n}\n","'use strict';\nmodule.exports = function generate_uniqueItems(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $valid = 'valid' + $lvl;\n  var $isData = it.opts.$data && $schema && $schema.$data,\n    $schemaValue;\n  if ($isData) {\n    out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; ';\n    $schemaValue = 'schema' + $lvl;\n  } else {\n    $schemaValue = $schema;\n  }\n  if (($schema || $isData) && it.opts.uniqueItems !== false) {\n    if ($isData) {\n      out += ' var ' + ($valid) + '; if (' + ($schemaValue) + ' === false || ' + ($schemaValue) + ' === undefined) ' + ($valid) + ' = true; else if (typeof ' + ($schemaValue) + ' != \\'boolean\\') ' + ($valid) + ' = false; else { ';\n    }\n    out += ' var i = ' + ($data) + '.length , ' + ($valid) + ' = true , j; if (i > 1) { ';\n    var $itemType = it.schema.items && it.schema.items.type,\n      $typeIsArray = Array.isArray($itemType);\n    if (!$itemType || $itemType == 'object' || $itemType == 'array' || ($typeIsArray && ($itemType.indexOf('object') >= 0 || $itemType.indexOf('array') >= 0))) {\n      out += ' outer: for (;i--;) { for (j = i; j--;) { if (equal(' + ($data) + '[i], ' + ($data) + '[j])) { ' + ($valid) + ' = false; break outer; } } } ';\n    } else {\n      out += ' var itemIndices = {}, item; for (;i--;) { var item = ' + ($data) + '[i]; ';\n      var $method = 'checkDataType' + ($typeIsArray ? 's' : '');\n      out += ' if (' + (it.util[$method]($itemType, 'item', it.opts.strictNumbers, true)) + ') continue; ';\n      if ($typeIsArray) {\n        out += ' if (typeof item == \\'string\\') item = \\'\"\\' + item; ';\n      }\n      out += ' if (typeof itemIndices[item] == \\'number\\') { ' + ($valid) + ' = false; j = itemIndices[item]; break; } itemIndices[item] = i; } ';\n    }\n    out += ' } ';\n    if ($isData) {\n      out += '  }  ';\n    }\n    out += ' if (!' + ($valid) + ') {   ';\n    var $$outStack = $$outStack || [];\n    $$outStack.push(out);\n    out = ''; /* istanbul ignore else */\n    if (it.createErrors !== false) {\n      out += ' { keyword: \\'' + ('uniqueItems') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { i: i, j: j } ';\n      if (it.opts.messages !== false) {\n        out += ' , message: \\'should NOT have duplicate items (items ## \\' + j + \\' and \\' + i + \\' are identical)\\' ';\n      }\n      if (it.opts.verbose) {\n        out += ' , schema:  ';\n        if ($isData) {\n          out += 'validate.schema' + ($schemaPath);\n        } else {\n          out += '' + ($schema);\n        }\n        out += '         , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n      }\n      out += ' } ';\n    } else {\n      out += ' {} ';\n    }\n    var __err = out;\n    out = $$outStack.pop();\n    if (!it.compositeRule && $breakOnError) {\n      /* istanbul ignore if */\n      if (it.async) {\n        out += ' throw new ValidationError([' + (__err) + ']); ';\n      } else {\n        out += ' validate.errors = [' + (__err) + ']; return false; ';\n      }\n    } else {\n      out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n    }\n    out += ' } ';\n    if ($breakOnError) {\n      out += ' else { ';\n    }\n  } else {\n    if ($breakOnError) {\n      out += ' if (true) { ';\n    }\n  }\n  return out;\n}\n","'use strict';\n\nvar KEYWORDS = [\n  'multipleOf',\n  'maximum',\n  'exclusiveMaximum',\n  'minimum',\n  'exclusiveMinimum',\n  'maxLength',\n  'minLength',\n  'pattern',\n  'additionalItems',\n  'maxItems',\n  'minItems',\n  'uniqueItems',\n  'maxProperties',\n  'minProperties',\n  'required',\n  'additionalProperties',\n  'enum',\n  'format',\n  'const'\n];\n\nmodule.exports = function (metaSchema, keywordsJsonPointers) {\n  for (var i=0; i<keywordsJsonPointers.length; i++) {\n    metaSchema = JSON.parse(JSON.stringify(metaSchema));\n    var segments = keywordsJsonPointers[i].split('/');\n    var keywords = metaSchema;\n    var j;\n    for (j=1; j<segments.length; j++)\n      keywords = keywords[segments[j]];\n\n    for (j=0; j<KEYWORDS.length; j++) {\n      var key = KEYWORDS[j];\n      var schema = keywords[key];\n      if (schema) {\n        keywords[key] = {\n          anyOf: [\n            schema,\n            { $ref: 'https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#' }\n          ]\n        };\n      }\n    }\n  }\n\n  return metaSchema;\n};\n","'use strict';\n\nvar MissingRefError = require('./error_classes').MissingRef;\n\nmodule.exports = compileAsync;\n\n\n/**\n * Creates validating function for passed schema with asynchronous loading of missing schemas.\n * `loadSchema` option should be a function that accepts schema uri and returns promise that resolves with the schema.\n * @this  Ajv\n * @param {Object}   schema schema object\n * @param {Boolean}  meta optional true to compile meta-schema; this parameter can be skipped\n * @param {Function} callback an optional node-style callback, it is called with 2 parameters: error (or null) and validating function.\n * @return {Promise} promise that resolves with a validating function.\n */\nfunction compileAsync(schema, meta, callback) {\n  /* eslint no-shadow: 0 */\n  /* global Promise */\n  /* jshint validthis: true */\n  var self = this;\n  if (typeof this._opts.loadSchema != 'function')\n    throw new Error('options.loadSchema should be a function');\n\n  if (typeof meta == 'function') {\n    callback = meta;\n    meta = undefined;\n  }\n\n  var p = loadMetaSchemaOf(schema).then(function () {\n    var schemaObj = self._addSchema(schema, undefined, meta);\n    return schemaObj.validate || _compileAsync(schemaObj);\n  });\n\n  if (callback) {\n    p.then(\n      function(v) { callback(null, v); },\n      callback\n    );\n  }\n\n  return p;\n\n\n  function loadMetaSchemaOf(sch) {\n    var $schema = sch.$schema;\n    return $schema && !self.getSchema($schema)\n            ? compileAsync.call(self, { $ref: $schema }, true)\n            : Promise.resolve();\n  }\n\n\n  function _compileAsync(schemaObj) {\n    try { return self._compile(schemaObj); }\n    catch(e) {\n      if (e instanceof MissingRefError) return loadMissingSchema(e);\n      throw e;\n    }\n\n\n    function loadMissingSchema(e) {\n      var ref = e.missingSchema;\n      if (added(ref)) throw new Error('Schema ' + ref + ' is loaded but ' + e.missingRef + ' cannot be resolved');\n\n      var schemaPromise = self._loadingSchemas[ref];\n      if (!schemaPromise) {\n        schemaPromise = self._loadingSchemas[ref] = self._opts.loadSchema(ref);\n        schemaPromise.then(removePromise, removePromise);\n      }\n\n      return schemaPromise.then(function (sch) {\n        if (!added(ref)) {\n          return loadMetaSchemaOf(sch).then(function () {\n            if (!added(ref)) self.addSchema(sch, ref, undefined, meta);\n          });\n        }\n      }).then(function() {\n        return _compileAsync(schemaObj);\n      });\n\n      function removePromise() {\n        delete self._loadingSchemas[ref];\n      }\n\n      function added(ref) {\n        return self._refs[ref] || self._schemas[ref];\n      }\n    }\n  }\n}\n","'use strict';\n\nvar IDENTIFIER = /^[a-z_$][a-z0-9_$-]*$/i;\nvar customRuleCode = require('./dotjs/custom');\nvar definitionSchema = require('./definition_schema');\n\nmodule.exports = {\n  add: addKeyword,\n  get: getKeyword,\n  remove: removeKeyword,\n  validate: validateKeyword\n};\n\n\n/**\n * Define custom keyword\n * @this  Ajv\n * @param {String} keyword custom keyword, should be unique (including different from all standard, custom and macro keywords).\n * @param {Object} definition keyword definition object with properties `type` (type(s) which the keyword applies to), `validate` or `compile`.\n * @return {Ajv} this for method chaining\n */\nfunction addKeyword(keyword, definition) {\n  /* jshint validthis: true */\n  /* eslint no-shadow: 0 */\n  var RULES = this.RULES;\n  if (RULES.keywords[keyword])\n    throw new Error('Keyword ' + keyword + ' is already defined');\n\n  if (!IDENTIFIER.test(keyword))\n    throw new Error('Keyword ' + keyword + ' is not a valid identifier');\n\n  if (definition) {\n    this.validateKeyword(definition, true);\n\n    var dataType = definition.type;\n    if (Array.isArray(dataType)) {\n      for (var i=0; i<dataType.length; i++)\n        _addRule(keyword, dataType[i], definition);\n    } else {\n      _addRule(keyword, dataType, definition);\n    }\n\n    var metaSchema = definition.metaSchema;\n    if (metaSchema) {\n      if (definition.$data && this._opts.$data) {\n        metaSchema = {\n          anyOf: [\n            metaSchema,\n            { '$ref': 'https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#' }\n          ]\n        };\n      }\n      definition.validateSchema = this.compile(metaSchema, true);\n    }\n  }\n\n  RULES.keywords[keyword] = RULES.all[keyword] = true;\n\n\n  function _addRule(keyword, dataType, definition) {\n    var ruleGroup;\n    for (var i=0; i<RULES.length; i++) {\n      var rg = RULES[i];\n      if (rg.type == dataType) {\n        ruleGroup = rg;\n        break;\n      }\n    }\n\n    if (!ruleGroup) {\n      ruleGroup = { type: dataType, rules: [] };\n      RULES.push(ruleGroup);\n    }\n\n    var rule = {\n      keyword: keyword,\n      definition: definition,\n      custom: true,\n      code: customRuleCode,\n      implements: definition.implements\n    };\n    ruleGroup.rules.push(rule);\n    RULES.custom[keyword] = rule;\n  }\n\n  return this;\n}\n\n\n/**\n * Get keyword\n * @this  Ajv\n * @param {String} keyword pre-defined or custom keyword.\n * @return {Object|Boolean} custom keyword definition, `true` if it is a predefined keyword, `false` otherwise.\n */\nfunction getKeyword(keyword) {\n  /* jshint validthis: true */\n  var rule = this.RULES.custom[keyword];\n  return rule ? rule.definition : this.RULES.keywords[keyword] || false;\n}\n\n\n/**\n * Remove keyword\n * @this  Ajv\n * @param {String} keyword pre-defined or custom keyword.\n * @return {Ajv} this for method chaining\n */\nfunction removeKeyword(keyword) {\n  /* jshint validthis: true */\n  var RULES = this.RULES;\n  delete RULES.keywords[keyword];\n  delete RULES.all[keyword];\n  delete RULES.custom[keyword];\n  for (var i=0; i<RULES.length; i++) {\n    var rules = RULES[i].rules;\n    for (var j=0; j<rules.length; j++) {\n      if (rules[j].keyword == keyword) {\n        rules.splice(j, 1);\n        break;\n      }\n    }\n  }\n  return this;\n}\n\n\n/**\n * Validate keyword definition\n * @this  Ajv\n * @param {Object} definition keyword definition object.\n * @param {Boolean} throwError true to throw exception if definition is invalid\n * @return {boolean} validation result\n */\nfunction validateKeyword(definition, throwError) {\n  validateKeyword.errors = null;\n  var v = this._validateKeyword = this._validateKeyword\n                                  || this.compile(definitionSchema, true);\n\n  if (v(definition)) return true;\n  validateKeyword.errors = v.errors;\n  if (throwError)\n    throw new Error('custom keyword definition is invalid: '  + this.errorsText(v.errors));\n  else\n    return false;\n}\n","'use strict';\nmodule.exports = function generate_custom(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $errorKeyword;\n  var $data = 'data' + ($dataLvl || '');\n  var $valid = 'valid' + $lvl;\n  var $errs = 'errs__' + $lvl;\n  var $isData = it.opts.$data && $schema && $schema.$data,\n    $schemaValue;\n  if ($isData) {\n    out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; ';\n    $schemaValue = 'schema' + $lvl;\n  } else {\n    $schemaValue = $schema;\n  }\n  var $rule = this,\n    $definition = 'definition' + $lvl,\n    $rDef = $rule.definition,\n    $closingBraces = '';\n  var $compile, $inline, $macro, $ruleValidate, $validateCode;\n  if ($isData && $rDef.$data) {\n    $validateCode = 'keywordValidate' + $lvl;\n    var $validateSchema = $rDef.validateSchema;\n    out += ' var ' + ($definition) + ' = RULES.custom[\\'' + ($keyword) + '\\'].definition; var ' + ($validateCode) + ' = ' + ($definition) + '.validate;';\n  } else {\n    $ruleValidate = it.useCustomRule($rule, $schema, it.schema, it);\n    if (!$ruleValidate) return;\n    $schemaValue = 'validate.schema' + $schemaPath;\n    $validateCode = $ruleValidate.code;\n    $compile = $rDef.compile;\n    $inline = $rDef.inline;\n    $macro = $rDef.macro;\n  }\n  var $ruleErrs = $validateCode + '.errors',\n    $i = 'i' + $lvl,\n    $ruleErr = 'ruleErr' + $lvl,\n    $asyncKeyword = $rDef.async;\n  if ($asyncKeyword && !it.async) throw new Error('async keyword in sync schema');\n  if (!($inline || $macro)) {\n    out += '' + ($ruleErrs) + ' = null;';\n  }\n  out += 'var ' + ($errs) + ' = errors;var ' + ($valid) + ';';\n  if ($isData && $rDef.$data) {\n    $closingBraces += '}';\n    out += ' if (' + ($schemaValue) + ' === undefined) { ' + ($valid) + ' = true; } else { ';\n    if ($validateSchema) {\n      $closingBraces += '}';\n      out += ' ' + ($valid) + ' = ' + ($definition) + '.validateSchema(' + ($schemaValue) + '); if (' + ($valid) + ') { ';\n    }\n  }\n  if ($inline) {\n    if ($rDef.statements) {\n      out += ' ' + ($ruleValidate.validate) + ' ';\n    } else {\n      out += ' ' + ($valid) + ' = ' + ($ruleValidate.validate) + '; ';\n    }\n  } else if ($macro) {\n    var $it = it.util.copy(it);\n    var $closingBraces = '';\n    $it.level++;\n    var $nextValid = 'valid' + $it.level;\n    $it.schema = $ruleValidate.validate;\n    $it.schemaPath = '';\n    var $wasComposite = it.compositeRule;\n    it.compositeRule = $it.compositeRule = true;\n    var $code = it.validate($it).replace(/validate\\.schema/g, $validateCode);\n    it.compositeRule = $it.compositeRule = $wasComposite;\n    out += ' ' + ($code);\n  } else {\n    var $$outStack = $$outStack || [];\n    $$outStack.push(out);\n    out = '';\n    out += '  ' + ($validateCode) + '.call( ';\n    if (it.opts.passContext) {\n      out += 'this';\n    } else {\n      out += 'self';\n    }\n    if ($compile || $rDef.schema === false) {\n      out += ' , ' + ($data) + ' ';\n    } else {\n      out += ' , ' + ($schemaValue) + ' , ' + ($data) + ' , validate.schema' + (it.schemaPath) + ' ';\n    }\n    out += ' , (dataPath || \\'\\')';\n    if (it.errorPath != '\"\"') {\n      out += ' + ' + (it.errorPath);\n    }\n    var $parentData = $dataLvl ? 'data' + (($dataLvl - 1) || '') : 'parentData',\n      $parentDataProperty = $dataLvl ? it.dataPathArr[$dataLvl] : 'parentDataProperty';\n    out += ' , ' + ($parentData) + ' , ' + ($parentDataProperty) + ' , rootData )  ';\n    var def_callRuleValidate = out;\n    out = $$outStack.pop();\n    if ($rDef.errors === false) {\n      out += ' ' + ($valid) + ' = ';\n      if ($asyncKeyword) {\n        out += 'await ';\n      }\n      out += '' + (def_callRuleValidate) + '; ';\n    } else {\n      if ($asyncKeyword) {\n        $ruleErrs = 'customErrors' + $lvl;\n        out += ' var ' + ($ruleErrs) + ' = null; try { ' + ($valid) + ' = await ' + (def_callRuleValidate) + '; } catch (e) { ' + ($valid) + ' = false; if (e instanceof ValidationError) ' + ($ruleErrs) + ' = e.errors; else throw e; } ';\n      } else {\n        out += ' ' + ($ruleErrs) + ' = null; ' + ($valid) + ' = ' + (def_callRuleValidate) + '; ';\n      }\n    }\n  }\n  if ($rDef.modifying) {\n    out += ' if (' + ($parentData) + ') ' + ($data) + ' = ' + ($parentData) + '[' + ($parentDataProperty) + '];';\n  }\n  out += '' + ($closingBraces);\n  if ($rDef.valid) {\n    if ($breakOnError) {\n      out += ' if (true) { ';\n    }\n  } else {\n    out += ' if ( ';\n    if ($rDef.valid === undefined) {\n      out += ' !';\n      if ($macro) {\n        out += '' + ($nextValid);\n      } else {\n        out += '' + ($valid);\n      }\n    } else {\n      out += ' ' + (!$rDef.valid) + ' ';\n    }\n    out += ') { ';\n    $errorKeyword = $rule.keyword;\n    var $$outStack = $$outStack || [];\n    $$outStack.push(out);\n    out = '';\n    var $$outStack = $$outStack || [];\n    $$outStack.push(out);\n    out = ''; /* istanbul ignore else */\n    if (it.createErrors !== false) {\n      out += ' { keyword: \\'' + ($errorKeyword || 'custom') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { keyword: \\'' + ($rule.keyword) + '\\' } ';\n      if (it.opts.messages !== false) {\n        out += ' , message: \\'should pass \"' + ($rule.keyword) + '\" keyword validation\\' ';\n      }\n      if (it.opts.verbose) {\n        out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n      }\n      out += ' } ';\n    } else {\n      out += ' {} ';\n    }\n    var __err = out;\n    out = $$outStack.pop();\n    if (!it.compositeRule && $breakOnError) {\n      /* istanbul ignore if */\n      if (it.async) {\n        out += ' throw new ValidationError([' + (__err) + ']); ';\n      } else {\n        out += ' validate.errors = [' + (__err) + ']; return false; ';\n      }\n    } else {\n      out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n    }\n    var def_customError = out;\n    out = $$outStack.pop();\n    if ($inline) {\n      if ($rDef.errors) {\n        if ($rDef.errors != 'full') {\n          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) + '\"; } ';\n          if (it.opts.verbose) {\n            out += ' ' + ($ruleErr) + '.schema = ' + ($schemaValue) + '; ' + ($ruleErr) + '.data = ' + ($data) + '; ';\n          }\n          out += ' } ';\n        }\n      } else {\n        if ($rDef.errors === false) {\n          out += ' ' + (def_customError) + ' ';\n        } else {\n          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) + '\"; } ';\n          if (it.opts.verbose) {\n            out += ' ' + ($ruleErr) + '.schema = ' + ($schemaValue) + '; ' + ($ruleErr) + '.data = ' + ($data) + '; ';\n          }\n          out += ' } } ';\n        }\n      }\n    } else if ($macro) {\n      out += '   var err =   '; /* istanbul ignore else */\n      if (it.createErrors !== false) {\n        out += ' { keyword: \\'' + ($errorKeyword || 'custom') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { keyword: \\'' + ($rule.keyword) + '\\' } ';\n        if (it.opts.messages !== false) {\n          out += ' , message: \\'should pass \"' + ($rule.keyword) + '\" keyword validation\\' ';\n        }\n        if (it.opts.verbose) {\n          out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n        }\n        out += ' } ';\n      } else {\n        out += ' {} ';\n      }\n      out += ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n      if (!it.compositeRule && $breakOnError) {\n        /* istanbul ignore if */\n        if (it.async) {\n          out += ' throw new ValidationError(vErrors); ';\n        } else {\n          out += ' validate.errors = vErrors; return false; ';\n        }\n      }\n    } else {\n      if ($rDef.errors === false) {\n        out += ' ' + (def_customError) + ' ';\n      } else {\n        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) + '\";  ';\n        if (it.opts.verbose) {\n          out += ' ' + ($ruleErr) + '.schema = ' + ($schemaValue) + '; ' + ($ruleErr) + '.data = ' + ($data) + '; ';\n        }\n        out += ' } } else { ' + (def_customError) + ' } ';\n      }\n    }\n    out += ' } ';\n    if ($breakOnError) {\n      out += ' else { ';\n    }\n  }\n  return out;\n}\n","'use strict';\n\nvar metaSchema = require('./refs/json-schema-draft-07.json');\n\nmodule.exports = {\n  $id: 'https://github.com/ajv-validator/ajv/blob/master/lib/definition_schema.js',\n  definitions: {\n    simpleTypes: metaSchema.definitions.simpleTypes\n  },\n  type: 'object',\n  dependencies: {\n    schema: ['validate'],\n    $data: ['validate'],\n    statements: ['inline'],\n    valid: {not: {required: ['macro']}}\n  },\n  properties: {\n    type: metaSchema.properties.type,\n    schema: {type: 'boolean'},\n    statements: {type: 'boolean'},\n    dependencies: {\n      type: 'array',\n      items: {type: 'string'}\n    },\n    metaSchema: {type: 'object'},\n    modifying: {type: 'boolean'},\n    valid: {type: 'boolean'},\n    $data: {type: 'boolean'},\n    async: {type: 'boolean'},\n    errors: {\n      anyOf: [\n        {type: 'boolean'},\n        {const: 'full'}\n      ]\n    }\n  }\n};\n"],"sourceRoot":""}