Haketilo

[submodule "schemas"]

	path = schemas

	url = ../hydrilla-json-schemas/

/* SPDX-License-Identifier: MIT AND CC0-1.0

 *

 * License text of the original lib/index.js from jsonschema library:

 *

 ***************************************

 *

 * jsonschema is licensed under MIT license.

 *

 * Copyright (C) 2012-2015 Tom de Grunt <tom@degrunt.nl>

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy of

 * this software and associated documentation files (the "Software"), to deal in

 * the Software without restriction, including without limitation the rights to

 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies

 * of the Software, and to permit persons to whom the Software is furnished to do

 * so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in all

 * copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

 * SOFTWARE.

 *

 *******************************************************************************

 *

 * License notice for the adaptation to use in Haketilo:

 *

 ***************************************

 *

 * Copyright (C) 2022 Wojtek Kosior <koszko@koszko.org>

 *

 * This program is free software: you can redistribute it and/or modify

 * it under the terms of the CC0 1.0 Universal License as published by

 * the Creative Commons Corporation.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * CC0 1.0 Universal License for more details.

 */

#FROM common/jsonschema/validator.js IMPORT Validator

#EXPORT Validator

#FROM common/jsonschema/helpers.js IMPORT ValidatorResult, ValidationError, \

                                          ValidatorResultError, SchemaError

#EXPORT ValidatorResult

#EXPORT ValidationError

#EXPORT ValidatorResultError

#EXPORT SchemaError

#FROM common/jsonschema/scan.js IMPORT SchemaScanResult, scan

#EXPORT scan

#EXPORT SchemaScanResult

function validate(instance, schema, options) {

    var v = new Validator();

    return v.validate(instance, schema, options);

};

#EXPORT validate

const haketilo_schemas = [

#INCLUDE schemas/api_query_result-1.0.1.schema.json

    ,

#INCLUDE schemas/api_mapping_description-1.0.1.schema.json

    ,

#INCLUDE schemas/api_resource_description-1.0.1.schema.json

    ,

#INCLUDE schemas/common_definitions-1.0.1.schema.json

].reduce((ac, s) => Object.assign(ac, {[s.$id]: s}), {});

#EXPORT haketilo_schemas

const haketilo_validator = new Validator();

Object.values(haketilo_schemas)

    .forEach(s => haketilo_validator.addSchema(s, s.$id));

#EXPORT haketilo_validator

/* SPDX-License-Identifier: MIT

 *

 * jsonschema is licensed under MIT license.

 *

 * Copyright (C) 2012-2015 Tom de Grunt <tom@degrunt.nl>

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy of

 * this software and associated documentation files (the "Software"), to deal in

 * the Software without restriction, including without limitation the rights to

 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies

 * of the Software, and to permit persons to whom the Software is furnished to do

 * so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in all

 * copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

 * SOFTWARE.

 */

#IMPORT common/jsonschema/helpers.js

/** @type ValidatorResult */

var ValidatorResult = helpers.ValidatorResult;

/** @type SchemaError */

var SchemaError = helpers.SchemaError;

var attribute = {};

const ignoreProperties = {

  // informative properties

  'id': true,

  'default': true,

  'description': true,

  'title': true,

  // arguments to other properties

  'additionalItems': true,

  'then': true,

  'else': true,

  // special-handled properties

  '$schema': true,

  '$ref': true,

  'extends': true,

};

#EXPORT ignoreProperties

/**

 * @name validators

 */

const validators = {};

/**

 * Validates whether the instance if of a certain type

 * @param instance

 * @param schema

 * @param options

 * @param ctx

 * @return {ValidatorResult|null}

 */

validators.type = function validateType (instance, schema, options, ctx) {

  // Ignore undefined instances

  if (instance === undefined) {

    return null;

  }

  var result = new ValidatorResult(instance, schema, options, ctx);

  var types = Array.isArray(schema.type) ? schema.type : [schema.type];

  if (!types.some(this.testType.bind(this, instance, schema, options, ctx))) {

    var list = types.map(function (v) {

      if(!v) return;

      var id = v.$id || v.id;

      return id ? ('<' + id + '>') : (v+'');

    });

    result.addError({

      name: 'type',

      argument: list,

      message: "is not of a type(s) " + list,

    });

  }

  return result;

};

function testSchemaNoThrow(instance, options, ctx, callback, schema){

  var throwError = options.throwError;

  var throwAll = options.throwAll;

  options.throwError = false;

  options.throwAll = false;

  var res = this.validateSchema(instance, schema, options, ctx);

  options.throwError = throwError;

  options.throwAll = throwAll;

  if (!res.valid && callback instanceof Function) {

    callback(res);

  }

  return res.valid;

}

/**

 * Validates whether the instance matches some of the given schemas

 * @param instance

 * @param schema

 * @param options

 * @param ctx

 * @return {ValidatorResult|null}

 */

validators.anyOf = function validateAnyOf (instance, schema, options, ctx) {

  // Ignore undefined instances

  if (instance === undefined) {

    return null;

  }

  var result = new ValidatorResult(instance, schema, options, ctx);

  var inner = new ValidatorResult(instance, schema, options, ctx);

  if (!Array.isArray(schema.anyOf)){

    throw new SchemaError("anyOf must be an array");

  }

  if (!schema.anyOf.some(

    testSchemaNoThrow.bind(

      this, instance, options, ctx, function(res){inner.importErrors(res);}

    ))) {

    var list = schema.anyOf.map(function (v, i) {

      var id = v.$id || v.id;

      if(id) return '<' + id + '>';

      return(v.title && JSON.stringify(v.title)) || (v['$ref'] && ('<' + v['$ref'] + '>')) || '[subschema '+i+']';

    });

    if (options.nestedErrors) {

      result.importErrors(inner);

    }

    result.addError({

      name: 'anyOf',

      argument: list,

      message: "is not any of " + list.join(','),

    });

  }

  return result;

};

/**

 * Validates whether the instance matches every given schema

 * @param instance

 * @param schema

 * @param options

 * @param ctx

 * @return {String|null}

 */

validators.allOf = function validateAllOf (instance, schema, options, ctx) {

  // Ignore undefined instances

  if (instance === undefined) {

    return null;

  }

  if (!Array.isArray(schema.allOf)){

    throw new SchemaError("allOf must be an array");

  }

  var result = new ValidatorResult(instance, schema, options, ctx);

  var self = this;

  schema.allOf.forEach(function(v, i){

    var valid = self.validateSchema(instance, v, options, ctx);

    if(!valid.valid){

      var id = v.$id || v.id;

      var msg = id || (v.title && JSON.stringify(v.title)) || (v['$ref'] && ('<' + v['$ref'] + '>')) || '[subschema '+i+']';

      result.addError({

        name: 'allOf',

        argument: { id: msg, length: valid.errors.length, valid: valid },

        message: 'does not match allOf schema ' + msg + ' with ' + valid.errors.length + ' error[s]:',

      });

      result.importErrors(valid);

    }

  });

  return result;

};

