anchor.diff:      /// Otherwise, returns `false`.
       let readChar cs (c: outref<_>) (idx: byref<CharStreamIndex>) =
           match cs.Source with
  -        | _ when idx.Index < cs.StartingIndex ->
  -            failwithf "Trying to view the %dth character of a stream, while the first %d have already been read." idx.Index cs.StartingIndex
  +        | _ when idx.Index < cs.Position.Index ->
  +            failwithf "Trying to view the %dth character of a stream, while the first %d have already been consumed." idx.Index cs.Position.Index
           | StaticBlock sb when idx.Index < uint64 sb.Length ->
               c <- sb.Span.[int idx.Index]
               idx <- idx.Index + GenericOne |> CharStreamIndex
               true
           | StaticBlock _ -> false
  +        | DynamicBlock db ->
  +            if idx.Index <= db.BufferEndingIndex then
  +                c <- cs.Source.[idx.Index]
  +                idx <- CharStreamIndex <| idx.Index + GenericOne
  +                true
  +            else
  +            match idx.Index - db.BufferEndingIndex with
  +            | 1UL ->
  +                let bufferContentLength = int db.BufferContentLength
  +                if bufferContentLength = db.Buffer.Length then
  +                    if db.BufferStartingIndex <> cs.StartingIndex then
  +                        Array.blit db.Buffer (int <| cs.StartingIndex - db.BufferStartingIndex) db.Buffer 0 bufferContentLength
  +                        db.BufferStartingIndex <- cs.StartingIndex
  +                    else
  +                        Array.Resize(&db.Buffer, db.Buffer.Length * 2)
  +                let cRead = db.Reader.Read()
  +                if cRead <> -1 then
  +                    db.BufferEndingIndex <- db.BufferEndingIndex + GenericOne
  +                    db.Buffer.[int <| idx.Index - db.BufferStartingIndex] <- char cRead
  +                    c <- cs.Source.[idx.Index]
  +                    idx <- CharStreamIndex db.BufferEndingIndex
  +                    true
  +                else
  +                    false
  +            | _ -> failwithf "Cannot read character at %d because the latest one was read at %d." idx.Index db.BufferEndingIndex
   
       /// Creates a `CharSpan` that contains the next `idxTo` characters of a `CharStream` from its position.
       /// On the dynamic block character stream, it ensures that the characters in the span stay in memory.
  
positive.code:     /// Creates an arbitrary object out of the characters at the given `CharSpan` at the returned `Position`.
      /// After that call, the characters at and before the span might be freed from memory, so this function must not be used twice.
      let unpinSpanAndGenerate symbol (fPostProcess: CharStreamCallback<'symbol>) cs (CharSpan (idxStart, idxEnd) as csp) =
          match cs.Source with
          | StaticBlock sb when cs.StartingIndex <= idxStart && uint64 sb.Length > idxEnd ->
              cs.StartingIndex <- idxEnd + 1UL
              let length = idxEnd - idxStart + 1UL |> int
              let span = sb.Span.Slice(int idxStart, length)
              fPostProcess.Invoke(symbol, cs.Position, span), cs.Position
          | StaticBlock _ ->
              failwithf "Trying to read the character span %O, from a stream that was last read at %d." csp cs.StartingIndex
  
      /// Creates a string out of the characters at the given `CharSpan` at the returned `Position`.
  
negative.code:         /// not always full in cases like an end of input.
          mutable BufferEndingIndex: uint64
      }
      /// The real length of the buffer, excluding the unpinned characters at the end.
      member x.BufferContentLength = x.BufferEndingIndex - x.BufferStartingIndex + GenericOne |> int
  
  /// A representation of a `CharStream`.
  type private CharStreamSource =
  