HTML 5.1

Precise rules for determining whether this conformance requirement is met are described in the description of the table model.

If a table element has a (non-conforming) summary attribute, and the user agent has not classified the table as a layout table, the user agent may report the contents of that attribute to the user.

---

Tables can be complicated to understand and navigate. To help users with this, user agents should clearly delineate cells in a table from each other, unless the user agent has classified the table as a layout table.

User agents, especially those that do table analysis on arbitrary content, are encouraged to find heuristics to determine which tables actually contain data and which are merely being used for layout. This specification does not define a precise heuristic, but the following are suggested as possible indicators:

Feature	Indication
The use of the role attribute with the value presentation	Probably a layout table
The use of the border attribute with the non-conforming value 0	Probably a layout table
The use of the non-conforming cellspacing and cellpadding attributes with the value 0	Probably a layout table
The use of caption, thead, or th elements	Probably a non-layout table
The use of the headers and scope attributes	Probably a non-layout table
The use of the border attribute with a value other than 0	Probably a non-layout table
Explicit visible borders set using CSS	Probably a non-layout table
The use of the summary attribute	Not a good indicator (both layout and non-layout tables have historically been given this attribute)

It is quite possible that the above suggestions are wrong. Implementors are urged to provide feedback elaborating on their experiences with trying to create a layout table detection heuristic.

The caption IDL attribute must return, on getting, the first caption element child of the table element, if any, or null otherwise. On setting, if the new value is a caption element, the first caption element child of the table element, if any, must be removed, and the new value must be inserted as the first node of the table element. If the new value is not a caption element, then a HierarchyRequestError DOM exception must be thrown instead.

The createCaption() method must return the first caption element child of the table element, if any; otherwise a new caption element must be created, inserted as the first node of the table element, and then returned.

The deleteCaption() method must remove the first caption element child of the table element, if any.

The tHead IDL attribute must return, on getting, the first thead element child of the table element, if any, or null otherwise. On setting, if the new value is a thead element, the first thead element child of the table element, if any, must be removed, and the new value must be inserted immediately before the first element in the table element that is neither a caption element nor a colgroup element, if any, or at the end of the table if there are no such elements. If the new value is not a thead element, then a HierarchyRequestError DOM exception must be thrown instead.

The createTHead() method must return the first thead element child of the table element, if any; otherwise a new thead element must be created and inserted immediately before the first element in the table element that is neither a caption element nor a colgroup element, if any, or at the end of the table if there are no such elements, and then that new element must be returned.

The deleteTHead() method must remove the first thead element child of the table element, if any.

The tFoot IDL attribute must return, on getting, the first tfoot element child of the table element, if any, or null otherwise. On setting, if the new value is a tfoot element, the first tfoot element child of the table element, if any, must be removed, and the new value must be inserted immediately before the first element in the table element that is neither a caption element, a colgroup element, nor a thead element, if any, or at the end of the table if there are no such elements. If the new value is not a tfoot element, then a HierarchyRequestError DOM exception must be thrown instead.

The createTFoot() method must return the first tfoot element child of the table element, if any; otherwise a new tfoot element must be created and inserted immediately before the first element in the table element that is neither a caption element, a colgroup element, nor a thead element, if any, or at the end of the table if there are no such elements, and then that new element must be returned.

The deleteTFoot() method must remove the first tfoot element child of the table element, if any.

The tBodies attribute must return an HTMLCollection rooted at the table node, whose filter matches only tbody elements that are children of the table element.

The createTBody() method must create a new tbody element, insert it immediately after the last tbody element child in the table element, if any, or at the end of the table element if the table element has no tbody element children, and then must return the new tbody element.

The rows attribute must return an HTMLCollection rooted at the table node, whose filter matches only tr elements that are either children of the table element, or children of thead, tbody, or tfoot elements that are themselves children of the table element. The elements in the collection must be ordered such that those elements whose parent is a thead are included first, in tree order, followed by those elements whose parent is either a table or tbody element, again in tree order, followed finally by those elements whose parent is a tfoot element, still in tree order.

The behavior of the insertRow(index) method depends on the state of the table. When it is called, the method must act as required by the first item in the following list of conditions that describes the state of the table and the index argument:

If index is less than −1 or greater than the number of elements in rows collection:

The method must throw an IndexSizeError exception.

If the rows collection has zero elements in it, and the table has no tbody elements in it:

The method must create a tbody element, then create a tr element, then append the tr element to the tbody element, then append the tbody element to the table element, and finally return the tr element.

If the rows collection has zero elements in it:

The method must create a tr element, append it to the last tbody element in the table, and return the tr element.

If index is −1 or equal to the number of items in rows collection:

The method must create a tr element, and append it to the parent of the last tr element in the rows collection. Then, the newly created tr element must be returned.

Otherwise:

The method must create a tr element, insert it immediately before the indexth tr element in the rows collection, in the same parent, and finally must return the newly created tr element.

When the deleteRow(index) method is called, the user agent must run the following steps:

1. If index is equal to −1, then index must be set to the number of items in the rows collection, minus one.

2. Now, if index is less than zero, or greater than or equal to the number of elements in the rows collection, the method must instead throw an IndexSizeError exception, and these steps must be aborted.

3. Otherwise, the method must remove the indexth element in the rows collection from its parent.

The border IDL attribute must reflect the content attribute of the same name.

The stopSorting() method is used in the table sorting model.

The IDL attribute sortable must reflect the sortable content attribute.

<section>
 <style scoped>
  table { border-collapse: collapse; border: solid thick; }
  colgroup, tbody { border: solid medium; }
  td { border: solid thin; height: 1.4em; width: 1.4em; text-align: center; padding: 0; }
 </style>
 <h1>Today's Sudoku</h1>
 <table>
  <colgroup><col><col><col>
  <colgroup><col><col><col>
  <colgroup><col><col><col>
  <tbody>
   <tr> <td> 1 <td>   <td> 3 <td> 6 <td>   <td> 4 <td> 7 <td>   <td> 9
   <tr> <td>   <td> 2 <td>   <td>   <td> 9 <td>   <td>   <td> 1 <td>
   <tr> <td> 7 <td>   <td>   <td>   <td>   <td>   <td>   <td>   <td> 6
  <tbody>
   <tr> <td> 2 <td>   <td> 4 <td>   <td> 3 <td>   <td> 9 <td>   <td> 8
   <tr> <td>   <td>   <td>   <td>   <td>   <td>   <td>   <td>   <td>
   <tr> <td> 5 <td>   <td>   <td> 9 <td>   <td> 7 <td>   <td>   <td> 1
  <tbody>
   <tr> <td> 6 <td>   <td>   <td>   <td> 5 <td>   <td>   <td>   <td> 2
   <tr> <td>   <td>   <td>   <td>   <td> 7 <td>   <td>   <td>   <td>
   <tr> <td> 9 <td>   <td>   <td> 8 <td>   <td> 2 <td>   <td>   <td> 5
 </table>