/**

 * Validates whether the instance matches exactly one of the given schemas

 * @param instance

 * @param schema

 * @param options

 * @param ctx

 * @return {String|null}

 */

validators.oneOf = function validateOneOf (instance, schema, options, ctx) {

  // Ignore undefined instances

  if (instance === undefined) {

    return null;

  }

  if (!Array.isArray(schema.oneOf)){

    throw new SchemaError("oneOf must be an array");

  }

  var result = new ValidatorResult(instance, schema, options, ctx);

  var inner = new ValidatorResult(instance, schema, options, ctx);

  var count = schema.oneOf.filter(

    testSchemaNoThrow.bind(

      this, instance, options, ctx, function(res) {inner.importErrors(res);}

    ) ).length;

  var list = schema.oneOf.map(function (v, i) {

    var id = v.$id || v.id;

    return id || (v.title && JSON.stringify(v.title)) || (v['$ref'] && ('<' + v['$ref'] + '>')) || '[subschema '+i+']';

  });

  if (count!==1) {

    if (options.nestedErrors) {

      result.importErrors(inner);

    }

    result.addError({

      name: 'oneOf',

      argument: list,

      message: "is not exactly one from " + list.join(','),

    });

  }

  return result;

};

/**

 * Validates "then" or "else" depending on the result of validating "if"

 * @param instance

 * @param schema

 * @param options

 * @param ctx

 * @return {String|null}

 */

validators.if = function validateIf (instance, schema, options, ctx) {

  // Ignore undefined instances

  if (instance === undefined) return null;

  if (!helpers.isSchema(schema.if)) throw new Error('Expected "if" keyword to be a schema');

  var ifValid = testSchemaNoThrow.call(this, instance, options, ctx, null, schema.if);

  var result = new ValidatorResult(instance, schema, options, ctx);

  var res;

  if(ifValid){

    if (schema.then === undefined) return;

    if (!helpers.isSchema(schema.then)) throw new Error('Expected "then" keyword to be a schema');

    res = this.validateSchema(instance, schema.then, options, ctx.makeChild(schema.then));

    result.importErrors(res);

  }else{

    if (schema.else === undefined) return;

    if (!helpers.isSchema(schema.else)) throw new Error('Expected "else" keyword to be a schema');

    res = this.validateSchema(instance, schema.else, options, ctx.makeChild(schema.else));

    result.importErrors(res);

  }

  return result;

};

function getEnumerableProperty(object, key){

  // Determine if `key` shows up in `for(var key in object)`

  // First test Object.hasOwnProperty.call as an optimization: that guarantees it does

  if(Object.hasOwnProperty.call(object, key)) return object[key];

  // Test `key in object` as an optimization; false means it won't

  if(!(key in object)) return;

  while( (object = Object.getPrototypeOf(object)) ){

    if(Object.propertyIsEnumerable.call(object, key)) return object[key];

  }

}

/**

 * Validates propertyNames

 * @param instance

 * @param schema

 * @param options

 * @param ctx

 * @return {String|null|ValidatorResult}

 */

validators.propertyNames = function validatePropertyNames (instance, schema, options, ctx) {

  if(!this.types.object(instance)) return;

  var result = new ValidatorResult(instance, schema, options, ctx);

  var subschema = schema.propertyNames!==undefined ? schema.propertyNames : {};

  if(!helpers.isSchema(subschema)) throw new SchemaError('Expected "propertyNames" to be a schema (object or boolean)');

  for (var property in instance) {

    if(getEnumerableProperty(instance, property) !== undefined){

      var res = this.validateSchema(property, subschema, options, ctx.makeChild(subschema));

      result.importErrors(res);

    }

  }

  return result;

};

/**

 * Validates properties

 * @param instance

 * @param schema

 * @param options

 * @param ctx

 * @return {String|null|ValidatorResult}

 */

validators.properties = function validateProperties (instance, schema, options, ctx) {

  if(!this.types.object(instance)) return;

  var result = new ValidatorResult(instance, schema, options, ctx);

  var properties = schema.properties || {};

  for (var property in properties) {

    var subschema = properties[property];

    if(subschema===undefined){

      continue;

    }else if(subschema===null){

      throw new SchemaError('Unexpected null, expected schema in "properties"');

    }

    if (typeof options.preValidateProperty == 'function') {

      options.preValidateProperty(instance, property, subschema, options, ctx);

    }

    var prop = getEnumerableProperty(instance, property);

    var res = this.validateSchema(prop, subschema, options, ctx.makeChild(subschema, property));

    if(res.instance !== result.instance[property]) result.instance[property] = res.instance;

    result.importErrors(res);

  }

  return result;

};

/**

 * Test a specific property within in instance against the additionalProperties schema attribute

 * This ignores properties with definitions in the properties schema attribute, but no other attributes.

 * If too many more types of property-existence tests pop up they may need their own class of tests (like `type` has)

 * @private

 * @return {boolean}

 */

function testAdditionalProperty (instance, schema, options, ctx, property, result) {

  if(!this.types.object(instance)) return;

  if (schema.properties && schema.properties[property] !== undefined) {

    return;

  }

  if (schema.additionalProperties === false) {

    result.addError({

      name: 'additionalProperties',

      argument: property,

      message: "is not allowed to have the additional property " + JSON.stringify(property),

    });

  } else {

    var additionalProperties = schema.additionalProperties || {};

    if (typeof options.preValidateProperty == 'function') {

      options.preValidateProperty(instance, property, additionalProperties, options, ctx);

    }

    var res = this.validateSchema(instance[property], additionalProperties, options, ctx.makeChild(additionalProperties, property));

    if(res.instance !== result.instance[property]) result.instance[property] = res.instance;

    result.importErrors(res);

  }

}

/**

 * Validates patternProperties

 * @param instance

 * @param schema

 * @param options

 * @param ctx

 * @return {String|null|ValidatorResult}

 */

validators.patternProperties = function validatePatternProperties (instance, schema, options, ctx) {

  if(!this.types.object(instance)) return;

  var result = new ValidatorResult(instance, schema, options, ctx);

  var patternProperties = schema.patternProperties || {};

  for (var property in instance) {

    var test = true;

    for (var pattern in patternProperties) {

      var subschema = patternProperties[pattern];

      if(subschema===undefined){

        continue;

      }else if(subschema===null){

        throw new SchemaError('Unexpected null, expected schema in "patternProperties"');

      }

      try {

        var regexp = new RegExp(pattern, 'u');

      } catch(_e) {

        // In the event the stricter handling causes an error, fall back on the forgiving handling

        // DEPRECATED

        regexp = new RegExp(pattern);

      }

      if (!regexp.test(property)) {

        continue;

      }

      test = false;

      if (typeof options.preValidateProperty == 'function') {

        options.preValidateProperty(instance, property, subschema, options, ctx);

      }

      var res = this.validateSchema(instance[property], subschema, options, ctx.makeChild(subschema, property));

      if(res.instance !== result.instance[property]) result.instance[property] = res.instance;

      result.importErrors(res);

    }

    if (test) {

      testAdditionalProperty.call(this, instance, schema, options, ctx, property, result);

    }

  }

  return result;

};

