anchor.diff:  // Code for parsing pipe tables
   
   /// Recognizes alignment specified in the passed separator line.
  -let (|PipeSeparatorLine|_|) = function
  +let (|TableCellSeparator|_|) = function
     | String.StartsAndEndsWith (":", ":") (String.EqualsRepeated "-") -> Some(AlignCenter)
     | String.StartsWith ":" (String.EqualsRepeated "-") -> Some(AlignLeft)
     | String.StartsAndEndsWith ("", ":") (String.EqualsRepeated "-") -> Some(AlignRight)
     | String.EqualsRepeated "-" -> Some(AlignDefault)
     | _ -> None
   
  -/// Recognizes rows of pipe table.
  +/// Recognizes row of pipe table.
   /// The function takes number of expected columns and array of delimiters.
   /// Returns list of strings between delimiters.
   let (|PipeTableRow|_|) (size:option<int>) delimiters (line:string) =
  
positive.code: /// Returns list of alignments.
  let (|PipeSeparatorRow|_|) size = function 
    | PipeTableRow size [|'|'; '+'|] parts ->
      if List.exists (function | PipeSeparatorLine _ -> false | _ -> true) parts then None
      else Some(List.map (function | PipeSeparatorLine alignment -> alignment | _ -> AlignDefault) parts)
    | _ -> None 
  
  /// Recognizes pipe table
  let (|PipeTableBlock|_|) input =
    let rec get_table_rows size acc = function
    | (PipeTableRow size [|'|'|] columns) :: rest ->
      get_table_rows size (List.map (fun l -> [l]) columns :: acc) rest
    | rest -> (List.rev acc, rest)
  
    match input with
    | (PipeTableRow None [|'|'|] headers) :: rest ->
      match rest with
      | (PipeSeparatorRow (Some headers.Length) alignments) :: rest ->
        let rows, others = get_table_rows (Some headers.Length) [] rest
        let header_paragraphs = headers |> List.map (fun l -> [l])
        Some((Some(header_paragraphs), alignments, rows), others)
      | _ -> None
    | (PipeSeparatorRow None alignments) :: rest ->
      let rows, others = get_table_rows (Some alignments.Length) [] rest
      Some((None, alignments, rows), others)    
    | _ -> None
  
  
  
negative.code:   | Blockquote(body, Lines.TrimBlankStart rest) ->
        yield QuotedBlock(parseParagraphs ctx body |> List.ofSeq)
        yield! parseParagraphs ctx rest
    | EmacsTableBlock((headers, alignments, rows), Lines.TrimBlankStart rest) 
    | PipeTableBlock((headers, alignments, rows), Lines.TrimBlankStart rest) ->
        let headParagraphs = 
          if headers.IsNone then None
          else Some(headers.Value |> List.map (fun i -> parseParagraphs ctx i |> List.ofSeq))
        yield TableBlock(headParagraphs, alignments,
          rows |> List.map (List.map (fun i -> parseParagraphs ctx i |> List.ofSeq)))
        yield! parseParagraphs ctx rest 
    | HorizontalRule :: (Lines.TrimBlankStart lines) ->
        yield HorizontalRule
        yield! parseParagraphs ctx lines
  