<!doctype html>

<!--
// Licensed under the Apache License, Version 2.0 (the "License"); you may not
// use this file except in compliance with the License. You may obtain a copy of
// the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
// License for the specific language governing permissions and limitations under
// the License.
-->

<html lang="en">
<head>
  <meta charset="utf-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
  <meta name="viewport" content="width=device-width,initial-scale=1">
  <meta http-equiv="Content-Language" content="en" />

  <title>Project Fauxton</title>

  <!-- Application styles. -->
  <link rel="stylesheet" href="<%= css %>">
  <% if (base) { %>
  <base href="<%= base %>"></base>
  <% } %>
</head>

<body id="home">
  <!-- Main container. -->
  <div role="main" id="main">
    <div id="global-notifications" class="container errors-container"></div>
    <div id="app-container"></div>

    <footer>
      <div id="footer-content"></div>
    </footer>
  </div>

  <!-- Application source. -->
  <script data-main="/config" src="<%= requirejs %>"></script>
</body>
</html>