/**

 * Validates additionalProperties

 * @param instance

 * @param schema

 * @param options

 * @param ctx

 * @return {String|null|ValidatorResult}

 */

validators.additionalProperties = function validateAdditionalProperties (instance, schema, options, ctx) {

  if(!this.types.object(instance)) return;

  // if patternProperties is defined then we'll test when that one is called instead

  if (schema.patternProperties) {

    return null;

  }

  var result = new ValidatorResult(instance, schema, options, ctx);

  for (var property in instance) {

    testAdditionalProperty.call(this, instance, schema, options, ctx, property, result);

  }

  return result;

};

/**

 * Validates whether the instance value is at least of a certain length, when the instance value is a string.

 * @param instance

 * @param schema

 * @return {String|null}

 */

validators.minProperties = function validateMinProperties (instance, schema, options, ctx) {

  if (!this.types.object(instance)) return;

  var result = new ValidatorResult(instance, schema, options, ctx);

  var keys = Object.keys(instance);

  if (!(keys.length >= schema.minProperties)) {

    result.addError({

      name: 'minProperties',

      argument: schema.minProperties,

      message: "does not meet minimum property length of " + schema.minProperties,

    });

  }

  return result;

};

/**

 * Validates whether the instance value is at most of a certain length, when the instance value is a string.

 * @param instance

 * @param schema

 * @return {String|null}

 */

validators.maxProperties = function validateMaxProperties (instance, schema, options, ctx) {

  if (!this.types.object(instance)) return;

  var result = new ValidatorResult(instance, schema, options, ctx);

  var keys = Object.keys(instance);

  if (!(keys.length <= schema.maxProperties)) {

    result.addError({

      name: 'maxProperties',

      argument: schema.maxProperties,

      message: "does not meet maximum property length of " + schema.maxProperties,

    });

  }

  return result;

};

/**

 * Validates items when instance is an array

 * @param instance

 * @param schema

 * @param options

 * @param ctx

 * @return {String|null|ValidatorResult}

 */

validators.items = function validateItems (instance, schema, options, ctx) {

  var self = this;

  if (!this.types.array(instance)) return;

  if (schema.items===undefined) return;

  var result = new ValidatorResult(instance, schema, options, ctx);

  instance.every(function (value, i) {

    if(Array.isArray(schema.items)){

      var items =  schema.items[i]===undefined ? schema.additionalItems : schema.items[i];

    }else{

      var items = schema.items;

    }

    if (items === undefined) {

      return true;

    }

    if (items === false) {

      result.addError({

        name: 'items',

        message: "additionalItems not permitted",

      });

      return false;

    }

    var res = self.validateSchema(value, items, options, ctx.makeChild(items, i));

    if(res.instance !== result.instance[i]) result.instance[i] = res.instance;

    result.importErrors(res);

    return true;

  });

  return result;

};

/**

 * Validates the "contains" keyword

 * @param instance

 * @param schema

 * @param options

 * @param ctx

 * @return {String|null|ValidatorResult}

 */

validators.contains = function validateContains (instance, schema, options, ctx) {

  var self = this;

  if (!this.types.array(instance)) return;

  if (schema.contains===undefined) return;

  if (!helpers.isSchema(schema.contains)) throw new Error('Expected "contains" keyword to be a schema');

  var result = new ValidatorResult(instance, schema, options, ctx);

  var count = instance.some(function (value, i) {

    var res = self.validateSchema(value, schema.contains, options, ctx.makeChild(schema.contains, i));

    return res.errors.length===0;

  });

  if(count===false){

    result.addError({

      name: 'contains',

      argument: schema.contains,

      message: "must contain an item matching given schema",

    });

  }

  return result;

};

/**

 * Validates minimum and exclusiveMinimum when the type of the instance value is a number.

 * @param instance

 * @param schema

 * @return {String|null}

 */

validators.minimum = function validateMinimum (instance, schema, options, ctx) {

  if (!this.types.number(instance)) return;

  var result = new ValidatorResult(instance, schema, options, ctx);

  if (schema.exclusiveMinimum && schema.exclusiveMinimum === true) {

    if(!(instance > schema.minimum)){

      result.addError({

        name: 'minimum',

        argument: schema.minimum,

        message: "must be greater than " + schema.minimum,

      });

    }

  } else {

    if(!(instance >= schema.minimum)){

      result.addError({

        name: 'minimum',

        argument: schema.minimum,

        message: "must be greater than or equal to " + schema.minimum,

      });

    }

  }

  return result;

};

/**

 * Validates maximum and exclusiveMaximum when the type of the instance value is a number.

 * @param instance

 * @param schema

 * @return {String|null}

 */

validators.maximum = function validateMaximum (instance, schema, options, ctx) {

  if (!this.types.number(instance)) return;

  var result = new ValidatorResult(instance, schema, options, ctx);

  if (schema.exclusiveMaximum && schema.exclusiveMaximum === true) {

    if(!(instance < schema.maximum)){

      result.addError({

        name: 'maximum',

        argument: schema.maximum,

        message: "must be less than " + schema.maximum,

      });

    }

  } else {

    if(!(instance <= schema.maximum)){

      result.addError({

        name: 'maximum',

        argument: schema.maximum,

        message: "must be less than or equal to " + schema.maximum,

      });

    }

  }

  return result;

};

/**

 * Validates the number form of exclusiveMinimum when the type of the instance value is a number.

 * @param instance

 * @param schema

 * @return {String|null}

 */

validators.exclusiveMinimum = function validateExclusiveMinimum (instance, schema, options, ctx) {

  // Support the boolean form of exclusiveMinimum, which is handled by the "minimum" keyword.

  if(typeof schema.exclusiveMinimum === 'boolean') return;

  if (!this.types.number(instance)) return;

  var result = new ValidatorResult(instance, schema, options, ctx);

  var valid = instance > schema.exclusiveMinimum;

  if (!valid) {

    result.addError({

      name: 'exclusiveMinimum',

      argument: schema.exclusiveMinimum,

      message: "must be strictly greater than " + schema.exclusiveMinimum,

    });

  }

  return result;

};

/**

 * Validates the number form of exclusiveMaximum when the type of the instance value is a number.

 * @param instance

 * @param schema

 * @return {String|null}

 */

validators.exclusiveMaximum = function validateExclusiveMaximum (instance, schema, options, ctx) {

  // Support the boolean form of exclusiveMaximum, which is handled by the "maximum" keyword.

  if(typeof schema.exclusiveMaximum === 'boolean') return;

  if (!this.types.number(instance)) return;

  var result = new ValidatorResult(instance, schema, options, ctx);

  var valid = instance < schema.exclusiveMaximum;

  if (!valid) {

    result.addError({

      name: 'exclusiveMaximum',

      argument: schema.exclusiveMaximum,

      message: "must be strictly less than " + schema.exclusiveMaximum,

    });

  }

  return result;

};

/**

 * Perform validation for multipleOf and divisibleBy, which are essentially the same.

 * @param instance

 * @param schema

 * @param validationType

 * @param errorMessage

 * @returns {String|null}

 */

