anchor.diff:  
     let inline pow10 n = Pow10Table.[clamp (n - MinimumPow10) 0 (Pow10Table.Length - 1)]
   
  -  let inline neos (s : string) (pos : int) : bool = pos < s.Length
  -  let inline eos  (s : string) (pos : int) : bool = pos >= s.Length
  -  let inline ch   (s : string) (pos : int) : char = s.[pos]
  -  let inline adv  (p : byref<int>)                = p <- p + 1
  -
  -  let inline raiseEos (v : IParseVisitor) (pos : int) : bool =
  -    v.Unexpected (pos, Tokens.EOS)
  -    false
  +  let inline isWhiteSpace (c : char) : bool =
  +    c = ' ' || c = '\t' || c = '\n' || c = '\r'
  +
  +  let inline isDigit (c : char) : bool =
  +    c >= '0' && c <= '9'
   
     let rec charsContains (i : int) (v : char) (vs : char []) : bool =
       if i < vs.Length then
  
positive.code:       let e = s.Length - 1
        for i = 0 to e do
          match s.[i] with
          | '\"'  -> str @"\"""
          | '\\'  -> str @"\\"
          | '/'   -> str @"\/"
          | '\b'  -> str @"\b"
          | '\f'  -> str @"\f"
          | '\n'  -> str @"\n"
          | '\r'  -> str @"\r"
          | '\t'  -> str @"\t"
          | c     -> ch c
        ch '"'
  
      let values b e (vs : 'T array) (a : 'T -> unit) =
  
negative.code:     member x.Expected       = filter expected
      member x.Unexpected     = filter unexpected
  
  open ParserDetails
  
  /// Attempts to parse a JSON document from a string
  ///   visitor : Parser visitor object
  ///   input   : Input string
  let tryParse (visitor : IParseVisitor) (input : string) (pos : int byref) : bool =
    let jp = JsonParser (input, visitor)
    let result =
      jp.consume_WhiteSpace     ()
      && jp.tryParse_RootValue  ()
      && jp.tryParse_Eos        ()
  
    pos <- jp.position
  
    result
  
  /// Returned by parse function
  type ParseResult =
  