</section>

<table>
 <caption>Characteristics with positive and negative sides</caption>
 <thead>
  <tr>
   <th> Characteristic
   <th> Negative
   <th> Positive
 <tbody>
  <tr>
   <th> Mood
   <td> Sad
   <td> Happy
  <tr>
   <th> Grade
   <td> Failing
   <td> Passing
</table>

User agents are encouraged to render tables using these techniques whenever the page does not use CSS and the table is not classified as a layout table.

The caption element takes part in the table model.

<caption>
<p>Table 1.
<p>This table shows the total score obtained from rolling two
six-sided dice. The first row represents the value of the first die,
the first column the value of the second die. The total is given in
the cell that corresponds to the values of the two dice.
</caption>

The colgroup element and its span attribute take part in the table model.

The span IDL attribute must reflect the content attribute of the same name. The value must be limited to only non-negative numbers greater than zero.

The col element and its span attribute take part in the table model.

The span IDL attribute must reflect the content attribute of the same name. The value must be limited to only non-negative numbers greater than zero.

The tbody element takes part in the table model.

The rows attribute must return an HTMLCollection rooted at the element, whose filter matches only tr elements that are children of the element.

The insertRow(index) method must, when invoked on an element table section, act as follows:

If index is less than −1 or greater than the number of elements in the rows collection, the method must throw an IndexSizeError exception.

If index is −1 or equal to the number of items in the rows collection, the method must create a tr element, append it to the element table section, and return the newly created tr element.

Otherwise, the method must create a tr element, insert it as a child of the table section element, immediately before the indexth tr element in the rows collection, and finally must return the newly created tr element.

The deleteRow(index) method must remove the indexth element in the rows collection from its parent. If index is less than zero or greater than or equal to the number of elements in the rows collection, the method must instead throw an IndexSizeError exception.

The thead element takes part in the table model.

<table>
 <caption> School auction sign-up sheet </caption>
 <thead>
  <tr>
   <th><label for=e1>Name</label>
   <th><label for=e2>Product</label>
   <th><label for=e3>Picture</label>
   <th><label for=e4>Price</label>
  <tr>
   <td>Your name here
   <td>What are you selling?
   <td>Link to a picture
   <td>Your reserve price
 <tbody>
  <tr>
   <td>Ms Danus
   <td>Doughnuts
   <td><img src="http://example.com/mydoughnuts.png" title="Doughnuts from Ms Danus">
   <td>$45
  <tr>
   <td><input id=e1 type=text name=who required form=f>
   <td><input id=e2 type=text name=what required form=f>
   <td><input id=e3 type=url name=pic form=f>
   <td><input id=e4 type=number step=0.01 min=0 value=0 required form=f>
</table>
<form id=f action="/auction.cgi">
 <input type=button name=add value="Submit">
</form>

The tfoot element takes part in the table model.

The tr element takes part in the table model.

The rowIndex attribute must, if the element has a parent table element, or a parent tbody, thead, or tfoot element and a grandparent table element, return the index of the tr element in that table element's rows collection. If there is no such table element, then the attribute must return −1.

The sectionRowIndex attribute must, if the element has a parent table, tbody, thead, or tfoot element, return the index of the tr element in the parent element's rows collection (for tables, that's the HTMLTableElement.rows collection; for table sections, that's the HTMLTableRowElement.rows collection). If there is no such parent element, then the attribute must return −1.

The cells attribute must return an HTMLCollection rooted at the tr element, whose filter matches only td and th elements that are children of the tr element.

The insertCell(index) method must act as follows:

If index is less than −1 or greater than the number of elements in the cells collection, the method must throw an IndexSizeError exception.

If index is equal to −1 or equal to the number of items in cells collection, the method must create a td element, append it to the tr element, and return the newly created td element.

Otherwise, the method must create a td element, insert it as a child of the tr element, immediately before the indexth td or th element in the cells collection, and finally must return the newly created td element.

The deleteCell(index) method must remove the indexth element in the cells collection from its parent. If index is less than zero or greater than or equal to the number of elements in the cells collection, the method must instead throw an IndexSizeError exception.

The td element and its colspan, rowspan, and headers attributes take part in the table model.

User agents, especially in non-visual environments or where displaying the table as a 2D grid is impractical, may give the user context for the cell when rendering the contents of a cell; for instance, giving its position in the table model, or listing the cell's header cells (as determined by the algorithm for assigning header cells). When a cell's header cells are being listed, user agents may use the value of abbr attributes on those header cells, if any, instead of the contents of the header cells themselves.

The th element and its colspan, rowspan, headers, and scope attributes take part in the table model.

The sort() method is used in the table sorting model.

The scope IDL attribute must reflect the content attribute of the same name, limited to only known values.

The abbr and sorted IDL attributes must reflect the content attributes of the same name.

<table>
   <caption>Measurement of legs and tails in Cats and English speakers</caption>
 <thead>
  <tr> <th> ID <th> Measurement <th> Average <th> Maximum
 <tbody>
  <tr> <td> <th scope=rowgroup> Cats <td> <td>
  <tr> <td> 93 <th scope=row> Legs <td> 3.5 <td> 4
  <tr> <td> 10 <th scope=row> Tails <td> 1 <td> 1
 </tbody>
 <tbody>
  <tr> <td> <th scope=rowgroup> English speakers <td> <td>
  <tr> <td> 32 <th scope=row> Legs <td> 2.67 <td> 4
  <tr> <td> 35 <th scope=row> Tails <td> 0.33 <td> 1
 </tbody>
  </table>

The colspan, rowspan, and headers attributes take part in the table model.

interface HTMLTableCellElement : HTMLElement {
           attribute unsigned long colSpan;
           attribute unsigned long rowSpan;
  [PutForwards=value] readonly attribute DOMSettableTokenList headers;
  readonly attribute long cellIndex;
};

The colSpan IDL attribute must reflect the colspan content attribute. Its default value is 1.

The rowSpan IDL attribute must reflect the rowspan content attribute. Its default value is 1.