var validateMultipleOfOrDivisbleBy = function validateMultipleOfOrDivisbleBy (instance, schema, options, ctx, validationType, errorMessage) {

  if (!this.types.number(instance)) return;

  var validationArgument = schema[validationType];

  if (validationArgument == 0) {

    throw new SchemaError(validationType + " cannot be zero");

  }

  var result = new ValidatorResult(instance, schema, options, ctx);

  var instanceDecimals = helpers.getDecimalPlaces(instance);

  var divisorDecimals = helpers.getDecimalPlaces(validationArgument);

  var maxDecimals = Math.max(instanceDecimals , divisorDecimals);

  var multiplier = Math.pow(10, maxDecimals);

  if (Math.round(instance * multiplier) % Math.round(validationArgument * multiplier) !== 0) {

    result.addError({

      name: validationType,

      argument:  validationArgument,

      message: errorMessage + JSON.stringify(validationArgument),

    });

  }

  return result;

};

/**

 * Validates divisibleBy when the type of the instance value is a number.

 * @param instance

 * @param schema

 * @return {String|null}

 */

validators.multipleOf = function validateMultipleOf (instance, schema, options, ctx) {

  return validateMultipleOfOrDivisbleBy.call(this, instance, schema, options, ctx, "multipleOf", "is not a multiple of (divisible by) ");

};

/**

 * Validates multipleOf when the type of the instance value is a number.

 * @param instance

 * @param schema

 * @return {String|null}

 */

validators.divisibleBy = function validateDivisibleBy (instance, schema, options, ctx) {

  return validateMultipleOfOrDivisbleBy.call(this, instance, schema, options, ctx, "divisibleBy", "is not divisible by (multiple of) ");

};

/**

 * Validates whether the instance value is present.

 * @param instance

 * @param schema

 * @return {String|null}

 */

validators.required = function validateRequired (instance, schema, options, ctx) {

  var result = new ValidatorResult(instance, schema, options, ctx);

  if (instance === undefined && schema.required === true) {

    // A boolean form is implemented for reverse-compatibility with schemas written against older drafts

    result.addError({

      name: 'required',

      message: "is required",

    });

  } else if (this.types.object(instance) && Array.isArray(schema.required)) {

    schema.required.forEach(function(n){

      if(getEnumerableProperty(instance, n)===undefined){

        result.addError({

          name: 'required',

          argument: n,

          message: "requires property " + JSON.stringify(n),

        });

      }

    });

  }

  return result;

};

/**

 * Validates whether the instance value matches the regular expression, when the instance value is a string.

 * @param instance

 * @param schema

 * @return {String|null}

 */

validators.pattern = function validatePattern (instance, schema, options, ctx) {

  if (!this.types.string(instance)) return;

  var result = new ValidatorResult(instance, schema, options, ctx);

  var pattern = schema.pattern;

  try {

    var regexp = new RegExp(pattern, 'u');

  } catch(_e) {

    // In the event the stricter handling causes an error, fall back on the forgiving handling

    // DEPRECATED

    regexp = new RegExp(pattern);

  }

  if (!instance.match(regexp)) {

    result.addError({

      name: 'pattern',

      argument: schema.pattern,

      message: "does not match pattern " + JSON.stringify(schema.pattern.toString()),

    });

  }

  return result;

};

/**

 * Validates whether the instance value is of a certain defined format or a custom

 * format.

 * The following formats are supported for string types:

 *   - date-time

 *   - date

 *   - time

 *   - ip-address

 *   - ipv6

 *   - uri

 *   - color

 *   - host-name

 *   - alpha

 *   - alpha-numeric

 *   - utc-millisec

 * @param instance

 * @param schema

 * @param [options]

 * @param [ctx]

 * @return {String|null}

 */

validators.format = function validateFormat (instance, schema, options, ctx) {

  if (instance===undefined) return;

  var result = new ValidatorResult(instance, schema, options, ctx);

  if (!result.disableFormat && !helpers.isFormat(instance, schema.format, this)) {

    result.addError({

      name: 'format',

      argument: schema.format,

      message: "does not conform to the " + JSON.stringify(schema.format) + " format",

    });

  }

  return result;

};

/**

 * Validates whether the instance value is at least of a certain length, when the instance value is a string.

 * @param instance

 * @param schema

 * @return {String|null}

 */

validators.minLength = function validateMinLength (instance, schema, options, ctx) {

  if (!this.types.string(instance)) return;

  var result = new ValidatorResult(instance, schema, options, ctx);

  var hsp = instance.match(/[\uDC00-\uDFFF]/g);

  var length = instance.length - (hsp ? hsp.length : 0);

  if (!(length >= schema.minLength)) {

    result.addError({

      name: 'minLength',

      argument: schema.minLength,

      message: "does not meet minimum length of " + schema.minLength,

    });

  }

  return result;

};

/**

 * Validates whether the instance value is at most of a certain length, when the instance value is a string.

 * @param instance

 * @param schema

 * @return {String|null}

 */

validators.maxLength = function validateMaxLength (instance, schema, options, ctx) {

  if (!this.types.string(instance)) return;

  var result = new ValidatorResult(instance, schema, options, ctx);

  // TODO if this was already computed in "minLength", use that value instead of re-computing

  var hsp = instance.match(/[\uDC00-\uDFFF]/g);

  var length = instance.length - (hsp ? hsp.length : 0);

  if (!(length <= schema.maxLength)) {

    result.addError({

      name: 'maxLength',

      argument: schema.maxLength,

      message: "does not meet maximum length of " + schema.maxLength,

    });

  }

  return result;

};

/**

 * Validates whether instance contains at least a minimum number of items, when the instance is an Array.

 * @param instance

 * @param schema

 * @return {String|null}

 */

validators.minItems = function validateMinItems (instance, schema, options, ctx) {

  if (!this.types.array(instance)) return;

  var result = new ValidatorResult(instance, schema, options, ctx);

  if (!(instance.length >= schema.minItems)) {

    result.addError({

      name: 'minItems',

      argument: schema.minItems,

      message: "does not meet minimum length of " + schema.minItems,

    });

  }

  return result;

};

/**

 * Validates whether instance contains no more than a maximum number of items, when the instance is an Array.

 * @param instance

 * @param schema

 * @return {String|null}

 */

validators.maxItems = function validateMaxItems (instance, schema, options, ctx) {

  if (!this.types.array(instance)) return;

  var result = new ValidatorResult(instance, schema, options, ctx);

  if (!(instance.length <= schema.maxItems)) {

    result.addError({

      name: 'maxItems',

      argument: schema.maxItems,

      message: "does not meet maximum length of " + schema.maxItems,

    });

  }

  return result;

};

/**

 * Deep compares arrays for duplicates

 * @param v

 * @param i

 * @param a

 * @private

 * @return {boolean}

 */

function testArrays (v, i, a) {

  var j, len = a.length;

  for (j = i + 1, len; j < len; j++) {

    if (helpers.deepCompareStrict(v, a[j])) {

      return false;

    }

  }

  return true;

}

