<!--
	Copyright 2009 The Go Authors. All rights reserved.
	Use of this source code is governed by a BSD-style
	license that can be found in the LICENSE file.
-->
<!--
	Note: Static (i.e., not template-generated) href and id
	attributes start with "pkg-" to make it impossible for
	them to conflict with generated attributes (some of which
	correspond to Go identifiers).
-->
{{with .PDoc}}
	{{if $.IsMain}}
		{{/* command documentation */}}
		{{comment_html .Doc}}
	{{else}}
		{{/* package documentation */}}
		<div id="short-nav">
			<dl>
			<dd><code>import "{{html .ImportPath}}"</code></dd>
			</dl>
			<dl>
			<dd><a href="#pkg-overview" class="overviewLink">Overview</a></dd>
			<dd><a href="#pkg-index" class="indexLink">Index</a></dd>
			{{if $.Examples}}
				<dd><a href="#pkg-examples" class="examplesLink">Examples</a></dd>
			{{end}}
			{{if $.Dirs}}
				<dd><a href="#pkg-subdirectories">Subdirectories</a></dd>
			{{end}}
			</dl>
		</div>
		<!-- The package's Name is printed as title by the top-level template -->
		<div id="pkg-overview" class="toggleVisible">
			<div class="collapsed">
				<h2 class="toggleButton" title="Click to show Overview section">Overview ▹</h2>
			</div>
			<div class="expanded">
				<h2 class="toggleButton" title="Click to hide Overview section">Overview ▾</h2>
				{{comment_html .Doc}}
				{{example_html $ ""}}
			</div>
		</div>

		<div id="pkg-index" class="toggleVisible">
		<div class="collapsed">
			<h2 class="toggleButton" title="Click to show Index section">Index ▹</h2>
		</div>
		<div class="expanded">
			<h2 class="toggleButton" title="Click to hide Index section">Index ▾</h2>

		<!-- Table of contents for API; must be named manual-nav to turn off auto nav. -->
			<div id="manual-nav">
			<dl>
			{{if .Consts}}
				<dd><a href="#pkg-constants">Constants</a></dd>
			{{end}}
			{{if .Vars}}
				<dd><a href="#pkg-variables">Variables</a></dd>
			{{end}}
			{{range .Funcs}}
				{{$name_html := html .Name}}
				<dd><a href="#{{$name_html}}">{{node_html $ .Decl false | sanitize}}</a></dd>
			{{end}}
			{{range .Types}}
				{{$tname_html := html .Name}}
				<dd><a href="#{{$tname_html}}">type {{$tname_html}}</a></dd>
				{{range .Funcs}}
					{{$name_html := html .Name}}
					<dd>&nbsp; &nbsp; <a href="#{{$name_html}}">{{node_html $ .Decl false | sanitize}}</a></dd>
				{{end}}
				{{range .Methods}}
					{{$name_html := html .Name}}
					<dd>&nbsp; &nbsp; <a href="#{{$tname_html}}.{{$name_html}}">{{node_html $ .Decl false | sanitize}}</a></dd>
				{{end}}
			{{end}}
			{{if $.Notes}}
				{{range $marker, $item := $.Notes}}
				<dd><a href="#pkg-note-{{$marker}}">{{noteTitle $marker | html}}s</a></dd>
				{{end}}
			{{end}}
			</dl>
			</div><!-- #manual-nav -->

		{{if $.Examples}}
		<div id="pkg-examples">
			<h3>Examples</h3>
			<div class="js-expandAll expandAll collapsed">(Expand All)</div>
			<dl>
			{{range $.Examples}}
			<dd><a class="exampleLink" href="#example_{{.Name}}">{{example_name .Name}}</a></dd>
			{{end}}
			</dl>
		</div>
		{{end}}

		{{with .Filenames}}
			<h3>Package files</h3>
			<p>
			<span style="font-size:90%">
			{{range .}}
				<a href="{{.|srcLink|html}}">{{.|filename|html}}</a>
			{{end}}
			</span>
			</p>
		{{end}}
		</div><!-- .expanded -->
		</div><!-- #pkg-index -->

		{{with .Consts}}
			<h2 id="pkg-constants">Constants</h2>
			{{range .}}
				{{comment_html .Doc}}
				<pre>{{node_html $ .Decl true}}</pre>
			{{end}}
		{{end}}
		{{with .Vars}}
			<h2 id="pkg-variables">Variables</h2>
			{{range .}}
				{{comment_html .Doc}}
				<pre>{{node_html $ .Decl true}}</pre>
			{{end}}
		{{end}}
		{{range .Funcs}}
			{{/* Name is a string - no need for FSet */}}
			{{$name_html := html .Name}}
			<h2 id="{{$name_html}}">func <a href="{{posLink_url $ .Decl}}">{{$name_html}}</a>
				<a class="permalink" href="#{{$name_html}}">&#xb6;</a>
				{{$since := since "func" "" .Name $.PDoc.ImportPath}}
				{{if $since}}<span title="Added in Go {{$since}}">{{$since}}</span>{{end}}
			</h2>
			<pre>{{node_html $ .Decl true}}</pre>
			{{comment_html .Doc}}
			{{example_html $ .Name}}

		{{end}}
		{{range .Types}}
			{{$tname := .Name}}
			{{$tname_html := html .Name}}
			<h2 id="{{$tname_html}}">type <a href="{{posLink_url $ .Decl}}">{{$tname_html}}</a>
				<a class="permalink" href="#{{$tname_html}}">&#xb6;</a>
				{{$since := since "type" "" .Name $.PDoc.ImportPath}}
				{{if $since}}<span title="Added in Go {{$since}}">{{$since}}</span>{{end}}
			</h2>
			{{comment_html .Doc}}
			<pre>{{node_html $ .Decl true}}</pre>

			{{range .Consts}}
				{{comment_html .Doc}}
				<pre>{{node_html $ .Decl true}}</pre>
			{{end}}

			{{range .Vars}}
				{{comment_html .Doc}}
				<pre>{{node_html $ .Decl true}}</pre>
			{{end}}

			{{example_html $ $tname}}

			{{range .Funcs}}
				{{$name_html := html .Name}}
				<h3 id="{{$name_html}}">func <a href="{{posLink_url $ .Decl}}">{{$name_html}}</a>
					<a class="permalink" href="#{{$name_html}}">&#xb6;</a>
					{{$since := since "func" "" .Name $.PDoc.ImportPath}}
					{{if $since}}<span title="Added in Go {{$since}}">{{$since}}</span>{{end}}
				</h3>
				<pre>{{node_html $ .Decl true}}</pre>
				{{comment_html .Doc}}
				{{example_html $ .Name}}
			{{end}}

			{{range .Methods}}
				{{$name_html := html .Name}}
				<h3 id="{{$tname_html}}.{{$name_html}}">func ({{html .Recv}}) <a href="{{posLink_url $ .Decl}}">{{$name_html}}</a>
					<a class="permalink" href="#{{$tname_html}}.{{$name_html}}">&#xb6;</a>
					{{$since := since "method" .Recv .Name $.PDoc.ImportPath}}
					{{if $since}}<span title="Added in Go {{$since}}">{{$since}}</span>{{end}}
				</h3>
				<pre>{{node_html $ .Decl true}}</pre>
				{{comment_html .Doc}}
				{{$name := printf "%s_%s" $tname .Name}}
				{{example_html $ $name}}
			{{end}}
		{{end}}
	{{end}}

	{{with $.Notes}}
		{{range $marker, $content := .}}
			<h2 id="pkg-note-{{$marker}}">{{noteTitle $marker | html}}s</h2>
			<ul style="list-style: none; padding: 0;">
			{{range .}}
			<li><a href="{{posLink_url $ .}}" style="float: left;">&#x261e;</a> {{comment_html .Body}}</li>
			{{end}}
			</ul>
		{{end}}
	{{end}}
{{end}}