The headers IDL attribute must reflect the content attribute of the same name.

The cellIndex IDL attribute must, if the element has a parent tr element, return the index of the cell's element in the parent element's cells collection. If there is no such parent element, then the attribute must return −1.

4.9.12 Processing model

The various table elements and their content attributes together define the table model.

A table consists of cells aligned on a two-dimensional grid of slots with coordinates (x, y). The grid is finite, and is either empty or has one or more slots. If the grid has one or more slots, then the x coordinates are always in the range 0 ≤ x < x_width, and the y coordinates are always in the range 0 ≤ y < y_height. If one or both of x_width and y_height are zero, then the table is empty (has no slots). Tables correspond to table elements.

A cell is a set of slots anchored at a slot (cell_x, cell_y), and with a particular width and height such that the cell covers all the slots with coordinates (x, y) where cell_x ≤ x < cell_x+width and cell_y ≤ y < cell_y+height. Cells can either be data cells or header cells. Data cells correspond to td elements, and header cells correspond to th elements. Cells of both types can have zero or more associated header cells.

It is possible, in certain error cases, for two cells to occupy the same slot.

A row is a complete set of slots from x=0 to x=x_width-1, for a particular value of y. Rows usually correspond to tr elements, though a row group can have some implied rows at the end in some cases involving cells spanning multiple rows.

A column is a complete set of slots from y=0 to y=y_height-1, for a particular value of x. Columns can correspond to col elements. In the absence of col elements, columns are implied.

A row group is a set of rows anchored at a slot (0, group_y) with a particular height such that the row group covers all the slots with coordinates (x, y) where 0 ≤ x < x_width and group_y ≤ y < group_y+height. Row groups correspond to tbody, thead, and tfoot elements. Not every row is necessarily in a row group.

A column group is a set of columns anchored at a slot (group_x, 0) with a particular width such that the column group covers all the slots with coordinates (x, y) where group_x ≤ x < group_x+width and 0 ≤ y < y_height. Column groups correspond to colgroup elements. Not every column is necessarily in a column group.

Row groups cannot overlap each other. Similarly, column groups cannot overlap each other.

A cell cannot cover slots that are from two or more row groups. It is, however, possible for a cell to be in multiple column groups. All the slots that form part of one cell are part of zero or one row groups and zero or more column groups.

In addition to cells, columns, rows, row groups, and column groups, tables can have a caption element associated with them. This gives the table a heading, or legend.

A table model error is an error with the data represented by table elements and their descendants. Documents must not have table model errors.

4.9.12.1 Forming a table

To determine which elements correspond to which slots in a table associated with a table element, to determine the dimensions of the table (x_width and y_height), and to determine if there are any table model errors, user agents must use the following algorithm:

1. Let x_width be zero.

2. Let y_height be zero.

3. Let pending tfoot elements be a list of tfoot elements, initially empty.

4. Let the table be the table represented by the table element. The x_width and y_height variables give the table's dimensions. The table is initially empty.

5. If the table element has no children elements, then return the table (which will be empty), and abort these steps.

6. Associate the first caption element child of the table element with the table. If there are no such children, then it has no associated caption element.

7. Let the current element be the first element child of the table element.

   If a step in this algorithm ever requires the current element to be advanced to the next child of the table when there is no such next child, then the user agent must jump to the step labeled end, near the end of this algorithm.

8. While the current element is not one of the following elements, advance the current element to the next child of the table:

   • colgroup
   • thead
   • tbody
   • tfoot
   • tr

9. If the current element is a colgroup, follow these substeps:

   1. Column groups: Process the current element according to the appropriate case below:

      If the current element has any col element children

      Follow these steps:

      1. Let x_start have the value of x_width.

      2. Let the current column be the first col element child of the colgroup element.

      3. Columns: If the current column col element has a span attribute, then parse its value using the rules for parsing non-negative integers.

         If the result of parsing the value is not an error or zero, then let span be that value.

         Otherwise, if the col element has no span attribute, or if trying to parse the attribute's value resulted in an error or zero, then let span be 1.

      4. Increase x_width by span.

      5. Let the last span columns in the table correspond to the current column col element.

      6. If current column is not the last col element child of the colgroup element, then let the current column be the next col element child of the colgroup element, and return to the step labeled columns.

      7. Let all the last columns in the table from x=x_start to x=x_width-1 form a new column group, anchored at the slot (x_start, 0), with width x_width-x_start, corresponding to the colgroup element.

      If the current element has no col element children

      1. If the colgroup element has a span attribute, then parse its value using the rules for parsing non-negative integers.

         If the result of parsing the value is not an error or zero, then let span be that value.

         Otherwise, if the colgroup element has no span attribute, or if trying to parse the attribute's value resulted in an error or zero, then let span be 1.

      2. Increase x_width by span.

      3. Let the last span columns in the table form a new column group, anchored at the slot (x_width-span, 0), with width span, corresponding to the colgroup element.

   2. Advance the current element to the next child of the table.

   3. While the current element is not one of the following elements, advance the current element to the next child of the table:

      • colgroup
      • thead
      • tbody
      • tfoot
      • tr

   4. If the current element is a colgroup element, jump to the step labeled column groups above.

10. Let y_current be zero.

11. Let the list of downward-growing cells be an empty list.

12. Rows: While the current element is not one of the following elements, advance the current element to the next child of the table:

    • thead
    • tbody
    • tfoot
    • tr

13. If the current element is a tr, then run the algorithm for processing rows, advance the current element to the next child of the table, and return to the step labeled rows.

14. Run the algorithm for ending a row group.

15. If the current element is a tfoot, then add that element to the list of pending tfoot elements, advance the current element to the next child of the table, and return to the step labeled rows.

16. The current element is either a thead or a tbody.

    Run the algorithm for processing row groups.

17. Advance the current element to the next child of the table.

18. Return to the step labeled rows.

19. End: For each tfoot element in the list of pending tfoot elements, in tree order, run the algorithm for processing row groups.

20. If there exists a row or column in the table containing only slots that do not have a cell anchored to them, then this is a table model error.

21. Return the table.

The algorithm for processing row groups, which is invoked by the set of steps above for processing thead, tbody, and tfoot elements, is:

1. Let y_start have the value of y_height.

2. For each tr element that is a child of the element being processed, in tree order, run the algorithm for processing rows.

3. If y_height > y_start, then let all the last rows in the table from y=y_start to y=y_height-1 form a new row group, anchored at the slot with coordinate (0, y_start), with height y_height-y_start, corresponding to the element being processed.

