{"version":3,"sources":["../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","webpack:///../../src/index.ts?0e3e","../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","../node_modules/ajv/lib/ajv.js"],"names":["checkDataType","dataType","data","strictNumbers","negate","EQUAL","AND","OK","NOT","module","exports","copy","o","to","key","checkDataTypes","dataTypes","length","code","types","toHash","t","array","object","null","number","integer","coerceToTypes","optionCoerceTypes","Array","isArray","i","COERCE_TO_TYPES","getProperty","escapeQuotes","equal","require","ucs2length","varOccurences","str","dataVar","matches","match","RegExp","varReplace","expr","replace","schemaHasRules","schema","rules","schemaHasRulesExcept","exceptKeyword","schemaUnknownRules","toQuotedString","getPathExpr","currentPath","jsonPointers","isNumber","joinPaths","getPath","prop","path","escapeJsonPointer","getData","$data","lvl","paths","up","jsonPointer","JSON_POINTER","test","Error","RELATIVE_JSON_POINTER","segments","split","segment","unescapeJsonPointer","unescapeFragment","decodeURIComponent","escapeFragment","encodeURIComponent","arr","hash","IDENTIFIER","SINGLE_QUOTE","a","b","URI","util","SchemaObject","traverse","resolve","compile","root","ref","refVal","this","_refs","call","_schemas","inlineRef","_opts","inlineRefs","validate","_compile","v","baseId","res","resolveSchema","undefined","p","parse","refPath","_getFullPath","getFullPath","_getId","Object","keys","id","normalizeId","resolveRecursive","getJsonPointer","parsedRef","resolveUrl","fullPath","url","ids","schemaId","baseIds","fullPaths","localRefs","self","allKeys","sch","jsonPtr","rootSchema","parentJsonPtr","parentKeyword","parentSchema","keyIndex","PREVENT_SCOPE_CHANGE","fragment","slice","parts","part","$ref","SIMPLE_INLINED","limit","checkNoRef","countKeys","item","count","Infinity","normalize","serialize","TRAILING_SLASH_HASH","constructor","source","flags","valueOf","prototype","toString","hasOwnProperty","MissingRefError","message","missingRef","missingSchema","errorSubclass","Subclass","create","Validation","errors","ajv","validation","MissingRef","obj","opts","cmp","f","cycles","node","aobj","value","bobj","seen","stringify","toJSON","isFinite","JSON","out","indexOf","TypeError","seenIndex","push","sort","splice","it","$keyword","$ruleType","$async","$refKeywords","RULES","all","$id","strictKeywords","$unknownKwd","keywords","$keywordsMsg","logger","warn","isTop","async","sourceCode","processCode","$lvl","level","$dataLvl","dataLevel","$schema","$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","type","$typeIsArray","nullable","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","keyword","implements","impl","$ruleImplementsSomeKeyword","$schemaValue","$isData","$isMax","$exclusiveKeyword","$schemaExcl","$isDataExcl","$op","$notOp","$errorKeyword","$schemaValueExcl","$exclusive","$exclType","$exclIsNumber","$opStr","$opExpr","Math","unicode","errorClasses","stableStringify","validateGenerator","ValidationError","checkCompiling","index","compIndex","compiling","_compilations","endCompiling","c","patternCode","patterns","defaultCode","refValCode","customRuleCode","vars","statement","refs","patternsHash","defaults","defaultsHash","customRules","compilation","callValidate","result","apply","arguments","formats","_formats","localCompile","cv","_schema","_root","isRoot","resolveRef","usePattern","useCustomRule","Function","makeValidate","e","error","_refVal","refCode","refIndex","resolvedRef","rootRefId","addLocalRef","localSchema","refId","replaceLocalRef","removeLocalRef","inline","regexStr","valueStr","rule","validateSchema","deps","definition","dependencies","every","errorsText","macro","sets","xl","x","shift","toLowerCase","toUpperCase","setInterval","target","isIRI","ALPHA$$","DIGIT$$","HEXDIG$$","merge","PCT_ENCODED$","subexp","SUB_DELIMS$$","RESERVED$$","SCHEME$","USERINFO$","UNRESERVED$$","DEC_OCTET_RELAXED$","H16$","LS32$","IPV4ADDRESS$","IPV6ADDRESS1$","IPV6ADDRESS2$","IPV6ADDRESS3$","IPV6ADDRESS4$","IPV6ADDRESS5$","IPV6ADDRESS6$","IPV6ADDRESS7$","IPV6ADDRESS8$","IPV6ADDRESS9$","ZONEID$","IPV6ADDRESS$","IP_LITERAL$","IPV6ADDRZ_RELAXED$","IPVFUTURE$","HOST$","REG_NAME$","PORT$","AUTHORITY$","PCHAR$","SEGMENT$","SEGMENT_NZ$","SEGMENT_NZ_NC$","PATH_ABEMPTY$","PATH_ABSOLUTE$","QUERY$","PATH_NOSCHEME$","PATH_ROOTLESS$","PATH_EMPTY$","IPRIVATE$$","FRAGMENT$","HIER_PART$","URI$","RELATIVE_PART$","RELATIVE$","buildExps","maxInt","base","tMin","tMax","skew","damp","initialBias","initialN","delimiter","regexPunycode","regexNonASCII","regexSeparators","baseMinusTMin","floor","stringFromCharCode","String","fromCharCode","RangeError","map","fn","mapDomain","string","ucs2decode","output","counter","charCodeAt","extra","basicToDigit","codePoint","digitToBasic","digit","flag","adapt","delta","numPoints","firstTime","k","decode","input","inputLength","n","bias","basic","lastIndexOf","j","oldi","w","baseMinusT","fromCodePoint","encode","currentValue","basicLength","handledCPCount","m","handledCPCountPlusOne","q","qMinusT","toUnicode","toASCII","punycode","SCHEMES","chr","newStr","il","parseInt","substr","c2","c3","_normalizeComponentEncoding","components","protocol","decodeUnreserved","decStr","pctDecChars","UNRESERVED","scheme","PCT_ENCODED","NOT_SCHEME","userinfo","NOT_USERINFO","pctEncChar","host","NOT_HOST","NOT_PATH","NOT_PATH_NOSCHEME","query","NOT_QUERY","NOT_FRAGMENT","_stripLeadingZeros","_normalizeIPv4","IPV4ADDRESS","address","_normalizeIPv6","IPV6ADDRESS","zone","reverse","last","first","firstFields","lastFields","isLastFieldIPv4Address","fieldCount","lastFieldsStart","fields","longestZeroFields","reduce","acc","field","lastLongest","newHost","newFirst","newLast","URI_PARSE","NO_MATCH_IS_UNDEFINED","uriString","options","iri","IRI_PROTOCOL","URI_PROTOCOL","reference","port","isNaN","schemeHandler","unicodeSupport","domainHost","_recomposeAuthority","uriTokens","_","$1","$2","RDS1","RDS2","RDS3","RDS5","im","s","authority","charAt","absolutePath","removeDotSegments","relative","tolerant","baseURI","relativeURI","schemelessOptions","assign","resolveComponents","uri","typeOf","uriA","uriB","ESCAPE","handler","secure","http","isSecure","wsComponents","resourceName","ws","O","ATEXT$$","VCHAR$$","SOME_DELIMS$$","NOT_LOCAL_PART","NOT_HFNAME","NOT_HFVALUE","mailtoComponents","unknownHeaders","headers","hfields","hfield","toAddrs","subject","unescapeComponent","body","addr","toArray","toAddr","atIdx","localPart","domain","name","URN_PARSE","urnComponents","nid","nss","urnScheme","uriComponents","UUID","uuidComponents","uuid","https","wss","mailto","urn","len","pos","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","format","maxItems","minItems","uniqueItems","maxProperties","minProperties","Cache","_cache","put","get","del","clear","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","regex","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","_errorDataPathProperty","$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","loopRequired","$requiredHash","i1","$pProperty","$additionalProperty","$useDefaults","$hasDefault","i4","$invalidName","$propertySch","$loopRequired","$itemType","KEYWORDS","metaSchema","keywordsJsonPointers","compileAsync","meta","callback","loadSchema","loadMetaSchemaOf","then","schemaObj","_addSchema","_compileAsync","getSchema","Promise","added","schemaPromise","_loadingSchemas","removePromise","addSchema","loadMissingSchema","definitionSchema","add","validateKeyword","_addRule","ruleGroup","rg","remove","throwError","_validateKeyword","$compile","$inline","$macro","$ruleValidate","$validateCode","$definition","$rDef","$validateSchema","$ruleErrs","$ruleErr","$asyncKeyword","statements","$parentDataProperty","def_callRuleValidate","modifying","valid","def_customError","simpleTypes","compileSchema","$dataMetaSchema","Ajv","schemaKeyRef","_meta","_skipValidation","checkUnique","addMetaSchema","skipValidation","throwOrLogError","defaultMeta","META_SCHEMA_ID","keyRef","_getSchemaObj","_fragments","_getSchemaFragment","removeSchema","_removeAllSchemas","cacheKey","addFormat","separator","text","dataPath","shouldAddSchema","cached","addUsedSchema","recursiveMeta","willValidate","currentOpts","_metaOpts","_validate","customKeyword","addKeyword","getKeyword","removeKeyword","META_IGNORE_OPTIONS","META_SUPPORT_DATA","log","noop","console","setLogger","cache","_get$IdOrId","_get$Id","chooseGetId","errorDataPath","metaOpts","getMetaSchemaOptions","addInitialFormats","addInitialKeywords","$dataSchema","addDefaultMetaSchema","optsSchemas","schemas","addInitialSchemas"],"mappings":"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","file":"static/js/3.c2769c5d.chunk.js","sourcesContent":["'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","'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"],"sourceRoot":""}