<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"/>
<title>About</title>
</head>
<body lang="EN-US">
<h2>About This Content</h2>

<p>November 6, 2016</p>
<h3>License</h3>

<p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise
indicated below, the Content is provided to you under the terms and conditions of the
Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available
at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>

<p>If you did not receive this Content directly from the Eclipse Foundation, the Content is
being redistributed by another party (&quot;Redistributor&quot;) and different terms and conditions may
apply to your use of any object code in the Content.  Check the Redistributor's license that was
provided with the Content.  If no such license exists, contact the Redistributor.  Unless otherwise
indicated below, the terms and conditions of the EPL still apply to any source code in the Content
and such source code may be obtained at <a href="http://www.eclipse.org/">http://www.eclipse.org</a>.</p>

<h3>Third Party Content</h3>
<p>The Content includes items that have been sourced from third parties as set out below. If you
did not receive this Content directly from the Eclipse Foundation, the following is provided
for informational purposes only, and you should look to the Redistributor's license for
terms and conditions of use.</p>

<h4>Closure Compiler</h4>

<p>The plug-in includes software developed by <a href="http://www.google.com" target="_blank">Google</a> as part of the Closure Compiler project.</p>

<p>Closure Compiler is provided to you under the terms and conditions of the <a href="http://www.apache.org/licenses/LICENSE-2.0.html" target="_blank">The Apache Software License, Version 2.0</a> (<a href="about_files/THE_APACHE_SOFTWARE_LICENSE__VERSION_2.0.html" target="_blank">THE_APACHE_SOFTWARE_LICENSE__VERSION_2.0.html</a>) and <a href="https://www.mozilla.org/en-US/MPL/1.1/" target="_blank">The Mozilla Public License Version 1.1</a> (<a href="about_files/MOZILLA_PUBLIC_LICENSE_VERSION__1.1.txt" target="_blank">MOZILLA_PUBLIC_LICENSE_VERSION__1.1.txt</a>) licenses.</p>


<p>Closure Compiler including its source is available from <a href="https://developers.google.com/closure/compiler/" target="_blank">developers.google.com/closure/compiler/</a>. Bugs or feature requests can be made in the project issue tracking system at <a href="http://github.com/google/closure-compiler/issues" target="_blank">github.com/google/closure-compiler/issues</a>.</p>


</body>
</html>
