anchor.diff:  were specified. In case a percolate request failed, the item response is substituted with an error message.
   
   [float]
  -=== How it works under the hood
  -
  -When indexing a document that contains a query in an index and the `.percolator` type the query part of the documents gets
  +=== How it Works Under the Hood
  +
  +When indexing a document that contains a query in an index and the `.percolator` type, the query part of the documents gets
   parsed into a Lucene query and is kept in memory until that percolator document is removed or the index containing the
  -`.percolator` type get removed. So all the active percolator queries are kept in memory.
  -
  -At percolate time the document specified in the request gets parsed into a Lucene document and is stored in a in-memory
  +`.percolator` type gets removed. So, all the active percolator queries are kept in memory.
  +
  +At percolate time, the document specified in the request gets parsed into a Lucene document and is stored in a in-memory
   Lucene index. This in-memory index can just hold this one document and it is optimized for that. Then all the queries
  -that are registered to the index that the percolate request is targeted for are going to be executed on this single document
  +that are registered to the index that the percolate request is targeted for, are going to be executed on this single document
   in-memory index. This happens on each shard the percolate request needs to execute.
   
   By using `routing`, `filter` or `query` features the amount of queries that need to be executed can be reduced and thus
  -the time the percolate api needs to run can be decreased.
  -
  -[float]
  -=== Important notes
  +the time the percolate API needs to run can be decreased.
  +
  +[float]
  +=== Important Notes
   
   Because the percolator API is processing one document at a time, it doesn't support queries and filters that run
   against child documents such as `has_child`, `has_parent` and `top_children`.
  
positive.code: * `track_scores` - Whether the `_score` is included for each match. The `_score` is based on the query and represents
  how the query matched the *percolate query's metadata*, *not* how the document (that is being percolated) matched
  the query. The `query` option is required for this option. Defaults to `false`.
  * `sort` - Define a sort specification like in the search api. Currently only sorting `_score` reverse (default relevancy)
  is supported. Other sort fields will throw an exception. The `size` and `query` option are required for this setting. Like
  `track_score` the score is based on the query and represents how the query matched to the percolate query's metadata
  and *not* how the document being percolated matched to the query.
  
negative.code: --------------------------------------------------
  
  [float]
  === Percolate API
  
  The percolate API executes in a distributed manner, meaning it executes on all shards an index points to.
  
  .Required options
  * `index` - The index that contains the `.percolator` type. This can also be an alias.
  * `type` - The type of the document to be percolated. The mapping of that type is used to parse document.
  * `doc` - The actual document to percolate. Unlike the other two options this needs to be specified in the request body. Note: This isn't required when percolating an existing document.
  
  [source,js]
  --------------------------------------------------
  