4. Run the algorithm for ending a row group.

The algorithm for ending a row group, which is invoked by the set of steps above when starting and ending a block of rows, is:

1. While y_current is less than y_height, follow these steps:

   1. Run the algorithm for growing downward-growing cells.

   2. Increase y_current by 1.

2. Empty the list of downward-growing cells.

The algorithm for processing rows, which is invoked by the set of steps above for processing tr elements, is:

1. If y_height is equal to y_current, then increase y_height by 1. (y_current is never greater than y_height.)

2. Let x_current be 0.

3. Run the algorithm for growing downward-growing cells.

4. If the tr element being processed has no td or th element children, then increase y_current by 1, abort this set of steps, and return to the algorithm above.

5. Let current cell be the first td or th element child in the tr element being processed.

6. Cells: While x_current is less than x_width and the slot with coordinate (x_current, y_current) already has a cell assigned to it, increase x_current by 1.

7. If x_current is equal to x_width, increase x_width by 1. (x_current is never greater than x_width.)

8. If the current cell has a colspan attribute, then parse that attribute's value, and let colspan be the result.

   If parsing that value failed, or returned zero, or if the attribute is absent, then let colspan be 1, instead.

9. If the current cell has a rowspan attribute, then parse that attribute's value, and let rowspan be the result.

   If parsing that value failed or if the attribute is absent, then let rowspan be 1, instead.

10. If rowspan is zero and the table element's Document is not set to quirks mode, then let cell grows downward be true, and set rowspan to 1. Otherwise, let cell grows downward be false.

11. If x_width < x_current+colspan, then let x_width be x_current+colspan.

12. If y_height < y_current+rowspan, then let y_height be y_current+rowspan.

13. Let the slots with coordinates (x, y) such that x_current ≤ x < x_current+colspan and y_current ≤ y < y_current+rowspan be covered by a new cell c, anchored at (x_current, y_current), which has width colspan and height rowspan, corresponding to the current cell element.

    If the current cell element is a th element, let this new cell c be a header cell; otherwise, let it be a data cell.

    To establish which header cells apply to the current cell element, use the algorithm for assigning header cells described in the next section.

    If any of the slots involved already had a cell covering them, then this is a table model error. Those slots now have two cells overlapping.

14. If cell grows downward is true, then add the tuple {c, x_current, colspan} to the list of downward-growing cells.

15. Increase x_current by colspan.

16. If current cell is the last td or th element child in the tr element being processed, then increase y_current by 1, abort this set of steps, and return to the algorithm above.

17. Let current cell be the next td or th element child in the tr element being processed.

18. Return to the step labeled cells.

When the algorithms above require the user agent to run the algorithm for growing downward-growing cells, the user agent must, for each {cell, cell_x, width} tuple in the list of downward-growing cells, if any, extend the cell cell so that it also covers the slots with coordinates (x, y_current), where cell_x ≤ x < cell_x+width.

4.9.12.2 Forming relationships between data cells and header cells

Each cell can be assigned zero or more header cells. The algorithm for assigning header cells to a cell principal cell is as follows.

1. Let header list be an empty list of cells.

2. Let (principal_x, principal_y) be the coordinate of the slot to which the principal cell is anchored.

3. If the principal cell has a headers attribute specified

   1. Take the value of the principal cell's headers attribute and split it on spaces, letting id list be the list of tokens obtained.

   2. For each token in the id list, if the first element in the Document with an ID equal to the token is a cell in the same table, and that cell is not the principal cell, then add that cell to header list.

   If principal cell does not have a headers attribute specified

   1. Let principal_width be the width of the principal cell.

   2. Let principal_height be the height of the principal cell.

   3. For each value of y from principal_y to principal_y+principal_height-1, run the internal algorithm for scanning and assigning header cells, with the principal cell, the header list, the initial coordinate (principal_x,y), and the increments Δx=−1 and Δy=0.

   4. For each value of x from principal_x to principal_x+principal_width-1, run the internal algorithm for scanning and assigning header cells, with the principal cell, the header list, the initial coordinate (x,principal_y), and the increments Δx=0 and Δy=−1.

   5. If the principal cell is anchored in a row group, then add all header cells that are row group headers and are anchored in the same row group with an x-coordinate less than or equal to principal_x+principal_width-1 and a y-coordinate less than or equal to principal_y+principal_height-1 to header list.

   6. If the principal cell is anchored in a column group, then add all header cells that are column group headers and are anchored in the same column group with an x-coordinate less than or equal to principal_x+principal_width-1 and a y-coordinate less than or equal to principal_y+principal_height-1 to header list.

4. Remove all the empty cells from the header list.

5. Remove any duplicates from the header list.

6. Remove principal cell from the header list if it is there.

7. Assign the headers in the header list to the principal cell.

The internal algorithm for scanning and assigning header cells, given a principal cell, a header list, an initial coordinate (initial_x, initial_y), and Δx and Δy increments, is as follows:

1. Let x equal initial_x.

2. Let y equal initial_y.

3. Let opaque headers be an empty list of cells.

4. If principal cell is a header cell

   Let in header block be true, and let headers from current header block be a list of cells containing just the principal cell.

   Otherwise

   Let in header block be false and let headers from current header block be an empty list of cells.

5. Loop: Increment x by Δx; increment y by Δy.

   For each invocation of this algorithm, one of Δx and Δy will be −1, and the other will be 0.

6. If either x or y is less than 0, then abort this internal algorithm.

7. If there is no cell covering slot (x, y), or if there is more than one cell covering slot (x, y), return to the substep labeled loop.

8. Let current cell be the cell covering slot (x, y).

9. If current cell is a header cell

   1. Set in header block to true.

   2. Add current cell to headers from current header block.

   3. Let blocked be false.

   4. If Δx is 0

      If there are any cells in the opaque headers list anchored with the same x-coordinate as the current cell, and with the same width as current cell, then let blocked be true.

      If the current cell is not a column header, then let blocked be true.

      If Δy is 0

      If there are any cells in the opaque headers list anchored with the same y-coordinate as the current cell, and with the same height as current cell, then let blocked be true.

      If the current cell is not a row header, then let blocked be true.

   5. If blocked is false, then add the current cell to the headers list.

   If current cell is a data cell and in header block is true

   Set in header block to false. Add all the cells in headers from current header block to the opaque headers list, and empty the headers from current header block list.

10. Return to the step labeled loop.