/**

 * Validates whether there are no duplicates, when the instance is an Array.

 * @param instance

 * @return {String|null}

 */

validators.uniqueItems = function validateUniqueItems (instance, schema, options, ctx) {

  if (schema.uniqueItems!==true) return;

  if (!this.types.array(instance)) return;

  var result = new ValidatorResult(instance, schema, options, ctx);

  if (!instance.every(testArrays)) {

    result.addError({

      name: 'uniqueItems',

      message: "contains duplicate item",

    });

  }

  return result;

};

/**

 * Validate for the presence of dependency properties, if the instance is an object.

 * @param instance

 * @param schema

 * @param options

 * @param ctx

 * @return {null|ValidatorResult}

 */

validators.dependencies = function validateDependencies (instance, schema, options, ctx) {

  if (!this.types.object(instance)) return;

  var result = new ValidatorResult(instance, schema, options, ctx);

  for (var property in schema.dependencies) {

    if (instance[property] === undefined) {

      continue;

    }

    var dep = schema.dependencies[property];

    var childContext = ctx.makeChild(dep, property);

    if (typeof dep == 'string') {

      dep = [dep];

    }

    if (Array.isArray(dep)) {

      dep.forEach(function (prop) {

        if (instance[prop] === undefined) {

          result.addError({

            // FIXME there's two different "dependencies" errors here with slightly different outputs

            // Can we make these the same? Or should we create different error types?

            name: 'dependencies',

            argument: childContext.propertyPath,

            message: "property " + prop + " not found, required by " + childContext.propertyPath,

          });

        }

      });

    } else {

      var res = this.validateSchema(instance, dep, options, childContext);

      if(result.instance !== res.instance) result.instance = res.instance;

      if (res && res.errors.length) {

        result.addError({

          name: 'dependencies',

          argument: childContext.propertyPath,

          message: "does not meet dependency required by " + childContext.propertyPath,

        });

        result.importErrors(res);

      }

    }

  }

  return result;

};

/**

 * Validates whether the instance value is one of the enumerated values.

 *

 * @param instance

 * @param schema

 * @return {ValidatorResult|null}

 */

validators['enum'] = function validateEnum (instance, schema, options, ctx) {

  if (instance === undefined) {

    return null;

  }

  if (!Array.isArray(schema['enum'])) {

    throw new SchemaError("enum expects an array", schema);

  }

  var result = new ValidatorResult(instance, schema, options, ctx);

  if (!schema['enum'].some(helpers.deepCompareStrict.bind(null, instance))) {

    result.addError({

      name: 'enum',

      argument: schema['enum'],

      message: "is not one of enum values: " + schema['enum'].map(String).join(','),

    });

  }

  return result;

};

/**

 * Validates whether the instance exactly matches a given value

 *

 * @param instance

 * @param schema

 * @return {ValidatorResult|null}

 */

validators['const'] = function validateEnum (instance, schema, options, ctx) {

  if (instance === undefined) {

    return null;

  }

  var result = new ValidatorResult(instance, schema, options, ctx);

  if (!helpers.deepCompareStrict(schema['const'], instance)) {

    result.addError({

      name: 'const',

      argument: schema['const'],

      message: "does not exactly match expected constant: " + schema['const'],

    });

  }

  return result;

};

/**

 * Validates whether the instance if of a prohibited type.

 * @param instance

 * @param schema

 * @param options

 * @param ctx

 * @return {null|ValidatorResult}

 */

validators.not = validators.disallow = function validateNot (instance, schema, options, ctx) {

  var self = this;

  if(instance===undefined) return null;

  var result = new ValidatorResult(instance, schema, options, ctx);

  var notTypes = schema.not || schema.disallow;

  if(!notTypes) return null;

  if(!Array.isArray(notTypes)) notTypes=[notTypes];

  notTypes.forEach(function (type) {

    if (self.testType(instance, schema, options, ctx, type)) {

      var id = type && (type.$id || type.id);

      var schemaId = id || type;

      result.addError({

        name: 'not',

        argument: schemaId,

        message: "is of prohibited type " + schemaId,

      });

    }

  });

  return result;

};

#EXPORT validators

/* SPDX-License-Identifier: MIT

 *

 * jsonschema is licensed under MIT license.

 *

 * Copyright (C) 2012-2015 Tom de Grunt <tom@degrunt.nl>

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy of

 * this software and associated documentation files (the "Software"), to deal in

 * the Software without restriction, including without limitation the rights to

 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies

 * of the Software, and to permit persons to whom the Software is furnished to do

 * so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in all

 * copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

 * SOFTWARE.

 */

#IMPORT common/jsonschema/urllib_mock.js AS uri

function ValidationError (message, instance, schema, path, name, argument) {

  if(Array.isArray(path)){

    this.path = path;

    this.property = path.reduce(function(sum, item){

      return sum + makeSuffix(item);

    }, 'instance');

  }else if(path !== undefined){

    this.property = path;

  }

  if (message) {

    this.message = message;

  }

  if (schema) {

    var id = schema.$id || schema.id;

    this.schema = id || schema;

  }

  if (instance !== undefined) {

    this.instance = instance;

  }

  this.name = name;

  this.argument = argument;

  this.stack = this.toString();

};

#EXPORT ValidationError

ValidationError.prototype.toString = function toString() {

  return this.property + ' ' + this.message;

};

function ValidatorResult(instance, schema, options, ctx) {

  this.instance = instance;

  this.schema = schema;

  this.options = options;

  this.path = ctx.path;

  this.propertyPath = ctx.propertyPath;

  this.errors = [];

  this.throwError = options && options.throwError;

  this.throwFirst = options && options.throwFirst;

  this.throwAll = options && options.throwAll;

  this.disableFormat = options && options.disableFormat === true;

};

ValidatorResult.prototype.addError = function addError(detail) {

  var err;

  if (typeof detail == 'string') {

    err = new ValidationError(detail, this.instance, this.schema, this.path);

  } else {

    if (!detail) throw new Error('Missing error detail');

    if (!detail.message) throw new Error('Missing error message');

    if (!detail.name) throw new Error('Missing validator type');

    err = new ValidationError(detail.message, this.instance, this.schema, this.path, detail.name, detail.argument);

  }

  this.errors.push(err);

  if (this.throwFirst) {

    throw new ValidatorResultError(this);

  }else if(this.throwError){

    throw err;

  }

  return err;

};

ValidatorResult.prototype.importErrors = function importErrors(res) {

  if (typeof res == 'string' || (res && res.validatorType)) {

    this.addError(res);

  } else if (res && res.errors) {

    Array.prototype.push.apply(this.errors, res.errors);

  }

};

function stringizer (v,i){

  return i+': '+v.toString()+'\n';

}

ValidatorResult.prototype.toString = function toString(res) {

  return this.errors.map(stringizer).join('');

};

Object.defineProperty(ValidatorResult.prototype, "valid", { get: function() {

  return !this.errors.length;

} });

#EXPORT ValidatorResult

