<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html>
<head>
	<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
	<link href="../book.css" rel="STYLESHEET" CHARSET="ISO-8859-1"	TYPE="text/css">
	<link rel="stylesheet" type="text/css" href="../content/PLUGINS_ROOT/PRODUCT_PLUGIN/book.css">
	<meta content="Copyright (c) 2000, 2010 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v2.0 which accompanies this distribution, and is available at https://www.eclipse.org/legal/epl-2.0/. Contributors: IBM Corporation - initial API and implementation" name="copyright">
	<title>JSDT Features</title>
</head>
<body>
<h1>JSDT Features</h1>

<h3>HTML and JSP With Embedded JavaScript (Requires WST and JST JS Support Plug-ins)</h3>
<ul>
	<li>Syntax Highlighting</li>
	<li>Highlight and check of matching bracket / parenthesis</li>
	<li>Auto-complete of brackets, parentheses and indentation</li>
	<li>Smart Code Completion based on real-time JavaScript Model</li>
	<li>Hover Help that display element declaration and JSDoc or Error message</li>
	<li>Completion Templates</li>
	<li>Indentation Correction</li>
	<li>Extensible customizable Code Formatting</li>
</ul>
</body>
</html>
