<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet type="text/xsl" href="../new_and_noteworthy.xsl"?>
<release
	name="2.0 M6"
	root="../../.."
>
	<!--
		<component name="component name, such as HTML, CSS, etc.">
		<item title="item title can go here">
		<title>item title can also go here</title>
		<description>description of this new feature, preferably with cropped .pngs of the UI</description>
		</item>
		</component>
	-->
	<component name="HTML">
		<item title="New formatting preferences">
			<description>
				Users can now specify if they want the formatter to
				align the end bracket of their start tag with the
				begin bracket for tags that span more than one line.
				The align end bracket preference can be found in the
				HTML <b>Source</b> preference page.
				<br />
				<br />
				<img
					src="web/newnote-formatprefs.png"
					alt="New bracket alignment option"
				/>
			</description>
		</item>
	</component>
</release>