function ValidatorResultError(result) {

  if(Error.captureStackTrace){

    Error.captureStackTrace(this, ValidatorResultError);

  }

  this.instance = result.instance;

  this.schema = result.schema;

  this.options = result.options;

  this.errors = result.errors;

}

ValidatorResultError.prototype = new Error();

ValidatorResultError.prototype.constructor = ValidatorResultError;

ValidatorResultError.prototype.name = "Validation Error";

#EXPORT ValidatorResultError

/**

 * Describes a problem with a Schema which prevents validation of an instance

 * @name SchemaError

 * @constructor

 */

function SchemaError (msg, schema) {

  this.message = msg;

  this.schema = schema;

  Error.call(this, msg);

  if(Error.captureStackTrace){

    Error.captureStackTrace(this, SchemaError);

  }

};

SchemaError.prototype = Object.create(Error.prototype,

  {

    constructor: {value: SchemaError, enumerable: false},

    name: {value: 'SchemaError', enumerable: false},

  });

#EXPORT SchemaError

function SchemaContext (schema, options, path, base, schemas) {

  this.schema = schema;

  this.options = options;

  if(Array.isArray(path)){

    this.path = path;

    this.propertyPath = path.reduce(function(sum, item){

      return sum + makeSuffix(item);

    }, 'instance');

  }else{

    this.propertyPath = path;

  }

  this.base = base;

  this.schemas = schemas;

};

SchemaContext.prototype.resolve = function resolve (target) {

  return uri.resolve(this.base, target);

};

SchemaContext.prototype.makeChild = function makeChild(schema, propertyName){

  var path = (propertyName===undefined) ? this.path : this.path.concat([propertyName]);

  var id = schema.$id || schema.id;

  var base = uri.resolve(this.base, id||'');

  var ctx = new SchemaContext(schema, this.options, path, base, Object.create(this.schemas));

  if(id && !ctx.schemas[base]){

    ctx.schemas[base] = schema;

  }

  return ctx;

};

#EXPORT SchemaContext

