anchor.diff:  p
       |  You can now train the model using a corpus for your language annotated
       |  with #[+a("http://universaldependencies.org/") Universal Dependencies].
  -    |  If your corpus uses the 
  -    |  #[+a("http://universaldependencies.org/docs/format.html") CoNLL-U] format, 
  +    |  If your corpus uses the
  +    |  #[+a("http://universaldependencies.org/docs/format.html") CoNLL-U] format,
       |  i.e. files with the extension #[code .conllu], you can use the
       |  #[+a("/docs/usage/cli#convert") #[code convert] command] to convert it to
       |  spaCy's #[+a("/docs/api/annotation#json-input") JSON format] for training.
  
positive.code:     |  to people and is likely to be unsurprising. As a rule of thumb, words
      |  that are very rare are unlikely to be useful stop words.
  
  p
      |  To improve readability, #[code STOP_WORDS] are separated by spaces and
      |  newlines, and added as a multiline string:
  
  +code("Example").
      STOP_WORDS = set("""
      a about above across after afterwards again against all almost alone along
      already also although always am among amongst amount an and another any anyhow
      anyone anything anyway anywhere are around as at
  
      back be became because become becomes becoming been before beforehand behind
      being below beside besides between beyond both bottom but by
      """).split())
  
  +h(3, "tag-map") Tag map
  
  
negative.code:     |  needs to know the language's character set. If the language you're adding
      |  uses non-latin characters, you might need to add the required character
      |  classes to the global
      |  #[+src(gh("spacy", "spacy/lang/punctuation.py")) punctuation.py].
      |  spaCy uses the #[+a("https://pypi.python.org/pypi/regex/") #[code regex] library]
      |  to keep this simple and readable. If the language requires very specific
      |  punctuation rules, you should consider overwriting the default regular
      |  expressions with your own in the language's #[code Defaults].
  
  p
      |  Here's an overview of the individual components that can be included
      |  in the language data. For more details on them, see the sections below.
  
  +table(["File name", "Variables", "Description"])
      +row
          +cell #[+src(gh()) stop_words.py]
          +cell #[code STOP_WORDS] (set)
          +cell
              |  List of most common words. Matching tokens will return #[code True]
              |  for #[code is_stop].
  
      +row
          +cell #[+src(gh()) tokenizer_exceptions.py]
          +cell #[code TOKENIZER_EXCEPTIONS] (dict), #[code TOKEN_MATCH] (regex)
          +cell
              |  Special-case rules for the tokenizer, for example, contractions
              |  and abbreviations containing punctuation.
  
      +row
          +cell #[+src(gh()) punctuation.py]
          +cell
              |  #[code TOKENIZER_PREFIXES], #[code TOKENIZER_SUFFIXES],
              |  #[code TOKENIZER_INFIXES] (dicts)
          +cell Regular expressions for splitting tokens, e.g. on punctuation.
  
      +row
          +cell #[+src(gh()) lex_attrs.py]
          +cell #[code LEX_ATTRS] (dict)
          +cell
              |  Functions for setting lexical attributes on tokens, e.g.
              |  #[code is_punct] or #[code like_num].
  
      +row
          +cell #[+src(gh()) tag_map.py]
          +cell #[code TAG_MAP] (dict)
          +cell
              |  Dictionary mapping strings in your tag set to
              |  #[+a("http://universaldependencies.org/u/pos/all.html") Universal Dependencies]
              |  tags.
  
      +row
          +cell #[+src(gh()) morph_rules.py]
          +cell #[code MORPH_RULES] (dict)
          +cell
  
      +row
          +cell #[+src(gh()) lemmatizer.py]
          +cell #[code LOOKUP] (dict)
          +cell
              |  Lookup-based lemmatization table. If more lemmatizer data is
              |  available, it should live in #[code /lemmatizer/lookup.py].
  
      +row
          +cell /lemmatizer
          +cell #[code LEMMA_RULES], #[code LEMMA_INDEX], #[code LEMMA_EXC] (dicts)
          +cell Lemmatization rules, keyed by part of speech.
  
  +h(3, "stop-words") Stop words
  
  p
      |  A #[+a("https://en.wikipedia.org/wiki/Stop_words") "stop list"] is a
      |  classic trick from the early days of information retrieval when search
      |  was largely about keyword presence and absence. It is still sometimes
      |  useful today to filter out common words from a bag-of-words model. To
      |  improve readability, #[code STOP_WORDS] are separated by spaces and
      |  newlines, and added as a multiline string.
  
  +aside("What does spaCy consider a stop word?")
      |  There's no particularly principal logic behind what words should be
  