anchor.diff:          | Empty -> ""
           | Cell(_, d) -> d
   
  +type HtmlTableRow = 
  +    | Row of HtmlTableCell [] *  HtmlNode
  +    | Empty 
  +    member x.Cells =
  +        match x with
  +        | Empty -> [||]
  +        | Row(cells, _) -> cells
  +
   type HtmlTable = 
       { Name : string
         HeaderNamesAndUnits : (string * Type option)[] option // always set at designtime, never at runtime
         InferedProperties : PrimitiveInferedProperty list option // sometimes set at designtime, never at runtime
         HasHeaders: bool option // always set at designtime, never at runtime
  -      Rows :  string [] []
  +      Rows :  HtmlTableRow []
         Html : HtmlNode }
       override x.ToString() =
           let sb = StringBuilder()
           use wr = new StringWriter(sb) 
           wr.WriteLine(x.Name)
  -        let data = array2D x.Rows
  +        let data = x.Rows
           let rows = data.GetLength(0)
  -        let columns = data.GetLength(1)
  +        let columns = (data |> Array.maxBy (fun r -> r.Cells.Length)).Cells.Length
           let widths = Array.zeroCreate columns 
  -        data |> Array2D.iteri (fun _ c cell ->
  -            widths.[c] <- max (widths.[c]) (cell.Length))
  +        data |> Array.iteri (fun _ row ->
  +            row.Cells |> Array.iteri (fun c cell -> widths.[c] <- max (widths.[c]) (cell.Data.Length)))
           for r in 0 .. rows - 1 do
               for c in 0 .. columns - 1 do
  -                wr.Write(data.[r,c].PadRight(widths.[c] + 1))
  +                wr.Write(data.[r].Cells.[c].Data.PadRight(widths.[c] + 1))
               wr.WriteLine()
           sb.ToString()
   
  
positive.code: 
                  Some hasHeaders, Some headerNamesAndUnits, inferedProperties
  
          let rows = res |> Array.map (Array.map (fun x -> x.Data))
  
          { Name = name
            HeaderNamesAndUnits = headerNamesAndUnits
            InferedProperties = inferedProperties
            HasHeaders = hasHeaders
            Rows = rows 
            Html = table } |> Some
  
      let private parseList makeUnique index (list:HtmlNode, parents:HtmlNode list) =
  
negative.code:     member __.GetObject(id:string) = 
          htmlObjects |> Map.find id
  
  type HtmlTableRow<'rowType>(htmlNode)
  
  type HtmlTable<'rowType> internal (name:string, headers:string[] option, values:'rowType[], html:HtmlNode) =
  
      member __.Name = name
  