A header cell anchored at the slot with coordinate (x, y) with width width and height height is said to be a column header if any of the following conditions are true:

• The cell's scope attribute is in the column state, or
• The cell's scope attribute is in the auto state, and there are no data cells in any of the cells covering slots with y-coordinates y .. y+height-1.

A header cell anchored at the slot with coordinate (x, y) with width width and height height is said to be a row header if any of the following conditions are true:

• The cell's scope attribute is in the row state, or
• The cell's scope attribute is in the auto state, the cell is not a column header, and there are no data cells in any of the cells covering slots with x-coordinates x .. x+width-1.

A header cell is said to be a column group header if its scope attribute is in the column group state.

A header cell is said to be a row group header if its scope attribute is in the row group state.

A cell is said to be an empty cell if it contains no elements and its text content, if any, consists only of White_Space characters.

To determine a th element's sorted attribute's column sort direction and column key ordinality, user agents must use the following algorithm:

1. Let direction be normal.

2. Let have explicit direction be false.

3. Let ordinality be 1.

4. Let have explicit ordinality be false.

5. Let tokens be the result of splitting the attribute's value on spaces.

6. For each token token in tokens, run the appropriate steps from the following list:

   If have explicit direction is false and token is an ASCII case-insensitive match for the string "reversed"

   Let direction be reversed and have explicit direction be true.

   If have explicit ordinality is false

   Parse token as an integer. If this resulted in an error or the value zero, then ignore the token. Otherwise, set ordinality to the parsed value, and set have explicit ordinality to true.

   Otherwise

   Ignore the token.

7. The column sort direction is the value of direction, and the column key ordinality is the value of ordinality.

---

The table sorting algorithm, which is applied to a table, is as follows:

1. Let table be the table element being sorted.

2. If table's currently-sorting flag is true, then abort these steps.

3. Set table's currently-sorting flag to true.

4. Fire a simple event named sort that is cancelable at table.

5. If the event fired in the previous step was canceled, then jump to the step labeled end below.

6. If table is not now a sorting-enabled table element, then jump to the step labeled end below.

   Even if table was a sorting-enabled table element when the algorithm was invoked, the DOM might have been entirely changed by the event handlers for the sort event, so this has to be verified at this stage, not earlier.

7. Let key heading cells be the sorting-enabled th elements of the table element table.

8. Sort key heading cells in ascending order of the column key ordinality of their sorted attributes, with those having the same column key ordinality being sorted in tree order.

9. Let row collection cursor be a pointer to an element, initially pointing at the first child of table that is after table's first thead, if any, and that is either a tbody or a tr element, assuming there is one. If there is no such child, then jump to the step labeled end below.

10. If table has no row group corresponding to a thead element, then set ignore first group to true. Otherwise, set it to false.

11. Row loop: Let rows be an empty list of tr elements.

12. Run the appropriate steps from the following list:

    If row collection cursor points to a tr element

    1. Collect: Append the element pointed to by row collection cursor to rows.

    2. If there are no tr or tbody children of table that are later siblings of the element pointed to by row collection cursor, or if the next such child is a tbody element, then jump to the step labeled group below.

    3. Let row collection cursor point to the next tr child of table that is a later sibling of the element pointed to by row collection cursor.

    4. Return to the step labeled collect above.

    If row collection cursor points to a tbody element

    1. Place all the tr element children of the element pointed to by row collection cursor into rows, in tree order.

    2. If rows is empty, jump to the step labeled increment loop below.

13. Group: Let groups be an empty list of groups of tr elements.

14. Let group be an empty group of tr elements.

15. Let group cursor be a pointer to an element, initially pointing at the first tr element in rows.

16. Start group: Let pending rows in group be 1.

17. Group loop: Append the tr element pointed to by group cursor to group.

18. If there are any cells whose highest row's element is the one pointed to by group cursor, then let tallest height be the number of rows covered by the tallest such cell.

19. If tallest height is greater than pending rows in group then set pending rows in group to tallest height.

20. Decrement pending rows in group by one.

21. Let group cursor point to the next tr element in rows, if any; otherwise, let it be null.

22. If group cursor is not null and pending rows in group is not zero, return to the step labeled group loop.

23. Append a new group to groups consisting of the tr elements in group.

24. Empty group.

25. If group cursor is not null, then return to the step labeled start group.

26. If ignore first group is true, then drop the first group in groups and set ignore first group to false.

27. Drop leading header groups: If groups is now empty, jump to the step labeled increment loop below.

28. If the first group of groups consists of tr elements whose element children are all th elements, then drop the first group in groups and return to the previous step (labeled drop leading header groups).

29. Let insertion point be a placeholder in a DOM tree, which can be used to reinsert nodes at a specific point in the DOM. Insert insertion point into the parent of the first tr element of the first group in groups, immediately before that tr element.

