node_modules

1 files changed, 151 insertions, 118 deletions

diff --git a/node_modules/ajv/README.md b/node_modules/ajv/README.md
index 9d4fcbb9c..4f69fc1d6 100644
--- a/node_modules/ajv/README.md
+++ b/node_modules/ajv/README.md
@@ -2,7 +2,7 @@
 
 # Ajv: Another JSON Schema Validator
 
-The fastest JSON Schema validator for node.js and browser. Supports [v5 proposals](https://github.com/json-schema/json-schema/wiki/v5-Proposals).
+The fastest JSON Schema validator for node.js and browser with draft 6 support.
 
 
 [![Build Status](https://travis-ci.org/epoberezkin/ajv.svg?branch=master)](https://travis-ci.org/epoberezkin/ajv)
@@ -10,12 +10,21 @@ The fastest JSON Schema validator for node.js and browser. Supports [v5 proposal
 [![npm downloads](https://img.shields.io/npm/dm/ajv.svg)](https://www.npmjs.com/package/ajv)
 [![Code Climate](https://codeclimate.com/github/epoberezkin/ajv/badges/gpa.svg)](https://codeclimate.com/github/epoberezkin/ajv)
 [![Coverage Status](https://coveralls.io/repos/epoberezkin/ajv/badge.svg?branch=master&service=github)](https://coveralls.io/github/epoberezkin/ajv?branch=master)
+[![Greenkeeper badge](https://badges.greenkeeper.io/epoberezkin/ajv.svg)](https://greenkeeper.io/)
 [![Gitter](https://img.shields.io/gitter/room/ajv-validator/ajv.svg)](https://gitter.im/ajv-validator/ajv)
 
 
-__Please note__: You can start using NEW beta version [5.0.4](https://github.com/epoberezkin/ajv/releases/tag/5.0.4-beta.3) (see [migration guide from 4.x.x](https://github.com/epoberezkin/ajv/releases/tag/5.0.1-beta.0)) with the support of JSON-Schema draft-06 (not officially published yet): `npm install ajv@^5.0.4-beta`.
+## Using version 5
 
-Also see [docs](https://github.com/epoberezkin/ajv/tree/5.0.4-beta.3) for 5.0.4.
+[JSON Schema draft-06](https://trac.tools.ietf.org/html/draft-wright-json-schema-validation-01) is published.
+
+[Ajv version 5.0.0](https://github.com/epoberezkin/ajv/releases/tag/5.0.0) that supports draft-06 is released. It may require either migrating your schemas or updating your code (to continue using draft-04 and v5 schemas).
+
+__Please note__: To use Ajv with draft-04 schemas you need to explicitly add meta-schema to the validator instance:
+
+```javascript
+ajv.addMetaSchema(require('ajv/lib/refs/json-schema-draft-04.json'));
+```
 
 
 ## Contents
@@ -32,7 +41,7 @@ Also see [docs](https://github.com/epoberezkin/ajv/tree/5.0.4-beta.3) for 5.0.4.
   - [$data reference](#data-reference)
   - NEW: [$merge and $patch keywords](#merge-and-patch-keywords)
   - [Defining custom keywords](#defining-custom-keywords)
-  - [Asynchronous schema compilation](#asynchronous-compilation)
+  - [Asynchronous schema compilation](#asynchronous-schema-compilation)
   - [Asynchronous validation](#asynchronous-validation)
 - Modifying data during validation
   - [Filtering data](#filtering-data)
@@ -66,15 +75,15 @@ Performace of different validators by [json-schema-benchmark](https://github.com
 
 ## Features
 
-- Ajv implements full [JSON Schema draft 4](http://json-schema.org/) standard:
-  - all validation keywords (see [JSON-Schema validation keywords](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md))
+- Ajv implements full JSON Schema [draft 6](http://json-schema.org/) and draft 4 standards:
+  - all validation keywords (see [JSON Schema validation keywords](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md))
   - full support of remote refs (remote schemas have to be added with `addSchema` or compiled to be available)
   - support of circular references between schemas
   - correct string lengths for strings with unicode pairs (can be turned off)
   - [formats](#formats) defined by JSON Schema draft 4 standard and custom formats (can be turned off)
   - [validates schemas against meta-schema](#api-validateschema)
-- supports [browsers](#using-in-browser) and nodejs 0.10-6.x
-- [asynchronous loading](#asynchronous-compilation) of referenced schemas during compilation
+- supports [browsers](#using-in-browser) and nodejs 0.10-7.x
+- [asynchronous loading](#asynchronous-schema-compilation) of referenced schemas during compilation
 - "All errors" validation mode with [option allErrors](#options)
 - [error messages with parameters](#validation-errors) describing error reasons to allow creating custom error messages
 - i18n error messages support with [ajv-i18n](https://github.com/epoberezkin/ajv-i18n) package
@@ -82,9 +91,10 @@ Performace of different validators by [json-schema-benchmark](https://github.com
 - [assigning defaults](#assigning-defaults) to missing properties and items
 - [coercing data](#coercing-data-types) to the types specified in `type` keywords
 - [custom keywords](#defining-custom-keywords)
-- keywords `switch`, `constant`, `contains`, `patternGroups`, `patternRequired`, `formatMaximum` / `formatMinimum` and `formatExclusiveMaximum` / `formatExclusiveMinimum` from [JSON-schema v5 proposals](https://github.com/json-schema/json-schema/wiki/v5-Proposals) with [option v5](#options)
-- [v5 meta-schema](https://raw.githubusercontent.com/epoberezkin/ajv/master/lib/refs/json-schema-v5.json#) for schemas using v5 keywords
-- [v5 $data reference](#data-reference) to use values from the validated data as values for the schema keywords
+- draft-6 keywords `const`, `contains` and `propertyNames`
+- draft-6 boolean schemas (`true`/`false` as a schema to always pass/fail).
+- keywords `switch`, `patternRequired`, `formatMaximum` / `formatMinimum` and `formatExclusiveMaximum` / `formatExclusiveMinimum` from [JSON-schema extension proposals](https://github.com/json-schema/json-schema/wiki/v5-Proposals) with [ajv-keywords](https://github.com/epoberezkin/ajv-keywords) package
+- [$data reference](#data-reference) to use values from the validated data as values for the schema keywords
 - [asynchronous validation](#asynchronous-validation) of custom formats and keywords
 
 Currently Ajv is the only validator that passes all the tests from [JSON Schema Test Suite](https://github.com/json-schema/JSON-Schema-Test-Suite) (according to [json-schema-benchmark](https://github.com/ebdrup/json-schema-benchmark), apart from the test that requires that `1.0` is not an integer that is impossible to satisfy in JavaScript).
@@ -96,12 +106,6 @@ Currently Ajv is the only validator that passes all the tests from [JSON Schema
 npm install ajv
 ```
 
-To install a stable beta version [5.0.4](https://github.com/epoberezkin/ajv/releases/tag/5.0.4-beta.3) (see [migration guide from 4.x.x](https://github.com/epoberezkin/ajv/releases/tag/5.0.1-beta.0)):
-
-```
-npm install ajv@^5.0.4-beta
-```
-
 
 ## <a name="usage"></a>Getting started
 
@@ -139,7 +143,7 @@ if (!valid) console.log(ajv.errorsText());
 
 See [API](#api) and [Options](#options) for more details.
 
-Ajv compiles schemas to functions and caches them in all cases (using schema stringified with [json-stable-stringify](https://github.com/substack/json-stable-stringify) as a key), so that the next time the same schema is used (not necessarily the same object instance) it won't be compiled again.
+Ajv compiles schemas to functions and caches them in all cases (using schema serialized with [json-stable-stringify](https://github.com/substack/json-stable-stringify) or a custom function as a key), so that the next time the same schema is used (not necessarily the same object instance) it won't be compiled again.
 
 The best performance is achieved when using compiled functions returned by `compile` or `getSchema` methods (there is no additional function call).
 
@@ -174,6 +178,7 @@ CLI is available as a separate npm package [ajv-cli](https://github.com/jessedc/
 
 - compiling JSON-schemas to test their validity
 - BETA: generating standalone module exporting a validation function to be used without Ajv (using [ajv-pack](https://github.com/epoberezkin/ajv-pack))
+- migrate schemas to draft-06 (using [json-schema-migrate](https://github.com/epoberezkin/json-schema-migrate))
 - validating data file(s) against JSON-schema
 - testing expected validity of data against JSON-schema
 - referenced schemas
@@ -190,20 +195,18 @@ Ajv supports all validation keywords from draft 4 of JSON-schema standard:
 - [type](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#type)
 - [for numbers](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#keywords-for-numbers) - maximum, minimum, exclusiveMaximum, exclusiveMinimum, multipleOf
 - [for strings](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#keywords-for-strings) - maxLength, minLength, pattern, format
-- [for arrays](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#keywords-for-arrays) - maxItems, minItems, uniqueItems, items, additionalItems
-- [for objects](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#keywords-for-objects) - maxProperties, minproperties, required, properties, patternProperties, additionalProperties, dependencies
-- [compound keywords](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#keywords-for-all-types) - enum, not, oneOf, anyOf, allOf
+- [for arrays](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#keywords-for-arrays) - maxItems, minItems, uniqueItems, items, additionalItems, [contains](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#contains)
+- [for objects](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#keywords-for-objects) - maxProperties, minproperties, required, properties, patternProperties, additionalProperties, dependencies, [propertyNames](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#propertynames)
+- [for all types](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#keywords-for-all-types) - enum, [const](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#const)
+- [compound keywords](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#compound-keywords) - not, oneOf, anyOf, allOf
 
-With option `v5: true` Ajv also supports all validation keywords and [$data reference](#data-reference) from [v5 proposals](https://github.com/json-schema/json-schema/wiki/v5-Proposals) for JSON-schema standard:
+With [ajv-keywords](https://github.com/epoberezkin/ajv-keywords) package Ajv also supports validation keywords from [JSON Schema extension proposals](https://github.com/json-schema/json-schema/wiki/v5-Proposals) for JSON-schema standard:
 
-- [switch](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#switch-v5-proposal) - conditional validation with a sequence of if/then clauses
-- [contains](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#contains-v5-proposal) - check that array contains a valid item
-- [constant](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#constant-v5-proposal) - check that data is equal to some value
-- [patternGroups](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#patterngroups-v5-proposal) - a more powerful alternative to patternProperties
-- [patternRequired](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#patternrequired-v5-proposal) - like `required` but with patterns that some property should match.
-- [formatMaximum, formatMinimum, formatExclusiveMaximum, formatExclusiveMinimum](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#formatmaximum--formatminimum-and-exclusiveformatmaximum--exclusiveformatminimum-v5-proposal) - setting limits for date, time, etc.
+- [switch](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#switch-proposed) - conditional validation with a sequence of if/then clauses
+- [patternRequired](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#patternrequired-proposed) - like `required` but with patterns that some property should match.
+- [formatMaximum, formatMinimum, formatExclusiveMaximum, formatExclusiveMinimum](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#formatmaximum--formatminimum-and-exclusiveformatmaximum--exclusiveformatminimum-proposed) - setting limits for date, time, etc.
 
-See [JSON-Schema validation keywords](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md) for more details.
+See [JSON Schema validation keywords](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md) for more details.
 
 
 ## Formats
@@ -214,8 +217,10 @@ The following formats are supported for string validation with "format" keyword:
 - _time_: time with optional time-zone.
 - _date-time_: date-time from the same source (time-zone is mandatory). `date`, `time` and `date-time` validate ranges in `full` mode and only regexp in `fast` mode (see [options](#options)).
 - _uri_: full uri with optional protocol.
+- _url_: [URL record](https://url.spec.whatwg.org/#concept-url).
+- _uri-template_: URI template according to [RFC6570](https://tools.ietf.org/html/rfc6570)
 - _email_: email address.
-- _hostname_: host name acording to [RFC1034](http://tools.ietf.org/html/rfc1034#section-3.5).
+- _hostname_: host name according to [RFC1034](http://tools.ietf.org/html/rfc1034#section-3.5).
 - _ipv4_: IP address v4.
 - _ipv6_: IP address v6.
 - _regex_: tests whether a string is a valid regular expression by passing it to RegExp constructor.
@@ -227,16 +232,16 @@ There are two modes of format validation: `fast` and `full`. This mode affects f
 
 You can add additional formats and replace any of the formats above using [addFormat](#api-addformat) method.
 
-The option `unknownFormats` allows to change the behaviour in case an unknown format is encountered - Ajv can either ignore them (default now) or fail schema compilation (will be the default in 5.0.0).
+The option `unknownFormats` allows to change the behaviour in case an unknown format is encountered - Ajv can either fail schema compilation (default) or ignore it (default in versions before 5.0.0). You also can whitelist specific format(s) to be ignored. See [Options](#options) for details.
 
 You can find patterns used for format validation and the sources that were used in [formats.js](https://github.com/epoberezkin/ajv/blob/master/lib/compile/formats.js).
 
 
 ## $data reference
 
-With `v5` option you can use values from the validated data as the values for the schema keywords. See [v5 proposal](https://github.com/json-schema/json-schema/wiki/$data-(v5-proposal)) for more information about how it works.
+With `$data` option you can use values from the validated data as the values for the schema keywords. See [proposal](https://github.com/json-schema/json-schema/wiki/$data-(v5-proposal)) for more information about how it works.
 
-`$data` reference is supported in the keywords: constant, enum, format, maximum/minimum, exclusiveMaximum / exclusiveMinimum, maxLength / minLength, maxItems / minItems, maxProperties / minProperties, formatMaximum / formatMinimum, formatExclusiveMaximum / formatExclusiveMinimum, multipleOf, pattern, required, uniqueItems.
+`$data` reference is supported in the keywords: const, enum, format, maximum/minimum, exclusiveMaximum / exclusiveMinimum, maxLength / minLength, maxItems / minItems, maxProperties / minProperties, formatMaximum / formatMinimum, formatExclusiveMaximum / formatExclusiveMinimum, multipleOf, pattern, required, uniqueItems.
 
 The value of "$data" should be a [JSON-pointer](https://tools.ietf.org/html/rfc6901) to the data (the root is always the top level data object, even if the $data reference is inside a referenced subschema) or a [relative JSON-pointer](http://tools.ietf.org/html/draft-luff-relative-json-pointer-00) (it is relative to the current point in data; if the $data reference is inside a referenced subschema it cannot point to the data outside of the root level for this subschema).
 
@@ -277,12 +282,12 @@ var validData = {
 }
 ```
 
-`$data` reference is resolved safely - it won't throw even if some property is undefined. If `$data` resolves to `undefined` the validation succeeds (with the exclusion of `constant` keyword). If `$data` resolves to incorrect type (e.g. not "number" for maximum keyword) the validation fails.
+`$data` reference is resolved safely - it won't throw even if some property is undefined. If `$data` resolves to `undefined` the validation succeeds (with the exclusion of `const` keyword). If `$data` resolves to incorrect type (e.g. not "number" for maximum keyword) the validation fails.
 
 
 ## $merge and $patch keywords
 
-With v5 option and the package [ajv-merge-patch](https://github.com/epoberezkin/ajv-merge-patch) you can use the keywords `$merge` and `$patch` that allow extending JSON-schemas with patches using formats [JSON Merge Patch (RFC 7396)](https://tools.ietf.org/html/rfc7396) and [JSON Patch (RFC 6902)](https://tools.ietf.org/html/rfc6902).
+With the package [ajv-merge-patch](https://github.com/epoberezkin/ajv-merge-patch) you can use the keywords `$merge` and `$patch` that allow extending JSON-schemas with patches using formats [JSON Merge Patch (RFC 7396)](https://tools.ietf.org/html/rfc7396) and [JSON Patch (RFC 6902)](https://tools.ietf.org/html/rfc6902).
 
 To add keywords `$merge` and `$patch` to Ajv instance use this code:
 
@@ -348,7 +353,7 @@ See the package [ajv-merge-patch](https://github.com/epoberezkin/ajv-merge-patch
 
 The advantages of using custom keywords are:
 
-- allow creating validation scenarios that cannot be expressed using JSON-Schema
+- allow creating validation scenarios that cannot be expressed using JSON Schema
 - simplify your schemas
 - help bringing a bigger part of the validation logic to your schemas
 - make your schemas more expressive, less verbose and closer to your application domain
@@ -391,27 +396,26 @@ Several custom keywords (typeof, instanceof, range and propertyNames) are define
 See [Defining custom keywords](https://github.com/epoberezkin/ajv/blob/master/CUSTOM.md) for more details.
 
 
-## Asynchronous compilation
+## Asynchronous schema compilation
 
-During asynchronous compilation remote references are loaded using supplied function. See `compileAsync` method and `loadSchema` [option](#options).
+During asynchronous compilation remote references are loaded using supplied function. See `compileAsync` [method](#api-compileAsync) and `loadSchema` [option](#options).
 
 Example:
 
 ```javascript
 var ajv = new Ajv({ loadSchema: loadSchema });
 
-ajv.compileAsync(schema, function (err, validate) {
-	if (err) return;
-	var valid = validate(data);
+ajv.compileAsync(schema).then(function (validate) {
+  var valid = validate(data);
+  // ...
 });
 
-function loadSchema(uri, callback) {
-	request.json(uri, function(err, res, body) {
-		if (err || res.statusCode >= 400)
-			callback(err || new Error('Loading error: ' + res.statusCode));
-		else
-			callback(null, body);
-	});
+function loadSchema(uri) {
+  return request.json(uri).then(function (res) {
+    if (res.statusCode >= 400)
+      throw new Error('Loading error: ' + res.statusCode);
+    return res.body;
+  });
 }
 ```
 
@@ -428,29 +432,39 @@ If your schema uses asynchronous formats/keywords or refers to some schema that
 
 __Please note__: all asynchronous subschemas that are referenced from the current or other schemas should have `"$async": true` keyword as well, otherwise the schema compilation will fail.
 
-Validation function for an asynchronous custom format/keyword should return a promise that resolves to `true` or `false` (or rejects with `new Ajv.ValidationError(errors)` if you want to return custom errors from the keyword function). Ajv compiles asynchronous schemas to either [generator function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function*) (default) that can be optionally transpiled with [regenerator](https://github.com/facebook/regenerator) or to [es7 async function](http://tc39.github.io/ecmascript-asyncawait/) that can be transpiled with [nodent](https://github.com/MatAtBread/nodent) or with regenerator as well. You can also supply any other transpiler as a function. See [Options](#options).
+Validation function for an asynchronous custom format/keyword should return a promise that resolves with `true` or `false` (or rejects with `new Ajv.ValidationError(errors)` if you want to return custom errors from the keyword function). Ajv compiles asynchronous schemas to either [es7 async functions](http://tc39.github.io/ecmascript-asyncawait/) that can optionally be transpiled with [nodent](https://github.com/MatAtBread/nodent) or with [regenerator](https://github.com/facebook/regenerator) or to [generator functions](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function*) that can be optionally transpiled with regenerator as well. You can also supply any other transpiler as a function. See [Options](#options).
 
 The compiled validation function has `$async: true` property (if the schema is asynchronous), so you can differentiate these functions if you are using both syncronous and asynchronous schemas.
 
 If you are using generators, the compiled validation function can be either wrapped with [co](https://github.com/tj/co) (default) or returned as generator function, that can be used directly, e.g. in [koa](http://koajs.com/) 1.0. `co` is a small library, it is included in Ajv (both as npm dependency and in the browser bundle).
 
-Generator functions are currently supported in Chrome, Firefox and node.js (0.11+); if you are using Ajv in other browsers or in older versions of node.js you should use one of available transpiling options. All provided async modes use global Promise class. If your platform does not have Promise you should use a polyfill that defines it.
+Async functions are currently supported in Chrome 55, Firefox 52, Node 7 (with --harmony-async-await) and MS Edge 13 (with flag).
 
-Validation result will be a promise that resolves to `true` or rejects with an exception `Ajv.ValidationError` that has the array of validation errors in `errors` property.
+Generator functions are currently supported in Chrome, Firefox and node.js.
+
+If you are using Ajv in other browsers or in older versions of node.js you should use one of available transpiling options. All provided async modes use global Promise class. If your platform does not have Promise you should use a polyfill that defines it.
+
+Validation result will be a promise that resolves with validated data or rejects with an exception `Ajv.ValidationError` that has the array of validation errors in `errors` property.
 
 
 Example:
 
 ```javascript
 /**
- * without "async" and "transpile" options (or with option {async: true})
+ * Default mode is non-transpiled generator function wrapped with `co`.
+ * Using package ajv-async (https://github.com/epoberezkin/ajv-async)
+ * you can auto-detect the best async mode.
+ * In this case, without "async" and "transpile" options
+ * (or with option {async: true})
  * Ajv will choose the first supported/installed option in this order:
- * 1. native generator function wrapped with co
- * 2. es7 async functions transpiled with nodent
- * 3. es7 async functions transpiled with regenerator
+ * 1. native async function
+ * 2. native generator function wrapped with co
+ * 3. es7 async functions transpiled with nodent
+ * 4. es7 async functions transpiled with regenerator
  */
 
-var ajv = new Ajv;
+var setupAsync = require('ajv-async');
+var ajv = setupAsync(new Ajv);
 
 ajv.addKeyword('idExists', {
   async: true,
@@ -485,9 +499,8 @@ var schema = {
 var validate = ajv.compile(schema);
 
 validate({ userId: 1, postId: 19 }))
-.then(function (valid) {
-  // "valid" is always true here
-  console.log('Data is valid');
+.then(function (data) {
+  console.log('Data is valid', data); // { userId: 1, postId: 19 }
 })
 .catch(function (err) {
   if (!(err instanceof Ajv.ValidationError)) throw err;
@@ -507,7 +520,9 @@ Ajv npm package includes minified browser bundles of regenerator and nodent in d
 #### Using nodent
 
 ```javascript
+var setupAsync = require('ajv-async');
 var ajv = new Ajv({ /* async: 'es7', */ transpile: 'nodent' });
+setupAsync(ajv);
 var validate = ajv.compile(schema); // transpiled es7 async function
 validate(data).then(successFunc).catch(errorFunc);
 ```
@@ -518,7 +533,9 @@ validate(data).then(successFunc).catch(errorFunc);
 #### Using regenerator
 
 ```javascript
+var setupAsync = require('ajv-async');
 var ajv = new Ajv({ /* async: 'es7', */ transpile: 'regenerator' });
+setupAsync(ajv);
 var validate = ajv.compile(schema); // transpiled es7 async function
 validate(data).then(successFunc).catch(errorFunc);
 ```
@@ -529,7 +546,7 @@ validate(data).then(successFunc).catch(errorFunc);
 #### Using other transpilers
 
 ```javascript
-var ajv = new Ajv({ async: 'es7', transpile: transpileFunc });
+var ajv = new Ajv({ async: 'es7', processCode: transpileFunc });
 var validate = ajv.compile(schema); // transpiled es7 async function
 validate(data).then(successFunc).catch(errorFunc);
 ```
@@ -541,12 +558,13 @@ See [Options](#options).
 
 |mode|transpile<br>speed*|run-time<br>speed*|bundle<br>size|
 |---|:-:|:-:|:-:|
+|es7 async<br>(native)|-|0.75|-|
 |generators<br>(native)|-|1.0|-|
-|es7.nodent|1.35|1.1|183Kb|
-|es7.regenerator|1.0|2.7|322Kb|
-|regenerator|1.0|3.2|322Kb|
+|es7.nodent|1.35|1.1|215Kb|
+|es7.regenerator|1.0|2.7|1109Kb|
+|regenerator|1.0|3.2|1109Kb|
 
-\* Relative performance in node v.4, smaller is better.
+\* Relative performance in node v.7, smaller is better.
 
 [nodent](https://github.com/MatAtBread/nodent) has several advantages:
 
@@ -555,8 +573,6 @@ See [Options](#options).
 - much better performace than native generators in other browsers
 - works in IE 9 (regenerator does not)
 
-[regenerator](https://github.com/facebook/regenerator) is a more widely adopted alternative.
-
 
 ## Filtering data
 
@@ -731,7 +747,7 @@ console.log(data2); // { foo: { bar: 2 } }
 
 - not in `properties` or `items` subschemas
 - in schemas inside `anyOf`, `oneOf` and `not` (see [#42](https://github.com/epoberezkin/ajv/issues/42))
-- in `if` subschema of v5 `switch` keyword
+- in `if` subschema of `switch` keyword
 - in schemas generated by custom macro keywords
 
 
@@ -795,8 +811,6 @@ See [Coercion rules](https://github.com/epoberezkin/ajv/blob/master/COERCION.md)
 
 Create Ajv instance.
 
-All the instance methods below are bound to the instance, so they can be used without the instance.
-
 
 ##### .compile(Object schema) -&gt; Function&lt;Object data&gt;
 
@@ -807,17 +821,19 @@ Validating function returns boolean and has properties `errors` with the errors
 Unless the option `validateSchema` is false, the schema will be validated against meta-schema and if schema is invalid the error will be thrown. See [options](#options).
 
 
-##### .compileAsync(Object schema, Function callback)
+##### <a name="api-compileAsync"></a>.compileAsync(Object schema [, Boolean meta] [, Function callback]) -&gt; Promise
 
-Asyncronous version of `compile` method that loads missing remote schemas using asynchronous function in `options.loadSchema`. Callback will always be called with 2 parameters: error (or null) and validating function. Error will be not null in the following cases:
+Asyncronous version of `compile` method that loads missing remote schemas using asynchronous function in `options.loadSchema`. This function returns a Promise that resolves to a validation function. An optional callback passed to `compileAsync` will be called with 2 parameters: error (or null) and validating function. The returned promise will reject (and callback if passed will be called with an error) when:
 
-- missing schema can't be loaded (`loadSchema` calls callback with error).
+- missing schema can't be loaded (`loadSchema` returns the Promise that rejects).
 - the schema containing missing reference is loaded, but the reference cannot be resolved.
 - schema (or some referenced schema) is invalid.
 
-The function compiles schema and loads the first missing schema multiple times, until all missing schemas are loaded.
+The function compiles schema and loads the first missing schema (or meta-schema), until all missing schemas are loaded.
+
+You can asynchronously compile meta-schema by passing `true` as the second parameter.
 
-See example in [Asynchronous compilation](#asynchronous-compilation).
+See example in [Asynchronous compilation](#asynchronous-schema-compilation).
 
 
 ##### .validate(Object schema|String key|String ref, data) -&gt; Boolean
@@ -853,18 +869,16 @@ By default the schema is validated against meta-schema before it is added, and i
 
 Adds meta schema(s) that can be used to validate other schemas. That function should be used instead of `addSchema` because there may be instance options that would compile a meta schema incorrectly (at the moment it is `removeAdditional` option).
 
-There is no need to explicitly add draft 4 meta schema (http://json-schema.org/draft-04/schema and http://json-schema.org/schema) - it is added by default, unless option `meta` is set to `false`. You only need to use it if you have a changed meta-schema that you want to use to validate your schemas. See `validateSchema`.
-
-With option `v5: true` [meta-schema that includes v5 keywords](https://raw.githubusercontent.com/epoberezkin/ajv/master/lib/refs/json-schema-v5.json) also added.
+There is no need to explicitly add draft 6 meta schema (http://json-schema.org/draft-06/schema and http://json-schema.org/schema) - it is added by default, unless option `meta` is set to `false`. You only need to use it if you have a changed meta-schema that you want to use to validate your schemas. See `validateSchema`.
 
 
 ##### <a name="api-validateschema"></a>.validateSchema(Object schema) -&gt; Boolean
 
-Validates schema. This method should be used to validate schemas rather than `validate` due to the inconsistency of `uri` format in JSON-Schema standard.
+Validates schema. This method should be used to validate schemas rather than `validate` due to the inconsistency of `uri` format in JSON Schema standard.
 
 By default this method is called automatically when the schema is added, so you rarely need to use it directly.
 
-If schema doesn't have `$schema` property it is validated against draft 4 meta-schema (option `meta` should not be false) or against [v5 meta-schema](https://raw.githubusercontent.com/epoberezkin/ajv/master/lib/refs/json-schema-v5.json#) if option `v5` is true.
+If schema doesn't have `$schema` property it is validated against draft 6 meta-schema (option `meta` should not be false).
 
 If schema has `$schema` property then the schema with this id (that should be previously added) is used to validate passed schema.
 
@@ -891,7 +905,7 @@ If no parameter is passed all schemas but meta-schemas will be removed and the c
 
 ##### <a name="api-addformat"></a>.addFormat(String name, String|RegExp|Function|Object format)
 
-Add custom format to validate strings. It can also be used to replace pre-defined formats for Ajv instance.
+Add custom format to validate strings or numbers. It can also be used to replace pre-defined formats for Ajv instance.
 
 Strings are converted to RegExp.
 
@@ -900,8 +914,9 @@ Function should return validation result as `true` or `false`.
 If object is passed it should have properties `validate`, `compare` and `async`:
 
 - _validate_: a string, RegExp or a function as described above.
-- _compare_: an optional comparison function that accepts two strings and compares them according to the format meaning. This function is used with keywords `formatMaximum`/`formatMinimum` (from [v5 proposals](https://github.com/json-schema/json-schema/wiki/v5-Proposals) - `v5` option should be used). It should return `1` if the first value is bigger than the second value, `-1` if it is smaller and `0` if it is equal.
+- _compare_: an optional comparison function that accepts two strings and compares them according to the format meaning. This function is used with keywords `formatMaximum`/`formatMinimum` (defined in [ajv-keywords](https://github.com/epoberezkin/ajv-keywords) package). It should return `1` if the first value is bigger than the second value, `-1` if it is smaller and `0` if it is equal.
 - _async_: an optional `true` value if `validate` is an asynchronous function; in this case it should return a promise that resolves with a value `true` or `false`.
+- _type_: an optional type of data that the format applies to. It can be `"string"` (default) or `"number"` (see https://github.com/epoberezkin/ajv/issues/291#issuecomment-259923858). If the type of data is different, the validation will pass.
 
 Custom formats can be also added via `formats` option.
 
@@ -970,7 +985,7 @@ Defaults:
 ```javascript
 {
   // validation and reporting options:
-  v5:               false,
+  $data:            false,
   allErrors:        false,
   verbose:          false,
   jsonPointers:     false,
@@ -978,19 +993,20 @@ Defaults:
   unicode:          true,
   format:           'fast',
   formats:          {},
-  unknownFormats:   'ignore',
+  unknownFormats:   true,
   schemas:          {},
   // referenced schema options:
+  schemaId:         undefined // recommended '$id'
   missingRefs:      true,
-  extendRefs:       true,
-  loadSchema:       undefined, // function(uri, cb) { /* ... */ cb(err, schema); },
+  extendRefs:       'ignore', // recommended 'fail'
+  loadSchema:       undefined, // function(uri: string): Promise {}
   // options to modify validated data:
   removeAdditional: false,
   useDefaults:      false,
   coerceTypes:      false,
   // asynchronous validation options:
-  async:            undefined,
-  transpile:        undefined,
+  async:            'co*',
+  transpile:        undefined, // requires ajv-async package
   // advanced options:
   meta:             true,
   validateSchema:   true,
@@ -1001,16 +1017,17 @@ Defaults:
   ownProperties:    false,
   multipleOfPrecision: false,
   errorDataPath:    'object',
-  sourceCode:       true,
   messages:         true,
-  beautify:         false,
-  cache:            new Cache
+  sourceCode:       false,
+  processCode:      undefined, // function (str: string): string {}
+  cache:            new Cache,
+  serialize:        undefined
 }
 ```
 
 ##### Validation and reporting options
 
-- _v5_: add keywords `switch`, `constant`, `contains`, `patternGroups`, `patternRequired`, `formatMaximum` / `formatMinimum` and `formatExclusiveMaximum` / `formatExclusiveMinimum` from [JSON-schema v5 proposals](https://github.com/json-schema/json-schema/wiki/v5-Proposals). With this option added schemas without `$schema` property are validated against [v5 meta-schema](https://raw.githubusercontent.com/epoberezkin/ajv/master/lib/refs/json-schema-v5.json#). `false` by default.
+- _$data_: support [$data references](#data-reference). Draft 6 meta-schema that is added by default will be extended to allow them. If you want to use another meta-schema you need to use $dataMetaSchema method to add support for $data reference. See [API](#api).
 - _allErrors_: check all rules collecting all errors. Default is to return after the first error.
 - _verbose_: include the reference to the part of the schema (`schema` and `parentSchema`) and validated data in errors (false by default).
 - _jsonPointers_: set `dataPath` propery of errors using [JSON Pointers](https://tools.ietf.org/html/rfc6901) instead of JavaScript property access notation.
@@ -1019,23 +1036,27 @@ Defaults:
 - _format_: formats validation mode ('fast' by default). Pass 'full' for more correct and slow validation or `false` not to validate formats at all. E.g., 25:00:00 and 2015/14/33 will be invalid time and date in 'full' mode but it will be valid in 'fast' mode.
 - _formats_: an object with custom formats. Keys and values will be passed to `addFormat` method.
 - _unknownFormats_: handling of unknown formats. Option values:
-  - `true` (will be default in 5.0.0) - if the unknown format is encountered the exception is thrown during schema compilation. If `format` keyword value is [v5 $data reference](#data-reference) and it is unknown the validation will fail.
-  - `[String]` - an array of unknown format names that will be ignored. This option can be used to allow usage of third party schemas with format(s) for which you don't have definitions, but still fail if some other unknown format is used. If `format` keyword value is [v5 $data reference](#data-reference) and it is not in this array the validation will fail.
-  - `"ignore"` (default now) - to log warning during schema compilation and always pass validation. This option is not recommended, as it allows to mistype format name. This behaviour is required by JSON-schema specification.
+  - `true` (default) - if an unknown format is encountered the exception is thrown during schema compilation. If `format` keyword value is [$data reference](#data-reference) and it is unknown the validation will fail.
+  - `[String]` - an array of unknown format names that will be ignored. This option can be used to allow usage of third party schemas with format(s) for which you don't have definitions, but still fail if another unknown format is used. If `format` keyword value is [$data reference](#data-reference) and it is not in this array the validation will fail.
+  - `"ignore"` - to log warning during schema compilation and always pass validation (the default behaviour in versions before 5.0.0). This option is not recommended, as it allows to mistype format name and it won't be validated without any error message. This behaviour is required by JSON-schema specification.
 - _schemas_: an array or object of schemas that will be added to the instance. If the order is important, pass array. In this case schemas must have IDs in them. Otherwise the object can be passed - `addSchema(value, key)` will be called for each schema in this object.
 
 
 ##### Referenced schema options
 
+- _schemaId_: this option defines which keywords are used as schema URI. Option value:
+  - `"$id"` (recommended) - only use `$id` keyword as schema URI (as specified in JSON Schema draft-06), ignore `id` keyword (if it is present a warning will be logged).
+  - `"id"` - only use `id` keyword as schema URI (as specified in JSON Schema draft-04), ignore `$id` keyword (if it is present a warning will be logged).
+  - `undefined` (default) - use both `$id` and `id` keywords as schema URI. If both are present (in the same schema object) and different the exception will be thrown during schema compilation.
 - _missingRefs_: handling of missing referenced schemas. Option values:
   - `true` (default) - if the reference cannot be resolved during compilation the exception is thrown. The thrown error has properties `missingRef` (with hash fragment) and `missingSchema` (without it). Both properties are resolved relative to the current base id (usually schema id, unless it was substituted).
   - `"ignore"` - to log error during compilation and always pass validation.
   - `"fail"` - to log error and successfully compile schema but fail validation if this rule is checked.
 - _extendRefs_: validation of other keywords when `$ref` is present in the schema. Option values:
-  - `true` (default) - validate all keywords in the schemas with `$ref`.
-  - `"ignore"` - when `$ref` is used other keywords are ignored (as per [JSON Reference](https://tools.ietf.org/html/draft-pbryan-zyp-json-ref-03#section-3) standard). A warning will be logged during the schema compilation.
-  - `"fail"` - if other validation keywords are used together with `$ref` the exception will be throw when the schema is compiled.
-- _loadSchema_: asynchronous function that will be used to load remote schemas when the method `compileAsync` is used and some reference is missing (option `missingRefs` should NOT be 'fail' or 'ignore'). This function should accept 2 parameters: remote schema uri and node-style callback. See example in [Asynchronous compilation](#asynchronous-compilation).
+  - `"ignore"` (default) - when `$ref` is used other keywords are ignored (as per [JSON Reference](https://tools.ietf.org/html/draft-pbryan-zyp-json-ref-03#section-3) standard). A warning will be logged during the schema compilation.
+  - `"fail"` (recommended) - if other validation keywords are used together with `$ref` the exception will be thrown when the schema is compiled. This option is recomended to make sure schema has no keywords that are ignored, which can be confusing.
+  - `true` - validate all keywords in the schemas with `$ref` (the default behaviour in versions before 5.0.0).
+- _loadSchema_: asynchronous function that will be used to load remote schemas when `compileAsync` [method](#api-compileAsync) is used and some reference is missing (option `missingRefs` should NOT be 'fail' or 'ignore'). This function should accept remote schema uri as a parameter and return a Promise that resolves to a schema. See example in [Asynchronous compilation](#asynchronous-schema-compilation).
 
 
 ##### Options to modify validated data
@@ -1058,42 +1079,54 @@ Defaults:
 ##### Asynchronous validation options
 
 - _async_: determines how Ajv compiles asynchronous schemas (see [Asynchronous validation](#asynchronous-validation)) to functions. Option values:
-  - `"*"` / `"co*"` - compile to generator function ("co*" - wrapped with `co.wrap`). If generators are not supported and you don't provide `transpile` option, the exception will be thrown when Ajv instance is created.
-  - `"es7"` - compile to es7 async function. Unless your platform supports them you need to provide `transpile` option. Currently only MS Edge 13 with flag supports es7 async functions according to [compatibility table](http://kangax.github.io/compat-table/es7/)).
-  - `true` - if transpile option is not passed Ajv will choose the first supported/installed async/transpile modes in this order: "co*" (native generator with co.wrap), "es7"/"nodent", "co*"/"regenerator" during the creation of the Ajv instance. If none of the options is available the exception will be thrown.
-  - `undefined`- Ajv will choose the first available async mode in the same way as with `true` option but when the first asynchronous schema is compiled.
-- _transpile_: determines whether Ajv transpiles compiled asynchronous validation function. Option values:
+  - `"*"` / `"co*"` (default) - compile to generator function ("co*" - wrapped with `co.wrap`). If generators are not supported and you don't provide `processCode` option (or `transpile` option if you use [ajv-async](https://github.com/epoberezkin/ajv-async) package), the exception will be thrown when async schema is compiled.
+  - `"es7"` - compile to es7 async function. Unless your platform supports them you need to provide `processCode`/`transpile` option. According to [compatibility table](http://kangax.github.io/compat-table/es7/)) async functions are supported by:
+    - Firefox 52,
+    - Chrome 55,
+    - Node.js 7 (with `--harmony-async-await`),
+    - MS Edge 13 (with flag).
+  - `undefined`/`true` - auto-detect async mode. It requires [ajv-async](https://github.com/epoberezkin/ajv-async) package. If transpile option is not passed ajv-async will choose the first of supported/installed async/transpile modes in this order:
+    - "es7" (native async functions),
+    - "co*" (native generators with co.wrap),
+    - "es7"/"nodent",
+    - "co*"/"regenerator" during the creation of the Ajv instance.
+
+  If none of the options is available the exception will be thrown.
+- _transpile_: Requires [ajv-async](https://github.com/epoberezkin/ajv-async) package. It determines whether Ajv transpiles compiled asynchronous validation function. Option values:
   - `"nodent"` - transpile with [nodent](https://github.com/MatAtBread/nodent). If nodent is not installed, the exception will be thrown. nodent can only transpile es7 async functions; it will enforce this mode.
   - `"regenerator"` - transpile with [regenerator](https://github.com/facebook/regenerator). If regenerator is not installed, the exception will be thrown.
-  - a function - this function should accept the code of validation function as a string and return transpiled code. This option allows you to use any other transpiler you prefer.
+  - a function - this function should accept the code of validation function as a string and return transpiled code. This option allows you to use any other transpiler you prefer. If you are passing a function, you can simply pass it to `processCode` option without using ajv-async.
 
 
 ##### Advanced options
 
-- _meta_: add [meta-schema](http://json-schema.org/documentation.html) so it can be used by other schemas (true by default). With option `v5: true` [v5 meta-schema](https://raw.githubusercontent.com/epoberezkin/ajv/master/lib/refs/json-schema-v5.json#) will be added as well. If an object is passed, it will be used as the default meta-schema for schemas that have no `$schema` keyword. This default meta-schema MUST have `$schema` keyword.
+- _meta_: add [meta-schema](http://json-schema.org/documentation.html) so it can be used by other schemas (true by default). If an object is passed, it will be used as the default meta-schema for schemas that have no `$schema` keyword. This default meta-schema MUST have `$schema` keyword.
 - _validateSchema_: validate added/compiled schemas against meta-schema (true by default). `$schema` property in the schema can either be http://json-schema.org/schema or http://json-schema.org/draft-04/schema or absent (draft-4 meta-schema will be used) or can be a reference to the schema previously added with `addMetaSchema` method. Option values:
   - `true` (default) -  if the validation fails, throw the exception.
   - `"log"` - if the validation fails, log error.
   - `false` - skip schema validation.
-- _addUsedSchema_: by default methods `compile` and `validate` add schemas to the instance if they have `id` property that doesn't start with "#". If `id` is present and it is not unique the exception will be thrown. Set this option to `false` to skip adding schemas to the instance and the `id` uniqueness check when these methods are used. This option does not affect `addSchema` method.
+- _addUsedSchema_: by default methods `compile` and `validate` add schemas to the instance if they have `$id` (or `id`) property that doesn't start with "#". If `$id` is present and it is not unique the exception will be thrown. Set this option to `false` to skip adding schemas to the instance and the `$id` uniqueness check when these methods are used. This option does not affect `addSchema` method.
 - _inlineRefs_: Affects compilation of referenced schemas. Option values:
   - `true` (default) - the referenced schemas that don't have refs in them are inlined, regardless of their size - that substantially improves performance at the cost of the bigger size of compiled schema functions.
   - `false` - to not inline referenced schemas (they will be compiled as separate functions).
   - integer number - to limit the maximum number of keywords of the schema that will be inlined.
 - _passContext_: pass validation context to custom keyword functions. If this option is `true` and you pass some context to the compiled validation function with `validate.call(context, data)`, the `context` will be available as `this` in your custom keywords. By default `this` is Ajv instance.
 - _loopRequired_: by default `required` keyword is compiled into a single expression (or a sequence of statements in `allErrors` mode). In case of a very large number of properties in this keyword it may result in a very big validation function. Pass integer to set the number of properties above which `required` keyword will be validated in a loop - smaller validation function size but also worse performance.
-- _ownProperties_: by default ajv iterates over all enumerable object properties; when this option is `true` only own enumerable object properties (i.e. found directly on the object rather than on its prototype) are iterated. Contributed by @mbroadst.
+- _ownProperties_: by default Ajv iterates over all enumerable object properties; when this option is `true` only own enumerable object properties (i.e. found directly on the object rather than on its prototype) are iterated. Contributed by @mbroadst.
 - _multipleOfPrecision_: by default `multipleOf` keyword is validated by comparing the result of division with parseInt() of that result. It works for dividers that are bigger than 1. For small dividers such as 0.01 the result of the division is usually not integer (even when it should be integer, see issue [#84](https://github.com/epoberezkin/ajv/issues/84)). If you need to use fractional dividers set this option to some positive integer N to have `multipleOf` validated using this formula: `Math.abs(Math.round(division) - division) < 1e-N` (it is slower but allows for float arithmetics deviations).
 - _errorDataPath_: set `dataPath` to point to 'object' (default) or to 'property' when validating keywords `required`, `additionalProperties` and `dependencies`.
-- _sourceCode_: add `sourceCode` property to validating function (for debugging; this code can be different from the result of toString call).
 - _messages_: Include human-readable messages in errors. `true` by default. `false` can be passed when custom messages are used (e.g. with [ajv-i18n](https://github.com/epoberezkin/ajv-i18n)).
-- _beautify_: format the generated function with [js-beautify](https://github.com/beautify-web/js-beautify) (the validating function is generated without line-breaks). `npm install js-beautify` to use this option. `true` or js-beautify options can be passed.
+- _sourceCode_: add `sourceCode` property to validating function (for debugging; this code can be different from the result of toString call).
+- _processCode_: an optional function to process generated code before it is passed to Function constructor. It can be used to either beautify (the validating function is generated without line-breaks) or to transpile code. Starting from version 5.0.0 this option replaced options:
+  - `beautify` that formatted the generated function using [js-beautify](https://github.com/beautify-web/js-beautify). If you want to beautify the generated code pass `require('js-beautify').js_beautify`.
+  - `transpile` that transpiled asynchronous validation function. You can still use `transpile` option with [ajv-async](https://github.com/epoberezkin/ajv-async) package. See [Asynchronous validation](#asynchronous-validation) for more information. 
 - _cache_: an optional instance of cache to store compiled schemas using stable-stringified schema as a key. For example, set-associative cache [sacjs](https://github.com/epoberezkin/sacjs) can be used. If not passed then a simple hash is used which is good enough for the common use case (a limited number of statically defined schemas). Cache should have methods `put(key, value)`, `get(key)`, `del(key)` and `clear()`.
+- _serialize_: an optional function to serialize schema to cache key. Pass `false` to use schema itself as a key (e.g., if WeakMap used as a cache). By default [json-stable-stringify](https://github.com/substack/json-stable-stringify) is used.
 
 
 ## Validation errors
 
-In case of validation failure Ajv assigns the array of errors to `.errors` property of validation function (or to `.errors` property of Ajv instance in case `validate` or `validateSchema` methods were called). In case of [asynchronous validation](#asynchronous-validation) the returned promise is rejected with the exception of the class `Ajv.ValidationError` that has `.errors` poperty.
+In case of validation failure Ajv assigns the array of errors to `.errors` property of validation function (or to `.errors` property of Ajv instance in case `validate` or `validateSchema` methods were called). In case of [asynchronous validation](#asynchronous-validation) the returned promise is rejected with the exception of the class `Ajv.ValidationError` that has `.errors` property.
 
 
 ### Error objects
@@ -1109,6 +1142,8 @@ Each error is an object with the following properties:
 - _parentSchema_: the schema containing the keyword (added with `verbose` option)
 - _data_: the data validated by the keyword (added with `verbose` option).
 
+__Please note__: `propertyNames` keyword schema validation errors have an additional property `propertyName`, `dataPath` points to the object. After schema validation for each property name, if it is invalid an additional error is added with the property `keyword` equal to `"propertyNames"`.
+
 
 ### Error parameters
 
@@ -1117,10 +1152,6 @@ Properties of `params` object in errors depend on the keyword that failed valida
 - `maxItems`, `minItems`, `maxLength`, `minLength`, `maxProperties`, `minProperties` - property `limit` (number, the schema of the keyword).
 - `additionalItems` - property `limit` (the maximum number of allowed items in case when `items` keyword is an array of schemas and `additionalItems` is false).
 - `additionalProperties` - property `additionalProperty` (the property not used in `properties` and `patternProperties` keywords).
-- `patternGroups` (with v5 option) - properties:
-  - `pattern`
-  - `reason` ("minimum"/"maximum"),
-  - `limit` (max/min allowed number of properties matching number)
 - `dependencies` - properties:
   - `property` (dependent property),
   - `missingProperty` (required missing dependency - only the first one is reported currently)
@@ -1134,7 +1165,8 @@ Properties of `params` object in errors depend on the keyword that failed valida
 - `multipleOf` - property `multipleOf` (the schema of the keyword)
 - `pattern` - property `pattern` (the schema of the keyword)
 - `required` - property `missingProperty` (required property that is missing).
-- `patternRequired` (with v5 option) - property `missingPattern` (required pattern that did not match any property).
+- `propertyNames` - property `propertyName` (an invalid property name).
+- `patternRequired` (in ajv-keywords) - property `missingPattern` (required pattern that did not match any property).
 - `type` - property `type` (required type(s), a string, can be a comma-separated list)
 - `uniqueItems` - properties `i` and `j` (indices of duplicate items).
 - `enum` - property `allowedValues` pointing to the array of values (the schema of the keyword).
@@ -1146,8 +1178,9 @@ Properties of `params` object in errors depend on the keyword that failed valida
 
 - [ajv-cli](https://github.com/epoberezkin/ajv-cli) - command line interface for Ajv
 - [ajv-i18n](https://github.com/epoberezkin/ajv-i18n) - internationalised error messages
-- [ajv-merge-patch](https://github.com/epoberezkin/ajv-merge-patch) - keywords $merge and $patch from v5 proposals.
+- [ajv-merge-patch](https://github.com/epoberezkin/ajv-merge-patch) - keywords $merge and $patch.
 - [ajv-keywords](https://github.com/epoberezkin/ajv-keywords) - several custom keywords that can be used with Ajv (typeof, instanceof, range, propertyNames)
+- [ajv-errors](https://github.com/epoberezkin/ajv-errors) - custom error messages for Ajv
 
 
 ## Some packages using Ajv
@@ -1167,7 +1200,7 @@ Properties of `params` object in errors depend on the keyword that failed valida
 - [rabbitmq-schema](https://github.com/tjmehta/rabbitmq-schema) - a schema definition module for RabbitMQ graphs and messages
 - [@query/schema](https://www.npmjs.com/package/@query/schema) - stream filtering with a URI-safe query syntax parsing to JSON Schema
 - [chai-ajv-json-schema](https://github.com/peon374/chai-ajv-json-schema) - chai plugin to us JSON-schema with expect in mocha tests
-- [grunt-jsonschema-ajv](https://github.com/SignpostMarv/grunt-jsonschema-ajv) - Grunt plugin for validating files against JSON-Schema
+- [grunt-jsonschema-ajv](https://github.com/SignpostMarv/grunt-jsonschema-ajv) - Grunt plugin for validating files against JSON Schema
 - [extract-text-webpack-plugin](https://github.com/webpack-contrib/extract-text-webpack-plugin) - extract text from bundle into a file
 - [electron-builder](https://github.com/electron-userland/electron-builder) - a solution to package and build a ready for distribution Electron app 
 - [addons-linter](https://github.com/mozilla/addons-linter) - Mozilla Add-ons Linter
@@ -1197,7 +1230,7 @@ Please see [Contributing guidelines](https://github.com/epoberezkin/ajv/blob/mas
 
 See https://github.com/epoberezkin/ajv/releases
 
-__Please note__: [Changes in version 5.0.1-beta](https://github.com/epoberezkin/ajv/releases/tag/5.0.1-beta.0).
+__Please note__: [Changes in version 5.0.0](https://github.com/epoberezkin/ajv/releases/tag/5.0.0).
 
 [Changes in version 4.6.0](https://github.com/epoberezkin/ajv/releases/tag/4.6.0).