{{# def.definitions }}
{{# def.errors }}
{{# def.setupKeyword }}
{{# def.$data }}

{{
  var $rule = this
    , $definition = 'definition' + $lvl
    , $rDef = $rule.definition
    , $validate = $rDef.validate
    , $compile
    , $inline
    , $macro
    , $ruleValidate
    , $validateCode;
}}

{{? $isData && $rDef.$data }}
  {{
    $validateCode = 'keywordValidate' + $lvl;
    var $validateSchema = $rDef.validateSchema;
  }}
  var {{=$definition}} = RULES.custom['{{=$keyword}}'].definition;
  var {{=$validateCode}} = {{=$definition}}.validate;
{{??}}
  {{
    $ruleValidate = it.useCustomRule($rule, $schema, it.schema, it);
    $schemaValue = 'validate.schema' + $schemaPath;
    $validateCode = $ruleValidate.code;
    $compile = $rDef.compile;
    $inline = $rDef.inline;
    $macro = $rDef.macro;
  }}
{{?}}

{{
  var $ruleErrs = $validateCode + '.errors'
    , $i = 'i' + $lvl
    , $ruleErr = 'ruleErr' + $lvl
    , $asyncKeyword = $rDef.async;

  if ($asyncKeyword && !it.async)
    throw new Error('async keyword in sync schema');
}}


{{? !($inline || $macro) }}{{=$ruleErrs}} = null;{{?}}
var {{=$errs}} = errors;
var valid{{=$lvl}};

{{## def.callRuleValidate:
  {{=$validateCode}}.call(
    {{? it.opts.passContext }}this{{??}}self{{?}}
    {{? $compile || $rDef.schema === false }}
      , {{=$data}}
    {{??}}
      , {{=$schemaValue}}
      , {{=$data}}
      , validate.schema{{=it.schemaPath}}
    {{?}}
    , {{# def.dataPath }}
    {{# def.passParentData }}
    , rootData
  )
#}}

{{## def.ruleValidationResult:
  {{? $inline }}
    {{? $rDef.statements }}
      valid{{=$lvl}}
    {{??}}
      ({{= $ruleValidate.validate }})
    {{?}}
  {{?? $macro }}
    valid{{=$it.level}}
  {{??}}
    {{? $asyncKeyword }}
      {{? $rDef.errors === false }}
        ({{=it.yieldAwait}}{{= def_callRuleValidate }})
      {{??}}
        valid{{=$lvl}}
      {{?}}
    {{??}}
      {{= def_callRuleValidate }}
    {{?}}
  {{?}}
#}}

{{## def.extendErrors:_inline:
  for (var {{=$i}}={{=$errs}}; {{=$i}}<errors; {{=$i}}++) {
    var {{=$ruleErr}} = vErrors[{{=$i}}];
    {{# _inline ? 'if (\{\{=$ruleErr\}\}.dataPath === undefined) {' : '' }}
      {{=$ruleErr}}.dataPath = (dataPath || '') + {{= it.errorPath }};
    {{# _inline ? '}' : '' }}
    {{# _inline ? 'if (\{\{=$ruleErr\}\}.schemaPath === undefined) {' : '' }}
      {{=$ruleErr}}.schemaPath = "{{=$errSchemaPath}}";
    {{# _inline ? '}' : '' }}
    {{? it.opts.verbose }}
      {{=$ruleErr}}.schema = {{=$schemaValue}};
      {{=$ruleErr}}.data = {{=$data}};
    {{?}}
  }
#}}

{{? $inline && $rDef.statements }}
  {{= $ruleValidate.validate }}
{{?? $macro }}
  {{# def.setupNextLevel }}
  {{
    $it.schema = $ruleValidate.validate;
    $it.schemaPath = '';
  }}
  {{# def.setCompositeRule }}
  {{ var $code = it.validate($it).replace(/validate\.schema/g, $validateCode); }}
  {{# def.resetCompositeRule }}
  {{= $code }}
{{?? !$inline }}
  {{# def.beginDefOut}}
    {{# def.callRuleValidate }}
  {{# def.storeDefOut:def_callRuleValidate }}

  {{? $rDef.errors !== false }}
    {{? $asyncKeyword }}
      {{ $ruleErrs = 'customErrors' + $lvl; }}
      var {{=$ruleErrs}} = null;
      try {
        valid{{=$lvl}} = {{=it.yieldAwait}}{{= def_callRuleValidate }};
      } catch (e) {
        valid{{=$lvl}} = false;
        if (e instanceof ValidationError) {{=$ruleErrs}} = e.errors;
        else throw e;
      }
    {{??}}
      {{=$validateCode}}.errors = null;
    {{?}}
  {{?}}
{{?}}


if ({{? $validateSchema }}
      !{{=$definition}}.validateSchema({{=$schemaValue}}) ||
    {{?}}
    !{{# def.ruleValidationResult }}) {
  {{ $errorKeyword = $rule.keyword; }}
  {{# def.beginDefOut}}
    {{# def.error:'custom' }}
  {{# def.storeDefOut:def_customError }}

  {{? $inline }}
    {{? $rDef.errors }}
      {{? $rDef.errors != 'full' }}
        {{# def.extendErrors:true }}
      {{?}}
    {{??}}
      {{? $rDef.errors === false}}
        {{= def_customError }}
      {{??}}
        if ({{=$errs}} == errors) {
          {{= def_customError }}
        } else {
          {{# def.extendErrors:true }}
        }
      {{?}}
    {{?}}
  {{?? $macro }}
    {{# def.extraError:'custom' }}
  {{??}}
    {{? $rDef.errors === false}}
      {{= def_customError }}
    {{??}}
      if (Array.isArray({{=$ruleErrs}})) {
        if (vErrors === null) vErrors = {{=$ruleErrs}};
        else vErrors = vErrors.concat({{=$ruleErrs}});
        errors = vErrors.length;
        {{# def.extendErrors:false }}
      } else {
        {{= def_customError }}
      }
    {{?}}
  {{?}}

 } {{? $breakOnError }} else { {{?}}