30. Sort the groups in groups, using the following algorithm to decide the relative order of any two groups a and b (the algorithm either returns that a comes before b, or that b comes before a):

    1. Let key index be an index into key heading cells, initially denoting the first element in the list.

    2. Let direction be a sort direction, initially ascending. Its other possible value is descending. When direction is toggled, that means that if its value is ascending, it must be changed to descending, and when its value is descending, it must be changed to ascending.

    3. Column loop: Let th be the key indexth th in key heading cells.

    4. If th's sorted attribute's column sort direction is reversed, then toggle direction.

    5. Let tentative order be the result of comparing two row groups using the th element th, with a and b as the rows.

    6. If tentative order is not "equal", then jump to the step labeled return below.

    7. Increment key index.

    8. If key index still denotes a th element in key heading cells, then jump back to the step above labeled column loop.

    9. If a's tr elements precede b's in tree order, then let tentative order be "a before b". Otherwise, let tentative order be "b before a".

    10. Return: Return the relative order given by the matching option from the following list:

        If direction is ascending and tentative order is "a before b"

        Return that a comes before b.

        If direction is ascending and tentative order is "b before a"

        Return that b comes before a.

        If direction is descending and tentative order is "a before b"

        Return that b comes before a.

        If direction is descending and tentative order is "b before a"

        Return that a comes before b.

    When the user agent is required to compare two row groups using the th element th, with a and b being the two row groups respectively, the user agent must run the following steps:

    1. Let x be the x-coordinate of the slots that th covers in its table.

    2. Let cell_a be the element corresponding to the cell in the first row of group a that covers the slot in that row whose x-coordinate is x.

       Let cell_b be the element corresponding to the cell in the first row of group b that covers the slot in that row whose x-coordinate is x.

       In either case, if there's no cell that actually covers the slot, then use the value null instead.

    3. Let type_a and value_a be the type and value of the cell cell_a, as defined below.

       Let type_b and value_b be the type and value of the cell cell_b, as defined below.

       The type and value of the cell cell are computed as follows.

       1. If cell is null, then the type is "string" and the value is the empty string; abort these steps.

       2. If, ignoring inter-element whitespace and nodes other than Element and Text nodes, cell has only one child and that child is a data element, then the value is the value of that data element's value attribute, if there is one, or the empty string otherwise; the type is "string".

       3. If, ignoring inter-element whitespace and nodes other than Element and Text nodes, cell has only one child and that child is a time element, then the value is the machine-readable equivalent of the element's contents, if any, and the type is the kind of value that is thus obtained (a month, a date, a yearless date, a time, a local date and time, a time-zone offset, a global date and time, a week, a year, or a duration); abort these steps after completing this one.

          If there is no machine-readable equivalent, then the type is "string" and the value is the empty string.

          If the type is a month, a date, a week, or a year, then change the value to be the instant in time (with no time zone) that describes the earliest moment that the value represents, and change the type to be a local date and time.

          For example, if the cell was <td><time>2011-11</time> then for sorting purposes the value is interpreted as "2011-11-01T00:00:00.000" and the type is treated as a local date and time rather than a month.

          Similarly, if the cell was <td><time datetime="2014">MMXIV</time> then for sorting purposes the value is interpreted as "2014-01-01T00:00:00.000" and the type is treated as a local date and time rather than a year.

       4. The value is the element's textContent. The type is "string".

    4. If type_a and type_b are not equal, then: return "a before b" if type_a is earlier in the following list than type_b, otherwise, return "b before a"; then, abort these steps.

       1. time
       2. yearless date
       3. local date and time
       4. global date and time
       5. time-zone offset
       6. duration
       7. "string"

    5. If value_a and value_b are equal, then return "equal" and abort these steps.

    6. If type_a and type_b are not "string", then: if value_a is earlier than value_b then return "a before b" and abort these steps, otherwise, return "b before a" and abort these steps.

       Values sort in their natural order, with the following additional constraints:

       For time values, 00:00:00.000 is the earliest value and 23:59:59.999 is the latest value.

       For yearless date values, 01-01 is the earliest value and 12-31 is the latest value; 02-28 is earlier than 02-29 which is earlier than 03-01.

       Values that are local date and time compare as if they were in the same time zone.

       For time-zone offset values, -23:59 is the earliest value and +23:59 is the latest value.

    7. Let components_a be the result of parsing the sort key value_a.

       Let components_b be the result of parsing the sort key value_b.

       As described below, components_a and components_b are tuples consisting of a list of n numbers, a list of n number strings, a list of n+1 non-numeric strings, and a list of 2n+1 raw strings, for any non-negative integer value of n (zero or more).

    8. Let order be the result a locale-specific string comparison of components_a's first non-numeric string and components_b's first non-numeric string, in the context of th.

       If order is not "equal" then return order and abort these steps.

    9. If components_a and components_b both have exactly one number, then run these substeps:

       1. If components_a's number is less than components_b's number, return "a before b".

          If components_b's number is less than components_a's number, return "b before a".

       2. Let order be the result a locale-specific string comparison of components_a's second non-numeric string and components_b's second non-numeric string, in the context of th.

          If order is not "equal" then return order and abort these steps.

       3. Let order be the result a locale-specific string comparison of components_a's number string and components_b's number string, in the context of th.

          If order is not "equal" then return order and abort these steps.

       Otherwise, run these substeps:

       1. If components_a has zero numbers but components_b has more than zero numbers, return "a before b".

          If components_b has zero numbers but components_a has more than zero numbers, return "b before a".

       2. If components_a has one number, return "a before b".

          If components_b has one number, return "b before a".

       3. If components_a and components_b have more than one number, run these substeps:

          1. Let count be the smaller of the number of numbers in components_a and the number of numbers in components_b.

          2. For each number in components_a and components_b from the first to the countth, in order: if components_a's number is less than components_b's number, then return "a before b" and abort these steps; otherwise, if components_b's number is less than components_a's number, return "b before a" and abort these steps.

          3. If components_a has fewer numbers than components_b, return "a before b" and abort these steps.

             If components_b has fewer numbers than components_a, return "b before a" and abort these steps.

          4. Let index be zero.

          5. String loop: Let order be the result a locale-specific string comparison of components_a's indexth number string and components_b's indexth number string, in the context of th.

             If order is not "equal" then return order and abort these steps.

          6. Increment index.

          7. Let order be the result a locale-specific string comparison of components_a's indexth separator string and components_b's indexth separator string, in the context of th.

             If order is not "equal" then return order and abort these steps.

          8. If index is less than the number of numbers in components_a and components_b, return to the step labeled string loop.

    10. Let index be zero.

    11. Final loop: Let order be the result a raw string comparison of components_a's nth raw string and components_b's nth raw string.

        If order is not "equal" then return order and abort these steps.

    12. Increment index.

    13. If index is less than the number of raw strings in components_a and components_b, return to the step labeled final loop.

    14. Return "equal".

31. Let new order be a list of tr elements consisting of the tr elements of all the groups in the newly ordered groups, with the tr elements being in the same order as the groups to which they belong are in groups, and the tr elements within each such group themselves being ordered in tree order.

32. Remove all the tr elements in new order from their parents, in tree order.

33. Insert all the tr elements in new order into the DOM at the location of insertion point, in the order these elements are found in new order.

34. Remove insertion point from the DOM.

35. Increment loop: If there are no tr or tbody children of table that are later siblings of the element pointed to by row collection cursor, then jump to the step labeled end below.

36. Let row collection cursor point to the next tr or tbody child of table that is a later sibling of the element pointed to by row collection cursor.

37. Return to the step labeled row loop above.

38. End: Set table's currently-sorting flag to false.

When a user agent is to parse the sort key value, it must run the following steps. These return a tuple consisting of a list of n numbers, a list of n number strings, a list of n+1 non-numeric strings, and a list of 2n+1 raw strings, respectively, for any non-negative integer value of n (zero or more).

1. Let raw strings be a list of strings initially containing just one entry, an empty string.

2. Let negatives prejudiced be false.

   Let decimals prejudiced be false.

   Let exponents prejudiced be false.

