CHANGES.md, README.md und 248 weitere dateien aktualisiert...

node_modules/har-validator/node_modules/ajv/lib/compile/resolve.js

 'use strict';
 
-var URI = require('uri-js')
-  , equal = require('fast-deep-equal')
+var url = require('url')
+  , equal = require('./equal')
   , util = require('./util')
-  , SchemaObject = require('./schema_obj')
-  , traverse = require('json-schema-traverse');
+  , SchemaObject = require('./schema_obj');
 
 module.exports = resolve;
 
@@ -48,7 +47,7 @@ function resolve(compile, root, ref) {
 
   if (schema instanceof SchemaObject) {
     v = schema.validate || compile.call(this, schema.schema, root, undefined, baseId);
-  } else if (schema !== undefined) {
+  } else if (schema) {
     v = inlineRef(schema, this._opts.inlineRefs)
         ? schema
         : compile.call(this, schema, root, undefined, baseId);
@@ -67,10 +66,10 @@ function resolve(compile, root, ref) {
  */
 function resolveSchema(root, ref) {
   /* jshint validthis: true */
-  var p = URI.parse(ref)
+  var p = url.parse(ref, false, true)
     , refPath = _getFullPath(p)
-    , baseId = getFullPath(this._getId(root.schema));
-  if (Object.keys(root.schema).length === 0 || refPath !== baseId) {
+    , baseId = getFullPath(root.schema.id);
+  if (refPath !== baseId) {
     var id = normalizeId(refPath);
     var refVal = this._refs[id];
     if (typeof refVal == 'string') {
@@ -90,7 +89,7 @@ function resolveSchema(root, ref) {
       }
     }
     if (!root.schema) return;
-    baseId = getFullPath(this._getId(root.schema));
+    baseId = getFullPath(root.schema.id);
   }
   return getJsonPointer.call(this, p, baseId, root.schema, root);
 }
@@ -104,8 +103,7 @@ function resolveRecursive(root, ref, parsedRef) {
     var schema = res.schema;
     var baseId = res.baseId;
     root = res.root;
-    var id = this._getId(schema);
-    if (id) baseId = resolveUrl(baseId, id);
+    if (schema.id) baseId = resolveUrl(baseId, schema.id);
     return getJsonPointer.call(this, parsedRef, baseId, schema, root);
   }
 }
@@ -115,33 +113,29 @@ var PREVENT_SCOPE_CHANGE = util.toHash(['properties', 'patternProperties', 'enum
 /* @this Ajv */
 function getJsonPointer(parsedRef, baseId, schema, root) {
   /* jshint validthis: true */
-  parsedRef.fragment = parsedRef.fragment || '';
-  if (parsedRef.fragment.slice(0,1) != '/') return;
-  var parts = parsedRef.fragment.split('/');
+  parsedRef.hash = parsedRef.hash || '';
+  if (parsedRef.hash.slice(0,2) != '#/') return;
+  var parts = parsedRef.hash.split('/');
 
   for (var i = 1; i < parts.length; i++) {
     var part = parts[i];
     if (part) {
       part = util.unescapeFragment(part);
       schema = schema[part];
-      if (schema === undefined) break;
-      var id;
-      if (!PREVENT_SCOPE_CHANGE[part]) {
-        id = this._getId(schema);
-        if (id) baseId = resolveUrl(baseId, id);
-        if (schema.$ref) {
-          var $ref = resolveUrl(baseId, schema.$ref);
-          var res = resolveSchema.call(this, root, $ref);
-          if (res) {
-            schema = res.schema;
-            root = res.root;
-            baseId = res.baseId;
-          }
+      if (!schema) break;
+      if (schema.id && !PREVENT_SCOPE_CHANGE[part]) baseId = resolveUrl(baseId, schema.id);
+      if (schema.$ref) {
+        var $ref = resolveUrl(baseId, schema.$ref);
+        var res = resolveSchema.call(this, root, $ref);
+        if (res) {
+          schema = res.schema;
+          root = res.root;
+          baseId = res.baseId;
         }
       }
     }
   }
-  if (schema !== undefined && schema !== root.schema)
+  if (schema && schema != root.schema)
     return { schema: schema, root: root, baseId: baseId };
 }
 
@@ -206,13 +200,14 @@ function countKeys(schema) {
 
 function getFullPath(id, normalize) {
   if (normalize !== false) id = normalizeId(id);
-  var p = URI.parse(id);
+  var p = url.parse(id, false, true);
   return _getFullPath(p);
 }
 
 
 function _getFullPath(p) {
-  return URI.serialize(p).split('#')[0] + '#';
+  var protocolSeparator = p.protocol || p.href.slice(0,2) == '//' ? '//' : '';
+  return (p.protocol||'') + protocolSeparator + (p.host||'') + (p.path||'')  + '#';
 }
 
 
@@ -224,47 +219,49 @@ function normalizeId(id) {
 
 function resolveUrl(baseId, id) {
   id = normalizeId(id);
-  return URI.resolve(baseId, id);
+  return url.resolve(baseId, id);
 }
 
 
 /* @this Ajv */
 function resolveIds(schema) {
-  var schemaId = normalizeId(this._getId(schema));
-  var baseIds = {'': schemaId};
-  var fullPaths = {'': getFullPath(schemaId, false)};
+  /* eslint no-shadow: 0 */
+  /* jshint validthis: true */
+  var id = normalizeId(schema.id);
   var localRefs = {};
-  var self = this;
-
-  traverse(schema, {allKeys: true}, function(sch, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) {
-    if (jsonPtr === '') return;
-    var id = self._getId(sch);
-    var baseId = baseIds[parentJsonPtr];
-    var fullPath = fullPaths[parentJsonPtr] + '/' + parentKeyword;
-    if (keyIndex !== undefined)
-      fullPath += '/' + (typeof keyIndex == 'number' ? keyIndex : util.escapeFragment(keyIndex));
-
-    if (typeof id == 'string') {
-      id = baseId = normalizeId(baseId ? URI.resolve(baseId, id) : id);
-
-      var refVal = self._refs[id];
-      if (typeof refVal == 'string') refVal = self._refs[refVal];
-      if (refVal && refVal.schema) {
-        if (!equal(sch, refVal.schema))
-          throw new Error('id "' + id + '" resolves to more than one schema');
-      } else if (id != normalizeId(fullPath)) {
-        if (id[0] == '#') {
-          if (localRefs[id] && !equal(sch, localRefs[id]))
+  _resolveIds.call(this, schema, getFullPath(id, false), id);
+  return localRefs;
+
+  /* @this Ajv */
+  function _resolveIds(schema, fullPath, baseId) {
+    /* jshint validthis: true */
+    if (Array.isArray(schema)) {
+      for (var i=0; i<schema.length; i++)
+        _resolveIds.call(this, schema[i], fullPath+'/'+i, baseId);
+    } else if (schema && typeof schema == 'object') {
+      if (typeof schema.id == 'string') {
+        var id = baseId = baseId
+                          ? url.resolve(baseId, schema.id)
+                          : schema.id;
+        id = normalizeId(id);
+
+        var refVal = this._refs[id];
+        if (typeof refVal == 'string') refVal = this._refs[refVal];
+        if (refVal && refVal.schema) {
+          if (!equal(schema, refVal.schema))
             throw new Error('id "' + id + '" resolves to more than one schema');
-          localRefs[id] = sch;
-        } else {
-          self._refs[id] = fullPath;
+        } else if (id != normalizeId(fullPath)) {
+          if (id[0] == '#') {
+            if (localRefs[id] && !equal(schema, localRefs[id]))
+              throw new Error('id "' + id + '" resolves to more than one schema');
+            localRefs[id] = schema;
+          } else {
+            this._refs[id] = fullPath;
+          }
         }
       }
+      for (var key in schema)
+        _resolveIds.call(this, schema[key], fullPath+'/'+util.escapeFragment(key), baseId);
     }
-    baseIds[jsonPtr] = baseId;
-    fullPaths[jsonPtr] = fullPath;
-  });
-
-  return localRefs;
+  }
 }

node_modules/har-validator/node_modules/ajv/lib/compile/rules.js

 'use strict';
 
-var ruleModules = require('../dotjs')
+var ruleModules = require('./_rules')
   , toHash = require('./util').toHash;
 
 module.exports = function rules() {
   var RULES = [
     { type: 'number',
-      rules: [ { 'maximum': ['exclusiveMaximum'] },
-               { 'minimum': ['exclusiveMinimum'] }, 'multipleOf', 'format'] },
+      rules: [ 'maximum', 'minimum', 'multipleOf'] },
     { type: 'string',
       rules: [ 'maxLength', 'minLength', 'pattern', 'format' ] },
     { type: 'array',
-      rules: [ 'maxItems', 'minItems', 'items', 'contains', 'uniqueItems' ] },
+      rules: [ 'maxItems', 'minItems', 'uniqueItems', 'items' ] },
     { type: 'object',
-      rules: [ 'maxProperties', 'minProperties', 'required', 'dependencies', 'propertyNames',
-               { 'properties': ['additionalProperties', 'patternProperties'] } ] },
-    { rules: [ '$ref', 'const', 'enum', 'not', 'anyOf', 'oneOf', 'allOf', 'if' ] }
+      rules: [ 'maxProperties', 'minProperties', 'required', 'dependencies', 'properties' ] },
+    { rules: [ '$ref', 'enum', 'not', 'anyOf', 'oneOf', 'allOf' ] }
   ];
 
-  var ALL = [ 'type', '$comment' ];
-  var KEYWORDS = [
-    '$schema', '$id', 'id', '$data', '$async', 'title',
-    'description', 'default', 'definitions',
-    'examples', 'readOnly', 'writeOnly',
-    'contentMediaType', 'contentEncoding',
-    'additionalItems', 'then', 'else'
-  ];
+  var ALL = [ 'type', 'additionalProperties', 'patternProperties' ];
+  var KEYWORDS = [ 'additionalItems', '$schema', 'id', 'title', 'description', 'default' ];
   var TYPES = [ 'number', 'integer', 'string', 'array', 'object', 'boolean', 'null' ];
   RULES.all = toHash(ALL);
-  RULES.types = toHash(TYPES);
 
   RULES.forEach(function (group) {
     group.rules = group.rules.map(function (keyword) {
-      var implKeywords;
-      if (typeof keyword == 'object') {
-        var key = Object.keys(keyword)[0];
-        implKeywords = keyword[key];
-        keyword = key;
-        implKeywords.forEach(function (k) {
-          ALL.push(k);
-          RULES.all[k] = true;
-        });
-      }
       ALL.push(keyword);
       var rule = RULES.all[keyword] = {
         keyword: keyword,
-        code: ruleModules[keyword],
-        implements: implKeywords
+        code: ruleModules[keyword]
       };
       return rule;
     });
-
-    RULES.all.$comment = {
-      keyword: '$comment',
-      code: ruleModules.$comment
-    };
-
-    if (group.type) RULES.types[group.type] = group;
   });
 
   RULES.keywords = toHash(ALL.concat(KEYWORDS));
+  RULES.types = toHash(TYPES);
   RULES.custom = {};
 
   return RULES;

node_modules/har-validator/node_modules/ajv/lib/compile/util.js

@@ -9,21 +9,19 @@ module.exports = {
   toHash: toHash,
   getProperty: getProperty,
   escapeQuotes: escapeQuotes,
-  equal: require('fast-deep-equal'),
   ucs2length: require('./ucs2length'),
   varOccurences: varOccurences,
   varReplace: varReplace,
   cleanUpCode: cleanUpCode,
-  finalCleanUpCode: finalCleanUpCode,
+  cleanUpVarErrors: cleanUpVarErrors,
   schemaHasRules: schemaHasRules,
   schemaHasRulesExcept: schemaHasRulesExcept,
-  schemaUnknownRules: schemaUnknownRules,
+  stableStringify: require('json-stable-stringify'),
   toQuotedString: toQuotedString,
   getPathExpr: getPathExpr,
   getPath: getPath,
   getData: getData,
   unescapeFragment: unescapeFragment,
-  unescapeJsonPointer: unescapeJsonPointer,
   escapeFragment: escapeFragment,
   escapeJsonPointer: escapeJsonPointer
 };
@@ -146,50 +144,35 @@ function cleanUpCode(out) {
 }
 
 
-var ERRORS_REGEXP = /[^v.]errors/g
+var ERRORS_REGEXP = /[^v\.]errors/g
   , REMOVE_ERRORS = /var errors = 0;|var vErrors = null;|validate.errors = vErrors;/g
   , REMOVE_ERRORS_ASYNC = /var errors = 0;|var vErrors = null;/g
   , RETURN_VALID = 'return errors === 0;'
   , RETURN_TRUE = 'validate.errors = null; return true;'
-  , RETURN_ASYNC = /if \(errors === 0\) return data;\s*else throw new ValidationError\(vErrors\);/
-  , RETURN_DATA_ASYNC = 'return data;'
-  , ROOTDATA_REGEXP = /[^A-Za-z_$]rootData[^A-Za-z0-9_$]/g
-  , REMOVE_ROOTDATA = /if \(rootData === undefined\) rootData = data;/;
+  , RETURN_ASYNC = /if \(errors === 0\) return true;\s*else throw new ValidationError\(vErrors\);/
+  , RETURN_TRUE_ASYNC = 'return true;';
 
-function finalCleanUpCode(out, async) {
+function cleanUpVarErrors(out, async) {
   var matches = out.match(ERRORS_REGEXP);
-  if (matches && matches.length == 2) {
-    out = async
+  if (!matches || matches.length !== 2) return out;
+  return async
           ? out.replace(REMOVE_ERRORS_ASYNC, '')
-               .replace(RETURN_ASYNC, RETURN_DATA_ASYNC)
+               .replace(RETURN_ASYNC, RETURN_TRUE_ASYNC)
           : out.replace(REMOVE_ERRORS, '')
                .replace(RETURN_VALID, RETURN_TRUE);
-  }
-
-  matches = out.match(ROOTDATA_REGEXP);
-  if (!matches || matches.length !== 3) return out;
-  return out.replace(REMOVE_ROOTDATA, '');
 }
 
 
 function schemaHasRules(schema, rules) {
-  if (typeof schema == 'boolean') return !schema;
   for (var key in schema) if (rules[key]) return true;
 }
 
 
 function schemaHasRulesExcept(schema, rules, exceptKeyword) {
-  if (typeof schema == 'boolean') return !schema && exceptKeyword != 'not';
   for (var key in schema) if (key != exceptKeyword && rules[key]) return true;
 }
 
 
-function schemaUnknownRules(schema, rules) {
-  if (typeof schema == 'boolean') return;
-  for (var key in schema) if (!rules[key]) return key;
-}
-
-
 function toQuotedString(str) {
   return '\'' + escapeQuotes(str) + '\'';
 }

node_modules/har-validator/node_modules/ajv/lib/data.js

-'use strict';
-
-var KEYWORDS = [
-  'multipleOf',
-  'maximum',
-  'exclusiveMaximum',
-  'minimum',
-  'exclusiveMinimum',
-  'maxLength',
-  'minLength',
-  'pattern',
-  'additionalItems',
-  'maxItems',
-  'minItems',
-  'uniqueItems',
-  'maxProperties',
-  'minProperties',
-  'required',
-  'additionalProperties',
-  'enum',
-  'format',
-  'const'
-];
-
-module.exports = function (metaSchema, keywordsJsonPointers) {
-  for (var i=0; i<keywordsJsonPointers.length; i++) {
-    metaSchema = JSON.parse(JSON.stringify(metaSchema));
-    var segments = keywordsJsonPointers[i].split('/');
-    var keywords = metaSchema;
-    var j;
-    for (j=1; j<segments.length; j++)
-      keywords = keywords[segments[j]];
-
-    for (j=0; j<KEYWORDS.length; j++) {
-      var key = KEYWORDS[j];
-      var schema = keywords[key];
-      if (schema) {
-        keywords[key] = {
-          anyOf: [
-            schema,
-            { $ref: 'https://raw.githubusercontent.com/epoberezkin/ajv/master/lib/refs/data.json#' }
-          ]
-        };
-      }
-    }
-  }
-
-  return metaSchema;
-};

node_modules/har-validator/node_modules/ajv/lib/definition_schema.js

-'use strict';
-
-var metaSchema = require('./refs/json-schema-draft-07.json');
-
-module.exports = {
-  $id: 'https://github.com/epoberezkin/ajv/blob/master/lib/definition_schema.js',
-  definitions: {
-    simpleTypes: metaSchema.definitions.simpleTypes
-  },
-  type: 'object',
-  dependencies: {
-    schema: ['validate'],
-    $data: ['validate'],
-    statements: ['inline'],
-    valid: {not: {required: ['macro']}}
-  },
-  properties: {
-    type: metaSchema.properties.type,
-    schema: {type: 'boolean'},
-    statements: {type: 'boolean'},
-    dependencies: {
-      type: 'array',
-      items: {type: 'string'}
-    },
-    metaSchema: {type: 'object'},
-    modifying: {type: 'boolean'},
-    valid: {type: 'boolean'},
-    $data: {type: 'boolean'},
-    async: {type: 'boolean'},
-    errors: {
-      anyOf: [
-        {type: 'boolean'},
-        {const: 'full'}
-      ]
-    }
-  }
-};

node_modules/har-validator/node_modules/ajv/lib/dot/_limit.jst

@@ -3,102 +3,47 @@
 {{# def.setupKeyword }}
 {{# def.$data }}
 
-{{## def.setExclusiveLimit:
-  $exclusive = true;
-  $errorKeyword = $exclusiveKeyword;
-  $errSchemaPath = it.errSchemaPath + '/' + $exclusiveKeyword;
-#}}
-
 {{
   var $isMax = $keyword == 'maximum'
     , $exclusiveKeyword = $isMax ? 'exclusiveMaximum' : 'exclusiveMinimum'
     , $schemaExcl = it.schema[$exclusiveKeyword]
-    , $isDataExcl = it.opts.$data && $schemaExcl && $schemaExcl.$data
+    , $isDataExcl = it.opts.v5 && $schemaExcl && $schemaExcl.$data
     , $op = $isMax ? '<' : '>'
-    , $notOp = $isMax ? '>' : '<'
-    , $errorKeyword = undefined;
+    , $notOp = $isMax ? '>' : '<';
 }}
 
 {{? $isDataExcl }}
   {{
     var $schemaValueExcl = it.util.getData($schemaExcl.$data, $dataLvl, it.dataPathArr)
       , $exclusive = 'exclusive' + $lvl
-      , $exclType = 'exclType' + $lvl
-      , $exclIsNumber = 'exclIsNumber' + $lvl
       , $opExpr = 'op' + $lvl
       , $opStr = '\' + ' + $opExpr + ' + \'';
   }}
   var schemaExcl{{=$lvl}} = {{=$schemaValueExcl}};
   {{ $schemaValueExcl = 'schemaExcl' + $lvl; }}
 
-  var {{=$exclusive}};
-  var {{=$exclType}} = typeof {{=$schemaValueExcl}};
-  if ({{=$exclType}} != 'boolean' && {{=$exclType}} != 'undefined' && {{=$exclType}} != 'number') {
+  var exclusive{{=$lvl}};
+  if (typeof {{=$schemaValueExcl}} != 'boolean' && typeof {{=$schemaValueExcl}} != 'undefined') {
     {{ var $errorKeyword = $exclusiveKeyword; }}
     {{# def.error:'_exclusiveLimit' }}
-  } else if ({{# def.$dataNotType:'number' }}
-            {{=$exclType}} == 'number'
-              ? (
-                  ({{=$exclusive}} = {{=$schemaValue}} === undefined || {{=$schemaValueExcl}} {{=$op}}= {{=$schemaValue}})
-                    ? {{=$data}} {{=$notOp}}= {{=$schemaValueExcl}}
-                    : {{=$data}} {{=$notOp}} {{=$schemaValue}}
-                )
-              : (
-                  ({{=$exclusive}} = {{=$schemaValueExcl}} === true)
-                    ? {{=$data}} {{=$notOp}}= {{=$schemaValue}}
-                    : {{=$data}} {{=$notOp}} {{=$schemaValue}}
-                )
+  } else if({{# def.$dataNotType:'number' }}
+            ((exclusive{{=$lvl}} = {{=$schemaValueExcl}} === true)
+              ? {{=$data}} {{=$notOp}}= {{=$schemaValue}}
+              : {{=$data}} {{=$notOp}} {{=$schemaValue}})
             || {{=$data}} !== {{=$data}}) {
-    var op{{=$lvl}} = {{=$exclusive}} ? '{{=$op}}' : '{{=$op}}=';
-    {{
-      if ($schema === undefined) {
-        $errorKeyword = $exclusiveKeyword;
-        $errSchemaPath = it.errSchemaPath + '/' + $exclusiveKeyword;
-        $schemaValue = $schemaValueExcl;
-        $isData = $isDataExcl;
-      }
-    }}
+    var op{{=$lvl}} = exclusive{{=$lvl}} ? '{{=$op}}' : '{{=$op}}=';
 {{??}}
   {{
-    var $exclIsNumber = typeof $schemaExcl == 'number'
+    var $exclusive = $schemaExcl === true
       , $opStr = $op;  /*used in error*/
+    if (!$exclusive) $opStr += '=';
+    var $opExpr = '\'' + $opStr + '\''; /*used in error*/
   }}
 
-  {{? $exclIsNumber && $isData }}
-    {{ var $opExpr = '\'' + $opStr + '\''; /*used in error*/ }}
-    if ({{# def.$dataNotType:'number' }}
-        ( {{=$schemaValue}} === undefined
-          || {{=$schemaExcl}} {{=$op}}= {{=$schemaValue}}
-            ? {{=$data}} {{=$notOp}}= {{=$schemaExcl}}
-            : {{=$data}} {{=$notOp}} {{=$schemaValue}} )
-        || {{=$data}} !== {{=$data}}) {
-  {{??}}
-    {{
-      if ($exclIsNumber && $schema === undefined) {
-          {{# def.setExclusiveLimit }}
-          $schemaValue = $schemaExcl;
-          $notOp += '=';
-      } else {
-        if ($exclIsNumber)
-          $schemaValue = Math[$isMax ? 'min' : 'max']($schemaExcl, $schema);
-
-        if ($schemaExcl === ($exclIsNumber ? $schemaValue : true)) {
-          {{# def.setExclusiveLimit }}
-          $notOp += '=';
-        } else {
-          $exclusive = false;
-          $opStr += '=';
-        }
-      }
-
-      var $opExpr = '\'' + $opStr + '\''; /*used in error*/
-    }}
-
-    if ({{# def.$dataNotType:'number' }}
-        {{=$data}} {{=$notOp}} {{=$schemaValue}}
-        || {{=$data}} !== {{=$data}}) {
-  {{?}}
+  if ({{# def.$dataNotType:'number' }}
+      {{=$data}} {{=$notOp}}{{?$exclusive}}={{?}} {{=$schemaValue}}
+      || {{=$data}} !== {{=$data}}) {
 {{?}}
-    {{ $errorKeyword = $errorKeyword || $keyword; }}
+    {{ var $errorKeyword = $keyword; }}
     {{# def.error:'_limit' }}
   } {{? $breakOnError }} else { {{?}}

node_modules/har-validator/node_modules/ajv/lib/dot/anyOf.jst

@@ -35,7 +35,7 @@
   {{= $closingBraces }}
 
   if (!{{=$valid}}) {
-    {{# def.extraError:'anyOf' }}
+    {{# def.addError:'anyOf' }}
   } else {
     {{# def.resetErrors }}
   {{? it.opts.allErrors }} } {{?}}

node_modules/har-validator/node_modules/ajv/lib/dot/comment.jst

-{{# def.definitions }}
-{{# def.setupKeyword }}
-
-{{ var $comment = it.util.toQuotedString($schema); }}
-{{? it.opts.$comment === true }}
-  console.log({{=$comment}});
-{{?? typeof it.opts.$comment == 'function' }}
-  self._opts.$comment({{=$comment}}, {{=it.util.toQuotedString($errSchemaPath)}}, validate.root.schema);
-{{?}}

node_modules/har-validator/node_modules/ajv/lib/dot/const.jst

-{{# def.definitions }}
-{{# def.errors }}
-{{# def.setupKeyword }}
-{{# def.$data }}
-
-{{? !$isData }}
-  var schema{{=$lvl}} = validate.schema{{=$schemaPath}};
-{{?}}
-var {{=$valid}} = equal({{=$data}}, schema{{=$lvl}});
-{{# def.checkError:'const' }}
-{{? $breakOnError }} else { {{?}}

node_modules/har-validator/node_modules/ajv/lib/dot/contains.jst

-{{# def.definitions }}
-{{# def.errors }}
-{{# def.setupKeyword }}
-{{# def.setupNextLevel }}
-
-
-{{
-  var $idx = 'i' + $lvl
-    , $dataNxt = $it.dataLevel = it.dataLevel + 1
-    , $nextData = 'data' + $dataNxt
-    , $currentBaseId = it.baseId
-    , $nonEmptySchema = {{# def.nonEmptySchema:$schema }};
-}}
-
-var {{=$errs}} = errors;
-var {{=$valid}};
-
-{{? $nonEmptySchema }}
-  {{# def.setCompositeRule }}
-
-  {{
-    $it.schema = $schema;
-    $it.schemaPath = $schemaPath;
-    $it.errSchemaPath = $errSchemaPath;
-  }}
-
-  var {{=$nextValid}} = false;
-
-  for (var {{=$idx}} = 0; {{=$idx}} < {{=$data}}.length; {{=$idx}}++) {
-    {{
-      $it.errorPath = it.util.getPathExpr(it.errorPath, $idx, it.opts.jsonPointers, true);
-      var $passData = $data + '[' + $idx + ']';
-      $it.dataPathArr[$dataNxt] = $idx;
-    }}
-
-    {{# def.generateSubschemaCode }}
-    {{# def.optimizeValidate }}
-
-    if ({{=$nextValid}}) break;
-  }
-
-  {{# def.resetCompositeRule }}
-  {{= $closingBraces }}
-
-  if (!{{=$nextValid}}) {
-{{??}}
-  if ({{=$data}}.length == 0) {
-{{?}}
-
-    {{# def.error:'contains' }}
-  } else {
-    {{? $nonEmptySchema }}
-      {{# def.resetErrors }}
-    {{?}}
-  {{? it.opts.allErrors }} } {{?}}
-
-{{# def.cleanUp }}

node_modules/har-validator/node_modules/ajv/lib/dot/custom.jst

@@ -6,8 +6,7 @@
 {{
   var $rule = this
     , $definition = 'definition' + $lvl
-    , $rDef = $rule.definition
-    , $closingBraces = '';
+    , $rDef = $rule.definition;
   var $validate = $rDef.validate;
   var $compile, $inline, $macro, $ruleValidate, $validateCode;
 }}
@@ -22,7 +21,6 @@
 {{??}}
   {{
     $ruleValidate = it.useCustomRule($rule, $schema, it.schema, it);
-    if (!$ruleValidate) return;
     $schemaValue = 'validate.schema' + $schemaPath;
     $validateCode = $ruleValidate.code;
     $compile = $rDef.compile;
@@ -78,16 +76,9 @@ var {{=$valid}};
 #}}
 
 
-{{? $isData && $rDef.$data }}
-  {{ $closingBraces += '}'; }}
-  if ({{=$schemaValue}} === undefined) {
-    {{=$valid}} = true;
-  } else {
-  {{? $validateSchema }}
-    {{ $closingBraces += '}'; }}
-    {{=$valid}} = {{=$definition}}.validateSchema({{=$schemaValue}});
-    if ({{=$valid}}) {
-  {{?}}
+{{? $validateSchema }}
+  {{=$valid}} = {{=$definition}}.validateSchema({{=$schemaValue}});
+  if ({{=$valid}}) {
 {{?}}
 
 {{? $inline }}
@@ -112,13 +103,13 @@ var {{=$valid}};
   {{# def.storeDefOut:def_callRuleValidate }}
 
   {{? $rDef.errors === false }}
-    {{=$valid}} = {{? $asyncKeyword }}await {{?}}{{= def_callRuleValidate }};
+    {{=$valid}} = {{? $asyncKeyword }}{{=it.yieldAwait}}{{?}}{{= def_callRuleValidate }};
   {{??}}
     {{? $asyncKeyword }}
       {{ $ruleErrs = 'customErrors' + $lvl; }}
       var {{=$ruleErrs}} = null;
       try {
-        {{=$valid}} = await {{= def_callRuleValidate }};
+        {{=$valid}} = {{=it.yieldAwait}}{{= def_callRuleValidate }};
       } catch (e) {
         {{=$valid}} = false;
         if (e instanceof ValidationError) {{=$ruleErrs}} = e.errors;
@@ -132,10 +123,12 @@ var {{=$valid}};
 {{?}}
 
 {{? $rDef.modifying }}
-  if ({{=$parentData}}) {{=$data}} = {{=$parentData}}[{{=$parentDataProperty}}];
+  {{=$data}} = {{=$parentData}}[{{=$parentDataProperty}}];
 {{?}}
 
-{{= $closingBraces }}
+{{? $validateSchema }}
+  }
+{{?}}
 
 {{## def.notValidationResult:
   {{? $rDef.valid === undefined }}

node_modules/har-validator/node_modules/ajv/lib/dot/defaults.def

 {{## def.assignDefault:
-  {{? it.compositeRule }}
-    {{
-      if (it.opts.strictDefaults) {
-        var $defaultMsg = 'default is ignored for: ' + $passData;
-        if (it.opts.strictDefaults === 'log') it.logger.warn($defaultMsg);
-        else throw new Error($defaultMsg);
-      }
-    }}
-  {{??}}
-    if ({{=$passData}} === undefined
-      {{? it.opts.useDefaults == 'empty' }}
-        || {{=$passData}} === null
-        || {{=$passData}} === ''
-      {{?}}
-    )
-      {{=$passData}} = {{? it.opts.useDefaults == 'shared' }}
-                         {{= it.useDefault($sch.default) }}
-                       {{??}}
-                         {{= JSON.stringify($sch.default) }}
-                       {{?}};
-  {{?}}
+  if ({{=$passData}} === undefined)
+    {{=$passData}} = {{? it.opts.useDefaults == 'shared' }}
+                       {{= it.useDefault($sch.default) }}
+                     {{??}}
+                       {{= JSON.stringify($sch.default) }}
+                     {{?}};
 #}}
 
 

node_modules/har-validator/node_modules/ajv/lib/dot/definitions.def

@@ -63,9 +63,7 @@
 
 
 {{## def.nonEmptySchema:_schema:
-  (it.opts.strictKeywords
-    ? typeof _schema == 'object' && Object.keys(_schema).length > 0
-    : it.util.schemaHasRules(_schema, it.RULES.all))
+  it.util.schemaHasRules(_schema, it.RULES.all)
 #}}
 
 
@@ -115,12 +113,12 @@
 {{## def.cleanUp: {{ out = it.util.cleanUpCode(out); }} #}}
 
 
-{{## def.finalCleanUp: {{ out = it.util.finalCleanUpCode(out, $async); }} #}}
+{{## def.cleanUpVarErrors: {{ out = it.util.cleanUpVarErrors(out, $async); }} #}}
 
 
 {{## def.$data:
   {{
-    var $isData = it.opts.$data && $schema && $schema.$data
+    var $isData = it.opts.v5 && $schema && $schema.$data
       , $schemaValue;
   }}
   {{? $isData }}
@@ -177,25 +175,8 @@
 #}}
 
 
-{{## def.iterateProperties:
+{{## def.checkOwnProperty:
   {{? $ownProperties }}
-    {{=$dataProperties}} = {{=$dataProperties}} || Object.keys({{=$data}});
-    for (var {{=$idx}}=0; {{=$idx}}<{{=$dataProperties}}.length; {{=$idx}}++) {
-      var {{=$key}} = {{=$dataProperties}}[{{=$idx}}];
-  {{??}}
-    for (var {{=$key}} in {{=$data}}) {
+    if (!Object.prototype.hasOwnProperty.call({{=$data}}, {{=$key}})) continue;
   {{?}}
 #}}
-
-
-{{## def.noPropertyInData:
-  {{=$useData}} === undefined
-  {{? $ownProperties }}
-    || !{{# def.isOwnProperty }}
-  {{?}}
-#}}
-
-
-{{## def.isOwnProperty:
-  Object.prototype.hasOwnProperty.call({{=$data}}, '{{=it.util.escapeQuotes($propertyKey)}}')
-#}}

node_modules/har-validator/node_modules/ajv/lib/dot/dependencies.jst

@@ -5,18 +5,9 @@
 {{# def.setupNextLevel }}
 
 
-{{## def.propertyInData:
-  {{=$data}}{{= it.util.getProperty($property) }} !== undefined
-  {{? $ownProperties }}
-    && Object.prototype.hasOwnProperty.call({{=$data}}, '{{=it.util.escapeQuotes($property)}}')
-  {{?}}
-#}}
-
-
 {{
   var $schemaDeps = {}
-    , $propertyDeps = {}
-    , $ownProperties = it.opts.ownProperties;
+    , $propertyDeps = {};
 
   for ($property in $schema) {
     var $sch = $schema[$property];
@@ -32,19 +23,17 @@ var {{=$errs}} = errors;
 var missing{{=$lvl}};
 {{ for (var $property in $propertyDeps) { }}
   {{ $deps = $propertyDeps[$property]; }}
-  {{? $deps.length }}
-    if ({{# def.propertyInData }}
-      {{? $breakOnError }}
-          && ({{# def.checkMissingProperty:$deps }})) {
-          {{# def.errorMissingProperty:'dependencies' }}
-      {{??}}
-        ) {
-          {{~ $deps:$propertyKey }}
-            {{# def.allErrorsMissingProperty:'dependencies' }}
-          {{~}}
-      {{?}}
-    } {{# def.elseIfValid }}
-  {{?}}
+  if ({{=$data}}{{= it.util.getProperty($property) }} !== undefined
+    {{? $breakOnError }}
+        && ({{# def.checkMissingProperty:$deps }})) {
+        {{# def.errorMissingProperty:'dependencies' }}
+    {{??}}
+      ) {
+        {{~ $deps:$reqProperty }}
+          {{# def.allErrorsMissingProperty:'dependencies' }}
+        {{~}}
+    {{?}}
+  } {{# def.elseIfValid }}
 {{ } }}
 
 {{
@@ -58,7 +47,7 @@ var missing{{=$lvl}};
   {{? {{# def.nonEmptySchema:$sch }} }}
     {{=$nextValid}} = true;
 
-    if ({{# def.propertyInData }}) {
+    if ({{=$data}}{{= it.util.getProperty($property) }} !== undefined) {
       {{ 
         $it.schema = $sch;
         $it.schemaPath = $schemaPath + it.util.getProperty($property);

node_modules/har-validator/node_modules/ajv/lib/dot/errors.def

@@ -87,37 +87,34 @@
 
 
 {{## def.concatSchema:{{?$isData}}' + {{=$schemaValue}} + '{{??}}{{=$schema}}{{?}}#}}
-{{## def.appendSchema:{{?$isData}}' + {{=$schemaValue}}{{??}}{{=$schemaValue}}'{{?}}#}}
+{{## def.appendSchema:{{?$isData}}' + {{=$schemaValue}}{{??}}{{=$schema}}'{{?}}#}}
 {{## def.concatSchemaEQ:{{?$isData}}' + {{=$schemaValue}} + '{{??}}{{=it.util.escapeQuotes($schema)}}{{?}}#}}
 
 {{## def._errorMessages = {
-  'false schema':  "'boolean schema is false'",
   $ref:            "'can\\\'t resolve reference {{=it.util.escapeQuotes($schema)}}'",
   additionalItems: "'should NOT have more than {{=$schema.length}} items'",
-  additionalProperties: "'{{? it.opts._errorDataPathProperty }}is an invalid additional property{{??}}should NOT have additional properties{{?}}'",
+  additionalProperties: "'should NOT have additional properties'",
   anyOf:           "'should match some schema in anyOf'",
-  const:           "'should be equal to constant'",
-  contains:        "'should contain a valid item'",
   dependencies:    "'should have {{? $deps.length == 1 }}property {{= it.util.escapeQuotes($deps[0]) }}{{??}}properties {{= it.util.escapeQuotes($deps.join(\", \")) }}{{?}} when property {{= it.util.escapeQuotes($property) }} is present'",
   'enum':          "'should be equal to one of the allowed values'",
   format:          "'should match format \"{{#def.concatSchemaEQ}}\"'",
-  'if':            "'should match \"' + {{=$ifClause}} + '\" schema'",
   _limit:          "'should be {{=$opStr}} {{#def.appendSchema}}",
   _exclusiveLimit: "'{{=$exclusiveKeyword}} should be boolean'",
-  _limitItems:     "'should NOT have {{?$keyword=='maxItems'}}more{{??}}fewer{{?}} than {{#def.concatSchema}} items'",
+  _limitItems:     "'should NOT have {{?$keyword=='maxItems'}}more{{??}}less{{?}} than {{#def.concatSchema}} items'",
   _limitLength:    "'should NOT be {{?$keyword=='maxLength'}}longer{{??}}shorter{{?}} than {{#def.concatSchema}} characters'",
-  _limitProperties:"'should NOT have {{?$keyword=='maxProperties'}}more{{??}}fewer{{?}} than {{#def.concatSchema}} properties'",
+  _limitProperties:"'should NOT have {{?$keyword=='maxProperties'}}more{{??}}less{{?}} than {{#def.concatSchema}} properties'",
   multipleOf:      "'should be multiple of {{#def.appendSchema}}",
   not:             "'should NOT be valid'",
   oneOf:           "'should match exactly one schema in oneOf'",
   pattern:         "'should match pattern \"{{#def.concatSchemaEQ}}\"'",
-  propertyNames:   "'property name \\'{{=$invalidName}}\\' is invalid'",
   required:        "'{{? it.opts._errorDataPathProperty }}is a required property{{??}}should have required property \\'{{=$missingProperty}}\\'{{?}}'",
   type:            "'should be {{? $typeIsArray }}{{= $typeSchema.join(\",\") }}{{??}}{{=$typeSchema}}{{?}}'",
   uniqueItems:     "'should NOT have duplicate items (items ## ' + j + ' and ' + i + ' are identical)'",
   custom:          "'should pass \"{{=$rule.keyword}}\" keyword validation'",
+  patternGroups:   "'should NOT have {{=$moreOrLess}} than {{=$limit}} properties matching pattern \"{{=it.util.escapeQuotes($pgProperty)}}\"'",
   patternRequired: "'should have property matching pattern \\'{{=$missingPattern}}\\''",
   switch:          "'should pass \"switch\" keyword validation'",
+  constant:        "'should be equal to constant'",
   _formatLimit:    "'should be {{=$opStr}} \"{{#def.concatSchemaEQ}}\"'",
   _formatExclusiveLimit: "'{{=$exclusiveKeyword}} should be boolean'"
 } #}}
@@ -127,17 +124,13 @@
 {{## def.schemaRefOrQS: {{?$isData}}validate.schema{{=$schemaPath}}{{??}}{{=it.util.toQuotedString($schema)}}{{?}} #}}
 
 {{## def._errorSchemas = {
-  'false schema':  "false",
   $ref:            "{{=it.util.toQuotedString($schema)}}",
   additionalItems: "false",
   additionalProperties: "false",
   anyOf:           "validate.schema{{=$schemaPath}}",
-  const:           "validate.schema{{=$schemaPath}}",
-  contains:        "validate.schema{{=$schemaPath}}",
   dependencies:    "validate.schema{{=$schemaPath}}",
   'enum':          "validate.schema{{=$schemaPath}}",
   format:          "{{#def.schemaRefOrQS}}",
-  'if':            "validate.schema{{=$schemaPath}}",
   _limit:          "{{#def.schemaRefOrVal}}",
   _exclusiveLimit: "validate.schema{{=$schemaPath}}",
   _limitItems:     "{{#def.schemaRefOrVal}}",
@@ -147,13 +140,14 @@
   not:             "validate.schema{{=$schemaPath}}",
   oneOf:           "validate.schema{{=$schemaPath}}",
   pattern:         "{{#def.schemaRefOrQS}}",
-  propertyNames:   "validate.schema{{=$schemaPath}}",
   required:        "validate.schema{{=$schemaPath}}",
   type:            "validate.schema{{=$schemaPath}}",
   uniqueItems:     "{{#def.schemaRefOrVal}}",
   custom:          "validate.schema{{=$schemaPath}}",
+  patternGroups:   "validate.schema{{=$schemaPath}}",
   patternRequired: "validate.schema{{=$schemaPath}}",
   switch:          "validate.schema{{=$schemaPath}}",
+  constant:        "validate.schema{{=$schemaPath}}",
   _formatLimit:    "{{#def.schemaRefOrQS}}",
   _formatExclusiveLimit: "validate.schema{{=$schemaPath}}"
 } #}}
@@ -162,17 +156,13 @@
 {{## def.schemaValueQS: {{?$isData}}{{=$schemaValue}}{{??}}{{=it.util.toQuotedString($schema)}}{{?}} #}}
 
 {{## def._errorParams = {
-  'false schema':  "{}",
   $ref:            "{ ref: '{{=it.util.escapeQuotes($schema)}}' }",
   additionalItems: "{ limit: {{=$schema.length}} }",
   additionalProperties: "{ additionalProperty: '{{=$additionalProperty}}' }",
   anyOf:           "{}",
-  const:           "{ allowedValue: schema{{=$lvl}} }",
-  contains:        "{}",
   dependencies:    "{ property: '{{= it.util.escapeQuotes($property) }}', missingProperty: '{{=$missingProperty}}', depsCount: {{=$deps.length}}, deps: '{{= it.util.escapeQuotes($deps.length==1 ? $deps[0] : $deps.join(\", \")) }}' }",
   'enum':          "{ allowedValues: schema{{=$lvl}} }",
   format:          "{ format: {{#def.schemaValueQS}} }",
-  'if':            "{ failingKeyword: {{=$ifClause}} }",
   _limit:          "{ comparison: {{=$opExpr}}, limit: {{=$schemaValue}}, exclusive: {{=$exclusive}} }",
   _exclusiveLimit: "{}",
   _limitItems:     "{ limit: {{=$schemaValue}} }",
@@ -180,15 +170,16 @@
   _limitProperties:"{ limit: {{=$schemaValue}} }",
   multipleOf:      "{ multipleOf: {{=$schemaValue}} }",
   not:             "{}",
-  oneOf:           "{ passingSchemas: {{=$passingSchemas}} }",
+  oneOf:           "{}",
   pattern:         "{ pattern: {{#def.schemaValueQS}} }",
-  propertyNames:   "{ propertyName: '{{=$invalidName}}' }",
   required:        "{ missingProperty: '{{=$missingProperty}}' }",
   type:            "{ type: '{{? $typeIsArray }}{{= $typeSchema.join(\",\") }}{{??}}{{=$typeSchema}}{{?}}' }",
   uniqueItems:     "{ i: i, j: j }",
   custom:          "{ keyword: '{{=$rule.keyword}}' }",
+  patternGroups:   "{ reason: '{{=$reason}}', limit: {{=$limit}}, pattern: '{{=it.util.escapeQuotes($pgProperty)}}' }",
   patternRequired: "{ missingPattern: '{{=$missingPattern}}' }",
   switch:          "{ caseIndex: {{=$caseIndex}} }",
+  constant:        "{}",
   _formatLimit:    "{ comparison: {{=$opExpr}}, limit: {{#def.schemaValueQS}}, exclusive: {{=$exclusive}} }",
   _formatExclusiveLimit: "{}"
 } #}}

node_modules/har-validator/node_modules/ajv/lib/dot/format.jst

@@ -15,16 +15,15 @@
 
 {{## def.$dataCheckFormat:
   {{# def.$dataNotType:'string' }}
-  ({{? $unknownFormats != 'ignore' }}
+  ({{? $unknownFormats === true || $allowUnknown }}
      ({{=$schemaValue}} && !{{=$format}}
       {{? $allowUnknown }}
         && self._opts.unknownFormats.indexOf({{=$schemaValue}}) == -1
       {{?}}) ||
    {{?}}
-   ({{=$format}} && {{=$formatType}} == '{{=$ruleType}}'
-                 && !(typeof {{=$format}} == 'function'
+   ({{=$format}} && !(typeof {{=$format}} == 'function'
                      ? {{? it.async}}
-                        (async{{=$lvl}} ? await {{=$format}}({{=$data}}) : {{=$format}}({{=$data}}))
+                        (async{{=$lvl}} ? {{=it.yieldAwait}} {{=$format}}({{=$data}}) : {{=$format}}({{=$data}}))
                        {{??}}
                         {{=$format}}({{=$data}})
                        {{?}}
@@ -50,17 +49,12 @@
 }}
 
 {{? $isData }}
-  {{
-    var $format = 'format' + $lvl
-      , $isObject = 'isObject' + $lvl
-      , $formatType = 'formatType' + $lvl;
-  }}
+  {{ var $format = 'format' + $lvl; }}
   var {{=$format}} = formats[{{=$schemaValue}}];
-  var {{=$isObject}} = typeof {{=$format}} == 'object'
-                        && !({{=$format}} instanceof RegExp)
-                        && {{=$format}}.validate;
-  var {{=$formatType}} = {{=$isObject}} && {{=$format}}.type || 'string';
-  if ({{=$isObject}}) {
+  var isObject{{=$lvl}} = typeof {{=$format}} == 'object'
+                          && !({{=$format}} instanceof RegExp)
+                          && {{=$format}}.validate;
+  if (isObject{{=$lvl}}) {
     {{? it.async}}
       var async{{=$lvl}} = {{=$format}}.async;
     {{?}}
@@ -70,34 +64,34 @@
 {{??}}
   {{ var $format = it.formats[$schema]; }}
   {{? !$format }}
-    {{? $unknownFormats == 'ignore' }}
-      {{ it.logger.warn('unknown format "' + $schema + '" ignored in schema at path "' + it.errSchemaPath + '"'); }}
-      {{# def.skipFormat }}
-    {{?? $allowUnknown && $unknownFormats.indexOf($schema) >= 0 }}
-      {{# def.skipFormat }}
-    {{??}}
+    {{? $unknownFormats === true || ($allowUnknown && $unknownFormats.indexOf($schema) == -1) }}
       {{ throw new Error('unknown format "' + $schema + '" is used in schema at path "' + it.errSchemaPath + '"'); }}
+    {{??}}
+      {{
+        if (!$allowUnknown) {
+          console.warn('unknown format "' + $schema + '" ignored in schema at path "' + it.errSchemaPath + '"');
+          if ($unknownFormats !== 'ignore')
+            console.warn('In the next major version it will throw exception. See option unknownFormats for more information');
+        }
+      }}
+      {{# def.skipFormat }}
     {{?}}
   {{?}}
   {{
     var $isObject = typeof $format == 'object'
                     && !($format instanceof RegExp)
                     && $format.validate;
-    var $formatType = $isObject && $format.type || 'string';
     if ($isObject) {
       var $async = $format.async === true;
       $format = $format.validate;
     }
   }}
-  {{? $formatType != $ruleType }}
-    {{# def.skipFormat }}
-  {{?}}
   {{? $async }}
     {{
       if (!it.async) throw new Error('async format in sync schema');
       var $formatRef = 'formats' + it.util.getProperty($schema) + '.validate';
     }}
-    if (!(await {{=$formatRef}}({{=$data}}))) {
+    if (!({{=it.yieldAwait}} {{=$formatRef}}({{=$data}}))) {
   {{??}}
     if (!{{# def.checkFormat }}) {
   {{?}}

node_modules/har-validator/node_modules/ajv/lib/dot/if.jst

-{{# def.definitions }}
-{{# def.errors }}
-{{# def.setupKeyword }}
-{{# def.setupNextLevel }}
-
-
-{{## def.validateIfClause:_clause:
-  {{
-    $it.schema = it.schema['_clause'];
-    $it.schemaPath = it.schemaPath + '._clause';
-    $it.errSchemaPath = it.errSchemaPath + '/_clause';
-  }}
-  {{# def.insertSubschemaCode }}
-  {{=$valid}} = {{=$nextValid}};
-  {{? $thenPresent && $elsePresent }}
-    {{ $ifClause = 'ifClause' + $lvl; }}
-    var {{=$ifClause}} = '_clause';
-  {{??}}
-    {{ $ifClause = '\'_clause\''; }}
-  {{?}}
-#}}
-
-{{
-  var $thenSch = it.schema['then']
-    , $elseSch = it.schema['else']
-    , $thenPresent = $thenSch !== undefined && {{# def.nonEmptySchema:$thenSch }}
-    , $elsePresent = $elseSch !== undefined && {{# def.nonEmptySchema:$elseSch }}
-    , $currentBaseId = $it.baseId;
-}}
-
-{{? $thenPresent || $elsePresent }}
-  {{
-    var $ifClause;
-    $it.createErrors = false;
-    $it.schema = $schema;
-    $it.schemaPath = $schemaPath;
-    $it.errSchemaPath = $errSchemaPath;
-  }}
-  var {{=$errs}} = errors;
-  var {{=$valid}} = true;
-
-  {{# def.setCompositeRule }}
-  {{# def.insertSubschemaCode }}
-  {{ $it.createErrors = true; }}
-  {{# def.resetErrors }}
-  {{# def.resetCompositeRule }}
-
-  {{? $thenPresent }}
-    if ({{=$nextValid}}) {
-      {{# def.validateIfClause:then }}
-    }
-    {{? $elsePresent }}
-      else {
-    {{?}}
-  {{??}}
-    if (!{{=$nextValid}}) {
-  {{?}}
-
-  {{? $elsePresent }}
-      {{# def.validateIfClause:else }}
-    }
-  {{?}}
-
-  if (!{{=$valid}}) {
-    {{# def.extraError:'if' }}
-  } 
-  {{? $breakOnError }} else { {{?}}
-
-  {{# def.cleanUp }}
-{{??}}
-  {{? $breakOnError }}
-    if (true) {
-  {{?}}
-{{?}}
-

node_modules/har-validator/node_modules/ajv/lib/dot/items.jst

@@ -90,6 +90,7 @@ var {{=$valid}};
     $it.errSchemaPath = $errSchemaPath;
   }}
   {{# def.validateItems: 0 }}
+  {{# def.ifResultValid }}
 {{?}}
 
 {{? $breakOnError }}

node_modules/har-validator/node_modules/ajv/lib/dot/missing.def

 {{## def.checkMissingProperty:_properties:
-  {{~ _properties:$propertyKey:$i }}
+  {{~ _properties:_$property:$i }}
     {{?$i}} || {{?}}
-    {{
-      var $prop = it.util.getProperty($propertyKey)
-        , $useData = $data + $prop;
-    }}
-    ( ({{# def.noPropertyInData }}) && (missing{{=$lvl}} = {{= it.util.toQuotedString(it.opts.jsonPointers ? $propertyKey : $prop) }}) )
+    {{ var $prop = it.util.getProperty(_$property); }}
+    ( {{=$data}}{{=$prop}} === undefined && (missing{{=$lvl}} = {{= it.util.toQuotedString(it.opts.jsonPointers ? _$property : $prop) }}) )
   {{~}}
 #}}
 
@@ -23,17 +20,15 @@
   {{# def.error:_error }}
 #}}
 
-
 {{## def.allErrorsMissingProperty:_error:
   {{
-    var $prop = it.util.getProperty($propertyKey)
-      , $missingProperty = it.util.escapeQuotes($propertyKey)
-      , $useData = $data + $prop;
+    var $prop = it.util.getProperty($reqProperty)
+      , $missingProperty = it.util.escapeQuotes($reqProperty);
     if (it.opts._errorDataPathProperty) {
-      it.errorPath = it.util.getPath($currentErrorPath, $propertyKey, it.opts.jsonPointers);
+      it.errorPath = it.util.getPath($currentErrorPath, $reqProperty, it.opts.jsonPointers);
     }
   }}
-  if ({{# def.noPropertyInData }}) {
+  if ({{=$data}}{{=$prop}} === undefined) {
     {{# def.addError:_error }}
   }
 #}}

node_modules/har-validator/node_modules/ajv/lib/dot/oneOf.jst

@@ -3,17 +3,11 @@
 {{# def.setupKeyword }}
 {{# def.setupNextLevel }}
 
-{{
-  var $currentBaseId = $it.baseId
-    , $prevValid = 'prevValid' + $lvl
-    , $passingSchemas = 'passingSchemas' + $lvl;
-}}
-
-var {{=$errs}} = errors
-  , {{=$prevValid}} = false
-  , {{=$valid}} = false
-  , {{=$passingSchemas}} = null;
+var {{=$errs}} = errors;
+var prevValid{{=$lvl}} = false;
+var {{=$valid}} = false;
 
+{{ var $currentBaseId = $it.baseId; }}
 {{# def.setCompositeRule }}
 
 {{~ $schema:$sch:$i }}
@@ -30,17 +24,13 @@ var {{=$errs}} = errors
   {{?}}
 
   {{? $i }}
-    if ({{=$nextValid}} && {{=$prevValid}}) {
+    if ({{=$nextValid}} && prevValid{{=$lvl}})
       {{=$valid}} = false;
-      {{=$passingSchemas}} = [{{=$passingSchemas}}, {{=$i}}];
-    } else {
+    else {
     {{ $closingBraces += '}'; }}
   {{?}}
 
-    if ({{=$nextValid}}) {
-      {{=$valid}} = {{=$prevValid}} = true;
-      {{=$passingSchemas}} = {{=$i}};
-    }
+    if ({{=$nextValid}}) {{=$valid}} = prevValid{{=$lvl}} = true;
 {{~}}
 
 {{# def.resetCompositeRule }}
@@ -48,7 +38,7 @@ var {{=$errs}} = errors
 {{= $closingBraces }}
 
 if (!{{=$valid}}) {
-  {{# def.extraError:'oneOf' }}
+  {{# def.error:'oneOf' }}
 } else {
   {{# def.resetErrors }}
 {{? it.opts.allErrors }} } {{?}}