<!DOCTYPE html>
% my $lang = app->localize->preference // 'en';
% my $desc = loc('korap_desc');
% my $keywords = loc('korap_keywords');
<html lang="<%= $lang %>" xml:lang="<%= $lang %>" xmlns="http://www.w3.org/1999/xhtml" xmlns:og="http://opengraphprotocol.org/schema/">
  <head prefix="og: http://ogp.me/ns# website: http://ogp.me/ns/website#">
    <title><%= title() // loc('korap_desc') %></title>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0, user-scalable=false, user-scalable=no" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1" />
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    <meta http-equiv="Content-Style-Type" content="text/css" />
    <meta http-equiv="Content-Script-Type" content="text/javascript" />
    <meta name="msapplication-TileImage" content="<%= url_for '/img/windows-tile.png' %>" />
    <meta name="msapplication-TileColor" content="#9bad0b" />
    <meta name="robots" content="<%= stash('robots') || 'noindex' %>" />
    <meta name="apple-mobile-web-app-status-bar-style" content="default" />
    <meta name="description" content="<%= $desc %>" />
    <meta name="language" content="<%= $lang %>" />
    <meta name="author" content="The KorAP Team" />
    <meta name="DC.type" content="service" />
    <meta name="DC.creator" content="IDS Mannheim" />
    <meta name="DC.title" content="<%= title() || loc('korap_short') %>" />
    <meta name="DC.description" content="<%= $desc %>" />
    <meta name="DC.format" content="text/html" />
    <meta name="DC.contributor" content="The KorAP Team" />
    <meta name="DC.publisher" content="IDS Mannheim" />
    <meta name="DC.language" content="<%= $lang %>" />
    <meta property="og:url" content="<%= url_for->to_abs %>" />
    <meta property="og:locale" content="<%= $lang %>" />
    <meta property="og:description" content="<%= $desc %>" />
    <meta property="og:image" content="<%= url_for '/img/korap-200.png' %>" />
    <meta property="og:image:width" content="200" />
    <meta property="og:image:height" content="200" />
    <meta name="twitter:image" content="<%= url_for '/img/korap-280.png' %>" />
    <meta name="twitter:description" content="<%= $desc %>" />
    <meta name="geo.region" content="<%= loc 'korap_region' %>" />
    <meta name="geo.placename" content="<%= loc 'korap_placename' %>" />
    <meta name="keywords" content="<%= $keywords %>" />
    <meta name="DC.subject" content="<%= $keywords %>" />

    <link rel="apple-touch-icon" href="<%= url_for '/img/apple-touch-icon.png' %>" />
    <link href="<%= stash 'prefix' %>/favicon.ico" rel="shortcut icon" type="image/x-icon" /> 
    
%= javascript begin  
  window.KorAP = window.KorAP || {};
  % my $api = url_for('index');
  % $api =~ s!/$!!;
  KorAP.URL = '<%== $api %>';
% end

% if ($c->app->mode eq 'development') {
    <link href="<%= stash 'prefix' %>/css/kalamar-<%= $Kalamar::VERSION %>.css?v=<%= random_string %>" type="text/css" rel="stylesheet" />
    <script data-main="/js/src/app/devel" src="/js/lib/require.js" async="async"></script>
% } else {
    <link href="<%= stash 'prefix' %>/css/kalamar-<%= $Kalamar::VERSION %>.css" type="text/css" rel="stylesheet" />
    <script src="<%= (stash('prefix') // '') . '/js/' . loc('jsFile', 'kalamar-' . $Kalamar::VERSION . '-en.js') %>" async="async"></script>
% };
      
    
  </head>
% my $embedded = 0;
% $embedded = 1 if stash('embedded');
  <body class="no-js<% if ($embedded) { %> embedded<% } %>" itemscope itemtype="http://schema.org/<%= stash('schematype') || 'WebApplication' %>">
    <script>document.body.classList.remove('no-js');</script>
    <div id="kalamar-bg"></div>
    
    %= include 'partial/side', embedded => $embedded
    
    % unless ($embedded) {
      %= include 'partial/header'
    % }

    <noscript>
      <p id="activate"><%= loc 'activateJS' %></p>
    </noscript>
    
    <main<% if (stash 'main_class') { %> class="<%= stash 'main_class' %>"<% } %>>
    %= content
    </main>

    % unless ($embedded) {
      %= include 'partial/footer'
    % };
    %= notifications 'Kalamar::Plugin::Notifications'

    %= content_block 'scripts'
    
  </body>
</html>