3. Let buffer be the empty string.

   Let index be zero.

   Let mode be "separator".

   When a subsequent step in this algorithm says to push the buffer, the user agent must run the following substeps:

   1. Add an entry to raw strings that consists of the value of buffer.

   2. Add an entry to raw strings that is the empty string.

   3. Decrement index by one.

   4. Set mode to "separator".

4. Let checkpoint buffer be the empty string.

   Let checkpoint index be zero.

   When a subsequent step in this algorithm says to checkpoint, the user agent must run the following substeps:

   1. Set the checkpoint buffer to the value of buffer.

   2. Set the checkpoint index to the value of index.

   When a subsequent step in this algorithm says to push the checkpoint, the user agent must run the following substeps:

   1. Add an entry to raw strings that consists of the value of checkpoint buffer.

   2. Add an entry to raw strings that is the empty string.

   3. Decrement index by one.

   4. Set mode to "separator".

5. Run through the following steps repeatedly until the condition in the last step is met.

   1. Top of loop: If index is equal to or greater than the number of characters in value, let c be EOF. Otherwise, let c be the indexth character in value.

   2. Run the appropriate steps from the following list:

      If mode is "separator"

      Run the appropriate substeps from the following list:

      If c is a space character

      Set negatives prejudiced to false.

      Set decimals prejudiced to false.

      Set exponents prejudiced to false.

      Append c to the last entry in raw strings.

      If c is a "-" (U+002D) character and negatives prejudiced is false

      Set buffer to the value of c.

      Set mode to "negative".

      If c is a "." (U+002E) character and decimals prejudiced is false

      Set buffer to the value of c.

      Set mode to "leading-decimal".

      If c is an ASCII digit

      Set buffer to the value of c.

      Set mode to "integral".

      If c is an uppercase ASCII letter or a lowercase ASCII letter

      Set exponents prejudiced to true.

      Append c to the last entry in raw strings.

      If c is EOF

      Do nothing.

      Otherwise

      Append c to the last entry in raw strings.

      If mode is "negative"

      Run the appropriate substeps from the following list:

      If c is a "-" (U+002D) character

      Set negatives prejudiced to true.

      Append buffer to the last entry in raw strings.

      Append c to the last entry in raw strings.

      Set mode to "separator".

      If c is a "." (U+002E) character and decimals prejudiced is false

      Append c to buffer.

      Set mode to "leading-decimal".

      If c is an ASCII digit

      Append c to buffer.

      Set mode to "integral".

      Otherwise

      Append buffer to the last entry in raw strings.

      Decrement index by one.

      Set mode to "separator".

      If mode is "integral"

      Run the appropriate substeps from the following list:

      If c is a "-" (U+002D) character

      Set negatives prejudiced to true.

      Push the buffer.

      If c is a "." (U+002E) character and decimals prejudiced is false

      Checkpoint.

      Append c to buffer.

      Set mode to "decimal".

      If c is an ASCII digit

      Append c to the last entry in raw strings.

      If c is a U+0045 LATIN CAPITAL LETTER E character or a U+0065 LATIN SMALL LETTER E character and exponents prejudiced is false

      Checkpoint.

      Append c to buffer.

      Set mode to "exponent".

      Otherwise

      Push the buffer.

      If mode is "leading-decimal"

      Run the appropriate substeps from the following list:

      If c is an ASCII digit

      Append c to buffer.

      Set mode to "decimal".

      Otherwise

      Append buffer to the last entry in raw strings.

      Decrement index by one.

      Set mode to "separator".

      If mode is "decimal"

      Run the appropriate substeps from the following list:

      If c is a "-" (U+002D) character

      Set negatives prejudiced to true.

      Push the buffer.

      If c is a "." (U+002E) character and numbers are coming is true

      Set decimals prejudiced to true.

      Push the checkpoint.

      If c is a "." (U+002E) character and numbers are not coming is true

      Push the buffer.

      If c is an ASCII digit

      Append c to buffer.

      If c is a U+0045 LATIN CAPITAL LETTER E character or a U+0065 LATIN SMALL LETTER E character and exponents prejudiced is false

      Checkpoint.

      Append c to buffer.

      Set mode to "exponent".

      Otherwise

      Push the buffer.

      If mode is "exponent"

      Run the appropriate substeps from the following list:

      If c is a "-" (U+002D) character and negatives prejudiced is false

      Append c to buffer.

      Set mode to "exponent-negative".

      If c is a "." (U+002E) character

      Set decimals prejudiced to true.

      Push the checkpoint.

      If c is an ASCII digit

      Append c to buffer.

      Set mode to "exponent-number".

      If c is a U+0045 LATIN CAPITAL LETTER E character or a U+0065 LATIN SMALL LETTER E character

      Set exponents prejudiced to true.

      Push the checkpoint.

      Otherwise

      Push the checkpoint.

      If mode is "exponent-negative"

      Run the appropriate substeps from the following list:

      If c is a "-" (U+002D) character

      Set negatives prejudiced to true.

      Push the checkpoint.

      If c is a "." (U+002E) character

      Set decimals prejudiced to true.

      Push the checkpoint.

      If c is an ASCII digit

      Append c to buffer.

      Set mode to "exponent-negative-number".

      If c is a U+0045 LATIN CAPITAL LETTER E character or a U+0065 LATIN SMALL LETTER E character

      Set exponents prejudiced to true.

      Push the checkpoint.

      Otherwise

      Push the checkpoint.

      If mode is "exponent-number"

      Run the appropriate substeps from the following list:

      If c is a "-" (U+002D) character

      Set negatives prejudiced to true.

      Push the buffer.

      If c is a "." (U+002E) character

      Set decimals prejudiced to true.

      Push the checkpoint.

      If c is an ASCII digit

      Append c to buffer.

      If c is a U+0045 LATIN CAPITAL LETTER E character or a U+0065 LATIN SMALL LETTER E character

      Set exponents prejudiced to true.

      Push the checkpoint.

      Otherwise

      Push the buffer.

      If mode is "exponent-negative-number"

      Run the appropriate substeps from the following list:

      If c is a "-" (U+002D) character

      Set negatives prejudiced to true.

      Push the checkpoint.

      If c is a "." (U+002E) character

      Set decimals prejudiced to true.

      Push the checkpoint.

      If c is an ASCII digit

      Append c to buffer.

      If c is a U+0045 LATIN CAPITAL LETTER E character or a U+0065 LATIN SMALL LETTER E character

      Set exponents prejudiced to true.

      Push the checkpoint.

      Otherwise

      Push the buffer.

   3. Increment index by one.

   4. If index is greater than the number of characters in value, stop repeating these substeps and continue along the overall steps. Otherwise, return to the step labeled top of loop.

