<!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>
		<title>CSS Test: rgba() colors</title>
		<link rel="author" title="L. David Baron" href="https://dbaron.org/" />
		<link rel="author" title="Mozilla Corporation" href="http://mozilla.com/" />
		<link rel="help" href="http://www.w3.org/TR/css3-color/#rgba-color" />
		<link rel="match" href="t32-opacity-basic-0.0-a-ref.html" />
		<meta name="flags" content="" />
		<meta name="assert" content="Opacity of 0.0 makes text transparent." />
		<style type="text/css"><![CDATA[
			html, body { background: white; }
			#one { color: rgb(0, 0, 0); }
			#two { color: rgba(0, 0, 0, 0); }
		]]></style>
	</head>
	<body>
		<p id="one">This should be the only text visible on this page.</p>
		<p id="two">This text should NOT be visible.</p>
	</body>
</html>