{{with .PAst}}
	{{range $filename, $ast := .}}
		<a href="{{$filename|srcLink|html}}">{{$filename|filename|html}}</a>:<pre>{{node_html $ $ast false}}</pre>
	{{end}}
{{end}}

{{with .Dirs}}
	{{/* DirList entries are numbers and strings - no need for FSet */}}
	{{if $.PDoc}}
		<h2 id="pkg-subdirectories">Subdirectories</h2>
	{{end}}
	<div class="pkg-dir">
		<table>
			<tr>
				<th class="pkg-name">Name</th>
				<th class="pkg-synopsis">Synopsis</th>
			</tr>

			{{if not (or (eq $.Dirname "/src/cmd") $.DirFlat)}}
			<tr>
				<td colspan="2"><a href="..">..</a></td>
			</tr>
			{{end}}

			{{range .List}}
				<tr>
				{{if $.DirFlat}}
					{{if .HasPkg}}
						<td class="pkg-name">
							<a href="{{html .Path}}/{{modeQueryString $.Mode | html}}">{{html .Path}}</a>
						</td>
					{{end}}
				{{else}}
					<td class="pkg-name" style="padding-left: {{multiply .Depth 20}}px;">
						<a href="{{html .Path}}/{{modeQueryString $.Mode | html}}">{{html .Name}}</a>
					</td>
				{{end}}
					<td class="pkg-synopsis">
						{{html .Synopsis}}
					</td>
				</tr>
			{{end}}
		</table>
	</div>
{{end}}