6. Let numbers be an empty list.

   Let number strings be an empty list.

   Let non-numeric strings be an empty list.

7. For each even-numbered entry in raw strings, in order, starting from the first entry (numbered 0), append an entry to non-numeric strings that consists of the result of trimming and collapsing the value of the entry.

8. If raw strings has more than one entry, then, for each odd-numbered entry in raw strings, in order, starting from the second entry (numbered 1), append an entry to number strings that consists of the value of the entry, and append an entry to number strings that consists of the result of parsing the value of the entry using the rules for parsing floating-point number values.

9. Return numbers, number strings, non-numeric strings, and raw strings respectively.

When the user agent is required by the step above to perform a locale-specific string comparison of two strings a and b in the context of an element e, the user agent must apply the Unicode Collation Algorithm, using the Default Unicode Collation Element Table as customized for the language of the element e in the Common Locale Data Repository, to the strings a and b, ignoring case. If the result of this algorithm places a first, then return "a before b"; if it places b first, then return "b before a"; otherwise, if they compare as equal, then return "equal". [UCA] [CLDR]

When the user agent is required by the step above to perform a raw string comparison of two strings a and b, the user agent must apply the Unicode Collation Algorithm, using the Default Unicode Collation Element Table without customizations, to the strings a and b. If the result of this algorithm places a first, then return "a before b"; if it places b first, then return "b before a"; otherwise, if they compare as equal, then return "equal". [UCA]

Where the steps above refer to trimming and collapsing a string value, it means running the following algorithm:

1. Strip leading and trailing whitespace from value.

2. Replace any sequence of one or more space characters in value with a single U+0020 SPACE character.

---

When any of the descendants of a sorting-enabled table element change in any way (including attributes changing), and when a table element becomes a sorting-enabled table element, the table element is said to become a table with a pending sort.

When the user agent is to sort the tables with pending sorts, which happens during the perform a microtask checkpoint algorithm, the user agent must run the following algorithm:

1. Let tables be a list of each table in the unit of related similar-origin browsing contexts that is a table with a pending sort, in the order that they became such, with those that become such at the same time being listed in tree order.

2. Let all the table elements in tables no longer be tables with a pending sort.

3. Apply the table sorting algorithm to each table in tables, in order.

---

When the user agent is to set the sort key to a th element target, it must run the following algorithm:

1. Let table be the table of the table of which target is a header cell.

2. If th is a sorting-enabled th element whose column key ordinality is 1, then: if its column sort direction is normal, set that element's sorted attribute to the string "reversed", otherwise, set it to the empty string; then, abort these steps.

3. Let current headers be the sorting-enabled th elements of the table element table, excluding target.

4. Sort current headers by their sorted attributes' column key ordinality, in ascending order, with elements that have the same column key ordinality being sorted in tree order.

5. Let level be 2.

6. For each th element th in current headers, in order, run the following substeps:

   1. If th's sorted attribute's column sort direction is normal, then set th's sorted attribute to a valid integer whose value is level. Otherwise, set it to the concatenation of the string "reversed", a U+0020 SPACE character, and a valid integer whose value is level.

   2. Increment level by 1.

7. Set target's sorted attribute to the empty string.

---

The activation behavior of a sorting interface th element is to set the sort key to the th element.

The table will be sorted the next time the user agent performs a microtask checkpoint.

The th element's sort() method, when invoked, must run the following steps:

1. If the th element is not a sorting-capable th element, then abort these steps.

2. Set the sort key to the th element.

   The table will be sorted the next time the user agent performs a microtask checkpoint.

The table element's stopSorting() method, when invoked, must remove the sorted attribute of all the sorting-enabled th elements of the table element on which the method was invoked.

<table>
 <caption>Specification values: <b>Steel</b>, <b>Castings</b>,
 Ann. A.S.T.M. A27-16, Class B;* P max. 0.06; S max. 0.05.</caption>
 <thead>
  <tr>
   <th rowspan=2>Grade.</th>
   <th rowspan=2>Yield Point.</th>
   <th colspan=2>Ultimate tensile strength</th>
   <th rowspan=2>Per cent elong. 50.8mm or 2 in.</th>
   <th rowspan=2>Per cent reduct. area.</th>
  </tr>
  <tr>
   <th>kg/mm<sup>2</sup></th>
   <th>lb/in<sup>2</sup></th>
  </tr>
 </thead>
 <tbody>
  <tr>
   <td>Hard</td>
   <td>0.45 ultimate</td>
   <td>56.2</td>
   <td>80,000</td>
   <td>15</td>
   <td>20</td>
  </tr>
  <tr>
   <td>Medium</td>
   <td>0.45 ultimate</td>
   <td>49.2</td>
   <td>70,000</td>
   <td>18</td>
   <td>25</td>
  </tr>
  <tr>
   <td>Soft</td>
   <td>0.45 ultimate</td>
   <td>42.2</td>
   <td>60,000</td>
   <td>22</td>
   <td>30</td>
  </tr>
 </tbody>
</table>

<table>
 <thead>
  <tr>
   <th>
   <th>2008
   <th>2007
   <th>2006
 <tbody>
  <tr>
   <th>Net sales
   <td>$ 32,479
   <td>$ 24,006
   <td>$ 19,315
  <tr>
   <th>Cost of sales
   <td>  21,334
   <td>  15,852
   <td>  13,717
 <tbody>
  <tr>
   <th>Gross margin
   <td>$ 11,145
   <td>$  8,154
   <td>$  5,598
 <tfoot>
  <tr>
   <th>Gross margin percentage
   <td>34.3%
   <td>34.0%
   <td>29.0%
</table>

<table>
 <colgroup> <col>
 <colgroup> <col> <col> <col>
 <thead>
  <tr> <th> <th>2008 <th>2007 <th>2006
 <tbody>
  <tr> <th scope=rowgroup> Research and development
       <td> $ 1,109 <td> $ 782 <td> $ 712
  <tr> <th scope=row> Percentage of net sales
       <td> 3.4% <td> 3.3% <td> 3.7%
 <tbody>
  <tr> <th scope=rowgroup> Selling, general, and administrative
       <td> $ 3,761 <td> $ 2,963 <td> $ 2,433
  <tr> <th scope=row> Percentage of net sales
       <td> 11.6% <td> 12.3% <td> 12.6%
</table>