const FORMAT_REGEXPS = {

  // 7.3.1. Dates, Times, and Duration

  'date-time': /^\d{4}-(?:0[0-9]{1}|1[0-2]{1})-(3[01]|0[1-9]|[12][0-9])[tT ](2[0-4]|[01][0-9]):([0-5][0-9]):(60|[0-5][0-9])(\.\d+)?([zZ]|[+-]([0-5][0-9]):(60|[0-5][0-9]))$/,

  'date': /^\d{4}-(?:0[0-9]{1}|1[0-2]{1})-(3[01]|0[1-9]|[12][0-9])$/,

  'time': /^(2[0-4]|[01][0-9]):([0-5][0-9]):(60|[0-5][0-9])$/,

  'duration': /P(T\d+(H(\d+M(\d+S)?)?|M(\d+S)?|S)|\d+(D|M(\d+D)?|Y(\d+M(\d+D)?)?)(T\d+(H(\d+M(\d+S)?)?|M(\d+S)?|S))?|\d+W)/i,

  // 7.3.2. Email Addresses

  // TODO: fix the email production

  'email': /^(?:[\w\!\#\$\%\&\'\*\+\-\/\=\?\^\`\{\|\}\~]+\.)*[\w\!\#\$\%\&\'\*\+\-\/\=\?\^\`\{\|\}\~]+@(?:(?:(?:[a-zA-Z0-9](?:[a-zA-Z0-9\-](?!\.)){0,61}[a-zA-Z0-9]?\.)+[a-zA-Z0-9](?:[a-zA-Z0-9\-](?!$)){0,61}[a-zA-Z0-9]?)|(?:\[(?:(?:[01]?\d{1,2}|2[0-4]\d|25[0-5])\.){3}(?:[01]?\d{1,2}|2[0-4]\d|25[0-5])\]))$/,

  'idn-email': /^("(?:[!#-\[\]-\u{10FFFF}]|\\[\t -\u{10FFFF}])*"|[!#-'*+\-/-9=?A-Z\^-\u{10FFFF}](?:\.?[!#-'*+\-/-9=?A-Z\^-\u{10FFFF}])*)@([!#-'*+\-/-9=?A-Z\^-\u{10FFFF}](?:\.?[!#-'*+\-/-9=?A-Z\^-\u{10FFFF}])*|\[[!-Z\^-\u{10FFFF}]*\])$/u,

  // 7.3.3. Hostnames

  // 7.3.4. IP Addresses

  'ip-address': /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/,

  // FIXME whitespace is invalid

  'ipv6': /^\s*((([0-9A-Fa-f]{1,4}:){7}([0-9A-Fa-f]{1,4}|:))|(([0-9A-Fa-f]{1,4}:){6}(:[0-9A-Fa-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-Fa-f]{1,4}:){5}(((:[0-9A-Fa-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-Fa-f]{1,4}:){4}(((:[0-9A-Fa-f]{1,4}){1,3})|((:[0-9A-Fa-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-Fa-f]{1,4}:){3}(((:[0-9A-Fa-f]{1,4}){1,4})|((:[0-9A-Fa-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-Fa-f]{1,4}:){2}(((:[0-9A-Fa-f]{1,4}){1,5})|((:[0-9A-Fa-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-Fa-f]{1,4}:){1}(((:[0-9A-Fa-f]{1,4}){1,6})|((:[0-9A-Fa-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-Fa-f]{1,4}){1,7})|((:[0-9A-Fa-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*$/,

  // 7.3.5. Resource Identifiers

  // TODO: A more accurate regular expression for "uri" goes:

  // [A-Za-z][+\-.0-9A-Za-z]*:((/(/((%[0-9A-Fa-f]{2}|[!$&-.0-9;=A-Z_a-z~])+|(\[(([Vv][0-9A-Fa-f]+\.[!$&-.0-;=A-Z_a-z~]+)?|[.0-:A-Fa-f]+)\])?)(:\d*)?)?)?#(%[0-9A-Fa-f]{2}|[!$&-;=?-Z_a-z~])*|(/(/((%[0-9A-Fa-f]{2}|[!$&-.0-9;=A-Z_a-z~])+|(\[(([Vv][0-9A-Fa-f]+\.[!$&-.0-;=A-Z_a-z~]+)?|[.0-:A-Fa-f]+)\])?)(:\d*)?[/?]|[!$&-.0-;=?-Z_a-z~])|/?%[0-9A-Fa-f]{2}|[!$&-.0-;=?-Z_a-z~])(%[0-9A-Fa-f]{2}|[!$&-;=?-Z_a-z~])*(#(%[0-9A-Fa-f]{2}|[!$&-;=?-Z_a-z~])*)?|/(/((%[0-9A-Fa-f]{2}|[!$&-.0-9;=A-Z_a-z~])+(:\d*)?|(\[(([Vv][0-9A-Fa-f]+\.[!$&-.0-;=A-Z_a-z~]+)?|[.0-:A-Fa-f]+)\])?:\d*|\[(([Vv][0-9A-Fa-f]+\.[!$&-.0-;=A-Z_a-z~]+)?|[.0-:A-Fa-f]+)\])?)?)?

  'uri': /^[a-zA-Z][a-zA-Z0-9+.-]*:[^\s]*$/,

  'uri-reference': /^(((([A-Za-z][+\-.0-9A-Za-z]*(:%[0-9A-Fa-f]{2}|:[!$&-.0-;=?-Z_a-z~]|[/?])|\?)(%[0-9A-Fa-f]{2}|[!$&-;=?-Z_a-z~])*|([A-Za-z][+\-.0-9A-Za-z]*:?)?)|([A-Za-z][+\-.0-9A-Za-z]*:)?\/((%[0-9A-Fa-f]{2}|\/((%[0-9A-Fa-f]{2}|[!$&-.0-9;=A-Z_a-z~])+|(\[(([Vv][0-9A-Fa-f]+\.[!$&-.0-;=A-Z_a-z~]+)?|[.0-:A-Fa-f]+)\])?)(:\d*)?[/?]|[!$&-.0-;=?-Z_a-z~])(%[0-9A-Fa-f]{2}|[!$&-;=?-Z_a-z~])*|(\/((%[0-9A-Fa-f]{2}|[!$&-.0-9;=A-Z_a-z~])+|(\[(([Vv][0-9A-Fa-f]+\.[!$&-.0-;=A-Z_a-z~]+)?|[.0-:A-Fa-f]+)\])?)(:\d*)?)?))#(%[0-9A-Fa-f]{2}|[!$&-;=?-Z_a-z~])*|(([A-Za-z][+\-.0-9A-Za-z]*)?%[0-9A-Fa-f]{2}|[!$&-.0-9;=@_~]|[A-Za-z][+\-.0-9A-Za-z]*[!$&-*,;=@_~])(%[0-9A-Fa-f]{2}|[!$&-.0-9;=@-Z_a-z~])*((([/?](%[0-9A-Fa-f]{2}|[!$&-;=?-Z_a-z~])*)?#|[/?])(%[0-9A-Fa-f]{2}|[!$&-;=?-Z_a-z~])*)?|([A-Za-z][+\-.0-9A-Za-z]*(:%[0-9A-Fa-f]{2}|:[!$&-.0-;=?-Z_a-z~]|[/?])|\?)(%[0-9A-Fa-f]{2}|[!$&-;=?-Z_a-z~])*|([A-Za-z][+\-.0-9A-Za-z]*:)?\/((%[0-9A-Fa-f]{2}|\/((%[0-9A-Fa-f]{2}|[!$&-.0-9;=A-Z_a-z~])+|(\[(([Vv][0-9A-Fa-f]+\.[!$&-.0-;=A-Z_a-z~]+)?|[.0-:A-Fa-f]+)\])?)(:\d*)?[/?]|[!$&-.0-;=?-Z_a-z~])(%[0-9A-Fa-f]{2}|[!$&-;=?-Z_a-z~])*|\/((%[0-9A-Fa-f]{2}|[!$&-.0-9;=A-Z_a-z~])+(:\d*)?|(\[(([Vv][0-9A-Fa-f]+\.[!$&-.0-;=A-Z_a-z~]+)?|[.0-:A-Fa-f]+)\])?:\d*|\[(([Vv][0-9A-Fa-f]+\.[!$&-.0-;=A-Z_a-z~]+)?|[.0-:A-Fa-f]+)\])?)?|[A-Za-z][+\-.0-9A-Za-z]*:?)?$/,

  'iri': /^[a-zA-Z][a-zA-Z0-9+.-]*:[^\s]*$/,

  'iri-reference': /^(((([A-Za-z][+\-.0-9A-Za-z]*(:%[0-9A-Fa-f]{2}|:[!$&-.0-;=?-Z_a-z~-\u{10FFFF}]|[/?])|\?)(%[0-9A-Fa-f]{2}|[!$&-;=?-Z_a-z~-\u{10FFFF}])*|([A-Za-z][+\-.0-9A-Za-z]*:?)?)|([A-Za-z][+\-.0-9A-Za-z]*:)?\/((%[0-9A-Fa-f]{2}|\/((%[0-9A-Fa-f]{2}|[!$&-.0-9;=A-Z_a-z~-\u{10FFFF}])+|(\[(([Vv][0-9A-Fa-f]+\.[!$&-.0-;=A-Z_a-z~-\u{10FFFF}]+)?|[.0-:A-Fa-f]+)\])?)(:\d*)?[/?]|[!$&-.0-;=?-Z_a-z~-\u{10FFFF}])(%[0-9A-Fa-f]{2}|[!$&-;=?-Z_a-z~-\u{10FFFF}])*|(\/((%[0-9A-Fa-f]{2}|[!$&-.0-9;=A-Z_a-z~-\u{10FFFF}])+|(\[(([Vv][0-9A-Fa-f]+\.[!$&-.0-;=A-Z_a-z~-\u{10FFFF}]+)?|[.0-:A-Fa-f]+)\])?)(:\d*)?)?))#(%[0-9A-Fa-f]{2}|[!$&-;=?-Z_a-z~-\u{10FFFF}])*|(([A-Za-z][+\-.0-9A-Za-z]*)?%[0-9A-Fa-f]{2}|[!$&-.0-9;=@_~-\u{10FFFF}]|[A-Za-z][+\-.0-9A-Za-z]*[!$&-*,;=@_~-\u{10FFFF}])(%[0-9A-Fa-f]{2}|[!$&-.0-9;=@-Z_a-z~-\u{10FFFF}])*((([/?](%[0-9A-Fa-f]{2}|[!$&-;=?-Z_a-z~-\u{10FFFF}])*)?#|[/?])(%[0-9A-Fa-f]{2}|[!$&-;=?-Z_a-z~-\u{10FFFF}])*)?|([A-Za-z][+\-.0-9A-Za-z]*(:%[0-9A-Fa-f]{2}|:[!$&-.0-;=?-Z_a-z~-\u{10FFFF}]|[/?])|\?)(%[0-9A-Fa-f]{2}|[!$&-;=?-Z_a-z~-\u{10FFFF}])*|([A-Za-z][+\-.0-9A-Za-z]*:)?\/((%[0-9A-Fa-f]{2}|\/((%[0-9A-Fa-f]{2}|[!$&-.0-9;=A-Z_a-z~-\u{10FFFF}])+|(\[(([Vv][0-9A-Fa-f]+\.[!$&-.0-;=A-Z_a-z~-\u{10FFFF}]+)?|[.0-:A-Fa-f]+)\])?)(:\d*)?[/?]|[!$&-.0-;=?-Z_a-z~-\u{10FFFF}])(%[0-9A-Fa-f]{2}|[!$&-;=?-Z_a-z~-\u{10FFFF}])*|\/((%[0-9A-Fa-f]{2}|[!$&-.0-9;=A-Z_a-z~-\u{10FFFF}])+(:\d*)?|(\[(([Vv][0-9A-Fa-f]+\.[!$&-.0-;=A-Z_a-z~-\u{10FFFF}]+)?|[.0-:A-Fa-f]+)\])?:\d*|\[(([Vv][0-9A-Fa-f]+\.[!$&-.0-;=A-Z_a-z~-\u{10FFFF}]+)?|[.0-:A-Fa-f]+)\])?)?|[A-Za-z][+\-.0-9A-Za-z]*:?)?$/u,

  'uuid': /^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i,

  // 7.3.6. uri-template

  'uri-template': /(%[0-9a-f]{2}|[!#$&(-;=?@\[\]_a-z~]|\{[!#&+,./;=?@|]?(%[0-9a-f]{2}|[0-9_a-z])(\.?(%[0-9a-f]{2}|[0-9_a-z]))*(:[1-9]\d{0,3}|\*)?(,(%[0-9a-f]{2}|[0-9_a-z])(\.?(%[0-9a-f]{2}|[0-9_a-z]))*(:[1-9]\d{0,3}|\*)?)*\})*/iu,

  // 7.3.7. JSON Pointers

  'json-pointer': /^(\/([\x00-\x2e0-@\[-}\x7f]|~[01])*)*$/iu,

  'relative-json-pointer': /^\d+(#|(\/([\x00-\x2e0-@\[-}\x7f]|~[01])*)*)$/iu,

  // hostname regex from: http://stackoverflow.com/a/1420225/5628

  'hostname': /^(?=.{1,255}$)[0-9A-Za-z](?:(?:[0-9A-Za-z]|-){0,61}[0-9A-Za-z])?(?:\.[0-9A-Za-z](?:(?:[0-9A-Za-z]|-){0,61}[0-9A-Za-z])?)*\.?$/,

  'host-name': /^(?=.{1,255}$)[0-9A-Za-z](?:(?:[0-9A-Za-z]|-){0,61}[0-9A-Za-z])?(?:\.[0-9A-Za-z](?:(?:[0-9A-Za-z]|-){0,61}[0-9A-Za-z])?)*\.?$/,

  'utc-millisec': function (input) {

    return (typeof input === 'string') && parseFloat(input) === parseInt(input, 10) && !isNaN(input);

  },

  // 7.3.8. regex

  'regex': function (input) {

    var result = true;

    try {

      new RegExp(input);

    } catch (e) {

      result = false;

    }

    return result;

  },

  // Other definitions

  // "style" was removed from JSON Schema in draft-4 and is deprecated

  'style': /[\r\n\t ]*[^\r\n\t ][^:]*:[\r\n\t ]*[^\r\n\t ;]*[\r\n\t ]*;?/,

  // "color" was removed from JSON Schema in draft-4 and is deprecated

  'color': /^(#?([0-9A-Fa-f]{3}){1,2}\b|aqua|black|blue|fuchsia|gray|green|lime|maroon|navy|olive|orange|purple|red|silver|teal|white|yellow|(rgb\(\s*\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\b\s*,\s*\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\b\s*,\s*\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\b\s*\))|(rgb\(\s*(\d?\d%|100%)+\s*,\s*(\d?\d%|100%)+\s*,\s*(\d?\d%|100%)+\s*\)))$/,

  'phone': /^\+(?:[0-9] ?){6,14}[0-9]$/,

  'alpha': /^[a-zA-Z]+$/,

  'alphanumeric': /^[a-zA-Z0-9]+$/,

};

FORMAT_REGEXPS.regexp = FORMAT_REGEXPS.regex;

FORMAT_REGEXPS.pattern = FORMAT_REGEXPS.regex;

FORMAT_REGEXPS.ipv4 = FORMAT_REGEXPS['ip-address'];

#EXPORT FORMAT_REGEXPS

function isFormat (input, format, validator) {

  if (typeof input === 'string' && FORMAT_REGEXPS[format] !== undefined) {

    if (FORMAT_REGEXPS[format] instanceof RegExp) {

      return FORMAT_REGEXPS[format].test(input);

    }

    if (typeof FORMAT_REGEXPS[format] === 'function') {

      return FORMAT_REGEXPS[format](input);

    }

  } else if (validator && validator.customFormats &&

      typeof validator.customFormats[format] === 'function') {

    return validator.customFormats[format](input);

  }

  return true;

};

#EXPORT isFormat

function makeSuffix (key) {

  key = key.toString();

  // This function could be capable of outputting valid a ECMAScript string, but the

  // resulting code for testing which form to use would be tens of thousands of characters long

  // That means this will use the name form for some illegal forms

  if (!key.match(/[.\s\[\]]/) && !key.match(/^[\d]/)) {

    return '.' + key;

  }

  if (key.match(/^\d+$/)) {

    return '[' + key + ']';

  }

  return '[' + JSON.stringify(key) + ']';

};

#EXPORT makeSuffix

function deepCompareStrict (a, b) {

  if (typeof a !== typeof b) {

    return false;

  }

  if (Array.isArray(a)) {

    if (!Array.isArray(b)) {

      return false;

    }

    if (a.length !== b.length) {

      return false;

    }

    return a.every(function (v, i) {

      return deepCompareStrict(a[i], b[i]);

    });

  }

  if (typeof a === 'object') {

    if (!a || !b) {

      return a === b;

    }

    var aKeys = Object.keys(a);

    var bKeys = Object.keys(b);

    if (aKeys.length !== bKeys.length) {

      return false;

    }

    return aKeys.every(function (v) {

      return deepCompareStrict(a[v], b[v]);

    });

  }

  return a === b;

};

#EXPORT deepCompareStrict

function deepMerger (target, dst, e, i) {

  if (typeof e === 'object') {

    dst[i] = deepMerge(target[i], e);

  } else {

    if (target.indexOf(e) === -1) {

      dst.push(e);

    }

  }

}

function copyist (src, dst, key) {

  dst[key] = src[key];

}

function copyistWithDeepMerge (target, src, dst, key) {

  if (typeof src[key] !== 'object' || !src[key]) {

    dst[key] = src[key];

  }

  else {

    if (!target[key]) {

      dst[key] = src[key];

    } else {

      dst[key] = deepMerge(target[key], src[key]);

    }

  }

}

function deepMerge (target, src) {

  var array = Array.isArray(src);

  var dst = array && [] || {};

  if (array) {

    target = target || [];

    dst = dst.concat(target);

    src.forEach(deepMerger.bind(null, target, dst));

  } else {

    if (target && typeof target === 'object') {

      Object.keys(target).forEach(copyist.bind(null, target, dst));

    }

    Object.keys(src).forEach(copyistWithDeepMerge.bind(null, target, src, dst));

  }

  return dst;

}

#EXPORT deepMerge

/**

 * Validates instance against the provided schema

 * Implements URI+JSON Pointer encoding, e.g. "%7e"="~0"=>"~", "~1"="%2f"=>"/"

 * @param o

 * @param s The path to walk o along

 * @return any

 */

function objectGetPath(o, s) {

  var parts = s.split('/').slice(1);

  var k;

  while (typeof (k=parts.shift()) == 'string') {

    var n = decodeURIComponent(k.replace(/~0/,'~').replace(/~1/g,'/'));

    if (!(n in o)) return;

    o = o[n];

  }

  return o;