<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
  <link rel="author" title="Boris Zbarsky" href="mailto:bzbarsky@mit.edu"/>
  <link rel="help" href="http://www.w3.org/TR/CSS21/tables.html#anonymous-boxes"/>
  <link rel="match" href="reference/table-anonymous-text-indent-ref.xht"/>
  <meta name="flags" content='dom'/>
  <script type="text/javascript"><![CDATA[
    function doTest() {
      var t = document.getElementById("target");
      t.style.textIndent = '20px';
    }
    ]]></script>
  <style><![CDATA[
    #target { text-indent: 0; display: table; }
    #target > * { display: table-cell; border: 1px solid black; }
  ]]></style>
</head>
<body onload="doTest()">
  <p>There should be 20px text-indent in the table below.</p>
  <div id="target">
    <div>First cell</div>
    Second cell (no element on purpose)
  </div>
</body>
</html>
