--- /dev/null
+# Hugo Docs
+
+Documentation site for [Hugo](https://github.com/gohugoio/hugo), the very fast and flexible static site generator built with love in GoLang.
+
+## Contributing
+
+We welcome contributions to Hugo of any kind including documentation, suggestions, bug reports, pull requests etc. Also check out our [contribution guide](https://gohugo.io/contribute/documentation/). We would love to hear from you.
+
+Note that this repository contains solely the documentation for Hugo. For contributions that aren't documentation-related please refer to the [hugo](https://github.com/gohugoio/hugo) repository.
+
+*Pull requests shall **only** contain changes to the actual documentation. However, changes on the code base of Hugo **and** the documentation shall be a single, atomic pull request in the [hugo](https://github.com/gohugoio/hugo) repository.*
+
++Spelling fixes are most welcomed, and if you want to contribute longer sections to the documentation, it would be great if you had these in mind when writing:
++
++* Short is good. People go to the library to read novels. If there is more than one way to _do a thing_ in Hugo, describe the current _best practice_ (avoid "… but you can also do …" and "… in older versions of Hugo you had to …".
++* For examples, try to find short snippets that teaches people about the concept. If the example is also useful as-is (copy and paste), then great, but don't list long and similar examples just so people can use them on their sites.
++* Hugo has users from all over the world, so an easy to understand and [simple English](https://simple.wikipedia.org/wiki/Basic_English) is good.
++
+## Branches
+
+* The `master` branch is where the site is automatically built from, and is the place to put changes relevant to the current Hugo version.
+* The `next` branch is where we store changes that is related to the next Hugo release. This can be previewed here: https://next--gohugoio.netlify.com/
+
+## Build
+
+To view the documentation site locally, you need to clone this repository:
+
+```bash
+git clone https://github.com/gohugoio/hugoDocs.git
+```
+
+Also note that the documentation version for a given version of Hugo can also be found in the `/docs` sub-folder of the [Hugo source repository](https://github.com/gohugoio/hugo).
+
+Then to view the docs in your browser, run Hugo and open up the link:
+
+```bash
+▶ hugo server
+
+Started building sites ...
+.
+.
+Serving pages from memory
+Web Server is available at http://localhost:1313/ (bind address 127.0.0.1)
+Press Ctrl+C to stop
+```
--- /dev/null
- description: Archetypes allow you to create new instances of content types and set default parameters from the command line.
+---
+title: Archetypes
+linktitle: Archetypes
- lastmod: 2017-02-01
++description: Archetypes are templates used when creating new content.
+date: 2017-02-01
+publishdate: 2017-02-01
- {{% note %}}
- This section is outdated, see https://github.com/gohugoio/hugoDocs/issues/11
- {{% /note %}}
- {{% todo %}}
- See above
- {{% /todo %}}
-
+keywords: [archetypes,generators,metadata,front matter]
+categories: ["content management"]
+menu:
+ docs:
+ parent: "content-management"
+ weight: 70
+ quicklinks:
+weight: 70 #rem
+draft: false
+aliases: [/content/archetypes/]
+toc: true
+---
+
- **Archetypes** are content files in the [archetypes directory][] of your project that contain preconfigured [front matter][] for your website's [content types][]. Archetypes facilitate consistent metadata across your website content and allow content authors to quickly generate instances of a content type via the `hugo new` command.
-
- {{< youtube bcme8AzVh6o >}}
-
- The `hugo new` generator for archetypes assumes your working directory is the content folder at the root of your project. Hugo is able to infer the appropriate archetype by assuming the content type from the content section passed to the CLI command:
+## What are Archetypes?
+
- ```
- hugo new <content-section>/<file-name.md>
- ```
++**Archetypes** are content template files in the [archetypes directory][] of your project that contain preconfigured [front matter][] and possibly also a content disposition for your website's [content types][]. These will be used when you run `hugo new`.
+
- We can use this pattern to create a new `.md` file in the `posts` section:
+
- {{% note "Override Content Type in a New File" %}}
- To override the content type Hugo infers from `[content-section]`, add the `--kind` flag to the end of the `hugo new` command.
- {{% /note %}}
-
- Running this command in a new site that does not have default or custom archetypes will create the following file:
-
- {{< output file="content/posts/my-first-post.md" >}}
- +++
- date = "2017-02-01T19:20:04-07:00"
- title = "my first post"
- draft = true
- +++
- {{< /output >}}
-
- {{% note %}}
- In this example, if you do not already have a `content/posts` directory, Hugo will create both `content/posts/` and `content/posts/my-first-post.md` for you.
- {{% /note %}}
-
- The auto-populated fields are worth examining:
-
- * `title` is generated from the new content's filename (i.e. in this case, `my-first-post` becomes `"my first post"`)
- * `date` and `title` are the variables that ship with Hugo and are therefore included in *all* content files created with the Hugo CLI. `date` is generated in [RFC 3339 format][] by way of Go's [`now()`][] function, which returns the current time.
- * The third variable, `draft = true`, is *not* inherited by your default or custom archetypes but is included in Hugo's automatically scaffolded `default.md` archetype for convenience.
-
- Three variables per content file are often not enough for effective content management of larger websites. Luckily, Hugo provides a simple mechanism for extending the number of variables through custom archetypes, as well as default archetypes to keep content creation DRY.
-
- ## Lookup Order for Archetypes
-
- Similar to the [lookup order for templates][lookup] in your `layouts` directory, Hugo looks for a section- or type-specific archetype, then a default archetype, and finally an internal archetype that ships with Hugo. For example, Hugo will look for an archetype for `content/posts/my-first-post.md` in the following order:
++The `hugo new` uses the `content-section` to find the most suitable archetype template in your project. If your project does not contain any archetype files, it will also look in the theme.
+
+{{< code file="archetype-example.sh" >}}
+hugo new posts/my-first-post.md
+{{< /code >}}
+
- 3. `themes/<THEME>/archetypes/posts.md`
- 4. `themes/<THEME>/archetypes/default.md` (Auto-generated with `hugo new site`)
-
- {{% note "Using a Theme Archetype" %}}
- If you wish to use archetypes that ship with a theme, the `theme` field must be specified in your [configuration file](/getting-started/configuration/).
- {{% /note %}}
-
- ## Choose Your Archetype's Front Matter Format
-
- By default, `hugo new` content files include front matter in the TOML format regardless of the format used in `archetypes/*.md`.
-
- You can specify a different default format in your site [configuration file][] file using the `metaDataFormat` directive. Possible values are `toml`, `yaml`, and `json`.
-
- ## Default Archetypes
-
- Default archetypes are convenient if your content's front matter stays consistent across multiple [content sections][sections].
++The above will create a new content file in `content/posts/my-first-post.md` using the first archetype file found of these:
+
+1. `archetypes/posts.md`
+2. `archetypes/default.md`
- ### Create the Default Archetype
++3. `themes/my-theme/posts.md`
++4. `themes/my-theme/default.md`
+
- When you create a new Hugo project using `hugo new site`, you'll notice that Hugo has already scaffolded a file at `archetypes/default.md`.
++The last two list items is only applicable if you use a theme and it uses the `my-theme` theme name as an example.
+
- The following examples are from a site that's using `tags` and `categories` as [taxonomies][]. If we assume that all content files will require these two key-values, we can create a `default.md` archetype that *extends* Hugo's base archetype. In this example, we are including "golang" and "hugo" as tags and "web development" as a category.
++## Create a New Archetype Template
+
- {{< code file="archetypes/default.md" >}}
- +++
- tags = ["golang", "hugo"]
- categories = ["web development"]
- +++
- {{< /code >}}
-
- {{% warning "EOL Characters in Text Editors"%}}
- If you get an `EOF error` when using `hugo new`, add a carriage return after the closing `+++` or `---` for your TOML or YAML front matter, respectively. (See the [troubleshooting article on EOF errors](/troubleshooting/eof-error/) for more information.)
- {{% /warning %}}
-
- ### Use the Default Archetype
-
- With an `archetypes/default.md` in place, we can use the CLI to create a new post in the `posts` content section:
-
- {{< code file="new-post-from-default.sh" >}}
- $ hugo new posts/my-new-post.md
- {{< /code >}}
-
- Hugo then creates a new markdown file with the following front matter:
-
- {{< output file="content/posts/my-new-post.md" >}}
- +++
- categories = ["web development"]
- date = "2017-02-01T19:20:04-07:00"
- tags = ["golang", "hugo"]
- title = "my new post"
- +++
- {{< /output >}}
-
- We see that the `title` and `date` key-values have been added in addition to the `tags` and `categories` key-values from `archetypes/default.md`.
-
- {{% note "Ordering of Front Matter" %}}
- You may notice that content files created with `hugo new` do not respect the order of the key-values specified in your archetype files. This is a [known issue](https://github.com/gohugoio/hugo/issues/452).
- {{% /note %}}
-
- ## Custom Archetypes
-
- Suppose your site's `posts` section requires more sophisticated front matter than what has been specified in `archetypes/default.md`. You can create a custom archetype for your posts at `archetypes/posts.md` that includes the full set of front matter to be added to the two default archetypes fields.
-
- ### Create a Custom Archetype
-
- {{< code file="archetypes/posts.md">}}
- +++
- description = ""
- tags = ""
- categories = ""
- +++
- {{< /code >}}
++A fictional example for the section `newsletter` and the archetype file `archetypes/newsletter.md`. Create a new file in `archetypes/newsletter.md` and open it in a text editor.
+
- ### Use a Custom Archetype
++{{< code file="archetypes/newsletter.md" >}}
++---
++title: "{{ replace .Name "-" " " | title }}"
++date: {{ .Date }}
++draft: true
++---
+
- With an `archetypes/posts.md` in place, you can use the Hugo CLI to create a new post with your preconfigured front matter in the `posts` content section:
++**Insert Lead paragraph here.**
+
- {{< code file="new-post-from-custom.sh" >}}
- $ hugo new posts/post-from-custom.md
++## New Cool Posts
+
- This time, Hugo recognizes our custom `archetypes/posts.md` archetype and uses it instead of `archetypes/default.md`. The generated file will now include the full list of front matter parameters, as well as the base archetype's `title` and `date`:
++{{ range first 10 ( where .Site.RegularPages "Type" "cool" ) }}
++* {{ .Title }}
++{{ end }}
+{{< /code >}}
+
- {{< output file="content/posts/post-from-custom-archetype.md" >}}
- +++
- categories = ""
- date = 2017-02-13T17:24:43-08:00
- description = ""
- tags = ""
- title = "post from custom archetype"
- +++
- {{< /output >}}
++When you create a new newsletter with:
+
- ### Hugo Docs Custom Archetype
++```bash
++hugo new newsletter/the-latest-cool.stuff.md
++```
+
- As an example of archetypes in practice, the following is the `functions` archetype from the Hugo docs:
++It will create a new newsletter type of content file based on the archetype template.
+
- {{< code file="archetypes/functions.md" >}}
- {{< readfile file="/archetypes/functions.md" >}}
- {{< /code >}}
++**Note:** the site will only be built if the `.Site` is in use in the archetype file, and this can be time consuming for big sites.
+
- {{% note %}}
- The preceding archetype is kept up to date with every Hugo build by using Hugo's [`readFile` function](/functions/readfile/). For similar examples, see [Local File Templates](/templates/files/).
- {{% /note %}}
++The above _newsletter type archetype_ illustrates the possibilities: The full Hugo `.Site` and all of Hugo's template funcs can be used in the archetype file.
+
- [`now()`]: http://golang.org/pkg/time/#Now
- [configuration file]: /getting-started/configuration/
- [sections]: /content-management/sections/
+
+[archetypes directory]: /getting-started/directory-structure/
- [RFC 3339 format]: https://www.ietf.org/rfc/rfc3339.txt
- [taxonomies]: /content-management/taxonomies/
- [lookup]: /templates/lookup/
- [templates]: /templates/
+[content types]: /content-management/types/
+[front matter]: /content-management/front-matter/
--- /dev/null
+---
+title: Links and Cross References
+description: Hugo makes it easy to link documents together.
+date: 2017-02-01
+publishdate: 2017-02-01
+lastmod: 2017-03-31
+categories: [content management]
+keywords: ["cross references","references", "anchors", "urls"]
+menu:
+ docs:
+ parent: "content-management"
+ weight: 100
+weight: 100 #rem
+aliases: [/extras/crossreferences/]
+toc: true
+---
+
+
+ The `ref` and `relref` shortcodes link documents together, both of which are [built-in Hugo shortcodes][]. These shortcodes are also used to provide links to headings inside of your content, whether across documents or within a document. The only difference between `ref` and `relref` is whether the resulting URL is absolute (`http://1.com/about/`) or relative (`/about/`), respectively.
+
+## Use `ref` and `relref`
+
+```
+{{</* ref "document.md" */>}}
+{{</* ref "#anchor" */>}}
+{{</* ref "document.md#anchor" */>}}
+{{</* relref "document.md" */>}}
+{{</* relref "#anchor" */>}}
+{{</* relref "document.md#anchor" */>}}
+```
+
+The single parameter to `ref` is a string with a content `documentname` (e.g., `about.md`) with or without an appended in-document `anchor` (`#who`) without spaces.
+
+### Document Names
+
+The `documentname` is the name of a document, including the format extension; this may be just the filename, or the relative path from the `content/` directory. With a document `content/blog/post.md`, either format will produce the same result:
+
+```
+{{</* relref "blog/post.md" */>}} => `/blog/post/`
+{{</* relref "post.md" */>}} => `/blog/post/`
+```
+
+If you have the same filename used across multiple sections, you should only use the relative path format; otherwise, the behavior will be `undefined`. This is best illustrated with an example `content` directory:
+
+```
+.
+└── content
+ ├── events
+ │ └── my-birthday.md
+ ├── galleries
+ │ └── my-birthday.md
+ ├── meta
+ │ └── my-article.md
+ └── posts
+ └── my-birthday.md
+```
+
+To be sure to get the correct reference in this case, use the full path:
+
+{{< code file="content/meta/my-article.md" copy="false" >}}
+{{</* relref "events/my-birthday.md" */>}} => /events/my-birthday/
+{{< /code >}}
+
+### With Multiple Output Formats
+
+If the page exists in multiple [output formats][], `ref` or `relref` can be used with a output format name:
+
+```
+ [Neat]({{</* ref "blog/neat.md" "amp" */>}})
+```
+
+### Anchors
+
+When an `anchor` is provided by itself, the current page’s unique identifier will be appended; when an `anchor` is provided appended to `documentname`, the found page's unique identifier will be appended:
+
+```
+{{</* relref "#anchors" */>}} => #anchors:9decaf7
+{{</* relref "about-hugo/hugo-features.md#content" */>}} => /blog/post/#who:badcafe
+```
+
+The above examples render as follows for this very page as well as a reference to the "Content" heading in the Hugo docs features pageyoursite
+
+```
+{{</* relref "#who" */>}} => #who:9decaf7
+{{</* relref "blog/post.md#who" */>}} => /blog/post/#who:badcafe
+```
+
+More information about document unique identifiers and headings can be found [below]({{< ref "#hugo-heading-anchors" >}}).
+
+### Examples
+
+* `{{</* ref "blog/post.md" */>}}` => `https://example.com/blog/post/`
+* `{{</* ref "post.md#tldr" */>}}` => `https://example.com/blog/post/#tldr:caffebad`
+* `{{</* relref "post.md" */>}}` => `/blog/post/`
+* `{{</* relref "blog/post.md#tldr" */>}}` => `/blog/post/#tldr:caffebad`
+* `{{</* ref "#tldr" */>}}` => `#tldr:badcaffe`
+* `{{</* relref "#tldr" */>}}` => `#tldr:badcaffe`
+
+## Hugo Heading Anchors
+
+When using Markdown document types, Hugo generates heading anchors automatically. The generated anchor for this section is `hugo-heading-anchors`. Because the heading anchors are generated automatically, Hugo takes some effort to ensure that heading anchors are unique both inside a document and across the entire site.
+
+Ensuring heading uniqueness across the site is accomplished with a unique identifier for each document based on its path. Unless a document is renamed or moved between sections *in the filesystem*, the unique identifier for the document will not change: `blog/post.md` will always have a unique identifier of `81df004c333b392d34a49fd3a91ba720`.
+
+`ref` and `relref` were added so you can make these reference links without having to know the document’s unique identifier. (The links in document tables of contents are automatically up-to-date with this value.)
+
+```
+{{</* relref "content-management/cross-references.md#hugo-heading-anchors" */>}}
+/content-management/cross-references/#hugo-heading-anchors:77cd9ea530577debf4ce0f28c8dca242
+```
+
++### Manually Specifying Anchors
++
++For Markdown content files, if the `headerIds` [Blackfriday extension][bfext] is
++enabled (which it is by default), user can manually specify the anchor for any
++heading.
++
++Few examples:
++
++```
++## Alpha 101 {#alpha}
++
++## Version 1.0 {#version-1-dot-0}
++```
+
+[built-in Hugo shortcodes]: /content-management/shortcodes/#using-the-built-in-shortcodes
+[lists]: /templates/lists/
+[output formats]: /templates/output-formats/
+[shortcode]: /content-management/shortcodes/
++[bfext]: /content-management/formats/#blackfriday-extensions
--- /dev/null
- Hugo supports GitHub-flavored markdown's use of triple back ticks, as well as provides a special [`highlight` nested shortcode][hlsc] to render syntax highlighting via [Pygments][]. For usage examples and a complete explanation, see the [syntax highlighting documentation][hl] in [developer tools][].
+---
+title: Supported Content Formats
+linktitle: Supported Content Formats
+description: Markdown and Emacs Org-Mode have native support, and additional formats (e.g. Asciidoc) come via external helpers.
+date: 2017-01-10
+publishdate: 2017-01-10
+lastmod: 2017-04-06
+categories: [content management]
+keywords: [markdown,asciidoc,mmark,pandoc,content format]
+menu:
+ docs:
+ parent: "content-management"
+ weight: 20
+weight: 20 #rem
+draft: false
+aliases: [/content/markdown-extras/,/content/supported-formats/,/doc/supported-formats/,/tutorials/mathjax/]
+toc: true
+---
+
+**Markdown is the main content format** and comes in two flavours: The excellent [Blackfriday project][blackfriday] (name your files `*.md` or set `markup = "markdown"` in front matter) or its fork [Mmark][mmark] (name your files `*.mmark` or set `markup = "mmark"` in front matter), both very fast markdown engines written in Go.
+
+For Emacs users, [goorgeous](https://github.com/chaseadamsio/goorgeous) provides built-in native support for Org-mode (name your files `*.org` or set `markup = "org"` in front matter)
+
+{{% note "Deeply Nested Lists" %}}
+Before you begin writing your content in markdown, Blackfriday has a known issue [(#329)](https://github.com/russross/blackfriday/issues/329) with handling deeply nested lists. Luckily, there is an easy workaround. Use 4-spaces (i.e., <kbd>tab</kbd>) rather than 2-space indentations.
+{{% /note %}}
+
+## Configure BlackFriday Markdown Rendering
+
+You can configure multiple aspects of Blackfriday as show in the following list. See the docs on [Configuration][config] for the full list of explicit directions you can give to Hugo when rendering your site.
+
+{{< readfile file="/content/readfiles/bfconfig.md" markdown="true" >}}
+
+## Extend Markdown
+
+Hugo provides some convenient methods for extending markdown.
+
+### Task Lists
+
+Hugo supports [GitHub-styled task lists (i.e., TODO lists)][gfmtasks] for the Blackfriday markdown renderer. If you do not want to use this feature, you can disable it in your configuration.
+
+#### Example Task List Input
+
+{{< code file="content/my-to-do-list.md" >}}
+- [ ] a task list item
+- [ ] list syntax required
+- [ ] incomplete
+- [x] completed
+{{< /code >}}
+
+#### Example Task List Output
+
+The preceding markdown produces the following HTML in your rendered website:
+
+```
+<ul class="task-list">
+ <li><input type="checkbox" disabled="" class="task-list-item"> a task list item</li>
+ <li><input type="checkbox" disabled="" class="task-list-item"> list syntax required</li>
+ <li><input type="checkbox" disabled="" class="task-list-item"> incomplete</li>
+ <li><input type="checkbox" checked="" disabled="" class="task-list-item"> completed</li>
+</ul>
+```
+
+#### Example Task List Display
+
+The following shows how the example task list will look to the end users of your website. Note that visual styling of lists is up to you. This list has been styled according to [the Hugo Docs stylesheet][hugocss].
+
+- [ ] a task list item
+- [ ] list syntax required
+- [ ] incomplete
+- [x] completed
+
+### Emojis
+
+To add emojis directly to content, set `enableEmoji` to `true` in your [site configuration][config]. To use emojis in templates or shortcodes, see [`emojify` function][].
+
+For a full list of emojis, see the [Emoji cheat sheet][emojis].
+
+### Shortcodes
+
+If you write in Markdown and find yourself frequently embedding your content with raw HTML, Hugo provides built-in shortcodes functionality. This is one of the most powerful features in Hugo and allows you to create your own Markdown extensions very quickly.
+
+See [Shortcodes][sc] for usage, particularly for the built-in shortcodes that ship with Hugo, and [Shortcode Templating][sct] to learn how to build your own.
+
+### Code Blocks
+
- [hl]: /tools/syntax-highlighting/
++Hugo supports GitHub-flavored markdown's use of triple back ticks, as well as provides a special [`highlight` shortcode][hlsc], and syntax highlights those code blocks natively using *Chroma*. Users also have an option to use *Pygments* instead. See the [Syntax Highlighting][hl] section for details.
+
+## Mmark
+
+Mmark is a [fork of BlackFriday][mmark] and markdown superset that is well suited for writing [IETF documentation][ietf]. You can see examples of the syntax in the [Mmark GitHub repository][mmarkgh] or the full syntax on [Miek Gieben's website][].
+
+### Use Mmark
+
+As Hugo ships with Mmark, using the syntax is as easy as changing the extension of your content files from `.md` to `.mmark`.
+
+In the event that you want to only use Mmark in specific files, you can also define the Mmark syntax in your content's front matter:
+
+```
+---
+title: My Post
+date: 2017-04-01
+markup: mmark
+---
+```
+
+{{% warning %}}
+Thare are some features not available in Mmark; one example being that shortcodes are not translated when used in an included `.mmark` file ([#3131](https://github.com/gohugoio/hugo/issues/3137)), and `EXTENSION_ABBREVIATION` ([#1970](https://github.com/gohugoio/hugo/issues/1970)) and the aforementioned GFM todo lists ([#2270](https://github.com/gohugoio/hugo/issues/2270)) are not fully supported. Contributions are welcome.
+{{% /warning %}}
+
+## MathJax with Hugo
+
+[MathJax](http://www.mathjax.org/) is a JavaScript library that allows the display of mathematical expressions described via a LaTeX-style syntax in the HTML (or Markdown) source of a web page. As it is a pure a JavaScript library, getting it to work within Hugo is fairly straightforward, but does have some oddities that will be discussed here.
+
+This is not an introduction into actually using MathJax to render typeset mathematics on your website. Instead, this page is a collection of tips and hints for one way to get MathJax working on a website built with Hugo.
+
+### Enable MathJax
+
+The first step is to enable MathJax on pages that you would like to have typeset math. There are multiple ways to do this (adventurous readers can consult the [Loading and Configuring](http://docs.mathjax.org/en/latest/configuration.html) section of the MathJax documentation for additional methods of including MathJax), but the easiest way is to use the secure MathJax CDN by include a `<script>` tag for the officially recommended secure CDN ([cdn.js.com](https://cdnjs.com)):
+
+{{< code file="add-mathjax-to-page.html" >}}
+<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML">
+</script>
+{{< /code >}}
+
+One way to ensure that this code is included in all pages is to put it in one of the templates that live in the `layouts/partials/` directory. For example, I have included this in the bottom of my template `footer.html` because I know that the footer will be included in every page of my website.
+
+### Options and Features
+
+MathJax is a stable open-source library with many features. I encourage the interested reader to view the [MathJax Documentation](http://docs.mathjax.org/en/latest/index.html), specifically the sections on [Basic Usage](http://docs.mathjax.org/en/latest/index.html#basic-usage) and [MathJax Configuration Options](http://docs.mathjax.org/en/latest/index.html#mathjax-configuration-options).
+
+### Issues with Markdown
+
+{{% note %}}
+The following issues with Markdown assume you are using `.md` for content and BlackFriday for parsing. Using [Mmark](#mmark) as your content format will obviate the need for the following workarounds.
+
+When using Mmark with MathJax, use `displayMath: [['$$','$$'], ['\\[','\\]']]`. See the [Mmark `README.md`](https://github.com/miekg/mmark/wiki/Syntax#math-blocks) for more information. In addition to MathJax, Mmark has been shown to work well with [KaTeX](https://github.com/Khan/KaTeX). See this [related blog post from a Hugo user](http://nosubstance.me/post/a-great-toolset-for-static-blogging/).
+{{% /note %}}
+
+After enabling MathJax, any math entered between proper markers (see the [MathJax documentation][mathjaxdocs]) will be processed and typeset in the web page. One issue that comes up, however, with Markdown is that the underscore character (`_`) is interpreted by Markdown as a way to wrap text in `emph` blocks while LaTeX (MathJax) interprets the underscore as a way to create a subscript. This "double speak" of the underscore can result in some unexpected and unwanted behavior.
+
+### Solution
+
+There are multiple ways to remedy this problem. One solution is to simply escape each underscore in your math code by entering `\_` instead of `_`. This can become quite tedious if the equations you are entering are full of subscripts.
+
+Another option is to tell Markdown to treat the MathJax code as verbatim code and not process it. One way to do this is to wrap the math expression inside a `<div>` `</div>` block. Markdown would ignore these sections and they would get passed directly on to MathJax and processed correctly. This works great for display style mathematics, but for inline math expressions the line break induced by the `<div>` is not acceptable. The syntax for instructing Markdown to treat inline text as verbatim is by wrapping it in backticks (`` ` ``). You might have noticed, however, that the text included in between backticks is rendered differently than standard text (on this site these are items highlighted in red). To get around this problem, we could create a new CSS entry that would apply standard styling to all inline verbatim text that includes MathJax code. Below I will show the HTML and CSS source that would accomplish this (note this solution was adapted from [this blog post](http://doswa.com/2011/07/20/mathjax-in-markdown.html)---all credit goes to the original author).
+
+{{< code file="mathjax-markdown-solution.html" >}}
+<script type="text/x-mathjax-config">
+MathJax.Hub.Config({
+ tex2jax: {
+ inlineMath: [['$','$'], ['\\(','\\)']],
+ displayMath: [['$$','$$'], ['\[','\]']],
+ processEscapes: true,
+ processEnvironments: true,
+ skipTags: ['script', 'noscript', 'style', 'textarea', 'pre'],
+ TeX: { equationNumbers: { autoNumber: "AMS" },
+ extensions: ["AMSmath.js", "AMSsymbols.js"] }
+ }
+});
+</script>
+
+<script type="text/x-mathjax-config">
+ MathJax.Hub.Queue(function() {
+ // Fix <code> tags after MathJax finishes running. This is a
+ // hack to overcome a shortcoming of Markdown. Discussion at
+ // https://github.com/mojombo/jekyll/issues/199
+ var all = MathJax.Hub.getAllJax(), i;
+ for(i = 0; i < all.length; i += 1) {
+ all[i].SourceElement().parentNode.className += ' has-jax';
+ }
+});
+</script>
+{{< /code >}}
+
+
+
+As before, this content should be included in the HTML source of each page that will be using MathJax. The next code snippet contains the CSS that is used to have verbatim MathJax blocks render with the same font style as the body of the page.
+
+{{< code file="mathjax-style.css" >}}
+code.has-jax {
+ font: inherit;
+ font-size: 100%;
+ background: inherit;
+ border: inherit;
+ color: #515151;
+}
+{{< /code >}}
+
+In the CSS snippet, notice the line `color: #515151;`. `#515151` is the value assigned to the `color` attribute of the `body` class in my CSS. In order for the equations to fit in with the body of a web page, this value should be the same as the color of the body.
+
+### Usage
+
+With this setup, everything is in place for a natural usage of MathJax on pages generated using Hugo. In order to include inline mathematics, just put LaTeX code in between `` `$ TeX Code $` `` or `` `\( TeX Code \)` ``. To include display style mathematics, just put LaTeX code in between `<div>$$TeX Code$$</div>`. All the math will be properly typeset and displayed within your Hugo generated web page!
+
+## Additional Formats Through External Helpers
+
+Hugo has a new concept called _external helpers_. It means that you can write your content using [Asciidoc][ascii], [reStructuredText][rest], or [pandoc]. If you have files with associated extensions, Hugo will call external commands to generate the content. ([See the Hugo source code for external helpers][helperssource].)
+
+For example, for Asciidoc files, Hugo will try to call the `asciidoctor` or `asciidoc` command. This means that you will have to install the associated tool on your machine to be able to use these formats. ([See the Asciidoctor docs for installation instructions](http://asciidoctor.org/docs/install-toolchain/)).
+
+To use these formats, just use the standard extension and the front matter exactly as you would do with natively supported `.md` files.
+
+Hugo passes reasonable default arguments to these external helpers by default:
+
+- `asciidoc`: `--no-header-footer --safe -`
+- `asciidoctor`: `--no-header-footer --safe --trace -`
+- `rst2html`: `--leave-comments --initial-header-level=2`
+- `pandoc`: `--mathjax`
+
+{{% warning "Performance of External Helpers" %}}
+Because additional formats are external commands generation performance will rely heavily on the performance of the external tool you are using. As this feature is still in its infancy, feedback is welcome.
+{{% /warning %}}
+
+## Learn Markdown
+
+Markdown syntax is simple enough to learn in a single sitting. The following are excellent resources to get you up and running:
+
+* [Daring Fireball: Markdown, John Gruber (Creator of Markdown)][fireball]
+* [Markdown Cheatsheet, Adam Pritchard][mdcheatsheet]
+* [Markdown Tutorial (Interactive), Garen Torikian][mdtutorial]
+
+[`emojify` function]: /functions/emojify/
+[ascii]: http://asciidoctor.org/
+[bfconfig]: /getting-started/configuration/#configuring-blackfriday-rendering
+[blackfriday]: https://github.com/russross/blackfriday
+[mmark]: https://github.com/miekg/mmark
+[config]: /getting-started/configuration/
+[developer tools]: /tools/
+[emojis]: https://www.webpagefx.com/tools/emoji-cheat-sheet/
+[fireball]: https://daringfireball.net/projects/markdown/
+[gfmtasks]: https://guides.github.com/features/mastering-markdown/#syntax
+[helperssource]: https://github.com/gohugoio/hugo/blob/77c60a3440806067109347d04eb5368b65ea0fe8/helpers/general.go#L65
++[hl]: /content-management/syntax-highlighting/
+[hlsc]: /content-management/shortcodes/#highlight
+[hugocss]: /css/style.css
+[ietf]: https://tools.ietf.org/html/
+[mathjaxdocs]: https://docs.mathjax.org/en/latest/
+[mdcheatsheet]: https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet
+[mdtutorial]: http://www.markdowntutorial.com/
+[Miek Gieben's website]: https://miek.nl/2016/March/05/mmark-syntax-document/
+[mmark]: https://github.com/miekg/mmark
+[mmarkgh]: https://github.com/miekg/mmark/wiki/Syntax
+[org]: http://orgmode.org/
+[pandoc]: http://www.pandoc.org/
+[Pygments]: http://pygments.org/
+[rest]: http://docutils.sourceforge.net/rst.html
+[sc]: /content-management/shortcodes/
+[sct]: /templates/shortcode-templates/
--- /dev/null
- ---
+---
+title: Menus
+linktitle: Menus
+description: Hugo has a simple yet powerful menu system.
+date: 2017-02-01
+publishdate: 2017-02-01
+lastmod: 2017-03-31
+categories: [content management]
+keywords: [menus]
+draft: false
+menu:
+ docs:
+ parent: "content-management"
+ weight: 120
+weight: 120 #rem
+aliases: [/extras/menus/]
+toc: true
+---
+
+{{% note "Lazy Blogger"%}}
+If all you want is a simple menu for your sections, see the ["Section Menu for Lazy Bloggers" in Menu Templates](/templates/menu-templates/#section-menu-for-lazy-bloggers).
+{{% /note %}}
+
+You can do this:
+
+* Place content in one or many menus
+* Handle nested menus with unlimited depth
+* Create menu entries without being attached to any content
+* Distinguish active element (and active branch)
+
+## What is a Menu in Hugo?
+
+A **menu** is a named array of menu entries accessible by name via the [`.Site.Menus` site variable][sitevars]. For example, you can access your site's `main` menu via `.Site.Menus.main`.
+
+{{% note "Menus on Multilingual Sites" %}}
+If you make use of the [multilingual feature](/content-management/multilingual/), you can define language-independent menus.
+{{% /note %}}
+
+A menu entry has the following properties (i.e., variables) available to it:
+
+`.URL`
+: string
+
+`.Name`
+: string
+
+`.Menu`
+: string
+
+`.Identifier`
+: string
+
+`.Pre`
+: template.HTML
+
+`.Post`
+: template.HTML
+
+`.Weight`
+: int
+
+`.Parent`
+: string
+
+`.Children`
+: Menu
+
+Note that menus also have the following functions available as well:
+
+`.HasChildren`
+: boolean
+
+Additionally, there are some relevant functions available to menus on a page:
+
+`.IsMenuCurrent`
+: (menu string, menuEntry *MenuEntry ) boolean
+
+`.HasMenuCurrent`
+: (menu string, menuEntry *MenuEntry) boolean
+
+## Add content to menus
+
+Hugo allows you to add content to a menu via the content's [front matter](/content-management/front-matter/).
+
+### Simple
+
+If all you need to do is add an entry to a menu, the simple form works well.
+
+#### A Single Menu
+
+```
+---
+menu: "main"
+---
+```
+
+#### Multiple Menus
+
+```
+---
+menu: ["main", "footer"]
+---
+```
+
+#### Advanced
+
+
+```
+---
+menu:
+ docs:
+ parent: 'extras'
+ weight: 20
+---
+```
+
+## Add Non-content Entries to a Menu
+
+You can also add entries to menus that aren’t attached to a piece of content. This takes place in your Hugo project's [`config` file][config].
+
+Here’s an example snippet pulled from a `config.toml`:
+
+{{< code file="config.toml" >}}
+[[menu.main]]
+ name = "about hugo"
+ pre = "<i class='fa fa-heart'></i>"
+ weight = -110
+ identifier = "about"
+ url = "/about/"
+[[menu.main]]
+ name = "getting started"
+ pre = "<i class='fa fa-road'></i>"
+ weight = -100
+ url = "/getting-started/"
+{{< /code >}}
+
+Here's the equivalent snippet in a `config.yaml`:
+
+{{< code file="config.yml" >}}
- docs:
- - Name: "about hugo"
- Pre: "<i class='fa fa-heart'></i>"
- Weight: -110
- Identifier: "about"
- URL: "/about/"
- - Name: "getting started"
- Pre: "<i class='fa fa-road'></i>"
- Weight: -100
- URL: "/getting-started/"
- ---
+menu:
++ main:
++ - name: "about hugo"
++ pre: "<i class='fa fa-heart'></i>"
++ weight: -110
++ identifier: "about"
++ url: "/about/"
++ - name: "getting started"
++ pre: "<i class='fa fa-road'></i>"
++ weight: -100
++ url: "/getting-started/"
+{{< /code >}}
+
+{{% note %}}
+The URLs must be relative to the context root. If the `baseURL` is `https://example.com/mysite/`, then the URLs in the menu must not include the context root `mysite`. Using an absolute URL will overide the baseURL. If the value used for `URL` in the above example is `https://subdomain.example.com/`, the output will be `https://subdomain.example.com`.
+{{% /note %}}
+
+## Nesting
+
+All nesting of content is done via the `parent` field.
+
+The parent of an entry should be the identifier of another entry. The identifier should be unique (within a menu).
+
+The following order is used to determine an Identifier:
+
+`.Name > .LinkTitle > .Title`
+
+This means that `.Title` will be used unless `.LinkTitle` is present, etc. In practice, `.Name` and `.Identifier` are only used to structure relationships and therefore never displayed.
+
+In this example, the top level of the menu is defined in your [site `config` file][config]). All content entries are attached to one of these entries via the `.Parent` field.
+
+## Render Menus
+
+See [Menu Templates](/templates/menu-templates/) for information on how to render your site menus within your templates.
+
+[config]: /getting-started/configuration/
+[multilingual]: /content-management/multilingual/
+[sitevars]: /variables/
--- /dev/null
- draft : true
+---
+title : "Page Bundles"
+description : "Content organization using Page Bundles"
+date : 2018-01-24T13:09:00-05:00
+lastmod : 2018-01-28T22:26:40-05:00
+linktitle : "Page Bundles"
+keywords : ["page", "bundle", "leaf", "branch"]
+categories : ["content management"]
- Page Bundles are a way to organize the content files. It's useful for
- cases where a page or section's content needs to be split into
- multiple content pages for convenience or has associated attachments
- like documents or images.
+toc : true
+menu :
+ docs:
+ identifier : "page-bundles"
+ parent : "content-management"
+ weight : 11
+---
+
- A Page Bundle can be one of two types:
++Page Bundles are a way to group [Page Resources](/content-management/page-resources/).
+
- - Leaf Bundle
- - Branch Bundle
++A Page Bundle can be one of:
+
- | Usage | Collection of content and attachments for single pages | Collection of content and attachments for section pages |
++- Leaf Bundle (leaf means it has no children)
++- Branch Bundle (home page, section, taxonomy terms, taxonomy list)
+
+| | Leaf Bundle | Branch Bundle |
+|-----------------|--------------------------------------------------------|---------------------------------------------------------|
- directory, that contains at least an **`index.md`** file.
-
- {{% note %}}
- Here `md` (markdown) is used just as an example. You can use any file
- type as a content resource as long as it is a MIME type recognized by
- Hugo (`json` files will, as one example, work fine). If you want to
- get exotic, you can define your own media type.
- {{% /note %}}
-
++| Usage | Collection of resources (pages, images etc.) for single pages | Collection of non-page resources (images etc.)for list pages |
+| Index file name | `index.md` [^fn:1] | `_index.md` [^fn:1] |
+| Layout type | `single` | `list` |
+| Nesting | Doesn't allow nesting of more bundles under it | Allows nesting of leaf/branch bundles under it |
+| Example | `content/posts/my-post/index.md` | `content/posts/_index.md` |
+
+
+## Leaf Bundles {#leaf-bundles}
+
+A _Leaf Bundle_ is a directory at any hierarchy within the `content/`
++directory, that contains an **`index.md`** file.
+
+### Examples of Leaf Bundle organization {#examples-of-leaf-bundle-organization}
+
+```text
+content/
+├── about
+│ ├── index.md
+├── posts
+│ ├── my-post
+│ │ ├── content1.md
+│ │ ├── content2.md
+│ │ ├── image1.jpg
+│ │ ├── image2.png
+│ │ └── index.md
+│ └── my-another-post
+│ └── index.md
+│
+└── another-section
+ ├── ..
+ └── not-a-leaf-bundle
+ ├── ..
+ └── another-leaf-bundle
+ └── index.md
+```
+
+In the above example `content/` directory, there are four leaf
+bundles:
+
+about
+: This leaf bundle is at the root level (directly under
+ `content` directory) and has only the `index.md`.
+
+my-post
+: This leaf bundle has the `index.md`, two other content
+ Markdown files and two image files.
+
+my-another-post
+: This leaf bundle has only the `index.md`.
+
+another-leaf-bundle
+: This leaf bundle is nested under couple of
+ directories. This bundle also has only the `index.md`.
+
+{{% note %}}
+The hierarchy depth at which a leaf bundle is created does not matter,
+as long as it is not inside another **leaf** bundle.
+{{% /note %}}
+
+
+### Headless Bundle {#headless-bundle}
+
+A headless bundle is a bundle that is configured to not get published
+anywhere:
+
+- It will have no `Permalink` and no rendered HTML in `public/`.
+- It will not be part of `.Site.RegularPages`, etc.
+
+But you can get it by `.Site.GetPage`. Here is an example:
+
+```html
+{{ $headless := .Site.GetPage "page" "some-headless-bundle" }}
+{{ $reusablePages := $headless.Resources.Match "author*" }}
+<h2>Authors</h2>
+{{ range $reusablePages }}
+ <h3>{{ .Title }}</h3>
+ {{ .Content }}
+{{ end }}
+```
+
+A leaf bundle can be made headless by adding below in the Front Matter
+(in the `index.md`):
+
+```toml
+headless = true
+```
+
+{{% note %}}
+Only leaf bundles can be made headless.
+{{% /note %}}
+
+There are many use cases of such headless page bundles:
+
+- Shared media galleries
+- Reusable page content "snippets"
+
+
+## Branch Bundles {#branch-bundles}
+
+A _Branch Bundle_ is any directory at any hierarchy within the
+`content/` directory, that contains at least an **`_index.md`** file.
+
+This `_index.md` can also be directly under the `content/` directory.
+
+{{% note %}}
+Here `md` (markdown) is used just as an example. You can use any file
+type as a content resource as long as it is a MIME type recognized by
+Hugo (`json` files will, as one example, work fine). If you want to
+get exotic, you can define your own media type.
+{{% /note %}}
+
+
+### Examples of Branch Bundle organization {#examples-of-branch-bundle-organization}
+
+```text
+content/
+├── branch-bundle-1
+│ ├── branch-content1.md
+│ ├── branch-content2.md
+│ ├── image1.jpg
+│ ├── image2.png
+│ └── _index.md
+└── branch-bundle-2
+ ├── _index.md
+ └── a-leaf-bundle
+ └── index.md
+```
+
+In the above example `content/` directory, there are two branch
+bundles (and a leaf bundle):
+
+`branch-bundle-1`
+: This branch bundle has the `_index.md`, two
+ other content Markdown files and two image files.
+
+`branch-bundle-2`
+: This branch bundle has the `_index.md` and a
+ nested leaf bundle.
+
+{{% note %}}
+The hierarchy depth at which a branch bundle is created does not
+matter.
+{{% /note %}}
+
+[^fn:1]: The `.md` extension is just an example. The extension can be `.html`, `.json` or any of any valid MIME type.
--- /dev/null
- By default, Hugo assumes `*.md` under `events` is of the `events` content type. However, we have specified that this particular file at `content/events/ my-first-event.md` is of type `event` and should render using the `birthday` layout.
+---
+title: Content Types
+linktitle: Types
+description: Hugo supports sites with multiple content types and assumes your site will be organized into sections, where each section represents the corresponding type.
+date: 2017-02-01
+publishdate: 2017-02-01
+lastmod: 2017-02-01
+categories: [content management]
+keywords: [lists,sections,content types,types,organization]
+menu:
+ docs:
+ parent: "content-management"
+ weight: 60
+weight: 60 #rem
+draft: false
+aliases: [/content/types]
+toc: true
+---
+
+A **content type** can have a unique set of metadata (i.e., [front matter][]) or customized [template][] and can be created by the `hugo new` command via [archetypes][].
+
+## What is a Content Type
+
+[Tumblr][] is a good example of a website with multiple content types. A piece of "content" could be a photo, quote, or a post, each with different sets of metadata and different visual rendering.
+
+## Assign a Content Type
+
+Hugo assumes that your site will be organized into [sections][] and each section represents a corresponding type. This is to reduce the amount of configuration necessary for new Hugo projects.
+
+If you are taking advantage of this default behavior, each new piece of content you place into a section will automatically inherit the type. Therefore a new file created at `content/posts/new-post.md` will automatically be assigned the type `posts`. Alternatively, you can set the content type in a content file's [front matter][] in the field "`type`".
+
+## Create New Content of a Specific Type
+
+You can manually add files to your content directories, but Hugo can create and populate a new content file with preconfigured front matter via [archetypes][].
+
+## Define a Content Type
+
+Creating a new content type is easy. You simply define the templates and archetype unique to your new content type, or Hugo will use defaults.
+
+
+{{% note "Declaring Content Types" %}}
+Remember, all of the following are *optional*. If you do not specifically declare content types in your front matter or develop specific layouts for content types, Hugo is smart enough to assume the content type from the file path and section. (See [Content Sections](/content-management/sections/) for more information.)
+{{% /note %}}
+
+The following examples take you stepwise through creating a new type layout for a content file that contains the following front matter:
+
+{{< code file="content/events/my-first-event.md" copy="false" >}}
++++
+title = My First Event
+date = "2016-06-24T19:20:04-07:00"
+description = "Today is my 36th birthday. How time flies."
+type = "event"
+layout = "birthday"
++++
+{{< /code >}}
+
- [Tumblr]: https://www.tumblr.com/
++By default, Hugo assumes `*.md` under `events` is of the `events` content type. However, we have specified that this particular file at `content/events/my-first-event.md` is of type `event` and should render using the `birthday` layout.
+
+### Create a Type Layout Directory
+
+Create a directory with the name of the type in `/layouts`. For creating these custom layouts, **type is always singular**; e.g., `events => event` and `posts => post`.
+
+For this example, you need to create `layouts/event/birthday.html`.
+
+{{% note %}}
+If you have multiple content files in your `events` directory that are of the `special` type and you don't want to define the `layout` specifically for each piece of content, you can create a layout at `layouts/special/single.html` to observe the [single page template lookup order](/templates/single-page-templates/).
+{{% /note %}}
+
+{{% warning %}}
+With the "everything is a page" data model introduced in v0.18 (see [Content Organization](/content-management/organization/)), you can use `_index.md` in content directories to add both content and front matter to [list pages](/templates/lists/). However, `type` and `layout` declared in the front matter of `_index.md` are *not* currently respected at build time as of v0.19. This is a known issue [(#3005)](https://github.com/gohugoio/hugo/issues/3005).
+{{% /warning %}}
+
+### Create Views
+
+Many sites support rendering content in a few different ways; e.g., a single page view and a summary view to be used when displaying a [list of section contents][sectiontemplates].
+
+Hugo limits assumptions about how you want to display your content to an intuitive set of sane defaults and will support as many different views of a content type as your site requires. All that is required for these additional views is that a template exists in each `/layouts/<TYPE>` directory with the same name.
+
+### Custom Content Type Template Lookup Order
+
+The lookup order for the `content/events/my-first-event.md` templates would be as follows:
+
+* `layouts/event/birthday.html`
+* `layouts/event/single.html`
+* `layouts/events/single.html`
+* `layouts/_default/single.html`
+
+### Create a Corresponding Archetype
+
+We can then create a custom archetype with preconfigured front matter at `event.md` in the `/archetypes` directory; i.e. `archetypes/event.md`.
+
+Read [Archetypes][archetypes] for more information on archetype usage with `hugo new`.
+
+[archetypes]: /content-management/archetypes/
+[front matter]: /content-management/front-matter/
+[sectiontemplates]: /templates/section-templates/
+[sections]: /content-management/sections/
+[template]: /templates/
++[Tumblr]: https://www.tumblr.com/
--- /dev/null
- description: Formats built-in Hugo dates---`.Date`, `.PublishDate`, and `.LastMod`---according to Go's layout string.
+---
+title: .Format
- * `.LastMod`
++description: Formats built-in Hugo dates---`.Date`, `.PublishDate`, and `.Lastmod`---according to Go's layout string.
+godocref: https://golang.org/pkg/time/#example_Time_Format
+date: 2017-02-01
+publishdate: 2017-02-01
+lastmod: 2017-02-01
+categories: [functions]
+menu:
+ docs:
+ parent: "functions"
+keywords: [dates,time]
+signature: [".Format FORMAT"]
+workson: [times]
+hugoversion:
+relatedfuncs: [dateFormat,now,Unix,time]
+deprecated: false
+aliases: []
+toc: true
+---
+
+`.Format` will format date values defined in your front matter and can be used as a property on the following [page variables][pagevars]:
+
+* `.PublishDate`
+* `.Date`
- `"January 2nd"`
- : **Returns**: `March 3rd`
-
++* `.Lastmod`
+
+Assuming a key-value of `date: 2017-03-03` in a content file's front matter, your can run the date through `.Format` followed by a layout string for your desired output at build time:
+
+```
+{{ .PublishDate.Format "January 2, 2006" }} => March 3, 2017
+```
+
+For formatting *any* string representations of dates defined in your front matter, see the [`dateFormat` function][dateFormat], which will still leverage the Golang layout string explained below but uses a slightly different syntax.
+
+## Go's Layout String
+
+Hugo templates [format your dates][time] via layout strings that point to a specific reference time:
+
+```
+Mon Jan 2 15:04:05 MST 2006
+```
+
+While this may seem arbitrary, the numerical value of `MST` is `07`, thus making the layout string a sequence of numbers.
+
+Here is a visual explanation [taken directly from the Go docs][gdex]:
+
+```
+ Jan 2 15:04:05 2006 MST
+=> 1 2 3 4 5 6 -7
+```
+
+### Hugo Date and Time Templating Reference
+
+The following examples show the layout string followed by the rendered output.
+
+The examples were rendered and tested in [CST][] and all point to the same field in a content file's front matter:
+
+```
+date: 2017-03-03T14:15:59-06:00
+```
+
+`.Date` (i.e. called via [page variable][pagevars])
+: **Returns**: `2017-03-03 14:15:59 -0600 CST`
+
+`"Monday, January 2, 2006"`
+: **Returns**: `Friday, March 3, 2017`
+
+`"Mon Jan 2 2006"`
+: **Returns**: `Fri Mar 3 2017`
+
+`"January 2006"`
+: **Returns**: `March 2017`
+
+`"2006-01-02"`
+: **Returns**: `2017-03-03`
+
+`"Monday"`
+: **Returns**: `Friday`
+
+`"02 Jan 06 15:04 MST"` (RFC822)
+: **Returns**: `03 Mar 17 14:15 CST`
+
+`"02 Jan 06 15:04 -0700"` (RFC822Z)
+: **Returns**: `03 Mar 17 14:15 -0600`
+
+`"Mon, 02 Jan 2006 15:04:05 MST"` (RFC1123)
+: **Returns**: `Fri, 03 Mar 2017 14:15:59 CST`
+
+`"Mon, 02 Jan 2006 15:04:05 -0700"` (RFC339)
+: **Returns**: `Fri, 03 Mar 2017 14:15:59 -0600`
+
+### Cardinal Numbers and Ordinal Abbreviations
+
+Spelled-out cardinal numbers (e.g. "one", "two", and "three") and ordinal abbreviations (i.e., with shorted suffixes like "1st", "2nd", and "3rd") are not currently supported:
+
+```
+{{.Date.Format "Jan 2nd 2006"}}
+```
+
+Hugo assumes you want to append `nd` as a string to the day of the month and outputs the following:
+
+```
+Mar 3nd 2017
+```
+
+<!-- Content idea: see https://discourse.gohugo.io/t/formatting-a-date-with-suffix-2nd/5701 -->
+
+### Use `.Local` and `.UTC`
+
+In conjunction with the [`dateFormat` function][dateFormat], you can also convert your dates to `UTC` or to local timezones:
+
+`{{ dateFormat "02 Jan 06 15:04 MST" .Date.UTC }}`
+: **Returns**: `03 Mar 17 20:15 UTC`
+
+`{{ dateFormat "02 Jan 06 15:04 MST" .Date.Local }}`
+: **Returns**: `03 Mar 17 14:15 CST`
+
+[CST]: https://en.wikipedia.org/wiki/Central_Time_Zone
+[dateFormat]: /functions/dateformat/
+[gdex]: https://golang.org/pkg/time/#example_Time_Format
+[pagevars]: /variables/page/
+[time]: https://golang.org/pkg/time/
--- /dev/null
- The example we will use will be an article on Oslo, which front matter should set to exactly the same name as the corresponding file name in `data/locations/`:
+---
+title: index
+linktitle: index
+description: Looks up the index(es) or key(s) of the data structure passed into it.
+godocref: https://golang.org/pkg/text/template/#hdr-Functions
+date: 2017-02-01
+publishdate: 2017-02-01
+lastmod: 2017-02-01
+categories: [functions]
+menu:
+ docs:
+ parent: "functions"
+keywords: []
+signature: ["index COLLECTION INDEX", "index COLLECTION KEY"]
+workson: []
+hugoversion:
+relatedfuncs: []
+deprecated: false
+aliases: [/functions/index/]
+needsexample: true
+---
+
+From the Godocs:
+
+> Returns the result of indexing its first argument by the following arguments. Thus "index x 1 2 3" is, in Go syntax, x[1][2][3]. Each indexed item must be a map, slice, or array.
+
+In Go templates, you can't access array, slice, or map elements directly the same way you would in Go. For example, `$.Site.Data.authors[.Params.authorkey]` isn't supported syntax.
+
+Instead, you have to use `index`, a function that handles the lookup for you.
+
+## Example: Load Data from a Path Based on Front Matter Params
+
+Assume you want to add a `location = ""` field to your front matter for every article written in `content/vacations/`. You want to use this field to populate information about the location at the bottom of the article in your `single.html` template. You also have a directory in `data/locations/` that looks like the following:
+
+```
+.
+└── data
+ └── locations
+ ├── abilene.toml
+ ├── chicago.toml
+ ├── oslo.toml
+ └── provo.toml
+```
+
+Here is an example of the data inside `data/locations/oslo.toml`:
+
+```
+website = "https://www.oslo.kommune.no"
+pop_city = 658390
+pop_metro = 1717900
+```
+
++The example we will use will be an article on Oslo, whose front matter should be set to exactly the same name as the corresponding file name in `data/locations/`:
+
+```
+title = "My Norwegian Vacation"
+location = "oslo"
+```
+
+The content of `oslo.toml` can be accessed from your template using the following node path: `.Site.Data.locations.oslo`. However, the specific file you need is going to change according to the front matter.
+
+This is where the `index` function is needed. `index` takes 2 parameters in this use case:
+
+1. The node path
+2. A string corresponding to the desired data; e.g.—
+
+```
+{{ index .Site.Data.locations “oslo” }}
+```
+
+The variable for `.Params.location` is a string and can therefore replace `oslo` in the example above:
+
+```
+{{ index .Site.Data.locations .Params.location }}
+=> map[website:https://www.oslo.kommune.no pop_city:658390 pop_metro:1717900]
+```
+
+Now the call will return the specific file according to the location specified in the content's front matter, but you will likely want to write specific properties to the template. You can do this by continuing down the node path via dot notation (`.`):
+
+```
+{{ (index .Site.Data.locations .Params.location).pop_city }}
+=> 658390
+```
+
--- /dev/null
- categories: [functions,fundamentals]
+---
+title: range
+linktitle:
+description: Iterates over a map, array, or slice.
+godocref:
+date: 2017-02-01
+publishdate: 2017-02-01
+lastmod: 2017-02-01
++categories: [functions]
+menu:
+ docs:
+ parent: "functions"
+keywords: [iteration]
+signature: ["range COLLECTION"]
+workson: []
+hugoversion:
+relatedfuncs: []
+deprecated: false
+draft: false
+aliases: []
+---
+
+Just like in the Go programming language, Go and Hugo templates make heavy use of `range` to iterate over a map, array or slice.
+
+`range` is fundamental to templating in Hugo. (See the [Introduction to Hugo Templates](/templates/introduction/) for more examples.
--- /dev/null
- categories: [functions,fundamentals]
+---
+title: title
+# linktitle:
+description: Converts all characters in the provided string to title case.
+godocref:
+date: 2017-02-01
+publishdate: 2017-02-01
+lastmod: 2017-02-01
++categories: [functions]
+menu:
+ docs:
+ parent: "functions"
+keywords: [strings]
+signature: ["title INPUT"]
+workson: []
+hugoversion:
+relatedfuncs: []
+deprecated: false
+aliases: []
+---
+
+
+```
+{{title "BatMan"}}` → "Batman"
+```
+
+Can be combined in pipes. In the following snippet, the link text is cleaned up using `humanize` to remove dashes and `title` to convert the value of `$name` to Intial Caps.
+
+```
+{{ range $name, $items := .Site.Taxonomies.categories }}
+ <li><a href="{{ printf "%s/%s" "categories" ($name | urlize | lower) | absURL }}">{{ $name | humanize | title }} ({{ len $items }})</a></li>
+{{ end }}
+```
--- /dev/null
- The following logical operators are vailable with `where`:
+---
+title: where
+# linktitle: where
+description: Filters an array to only the elements containing a matching value for a given field.
+godocref:
+date: 2017-02-01
+publishdate: 2017-02-01
+lastmod: 2017-02-01
+categories: [functions]
+menu:
+ docs:
+ parent: "functions"
+keywords: [filtering]
+signature: ["where COLLECTION KEY [OPERATOR] MATCH"]
+workson: [lists,taxonomies,terms,groups]
+hugoversion:
+relatedfuncs: [intersect,first,after,last]
+deprecated: false
+toc: true
+needsexample: true
+---
+
+`where` filters an array to only the elements containing a matching value for a given field.
+
+```
+{{ range where .Data.Pages "Section" "post" }}
+ {{ .Content }}
+{{ end }}
+```
+
+It can be used by dot-chaining the second argument to refer to a nested element of a value.
+
+```
++++
+series: golang
++++
+```
+
+```
+{{ range where .Site.Pages "Params.series" "golang" }}
+ {{ .Content }}
+{{ end }}
+```
+
+It can also be used with the logical operators `!=`, `>=`, `in`, etc. Without an operator, `where` compares a given field with a matching value equivalent to `=`.
+
+```
+{{ range where .Data.Pages "Section" "!=" "post" }}
+ {{ .Content }}
+{{ end }}
+```
+
++The following logical operators are available with `where`:
+
+`=`, `==`, `eq`
+: `true` if a given field value equals a matching value
+
+`!=`, `<>`, `ne`
+: `true` if a given field value doesn't equal a matching value
+
+`>=`, `ge`
+: `true` if a given field value is greater than or equal to a matching value
+
+`>`, `gt`
+: `true` if a given field value is greater than a matching value
+
+`<=`, `le`
+: `true` if a given field value is lesser than or equal to a matching value
+
+`<`, `lt`
+: `true` if a given field value is lesser than a matching value
+
+`in`
+: `true` if a given field value is included in a matching value; a matching value must be an array or a slice
+
+`not in`
+: `true` if a given field value isn't included in a matching value; a matching value must be an array or a slice
+
+`intersect`
+: `true` if a given field value that is a slice/array of strings or integers contains elements in common with the matching value; it follows the same rules as the [`intersect` function][intersect].
+
+## Use `where` with `intersect`
+
+```
+{{ range where .Site.Pages ".Params.tags" "intersect" .Params.tags }}
+ {{ if ne .Permalink $.Permalink }}
+ {{ .Render "summary" }}
+ {{ end }}
+{{ end }}
+```
+
+You can also put the returned value of the `where` clauses into a variable:
+
+{{< code file="where-intersect-variables.html" >}}
+{{ $v1 := where .Site.Pages "Params.a" "v1" }}
+{{ $v2 := where .Site.Pages "Params.b" "v2" }}
+{{ $filtered := $v1 | intersect $v2 }}
+{{ range $filtered }}
+{{ end }}
+{{< /code >}}
+
+## Use `where` with `first`
+
+The following grabs the first five content files in `post` using the [default ordering](/templates/lists/) for lists (i.e., `weight => date`):
+
+{{< code file="where-with-first.html" >}}
+{{ range first 5 (where .Data.Pages "Section" "post") }}
+ {{ .Content }}
+{{ end }}
+{{< /code >}}
+
+## Nest `where` Clauses
+
+You can also nest `where` clauses to drill down on lists of content by more than one parameter. The following first grabs all pages in the "blog" section and then ranges through the result of the first `where` clause and finds all pages that are *not* featured:
+
+```
+{{ range where (where .Data.Pages "Section" "blog" ) ".Params.featured" "!=" "true" }}
+```
+
+## Unset Fields
+
+Filtering only works for set fields. To check whether a field is set or exists, you can use the operand `nil`.
+
+This can be useful to filter a small amount of pages from a large pool. Instead of set field on all pages, you can set field on required pages only.
+
+Only the following operators are available for `nil`
+
+* `=`, `==`, `eq`: True if the given field is not set.
+* `!=`, `<>`, `ne`: True if the given field is set.
+
+```
+{{ range where .Data.Pages ".Params.specialpost" "!=" nil }}
+ {{ .Content }}
+{{ end }}
+```
+
+## Portable `where` filters
+
+This is especially important for themes, but to list the most relevant pages on the front page or similar, you can use `.Site.Params.mainSections` list.
+
+This will, by default, list pages from the _section with the most pages_.
+
+```html
+{{ $pages := where .Site.RegularPages "Type" "in" .Site.Params.mainSections }}
+```
+
+The user can override the default in `config.toml`:
+
+```toml
+[params]
+mainSections = ["blog", "docs"]
+```
+
+[intersect]: /functions/intersect/
--- /dev/null
- categories: [functions,fundamentals]
+---
+title: with
+# linktitle: with
+description: Rebinds the context (`.`) within its scope and skips the block if the variable is absent.
+godocref:
+date: 2017-02-01
+publishdate: 2017-02-01
+lastmod: 2017-03-12
++categories: [functions]
+menu:
+ docs:
+ parent: "functions"
+keywords: [conditionals]
+signature: ["with INPUT"]
+workson: []
+hugoversion:
+relatedfuncs: []
+deprecated: false
+---
+
+An alternative way of writing an `if` statement and then referencing the same value is to use `with` instead. `with` rebinds the context (`.`) within its scope and skips the block if the variable is absent or unset.
+
+The following example checks for a [user-defined site variable](/variables/site/) called `twitteruser`. If the key-value is not set, the following will render nothing:
+
+{{< code file="layouts/partials/twitter.html" >}}
+{{with .Site.Params.twitteruser}}<span class="twitter">
+<a href="https://twitter.com/{{.}}" rel="author">
+<img src="/images/twitter.png" width="48" height="48" title="Twitter: {{.}}"
+ alt="Twitter"></a>
+</span>{{end}}
+{{< /code >}}
--- /dev/null
- description: Often the default settings are good enough, but the config file can provide highly granular control over how your site is rendered.
+---
+title: Configure Hugo
+linktitle: Configuration
- The [directory structure][] of a Hugo website—or more precisely, the source organization of files containing the website's content and templates—provides most of the configuration information that Hugo needs in order to generate a finished website.
++description: How to configure your Hugo site.
+date: 2013-07-01
+publishdate: 2017-01-02
+lastmod: 2017-03-05
+categories: [getting started,fundamentals]
+keywords: [configuration,toml,yaml,json]
+menu:
+ docs:
+ parent: "getting-started"
+ weight: 60
+weight: 60
+sections_weight: 60
+draft: false
+aliases: [/overview/source-directory/,/overview/configuration/]
+toc: true
+---
+
- Because of Hugo's sensible defaults, many websites may not need a configuration file. Hugo is designed to recognize certain typical usage patterns.
+
- ### All Variables, YAML
-
- The following is the full list of Hugo-defined variables in an example YAML file. The values provided in this example represent the default values used by Hugo.
-
- {{< code file="config.yml" download="config.yml" >}}
- archetypeDir: "archetypes"
- # hostname (and path) to the root, e.g. http://spf13.com/
- baseURL: ""
- # include content marked as draft
- buildDrafts: false
- # include content with publishdate in the future
- buildFuture: false
- # include content already expired
- buildExpired: false
- # enable this to make all relative URLs relative to content root. Note that this does not affect absolute URLs. See the "URL Management" page
- relativeURLs: false
- canonifyURLs: false
- # config file (default is path/config.yaml|json|toml)
- config: "config.toml"
- contentDir: "content"
- dataDir: "data"
- defaultLayout: "post"
- # Missing translations will default to this content language
- defaultContentLanguage: "en"
- # Renders the default content language in subdir, e.g. /en/. The root directory / will redirect to /en/
- defaultContentLanguageInSubdir: false
- disableLiveReload: false
- # Enable GitInfo feature
- enableGitInfo: false
- # Build robots.txt file
- enableRobotsTXT: false
- # Do not inject generator meta tag on homepage
- disableHugoGeneratorInject: false
- # Allows you to disable all page types and will render nothing related to 'kind';
- # values = "page", "home", "section", "taxonomy", "taxonomyTerm", "RSS", "sitemap", "robotsTXT", "404"
- disableKinds: []
- # Do not make the url/path to lowercase
- disablePathToLower: false ""
- # Enable Emoji emoticons support for page content; see emoji-cheat-sheet.com
- enableEmoji: false
- # Show a placeholder instead of the default value or an empty string if a translation is missing
- enableMissingTranslationPlaceholders: false
- footnoteAnchorPrefix: ""
- footnoteReturnLinkContents: ""
- # google analytics tracking id
- googleAnalytics: ""
- # if true, auto-detect Chinese/Japanese/Korean Languages in the content. (.Summary and .WordCount can work properly in CJKLanguage)
- hasCJKLanguage: false
- languageCode: ""
- # the length of text to show in a .Summary
- summaryLength: 70
- layoutDir: "layouts"
- # Enable Logging
- log: false
- # Log File path (if set, logging enabled automatically)
- logFile: ""
- # "toml","yaml", or "json"
- metaDataFormat: "toml"
- newContentEditor: ""
- # Don't sync permission mode of files
- noChmod: false
- # Don't sync modification time of files
- noTimes: false
- # Pagination
- paginate: 10
- paginatePath: "page"
- # See "content-management/permalinks"
- permalinks:
- # Pluralize titles in lists using inflect
- pluralizeListTitles: true
- # Preserve special characters in taxonomy names ("Gérard Depardieu" vs "Gerard Depardieu")
- preserveTaxonomyNames: false
- # filesystem path to write files to
- publishDir: "public"
- # enables syntax guessing for code fences without specified language
- pygmentsCodeFencesGuessSyntax: false
- # color-codes for highlighting derived from this style
- pygmentsStyle: "monokai"
- # true use pygments-css or false will color code directly
- pygmentsUseClasses: false
- # maximum number of items in the RSS feed
- rssLimit: 15
- # see "Section Menu for Lazy Bloggers", /templates/menu-templates for more info
- SectionPagesMenu: ""
- # default sitemap configuration map
- sitemap:
- # filesystem path to read files relative from
- source: ""
- staticDir: "static"
- # display memory and timing of different steps of the program
- stepAnalysis: false
- # display metrics about template executions
- templateMetrics: false
- # theme to use (located by default in /themes/THEMENAME/)
- themesDir: "themes"
- theme: ""
- title: ""
- # Title Case style guide for the title func and other automatic title casing in Hugo.
- // Valid values are "AP" (default), "Chicago" and "Go" (which was what you had in Hugo <= 0.25.1).
- // See https://www.apstylebook.com/ and http://www.chicagomanualofstyle.org/home.html
- titleCaseStyle: "AP"
- # if true, use /filename.html instead of /filename/
- uglyURLs: false
- # verbose output
- verbose: false
- # verbose logging
- verboseLog: false
- # watch filesystem for changes and recreate as needed
- watch: true
- taxonomies:
- - category: "categories"
- - tag: "tags"
- {{< /code >}}
-
++## All Configuration Settings
++
++The following is the full list of Hugo-defined variables with its default value in parens.
++
++archetypeDir ("archetypes")
++: The directory where Hugo finds archetype files (content templates).
++
++baseURL
++: Hostname (and path) to the root, e.g. http://bep.is/
++
++buildDrafts (false)
++: Include drafts when building.
++
++buildExpired (false)
++: Include content already expired.
++
++buildFuture (false)
++: Include content with publishdate in the future.
++
++canonifyURLs (false)
++: Enable to turn relative URLs into absolute.
++
++config ("config.toml")
++: Config file (default is path/config.yaml|json|toml).
++
++contentDir ("content")
++: The directory from where Hugo reads content files.
++
++dataDir ("data")
++: The directory from where Hugo reads data files.
++
++defaultContentLanguage ("en")
++: Content without language indicator will default to this language.
++
++defaultContentLanguageInSubdir (false)
++: Renders the default content language in subdir, e.g. /en/. The root directory / will redirect to /en/.
++
++disableHugoGeneratorInject (false)
++: Hugo will, by default, inject a generator meta tag in the HTML head on the _home page only_. You can turn it off, but we would really appreciate if you don't, as this is a good way to watch Hugo's popularity on the rise.
++
++disableKinds ([])
++: Allows you to disable all page types and will render nothing related to 'kind'. Allowed values are "page", "home", "section", "taxonomy", "taxonomyTerm", "RSS", "sitemap", "robotsTXT", "404".
++
++disableLiveReload (false)
++: Turn off automatic live reloading of browser window.
++
++disablePathToLower (false)
++: Do not make the url/path to lowercase.
++
++enableEmoji (false)
++: Enable Emoji emoticons support for page content; see emoji-cheat-sheet.com.
++
++enableGitInfo (false)
++: If the Hugo site is versioned by Git, you will then get a `.GitInfo` object per page, and `Lastmod` will get updated by the last commit date for content.
++
++enableMissingTranslationPlaceholders (false)
++: Show a placeholder instead of the default value or an empty string if a translation is missing
++
++enableRobotsTXT (false)
++: When enabled, Hugo will generate a `robots.txt` file.
++
++footnoteAnchorPrefix ("")
++: A prefix for your footnote anchors.
++
++footnoteReturnLinkContents ("")
++: A return link for your footnote.
++
++googleAnalytics ("")
++: google analytics tracking id
++
++hasCJKLanguage (false)
++: If true, auto-detect Chinese/Japanese/Korean Languages in the content. This will make `.Summary` and `.WordCount` behave correctly in CJK languages.
++
++imaging
++: See [Image Processing Config](/content-management/image-processing/#image-processing-config).
++
++languages
++: See [Configure Languages](/content-management/multilingual/#configure-languages).
++
++languageCode ("")
++: The site's language code.
++
++layoutDir ("layouts")
++: The directory from where Hugo reads layouts (templates).
++
++log (false)
++: Enable logging.
++
++logFile ("")
++: Log File path (if set, logging enabled automatically).
++
++menu
++: See [Add Non-content Entries to a Menu](/content-management/menus/#add-non-content-entries-to-a-menu).
++
++metaDataFormat ("toml")
++: "toml","yaml", or "json"
++
++newContentEditor ("")
++: The editor to use when creating new content.
++
++noChmod (false)
++: Don't sync permission mode of files.
++
++noTimes (false)
++: Don't sync modification time of files
++
++paginate (10)
++: Default number of pages per page in pagination.
++
++paginatePath ("page")
++: The path element used during pagination (http://example.com/page/2).
++
++permalinks
++: See [Content Management](/content-management/urls/#permalinks)
++
++pluralizeListTitles (true)
++: Pluralize titles in lists using inflect.
++
++preserveTaxonomyNames (false)
++: Preserve special characters in taxonomy names ("Gérard Depardieu" vs "Gerard Depardieu").
++
++publishDir ("public")
++: The directory to where Hugo will write the final static site (the HTML files etc.).
++
++pygmentsCodeFencesGuessSyntax (false)
++: Enables syntax guessing for code fences without specified language.
++
++pygmentsStyle ("monokai")
++: Color-codes for highlighting derived from this style. See https://help.farbox.com/pygments.html
++
++pygmentsUseClasses (false)
++: Enable to use external CSS for code highlighting.
++
++related
++: See [Related Content](/content-management/related/#configure-related-content).
++
++relativeURLs (false)
++: Enable this to make all relative URLs relative to content root. Note that this does not affect absolute URLs.
++
++rssLimit (15)
++: Maximum number of items in the RSS feed.
++
++sectionPagesMenu ("")(
++: See ["Section Menu for Lazy Bloggers"](/templates/menu-templates/#section-menu-for-lazy-bloggers).
++
++sitemap
++: Default sitemap configuration.
++
++staticDir ("static")
++: Relative directory from where Hugo reads static files.
++
++stepAnalysis (false)
++: Display memory and timing of different steps of the program.
++
++summaryLength (70)
++: The length of text to show in a `.Summary`.
++
++taxonomies
++: See [Configure Taxonomies](content-management/taxonomies#configure-taxonomies)
++
++theme ("")
++: Theme to use (located by default in /themes/THEMENAME/)
++
++themesDir ("themes")
++: The directory where Hugo reads the themes from.
++
++title ("")
++: Site title.
++
++uglyURLs (false)
++: When enabled creates URL on the form `/filename.html` instead of `/filename/`
++
++verbose (false)
++: Enable verbose output.
++
++verboseLog (false)
++: Enable verbose logging.
++
++watch (false)
++: Watch filesystem for changes and recreate as needed.
++
++{{% note %}}
++If you are developing your site on a \*nix machine, here is a handy shortcut for finding a configuration option from the command line:
++```
++cd ~/sites/yourhugosite
++hugo config | grep emoji
++```
++
++which shows output like
++
++```
++enableemoji: true
++```
++{{% /note %}}
+
+## Configuration Lookup Order
+
+Similar to the template [lookup order][], Hugo has a default set of rules for searching for a configuration file in the root of your website's source directory as a default behavior:
+
+1. `./config.toml`
+2. `./config.yaml`
+3. `./config.json`
+
+In your `config` file, you can direct Hugo as to how you want your website rendered, control your website's menus, and arbitrarily define site-wide parameters specific to your project.
+
+## YAML Configuration
+
+The following is a typical example of a YAML configuration file. The values nested under `params:` will populate the [`.Site.Params`][] variable for use in [templates][]:
+
+{{< code file="config.yml">}}
+baseURL: "https://yoursite.example.com/"
+title: "My Hugo Site"
+footnoteReturnLinkContents: "↩"
+permalinks:
+ post: /:year/:month/:title/
+params:
+ Subtitle: "Hugo is Absurdly Fast!"
+ AuthorName: "Jon Doe"
+ GitHubUser: "spf13"
+ ListOfFoo:
+ - "foo1"
+ - "foo2"
+ SidebarRecentLimit: 5
+{{< /code >}}
+
- ### All Variables, TOML
-
- The following is the full list of Hugo-defined variables in an example TOML file. The values provided in this example represent the default values used by Hugo.
-
- {{< code file="config.toml" download="config.toml">}}
- archetypeDir = "archetypes"
- # hostname (and path) to the root, e.g. http://spf13.com/
- baseURL = ""
- # include content marked as draft
- buildDrafts = false
- # include content with publishdate in the future
- buildFuture = false
- # include content already expired
- buildExpired = false
- # enable this to make all relative URLs relative to content root. Note that this does not affect absolute URLs.
- relativeURLs = false
- canonifyURLs = false
- # config file (default is path/config.yaml|json|toml)
- config = "config.toml"
- contentDir = "content"
- dataDir = "data"
- defaultLayout = "post"
- # Missing translations will default to this content language
- defaultContentLanguage = "en"
- # Renders the default content language in subdir, e.g. /en/. The root directory / will redirect to /en/
- defaultContentLanguageInSubdir = false
- disableLiveReload = false
- # Enable GitInfo feature
- enableGitInfo = false
- # Build robots.txt file
- enableRobotsTXT = false
- # Do not inject generator meta tag on homepage
- disableHugoGeneratorInject = false
- # Allows you to disable all page types and will render nothing related to 'kind';
- # values = "page", "home", "section", "taxonomy", "taxonomyTerm", "RSS", "sitemap", "robotsTXT", "404"
- disableKinds = []
- # Do not make the url/path to lowercase
- disablePathToLower = false
- # Enable Emoji emoticons support for page content; see emoji-cheat-sheet.com
- enableEmoji = false
- # Show a placeholder instead of the default value or an empty string if a translation is missing
- enableMissingTranslationPlaceholders = false
- footnoteAnchorPrefix = ""
- footnoteReturnLinkContents = ""
- # google analytics tracking id
- googleAnalytics = ""
- # if true, auto-detect Chinese/Japanese/Korean Languages in the content. (.Summary and .WordCount can work properly in CJKLanguage)
- hasCJKLanguage = false
- languageCode = ""
- # the length of text to show in a .Summary
- summaryLength = 70
- layoutDir = "layouts"
- # Enable Logging
- log = false
- # Log File path (if set, logging enabled automatically)
- logFile =
- # maximum number of items in the RSS feed
- rssLimit = 15
- # "toml","yaml", or "json"
- metaDataFormat = "toml"
- newContentEditor = ""
- # Don't sync permission mode of files
- noChmod = false
- # Don't sync modification time of files
- noTimes = false
- # Pagination
- paginate = 10
- paginatePath = "page"
- # See "content-management/permalinks"
- permalinks =
- # Pluralize titles in lists using inflect
- pluralizeListTitles = true
- # Preserve special characters in taxonomy names ("Gérard Depardieu" vs "Gerard Depardieu")
- preserveTaxonomyNames = false
- # filesystem path to write files to
- publishDir = "public"
- # enables syntax guessing for code fences without specified language
- pygmentsCodeFencesGuessSyntax = false
- # color-codes for highlighting derived from this style
- pygmentsStyle = "monokai"
- # true: use pygments-css or false: color-codes directly
- pygmentsUseClasses = false
- # see "Section Menu for Lazy Bloggers", /templates/menu-templates for more info
- SectionPagesMenu =
- # default sitemap configuration map
- sitemap =
- # filesystem path to read static files relative from
- staticDir = "static"
- # display memory and timing of different steps of the program
- stepAnalysis = false
- # theme to use (located by default in /themes/THEMENAME/)
- themesDir = "themes"
- theme = ""
- title = ""
- # if true, use /filename.html instead of /filename/
- uglyURLs = false
- # verbose output
- verbose = false
- # verbose logging
- verboseLog = false
- # watch filesystem for changes and recreate as needed
- watch = true
- [taxonomies]
- category = "categories"
- tag = "tags"
- {{< /code >}}
+## TOML Configuration
+
+The following is an example of a TOML configuration file. The values under `[params]` will populate the `.Site.Params` variable for use in [templates][]:
+
+{{< code file="config.toml">}}
+contentDir = "content"
+layoutDir = "layouts"
+publishDir = "public"
+buildDrafts = false
+baseURL = "https://yoursite.example.com/"
+canonifyURLs = true
+title = "My Hugo Site"
+
+[taxonomies]
+ category = "categories"
+ tag = "tags"
+
+[params]
+ subtitle = "Hugo is Absurdly Fast!"
+ author = "John Doe"
+{{< /code >}}
+
- {{% note %}}
- If you are developing your site on a \*nix machine, here is a handy shortcut for finding a configuration option from the command line:
- ```
- cd ~/sites/yourhugosite
- hugo config | grep emoji
- ```
+
- which shows output like
+
- ```
- enableemoji: true
- ```
- {{% /note %}}
-
- ## Environmental Variables
+
++## Configure with Environment Variables
+
+In addition to the 3 config options already mentioned, configuration key-values can be defined through operating system environment variables.
+
+For example, the following command will effectively set a website's title on Unix-like systems:
+
+```
+$ env HUGO_TITLE="Some Title" hugo
+```
+
++This is really useful if you use a service such as Netlify to deploy your site. Look at the Hugo docs [Netlify configuration file](https://github.com/gohugoio/hugoDocs/blob/master/netlify.toml) for an example.
++
+{{% note "Setting Environment Variables" %}}
+Names must be prefixed with `HUGO_` and the configuration key must be set in uppercase when setting operating system environment variables.
+{{% /note %}}
+
++{{< todo >}}
++Test and document setting params via JSON env var.
++{{< /todo >}}
++
+## Ignore Files When Rendering
+
+The following statement inside `./config.toml` will cause Hugo to ignore files ending with `.foo` and `.boo` when rendering:
+
+```
+ignoreFiles = [ "\\.foo$", "\\.boo$" ]
+```
+
+The above is a list of regular expressions. Note that the backslash (`\`) character is escaped in this example to keep TOML happy.
+
+## Configure Blackfriday
+
+[Blackfriday](https://github.com/russross/blackfriday) is Hugo's built-in Markdown rendering engine.
+
+Hugo typically configures Blackfriday with sane default values that should fit most use cases reasonably well.
+
+However, if you have specific needs with respect to Markdown, Hugo exposes some of its Blackfriday behavior options for you to alter. The following table lists these Hugo options, paired with the corresponding flags from Blackfriday's source code ( [html.go](https://github.com/russross/blackfriday/blob/master/html.go) and [markdown.go](https://github.com/russross/blackfriday/blob/master/markdown.go)).
+
+{{< readfile file="/content/readfiles/bfconfig.md" markdown="true" >}}
+
+{{% note %}}
+1. Blackfriday flags are *case sensitive* as of Hugo v0.15.
+2. Blackfriday flags must be grouped under the `blackfriday` key and can be set on both the site level *and* the page level. Any setting on a page will override its respective site setting.
+{{% /note %}}
+
+{{< code file="bf-config.toml" >}}
+[blackfriday]
+ angledQuotes = true
+ fractions = false
+ plainIDAnchors = true
+ extensions = ["hardLineBreak"]
+{{< /code >}}
+
+{{< code file="bf-config.yml" >}}
+blackfriday:
+ angledQuotes: true
+ fractions: false
+ plainIDAnchors: true
+ extensions:
+ - hardLineBreak
+{{< /code >}}
+
+## Configure Additional Output Formats
+
+Hugo v0.20 introduced the ability to render your content to multiple output formats (e.g., to JSON, AMP html, or CSV). See [Output Formats][] for information on how to add these values to your Hugo project's configuration file.
+
+## Configuration Format Specs
+
+* [TOML Spec][toml]
+* [YAML Spec][yaml]
+* [JSON Spec][json]
+
+[`.Site.Params`]: /variables/site/
+[directory structure]: /getting-started/directory-structure
+[json]: https://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf "Specification for JSON, JavaScript Object Notation"
+[lookup order]: /templates/lookup-order/
+[Output Formats]: /templates/output-formats/
+[templates]: /templates/
+[toml]: https://github.com/toml-lang/toml
+[yaml]: http://yaml.org/spec/
--- /dev/null
- title: "0.37"
- description: "0.37"
- slug: "0.37"
+
+---
+date: 2018-02-27
- The main item in Hugo `0.37` is that we now properly preserve the colour palette when processing `PNG` images. We got reports from users experiencing their `PNG` images getting bigger in file size when scaled down. Now, if you, as an example, start out with a carefully chosen 8 bit colour palette (i.e. `PNG-8`), this is now what you will end up with. A special thanks to [@aitva](https://github.com/aitva) for doing the investigative work finding a proper fix for this issue.
++title: "Hugo 0.37: Preserve PNG Colour Palette"
++description: "Reduces processed PNG file sizes. And 0.37 is built with Go 1.10!"
+categories: ["Releases"]
+---
+
++The main item in Hugo `0.37` is that we now properly preserve the colour palette when processing `PNG` images. We got reports from users experiencing their `PNG` images getting bigger in file size when scaled down. Now, if you, as an example, start out with a carefully chosen 8 bit colour palette (i.e. `PNG-8`), this is now what you will end up with. A special thanks to [@aitva](https://github.com/aitva) for doing the investigative work finding a proper fix for this issue.
+
+This release represents **40 contributions by 5 contributors** to the main Hugo code base.
+
+[@bep](https://github.com/bep) leads the Hugo development with a significant amount of contributions, but also a big shoutout to [@vassudanagunta](https://github.com/vassudanagunta), [@kaushalmodi](https://github.com/kaushalmodi), and [@curttimson](https://github.com/curttimson) for their ongoing contributions.
+
+And as always a big thanks to [@digitalcraftsman](https://github.com/digitalcraftsman) for his relentless work on keeping the documentation and the themes site in pristine condition.
+
+Many have also been busy writing and fixing the documentation in [hugoDocs](https://github.com/gohugoio/hugoDocs),
+which has received **24 contributions by 8 contributors**. A special thanks to [@bep](https://github.com/bep), [@4RU](https://github.com/4RU), [@kaushalmodi](https://github.com/kaushalmodi), and [@mitchchn](https://github.com/mitchchn) for their work on the documentation site.
+
+Hugo now has:
+
+* 23649+ [stars](https://github.com/gohugoio/hugo/stargazers)
+* 447+ [contributors](https://github.com/gohugoio/hugo/graphs/contributors)
+* 197+ [themes](http://themes.gohugo.io/)
+
+## Notes
+
+* Hugo will now convert non-string `YAML` map keys to string. See [#4393](https://github.com/gohugoio/hugo/issues/4393) for more information. You will get a `WARNING` in the console if you are touched by this.
+* We have improved the `PNG` processing, and have incremented the version numbers on the URL for the processed `PNG` image. This will just work, but you may want to run `hugo --gc` to clean up some old stale images in the resource cache.
+
+## Enhancements
+
+### Templates
+
+* Add template func for TOML/JSON/YAML docs examples conversion. This is mainly motivated by the needs of the Hugo docs site. [d382502d](https://github.com/gohugoio/hugo/commit/d382502d6dfa1c066545e215ba83e2e0a9d2c8d7) [@bep](https://github.com/bep) [#4389](https://github.com/gohugoio/hugo/issues/4389)
+
+### Core
+
+* Refactor tests for JSON, YAML and TOML equivalency, add coverage [82eefded](https://github.com/gohugoio/hugo/commit/82eefded1353f0198fd8fe9f7df1aa620d3d50eb) [@vassudanagunta](https://github.com/vassudanagunta)
+* Re-enable YAML data tests disabled in f554503f [e1728349](https://github.com/gohugoio/hugo/commit/e1728349930e2cc1b6580766473de98adb0f3e50) [@vassudanagunta](https://github.com/vassudanagunta)
+
+### Other
+
+* Preserve color palette for PNG images [799c654b](https://github.com/gohugoio/hugo/commit/799c654b0d39ec869c2da24d41de3636eb7157f0) [@bep](https://github.com/bep) [#4416](https://github.com/gohugoio/hugo/issues/4416)
+* Use `Floyd-Steinberg` dithering for PNGs [13ea1e7c](https://github.com/gohugoio/hugo/commit/13ea1e7c352852966f88ef119d9434bbb1ee62fa) [@bep](https://github.com/bep) [#4453](https://github.com/gohugoio/hugo/issues/4453)
+* Make `ge`, `le` etc. work with the Hugo Version number [0602135f](https://github.com/gohugoio/hugo/commit/0602135fd44b0cfa0a51b0ec6e451ae58ac95666) [@bep](https://github.com/bep) [#4443](https://github.com/gohugoio/hugo/issues/4443)
+* Update dependencies [eaf573a2](https://github.com/gohugoio/hugo/commit/eaf573a2778e79287b871b69f4959fd3082d8887) [@bep](https://github.com/bep) [#4418](https://github.com/gohugoio/hugo/issues/4418)
+* Update to Go 1.10 (!) Take 2 [a3f26e56](https://github.com/gohugoio/hugo/commit/a3f26e56368c62b0900a10d83a11b7783630963b) [@bep](https://github.com/bep)
+* Update to Go 1.10 (!) [ff10c15a](https://github.com/gohugoio/hugo/commit/ff10c15a93632043f7a7f6551a30487c9ef58c50) [@bep](https://github.com/bep)
+* Add WARNING for integer YAML keys [0816a97a](https://github.com/gohugoio/hugo/commit/0816a97a469f11d8e9706143975eaa532e29639b) [@bep](https://github.com/bep) [#4393](https://github.com/gohugoio/hugo/issues/4393)
+* Tune stringifyMapKeys [10a917df](https://github.com/gohugoio/hugo/commit/10a917dfdce8851666c5b89ebc02af6f6c84ab59) [@bep](https://github.com/bep)
+* Rename stringifyYAMLMapKeys to stringifyMapKeys [d4beef0d](https://github.com/gohugoio/hugo/commit/d4beef0d2bb8f6481fa80e1d938454a7d4e38814) [@bep](https://github.com/bep)
+* Add benchmarks for stringifyYAMLMapKeys [51213e0b](https://github.com/gohugoio/hugo/commit/51213e0be19fc19dbca9815afa95c73bd6d159c2) [@bep](https://github.com/bep)
+* Add support for `YAML` array data files [1fa24177](https://github.com/gohugoio/hugo/commit/1fa2417777d82b81bf37919ad02de4f5dcbf0d50) [@vassudanagunta](https://github.com/vassudanagunta) [#3890](https://github.com/gohugoio/hugo/issues/3890)
+* Account for array type data in data dir merge/override logic [bb549a0d](https://github.com/gohugoio/hugo/commit/bb549a0d57505a6b8f28930bb91a9ab44cbb3288) [@vassudanagunta](https://github.com/vassudanagunta) [#4366](https://github.com/gohugoio/hugo/issues/4366)
+* Add "target" and "rel" parameters to figure shortcode [2e95ec68](https://github.com/gohugoio/hugo/commit/2e95ec6844bf65a25485bdc8e2638e45788f2dcf) [@kaushalmodi](https://github.com/kaushalmodi)
+* image" property, not "twitter:image:src" [76d38d5e](https://github.com/gohugoio/hugo/commit/76d38d5e5322fc6220fb9e74f9ca0668606ebb5d) [@kaushalmodi](https://github.com/kaushalmodi)
+
+## Fixes
+
+### Core
+
+* Continue `GitInfo` lookup on error [e9750d83](https://github.com/gohugoio/hugo/commit/e9750d831f749afa928d8a099af5889d18cb2484) [@bep](https://github.com/bep)
+* Fix paginator `URL` for sections with URL in front matter [9f740b37](https://github.com/gohugoio/hugo/commit/9f740b37cfb3278e34a5d085380ccd4d619dabff) [@bep](https://github.com/bep) [#4415](https://github.com/gohugoio/hugo/issues/4415)
+
+### Other
+
+* Fix bug in Site.assembleSections method [00868081](https://github.com/gohugoio/hugo/commit/00868081f624928d773a7b698654766f8cd70069) [@vassudanagunta](https://github.com/vassudanagunta) [#4447](https://github.com/gohugoio/hugo/issues/4447)
+* Update Blackfriday to fix footnote HTML5 validation error [492fea7c](https://github.com/gohugoio/hugo/commit/492fea7cd2bfcbdfe9f56aa0ae659cf62648833b) [@bep](https://github.com/bep) [#4433](https://github.com/gohugoio/hugo/issues/4433)
+* Fix `YAML` maps key type [16a5c745](https://github.com/gohugoio/hugo/commit/16a5c74519771138023f019fe535fa5b250dc50d) [@dmgawel](https://github.com/dmgawel) [#2441](https://github.com/gohugoio/hugo/issues/2441)
+* Remove `ERROR` on missing baseURL [55bd46a6](https://github.com/gohugoio/hugo/commit/55bd46a633d68f62e131457631ba839d6f876a55) [@bep](https://github.com/bep) [#4397](https://github.com/gohugoio/hugo/issues/4397)
+
+
+
+
+
--- /dev/null
- title: "0.37.1"
- description: "0.37.1"
+
+---
+date: 2018-03-07
-
-
++title: "Hugo 0.37.1: One Bugfix"
++description: "Fixes SVG (and similar) handling as page resources."
+categories: ["Releases"]
+images:
+- images/blog/hugo-bug-poster.png
+
+---
+
+This is a bug-fix release with a one important fix:
+
+Image content such as `SVG` cannot be scaled with the built-in image processing methods, but it should still be possible to use them as page resources. This was a regression in Hugo `0.37` and is now fixed. [ba94abbf](https://github.com/gohugoio/hugo/commit/ba94abbf5dd90f989242af8a7027d67a572a6128) [@bep](https://github.com/bep) [#4455](https://github.com/gohugoio/hugo/issues/4455)
+
+
+
+
+
+
--- /dev/null
--- /dev/null
++
++Small Multiples is a multidisciplinary team of data specialists, designers and developers that help people make the best use of their data, a journey that starts from strategy, to concepts, mock-ups, prototypes, design, and development.
++
--- /dev/null
--- /dev/null
++---
++
++title: Small Multiples
++date: 2018-02-28
++description: "\"Hugo has excellent support and integration with Netlify and we were immediately blown away by how fast it was.\""
++siteURL: https://smallmultiples.com.au/
++byline: "[Small Multiples](https://smallmultiples.com.au/)"
++draft: true
++---
++
++Previously we had built and hosted our website with SquareSpace. Although SquareSpace was adequate for quickly showcasing our work, we felt it didn’t reflect our technical capabilities and the types of products we build for our clients.
++
++For many client applications, static front-end sites provide fast, scalable solutions that can easily connect with any back-end service, API or static data. We wanted to use the same processes and infrastructure that we use to host and deploy many of our products, so we felt that building a static site was the right solution for our website.
++
++Netlify is a hosting and deployment service that we use for many products. Our developers really like it because it has strong integration with GitHub and it works with the build tools we use such as Yarn and Webpack. It creates a production build every time we commit to our GitHub repository. This means we can share and preview every change internally or with clients.
++
++Application development has become increasingly complex and there is a strong motivation to simplify this process by avoiding complicated backends in favour of applications that consume static data and APIs (a JAMstack).
++
++Libraries like React make this easy, but we also wanted something that was server rendered. This led us to look at React based tools for static site generation such as GatsbyJS. We liked GatsbyJS, but in the end, we didn’t choose it due to the lack of availability of a simple CMS driven data source.
++
++For this, we considered Contentful. Contentful is a beautifully designed application. It’s basically a headless CMS, but it’s not specifically designed for websites and it becomes quite expensive at a commercial level. Their free tier is possibly a good option for personal sites especially with Gatsby. We also evaluated prose.io. This is a free service for editing markdown files in a GitHub repository. It works well, but it’s quite basic and didn’t provide the editing experience we were looking for.
++
++At the same time, we started exploring Hugo. Hugo is a static site generator similar to Jekyll, but it’s written in Go. It has excellent support and integration with Netlify and we were immediately blown away by how fast it was.
++
++We had been closely following the redevelopment of the Smashing Magazine website. We knew this was being powered by Hugo and Netlify and this showed us that Hugo could work for a large scale sites.
++
++The deciding factor, however, was the availability of CMS options that integrate well with Hugo. Netlify has an open source project called NetlifyCMS and there are also hosted services like Forestry.io. These both provide a CMS with an editing interface for markdown files and images. There is no database, instead, changes are committed directly back into the GitHub repository.
++
++In the end, we chose Hugo on Netlify, with Forestry as our CMS. The site is built and redeployed immediately with Netlify watching for changes to the GitHub repository.
++
++Was this the right choice? For us, yes, but we learnt a few things along the way.
++
++The Hugo templating language was very powerful, although also frustrating at times. The queries used to filter list pages are concise but difficult to read. Although it’s easy to get started, Hugo can have a significant learning curve as you try to do more complicated things.
++
++Hugo has particular expectations when it comes to CMS concepts like tags, categories, RSS, related content and menus. Some parts of our initial design did not match perfectly with how these work in Hugo. It took some time to figure out how to make things work the way we wanted without losing all the benefits of structured content.
++
++There were a few teething issues. We picked some relatively new technologies and as a result, we encountered some bugs. We were forced to find some workarounds and logged some issues with Hugo during the course of development. Most of these were fixed and features were added with releases happening frequently over the time we were working on the project. This can be exciting but also frustrating. We can see Hugo is developing in the right direction.
++
++NetlifyCMS was also very new when we first looked at it and this is partly why we opted for Forestry. Forestry is an excellent choice for an out-of-the-box CMS and it needs very little code configuration. It provided a better editing experience for non-technical users. I would still say this is true, but it also provides fewer options for customisation when compared with NetlifyCMS.
++
++Fortunately, the site is more portable now than it was, or would have been with a dynamic CMS like WordPress, or a fully hosted service like SquareSpace. It should be comparatively easy to swap the publishing functions from Forestry to NetlifyCMS or to change the templates. No part of the pipe-line is tightly coupled, the hosting, the CMS and the templates and the build process can all be updated independently, without changing anything else.
++
++We have complete control over the design and mark-up produced. This means we can implement a better responsive design and have a stronger focus on accessibility and performance.
++
++These technology choices gave us a good performance baseline. It was important to implement a site that took advantage of this. As a data visualisation agency, it can be difficult to optimise for performance with a small bundle size, while also aiming for high-quality visuals and working with large datasets. This meant we spent a lot of time optimising assets making sure there was little blocking the critical path for faster rendering and lazy-load images and videos.
++
++The end result is a high performance site. We think this could have been achieved with GatsbyJS, Hugo or any another static site generator. However, what was important was the decision to use static infrastructure for speed, security, flexibility and hopefully a better ongoing development experience. If you are looking at choosing a static site generator or wondering whether a static is the right choice for you, we hope this has helped.
--- /dev/null
- And then in the `partial/artist.html`:
+---
+title: Data Templates
+linktitle:
+description: In addition to Hugo's built-in variables, you can specify your own custom data in templates or shortcodes that pull from both local and dynamic sources.
+date: 2017-02-01
+publishdate: 2017-02-01
+lastmod: 2017-03-12
+categories: [templates]
+keywords: [data,dynamic,csv,json,toml,yaml]
+menu:
+ docs:
+ parent: "templates"
+ weight: 80
+weight: 80
+sections_weight: 80
+draft: false
+aliases: [/extras/datafiles/,/extras/datadrivencontent/,/doc/datafiles/]
+toc: true
+---
+
+<!-- begin data files -->
+
+Hugo supports loading data from YAML, JSON, and TOML files located in the `data` directory in the root of your Hugo project.
+
+{{< youtube FyPgSuwIMWQ >}}
+
+## The Data Folder
+
+The `data` folder is where you can store additional data for Hugo to use when generating your site. Data files aren't used to generate standalone pages; rather, they're meant to be supplemental to content files. This feature can extend the content in case your front matter fields grow out of control. Or perhaps you want to show a larger dataset in a template (see example below). In both cases, it's a good idea to outsource the data in their own files.
+
+These files must be YAML, JSON, or TOML files (using the `.yml`, `.yaml`, `.json`, or `.toml` extension). The data will be accessible as a `map` in the `.Site.Data` variable.
+
+## Data Files in Themes
+
+Data Files can also be used in [Hugo themes][themes] but note that theme data files follow the same logic as other template files in the [Hugo lookup order][lookup] (i.e., given two files with the same name and relative path, the file in the root project `data` directory will override the file in the `themes/<THEME>/data` directory).
+
+Therefore, theme authors should take care to not include data files that could be easily overwritten by a user who decides to [customize a theme][customize]. For theme-specific data items that shouldn't be overridden, it can be wise to prefix the folder structure with a namespace; e.g. `mytheme/data/<THEME>/somekey/...`. To check if any such duplicate exists, run hugo with the `-v` flag.
+
+The keys in the map created with data templates from data files will be a dot-chained set of `path`, `filename`, and `key` in file (if applicable).
+
+This is best explained with an example:
+
+## Example: Jaco Pastorius' Solo Discography
+
+[Jaco Pastorius](http://en.wikipedia.org/wiki/Jaco_Pastorius_discography) was a great bass player, but his solo discography is short enough to use as an example. [John Patitucci](http://en.wikipedia.org/wiki/John_Patitucci) is another bass giant.
+
+The example below is a bit contrived, but it illustrates the flexibility of data Files. This example uses TOML as its file format with the two following data files:
+
+* `data/jazz/bass/jacopastorius.toml`
+* `data/jazz/bass/johnpatitucci.toml`
+
+`jacopastorius.toml` contains the content below. `johnpatitucci.toml` contains a similar list:
+
+```
+discography = [
+"1974 – Modern American Music … Period! The Criteria Sessions",
+"1974 – Jaco",
+"1976 - Jaco Pastorius",
+"1981 - Word of Mouth",
+"1981 - The Birthday Concert (released in 1995)",
+"1982 - Twins I & II (released in 1999)",
+"1983 - Invitation",
+"1986 - Broadway Blues (released in 1998)",
+"1986 - Honestly Solo Live (released in 1990)",
+"1986 - Live In Italy (released in 1991)",
+"1986 - Heavy'n Jazz (released in 1992)",
+"1991 - Live In New York City, Volumes 1-7.",
+"1999 - Rare Collection (compilation)",
+"2003 - Punk Jazz: The Jaco Pastorius Anthology (compilation)",
+"2007 - The Essential Jaco Pastorius (compilation)"
+]
+```
+
+The list of bass players can be accessed via `.Site.Data.jazz.bass`, a single bass player by adding the filename without the suffix, e.g. `.Site.Data.jazz.bass.jacopastorius`.
+
+You can now render the list of recordings for all the bass players in a template:
+
+```
+{{ range $.Site.Data.jazz.bass }}
+ {{ partial "artist.html" . }}
+{{ end }}
+```
+
++And then in the `partials/artist.html`:
+
+```
+<ul>
+{{ range .discography }}
+ <li>{{ . }}</li>
+{{ end }}
+</ul>
+```
+
+Discover a new favorite bass player? Just add another `.toml` file in the same directory.
+
+## Example: Accessing Named Values in a Data File
+
+Assume you have the following YAML structure in your `User0123.yml` data file located directly in `data/`:
+
+```
+Name: User0123
+"Short Description": "He is a **jolly good** fellow."
+Achievements:
+ - "Can create a Key, Value list from Data File"
+ - "Learns Hugo"
+ - "Reads documentation"
+```
+
+You can use the following code to render the `Short Description` in your layout::
+
+```
+<div>Short Description of {{.Site.Data.User0123.Name}}: <p>{{ index .Site.Data.User0123 "Short Description" | markdownify }}</p></div>
+```
+
+Note the use of the [`markdownify` template function][markdownify]. This will send the description through the Blackfriday Markdown rendering engine.
+
+<!-- begin "Data-drive Content" page -->
+
+## Data-Driven Content
+
+In addition to the [data files](/extras/datafiles/) feature, Hugo also a "data-driven content" feature, which lets you load any [JSON](http://www.json.org/) or [CSV](http://en.wikipedia.org/wiki/Comma-separated_values) file from nearly any resource.
+
+Data-driven content currently consists of two functions, `getJSON` and `getCSV`, which are available in all template files.
+
+## Implementation details
+
+### Call the Functions with a URL
+
+In your template, call the functions like this:
+
+```
+{{ $dataJ := getJSON "url" }}
+{{ $dataC := getCSV "separator" "url" }}
+```
+
+If you use a prefix or postfix for the URL, the functions accept [variadic arguments][variadic]:
+
+```
+{{ $dataJ := getJSON "url prefix" "arg1" "arg2" "arg n" }}
+{{ $dataC := getCSV "separator" "url prefix" "arg1" "arg2" "arg n" }}
+```
+
+The separator for `getCSV` must be put in the first position and can only be one character long.
+
+All passed arguments will be joined to the final URL:
+
+```
+{{ $urlPre := "https://api.github.com" }}
+{{ $gistJ := getJSON $urlPre "/users/GITHUB_USERNAME/gists" }}
+```
+
+This will resolve internally to the following:
+
+```
+{{ $gistJ := getJSON "https://api.github.com/users/GITHUB_USERNAME/gists" }}
+```
+
+Finally, you can range over an array. This example will output the
+first 5 gists for a GitHub user:
+
+```
+<ul>
+ {{ $urlPre := "https://api.github.com" }}
+ {{ $gistJ := getJSON $urlPre "/users/GITHUB_USERNAME/gists" }}
+ {{ range first 5 $gistJ }}
+ {{ if .public }}
+ <li><a href="{{ .html_url }}" target="_blank">{{ .description }}</a></li>
+ {{ end }}
+ {{ end }}
+</ul>
+```
+
+### Example for CSV files
+
+For `getCSV`, the one-character-long separator must be placed in the first position followed by the URL. The following is an example of creating an HTML table in a [partial template][partials] from a published CSV:
+
+{{< code file="layouts/partials/get-csv.html" >}}
+ <table>
+ <thead>
+ <tr>
+ <th>Name</th>
+ <th>Position</th>
+ <th>Salary</th>
+ </tr>
+ </thead>
+ <tbody>
+ {{ $url := "http://a-big-corp.com/finance/employee-salaries.csv" }}
+ {{ $sep := "," }}
+ {{ range $i, $r := getCSV $sep $url }}
+ <tr>
+ <td>{{ index $r 0 }}</td>
+ <td>{{ index $r 1 }}</td>
+ <td>{{ index $r 2 }}</td>
+ </tr>
+ {{ end }}
+ </tbody>
+ </table>
+{{< /code >}}
+
+The expression `{{index $r number}}` must be used to output the nth-column from the current row.
+
+### Cache URLs
+
+Each downloaded URL will be cached in the default folder `$TMPDIR/hugo_cache/`. The variable `$TMPDIR` will be resolved to your system-dependent temporary directory.
+
+With the command-line flag `--cacheDir`, you can specify any folder on your system as a caching directory.
+
+You can also set `cacheDir` in the [main configuration file][config].
+
+If you don't like caching at all, you can fully disable caching with the command line flag `--ignoreCache`.
+
+### Authentication When Using REST URLs
+
+Currently, you can only use those authentication methods that can be put into an URL. [OAuth][] and other authentication methods are not implemented.
+
+### Load Local files
+
+To load local files with `getJSON` and `getCSV`, the source files must reside within Hugo's working directory. The file extension does not matter, but the content does.
+
+It applies the same output logic as above in [Calling the Functions with a URL](#calling-the-functions-with-a-url).
+
+## LiveReload with Data Files
+
+There is no chance to trigger a [LiveReload][] when the content of a URL changes. However, when a *local* file changes (i.e., `data/*` and `themes/<THEME>/data/*`), a LiveReload will be triggered. Symlinks are not supported. Note too that because downloading of data takes a while, Hugo stops processing your Markdown files until the data download has completed.
+
+{{% warning "URL Data and LiveReload" %}}
+If you change any local file and the LiveReload is triggered, Hugo will read the data-driven (URL) content from the cache. If you have disabled the cache (i.e., by running the server with `hugo server --ignoreCache`), Hugo will re-download the content every time LiveReload triggers. This can create *huge* traffic. You may reach API limits quickly.
+{{% /warning %}}
+
+## Examples of Data-driven Content
+
+- Photo gallery JSON powered: [https://github.com/pcdummy/hugo-lightslider-example](https://github.com/pcdummy/hugo-lightslider-example)
+- GitHub Starred Repositories [in a post](https://github.com/SchumacherFM/blog-cs/blob/master/content%2Fposts%2Fgithub-starred.md) using data-driven content in a [custom short code](https://github.com/SchumacherFM/blog-cs/blob/master/layouts%2Fshortcodes%2FghStarred.html).
+
+## Specs for Data Formats
+
+* [TOML Spec][toml]
+* [YAML Spec][yaml]
+* [JSON Spec][json]
+* [CSV Spec][csv]
+
+[config]: /getting-started/configuration/
+[csv]: https://tools.ietf.org/html/rfc4180
+[customize]: /themes/customizing/
+[json]: https://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf "Specification for JSON, JavaScript Object Notation"
+[LiveReload]: /getting-started/usage/#livereload
+[lookup]: /templates/lookup-order/
+[markdownify]: /functions/markdownify/
+[OAuth]: http://en.wikipedia.org/wiki/OAuth
+[partials]: /templates/partials/
+[themes]: /themes/
+[toml]: https://github.com/toml-lang/toml
+[variadic]: http://en.wikipedia.org/wiki/Variadic_function
+[vars]: /variables/
+[yaml]: http://yaml.org/spec/
--- /dev/null
- #### Default Section Templates
-
- 1. `layouts/_default/section.html`
- 2. `layouts/_default/list.html`
-
- #### Default Taxonomy List Templates
-
- 1. `layouts/_default/taxonomy.html`
- 2. `themes/<THEME>/layouts/_default/taxonomy.html`
+---
+title: Lists of Content in Hugo
+linktitle: List Page Templates
+description: Lists have a specific meaning and usage in Hugo when it comes to rendering your site homepage, section page, taxonomy list, or taxonomy terms list.
+date: 2017-02-01
+publishdate: 2017-02-01
+lastmod: 2017-02-01
+categories: [templates]
+keywords: [lists,sections,rss,taxonomies,terms]
+menu:
+ docs:
+ parent: "templates"
+ weight: 22
+weight: 22
+sections_weight: 22
+draft: false
+aliases: [/templates/list/,/layout/indexes/]
+toc: true
+---
+
+## What is a List Page Template?
+
+{{< youtube 8b2YTSMdMps >}}
+
+A list page template is a template used to render multiple pieces of content in a single HTML page. The exception to this rule is the homepage, which is still a list but has its own [dedicated template][homepage].
+
+Hugo uses the term *list* in its truest sense; i.e. a sequential arrangement of material, especially in alphabetical or numerical order. Hugo uses list templates on any output HTML page where content is traditionally listed:
+
+* [Taxonomy terms pages][taxterms]
+* [Taxonomy list pages][taxlists]
+* [Section list pages][sectiontemps]
+* [RSS][rss]
+
+For template lookup order, see [Template Lookup](/templates/lookup-order/).
+
+The idea of a list page comes from the [hierarchical mental model of the web][mentalmodel] and is best demonstrated visually:
+
+
+
+## List Defaults
+
+### Default Templates
+
+Since section lists and taxonomy lists (N.B., *not* [taxonomy terms lists][taxterms]) are both *lists* with regards to their templates, both have the same terminating default of `_default/list.html` or `themes/<THEME>/layouts/_default/list.html` in their lookup order. In addition, both [section lists][sectiontemps] and [taxonomy lists][taxlists] have their own default list templates in `_default`:
+
++See [Template Lookup Order](/templates/lookup-order/) for the complete reference.
+
+## Add Content and Front Matter to List Pages
+
+Since v0.18, [everything in Hugo is a `Page`][bepsays]. This means list pages and the homepage can have associated content files (i.e. `_index.md`) that contain page metadata (i.e., front matter) and content.
+
+This new model allows you to include list-specific front matter via `.Params` and also means that list templates (e.g., `layouts/_default/list.html`) have access to all [page variables][pagevars].
+
+{{% note %}}
+It is important to note that all `_index.md` content files will render according to a *list* template and not according to a [single page template](/templates/single-page-templates/).
+{{% /note %}}
+
+### Example Project Directory
+
+The following is an example of a typical Hugo project directory's content:
+
+```
+.
+...
+├── content
+| ├── post
+| | ├── _index.md
+| | ├── post-01.md
+| | └── post-02.md
+| └── quote
+| | ├── quote-01.md
+| | └── quote-02.md
+...
+```
+
+Using the above example, let's assume you have the following in `content/post/_index.md`:
+
+{{< code file="content/post/_index.md" >}}
+---
+title: My Golang Journey
+date: 2017-03-23
+publishdate: 2017-03-24
+---
+
+I decided to start learning Golang in March 2017.
+
+Follow my journey through this new blog.
+{{< /code >}}
+
+You can now access this `_index.md`'s' content in your list template:
+
+{{< code file="layouts/_default/list.html" download="list.html" >}}
+{{ define "main" }}
+<main>
+ <article>
+ <header>
+ <h1>{{.Title}}</h1>
+ </header>
+ <!-- "{{.Content}}" pulls from the markdown content of the corresponding _index.md -->
+ {{.Content}}
+ </article>
+ <ul>
+ <!-- Ranges through content/post/*.md -->
+ {{ range .Data.Pages }}
+ <li>
+ <a href="{{.Permalink}}">{{.Date.Format "2006-01-02"}} | {{.Title}}</a>
+ </li>
+ {{ end }}
+ </ul>
+</main>
+{{ end }}
+{{< /code >}}
+
+This above will output the following HTML:
+
+{{< code file="example.com/post/index.html" copy="false" >}}
+<!--top of your baseof code-->
+<main>
+ <article>
+ <header>
+ <h1>My Golang Journey</h1>
+ </header>
+ <p>I decided to start learning Golang in March 2017.</p>
+ <p>Follow my journey through this new blog.</p>
+ </article>
+ <ul>
+ <li><a href="/post/post-01/">Post 1</a></li>
+ <li><a href="/post/post-02/">Post 2</a></li>
+ </ul>
+</main>
+<!--bottom of your baseof-->
+{{< /code >}}
+
+### List Pages Without `_index.md`
+
+You do *not* have to create an `_index.md` file for every list page (i.e. section, taxonomy, taxonomy terms, etc) or the homepage. If Hugo does not find an `_index.md` within the respective content section when rendering a list template, the page will be created but with no `{{.Content}}` and only the default values for `.Title` etc.
+
+Using this same `layouts/_default/list.html` template and applying it to the `quotes` section above will render the following output. Note that `quotes` does not have an `_index.md` file to pull from:
+
+{{< code file="example.com/quote/index.html" copy="false" >}}
+<!--baseof-->
+<main>
+ <article>
+ <header>
+ <!-- Hugo assumes that .Title is the name of the section since there is no _index.md content file from which to pull a "title:" field -->
+ <h1>Quotes</h1>
+ </header>
+ </article>
+ <ul>
+ <li><a href="https://example.com/quote/quotes-01/">Quote 1</a></li>
+ <li><a href="https://example.com/quote/quotes-02/">Quote 2</a></li>
+ </ul>
+</main>
+<!--baseof-->
+{{< /code >}}
+
+{{% note %}}
+The default behavior of Hugo is to pluralize list titles; hence the inflection of the `quote` section to "Quotes" when called with the `.Title` [page variable](/variables/page/). You can change this via the `pluralizeListTitles` directive in your [site configuration](/getting-started/configuration/).
+{{% /note %}}
+
+## Example List Templates
+
+### Section Template
+
+This list template has been modified slightly from a template originally used in [spf13.com](http://spf13.com/). It makes use of [partial templates][partials] for the chrome of the rendered page rather than using a [base template][base] The examples that follow also use the [content view templates][views] `li.html` or `summary.html`.
+
+{{< code file="layouts/section/post.html" >}}
+{{ partial "header.html" . }}
+{{ partial "subheader.html" . }}
+<main>
+ <div>
+ <h1>{{ .Title }}</h1>
+ <ul>
+ <!-- Renders the li.html content view for each content/post/*.md -->
+ {{ range .Data.Pages }}
+ {{ .Render "li"}}
+ {{ end }}
+ </ul>
+ </div>
+</main>
+{{ partial "footer.html" . }}
+{{< /code >}}
+
+### Taxonomy Template
+
+{{< code file="layouts/_default/taxonomies.html" download="taxonomies.html" >}}
+{{ define "main" }}
+<main>
+ <div>
+ <h1>{{ .Title }}</h1>
+ <!-- ranges through each of the content files associated with a particular taxonomy term and renders the summary.html content view -->
+ {{ range .Data.Pages }}
+ {{ .Render "summary"}}
+ {{ end }}
+ </div>
+</main>
+{{ end }}
+{{< /code >}}
+
+## Order Content
+
+Hugo lists render the content based on metadata you provide in [front matter][]. In addition to sane defaults, Hugo also ships with multiple methods to make quick work of ordering content inside list templates:
+
+### Default: Weight > Date > LinkTitle > FilePath
+
+{{< code file="layouts/partials/default-order.html" >}}
+<ul>
+ {{ range .Data.Pages }}
+ <li>
+ <h1><a href="{{ .Permalink }}">{{ .Title }}</a></h1>
+ <time>{{ .Date.Format "Mon, Jan 2, 2006" }}</time>
+ </li>
+ {{ end }}
+</ul>
+{{< /code >}}
+
+### By Weight
+
+{{< code file="layouts/partials/by-weight.html" >}}
+<ul>
+ {{ range .Data.Pages.ByWeight }}
+ <li>
+ <h1><a href="{{ .Permalink }}">{{ .Title }}</a></h1>
+ <time>{{ .Date.Format "Mon, Jan 2, 2006" }}</time>
+ </li>
+ {{ end }}
+</ul>
+{{< /code >}}
+
+### By Date
+
+{{< code file="layouts/partials/by-date.html" >}}
+<ul>
+ <!-- orders content according to the "date" field in front matter -->
+ {{ range .Data.Pages.ByDate }}
+ <li>
+ <h1><a href="{{ .Permalink }}">{{ .Title }}</a></h1>
+ <time>{{ .Date.Format "Mon, Jan 2, 2006" }}</time>
+ </li>
+ {{ end }}
+</ul>
+{{< /code >}}
+
+### By Publish Date
+
+{{< code file="layouts/partials/by-publish-date.html" >}}
+<ul>
+ <!-- orders content according to the "publishdate" field in front matter -->
+ {{ range .Data.Pages.ByPublishDate }}
+ <li>
+ <h1><a href="{{ .Permalink }}">{{ .Title }}</a></h1>
+ <time>{{ .Date.Format "Mon, Jan 2, 2006" }}</time>
+ </li>
+ {{ end }}
+</ul>
+{{< /code >}}
+
+### By Expiration Date
+
+{{< code file="layouts/partials/by-expiry-date.html" >}}
+<ul>
+ {{ range .Data.Pages.ByExpiryDate }}
+ <li>
+ <h1><a href="{{ .Permalink }}">{{ .Title }}</a></h1>
+ <time>{{ .Date.Format "Mon, Jan 2, 2006" }}</time>
+ </li>
+ {{ end }}
+</ul>
+{{< /code >}}
+
+### By Last Modified Date
+
+{{< code file="layouts/partials/by-last-mod.html" >}}
+<ul>
+ <!-- orders content according to the "lastmod" field in front matter -->
+ {{ range .Data.Pages.ByLastmod }}
+ <li>
+ <h1><a href="{{ .Permalink }}">{{ .Title }}</a></h1>
+ <time>{{ .Date.Format "Mon, Jan 2, 2006" }}</time>
+ </li>
+ {{ end }}
+</ul>
+{{< /code >}}
+
+### By Length
+
+{{< code file="layouts/partials/by-length.html" >}}
+<ul>
+ <!-- orders content according to content length in ascending order (i.e., the shortest content will be listed first) -->
+ {{ range .Data.Pages.ByLength }}
+ <li>
+ <h1><a href="{{ .Permalink }}">{{ .Title }}</a></h1>
+ <time>{{ .Date.Format "Mon, Jan 2, 2006" }}</time>
+ </li>
+ {{ end }}
+</ul>
+{{< /code >}}
+
+### By Title
+
+{{< code file="layouts/partials/by-title.html" >}}
+<ul>
+ <!-- ranges through content in ascending order according to the "title" field set in front matter -->
+ {{ range .Data.Pages.ByTitle }}
+ <li>
+ <h1><a href="{{ .Permalink }}">{{ .Title }}</a></h1>
+ <time>{{ .Date.Format "Mon, Jan 2, 2006" }}</time>
+ </li>
+ {{ end }}
+</ul>
+{{< /code >}}
+
+### By Link Title
+
+{{< code file="layouts/partials/by-link-title.html" >}}
+<ul>
+ <!-- ranges through content in ascending order according to the "linktitle" field in front matter. If a "linktitle" field is not set, the range will start with content that only has a "title" field and use that value for .LinkTitle -->
+ {{ range .Data.Pages.ByLinkTitle }}
+ <li>
+ <h1><a href="{{ .Permalink }}">{{ .LinkTitle }}</a></h1>
+ <time>{{ .Date.Format "Mon, Jan 2, 2006" }}</time>
+ </li>
+ {{ end }}
+</ul>
+{{< /code >}}
+
+### By Parameter
+
+Order based on the specified front matter parameter. Content that does not have the specified front matter field will use the site's `.Site.Params` default. If the parameter is not found at all in some entries, those entries will appear together at the end of the ordering.
+
+{{< code file="layouts/partials/by-rating.html" >}}
+<!-- Ranges through content according to the "rating" field set in front matter -->
+{{ range (.Data.Pages.ByParam "rating") }}
+ <!-- ... -->
+{{ end }}
+{{< /code >}}
+
+If the targeted front matter field is nested beneath another field, you can access the field using dot notation.
+
+{{< code file="layouts/partials/by-nested-param.html" >}}
+{{ range (.Data.Pages.ByParam "author.last_name") }}
+ <!-- ... -->
+{{ end }}
+{{< /code >}}
+
+### Reverse Order
+
+Reversing order can be applied to any of the above methods. The following uses `ByDate` as an example:
+
+{{< code file="layouts/partials/by-date-reverse.html" >}}
+<ul>
+ {{ range .Data.Pages.ByDate.Reverse }}
+ <li>
+ <h1><a href="{{ .Permalink }}">{{ .Title }}</a></h1>
+ <time>{{ .Date.Format "Mon, Jan 2, 2006" }}</time>
+ </li>
+ {{ end }}
+</ul>
+{{< /code >}}
+
+## Group Content
+
+Hugo provides some functions for grouping pages by Section, Type, Date, etc.
+
+### By Page Field
+
+{{< code file="layouts/partials/by-page-field.html" >}}
+<!-- Groups content according to content section. The ".Key" in this instance will be the section's title. -->
+{{ range .Data.Pages.GroupBy "Section" }}
+<h3>{{ .Key }}</h3>
+<ul>
+ {{ range .Pages }}
+ <li>
+ <a href="{{ .Permalink }}">{{ .Title }}</a>
+ <div class="meta">{{ .Date.Format "Mon, Jan 2, 2006" }}</div>
+ </li>
+ {{ end }}
+</ul>
+{{ end }}
+{{< /code >}}
+
+In the above example, you may want `{{.Title}}` to point the `title` field you have added to your `_index.md` file instead. You can access this value using the [`.GetPage` function][getpage]:
+
+{{< code file="layouts/partials/by-page-field.html" >}}
+<!-- Groups content according to content section.-->
+{{ range .Data.Pages.GroupBy "Section" }}
+<!-- Checks for existence of _index.md for a section; if available, pulls from "title" in front matter -->
+{{ with $.Site.GetPage "section" .Key }}
+<h3>{{.Title}}</h3>
+{{ else }}
+<!-- If no _index.md is available, ".Key" defaults to the section title and filters to title casing -->
+<h3>{{ .Key | title }}</h3>
+{{ end }}
+<ul>
+ {{ range .Pages }}
+ <li>
+ <a href="{{ .Permalink }}">{{ .Title }}</a>
+ <div class="meta">{{ .Date.Format "Mon, Jan 2, 2006" }}</div>
+ </li>
+ {{ end }}
+</ul>
+{{ end }}
+{{< /code >}}
+
+### By Date
+
+{{< code file="layouts/partials/by-page-date.html" >}}
+<!-- Groups content by month according to the "date" field in front matter -->
+{{ range .Data.Pages.GroupByDate "2006-01" }}
+<h3>{{ .Key }}</h3>
+<ul>
+ {{ range .Pages }}
+ <li>
+ <a href="{{ .Permalink }}">{{ .Title }}</a>
+ <div class="meta">{{ .Date.Format "Mon, Jan 2, 2006" }}</div>
+ </li>
+ {{ end }}
+</ul>
+{{ end }}
+{{< /code >}}
+
+### By Publish Date
+
+{{< code file="layouts/partials/by-page-publish-date.html" >}}
+<!-- Groups content by month according to the "publishdate" field in front matter -->
+{{ range .Data.Pages.GroupByPublishDate "2006-01" }}
+<h3>{{ .Key }}</h3>
+<ul>
+ {{ range .Pages }}
+ <li>
+ <a href="{{ .Permalink }}">{{ .Title }}</a>
+ <div class="meta">{{ .PublishDate.Format "Mon, Jan 2, 2006" }}</div>
+ </li>
+ {{ end }}
+</ul>
+{{ end }}
+{{< /code >}}
+
+### By Page Parameter
+
+{{< code file="layouts/partials/by-page-param.html" >}}
+<!-- Groups content according to the "param_key" field in front matter -->
+{{ range .Data.Pages.GroupByParam "param_key" }}
+<h3>{{ .Key }}</h3>
+<ul>
+ {{ range .Pages }}
+ <li>
+ <a href="{{ .Permalink }}">{{ .Title }}</a>
+ <div class="meta">{{ .Date.Format "Mon, Jan 2, 2006" }}</div>
+ </li>
+ {{ end }}
+</ul>
+{{ end }}
+{{< /code >}}
+
+### By Page Parameter in Date Format
+
+The following template takes grouping by `date` a step further and uses Golang's layout string. See the [`Format` function][] for more examples of how to use Golang's layout string to format dates in Hugo.
+
+{{< code file="layouts/partials/by-page-param-as-date.html" >}}
+<!-- Groups content by month according to the "param_key" field in front matter -->
+{{ range .Data.Pages.GroupByParamDate "param_key" "2006-01" }}
+<h3>{{ .Key }}</h3>
+<ul>
+ {{ range .Pages }}
+ <li>
+ <a href="{{ .Permalink }}">{{ .Title }}</a>
+ <div class="meta">{{ .Date.Format "Mon, Jan 2, 2006" }}</div>
+ </li>
+ {{ end }}
+</ul>
+{{ end }}
+{{< /code >}}
+
+### Reverse Key Order
+
+Ordering of groups is performed by keys in alphanumeric order (A–Z, 1–100) and in reverse chronological order (i.e., with the newest first) for dates.
+
+While these are logical defaults, they are not always the desired order. There are two different syntaxes to change Hugo's default ordering for groups, both of which work the same way.
+
+#### 1. Adding the Reverse Method
+
+```
+{{ range (.Data.Pages.GroupBy "Section").Reverse }}
+```
+
+```
+{{ range (.Data.Pages.GroupByDate "2006-01").Reverse }}
+```
+
+#### 2. Providing the Alternate Direction
+
+```
+{{ range .Data.Pages.GroupByDate "2006-01" "asc" }}
+```
+
+```
+{{ range .Data.Pages.GroupBy "Section" "desc" }}
+```
+
+### Order Within Groups
+
+Because Grouping returns a `{{.Key}}` and a slice of pages, all of the ordering methods listed above are available.
+
+Here is the ordering for the example that follows:
+
+1. Content is grouped by month according to the `date` field in front matter.
+2. Groups are listed in ascending order (i.e., the oldest groups first)
+3. Pages within each respective group are ordered alphabetically according to the `title`.
+
+{{< code file="layouts/partials/by-group-by-page.html" >}}
+{{ range .Data.Pages.GroupByDate "2006-01" "asc" }}
+<h3>{{ .Key }}</h3>
+<ul>
+ {{ range .Pages.ByTitle }}
+ <li>
+ <a href="{{ .Permalink }}">{{ .Title }}</a>
+ <div class="meta">{{ .Date.Format "Mon, Jan 2, 2006" }}</div>
+ </li>
+ {{ end }}
+</ul>
+{{ end }}
+{{< /code >}}
+
+## Filter and Limiting Lists
+
+Sometimes you only want to list a subset of the available content. A common is to only display “Posts” on blog's homepage. You can accomplish this with the `where` function.
+
+### `where`
+
+`where` works in a similar manner to the [`where` keyword in SQL][wherekeyword]. It selects all elements of the array or slice that match the provided field and value. `where` takes three arguments:
+
+1. `array` *or* `slice of maps or structs`
+2. `key` *or* `field name`
+3. `match value`
+
+{{< code file="layouts/_default/.html" >}}
+{{ range where .Data.Pages "Section" "post" }}
+ {{ .Content }}
+{{ end }}
+{{< /code >}}
+
+You can see more examples in the [functions documentation for `where`][wherefunction].
+
+### `first`
+
+`first` works in a similar manner to the [`limit` keyword in SQL][limitkeyword]. It reduces the array to only the `first N` elements. It takes the array and number of elements as input. `first` takes two arguments:
+
+1. `array` *or* `slice of maps or structs`
+2. `number of elements`
+
+{{< code file="layout/_default/section.html" >}}
+{{ range first 10 .Data.Pages }}
+ {{ .Render "summary" }}
+{{ end }}
+{{< /code >}}
+
+### `first` and `where` Together
+
+Using `first` and `where` together can be very powerful:
+
+{{< code file="first-and-where-together.html" >}}
+<!-- Orders the content inside the "posts" section by the "title" field and then ranges through only the first 5 posts -->
+{{ range first 5 (where .Data.Pages "Section" "post").ByTitle }}
+ {{ .Content }}
+{{ end }}
+{{< /code >}}
+
+[base]: /templates/base/
+[bepsays]: http://bepsays.com/en/2016/12/19/hugo-018/
+[directorystructure]: /getting-started/directory-structure/
+[`Format` function]: /functions/format/
+[front matter]: /content-management/front-matter/
+[getpage]: /functions/getpage/
+[homepage]: /templates/homepage/
+[homepage]: /templates/homepage/
+[limitkeyword]: https://www.techonthenet.com/sql/select_limit.php
+[mentalmodel]: http://webstyleguide.com/wsg3/3-information-architecture/3-site-structure.html
+[pagevars]: /variables/page/
+[partials]: /templates/partials/
+[RSS 2.0]: http://cyber.law.harvard.edu/rss/rss.html "RSS 2.0 Specification"
+[rss]: /templates/rss/
+[sections]: /content-management/sections/
+[sectiontemps]: /templates/section-templates/
+[sitevars]: /variables/site/
+[taxlists]: /templates/taxonomy-templates/#taxonomy-list-templates/
+[taxterms]: /templates/taxonomy-templates/#taxonomy-terms-templates/
+[taxvars]: /variables/taxonomy/
+[views]: /templates/views/
+[wherefunction]: /functions/where/
+[wherekeyword]: https://www.techonthenet.com/sql/where.php
--- /dev/null
- See [Template Lookup](/templates/lookup-order/).
+---
+title: RSS Templates
+linktitle: RSS Templates
+description: Hugo ships with its own RSS 2.0 template that requires almost no configuration, or you can create your own RSS templates.
+date: 2017-02-01
+publishdate: 2017-02-01
+lastmod: 2017-02-01
+keywords: [rss, xml, templates]
+categories: [templates]
+menu:
+ docs:
+ parent: "templates"
+ weight: 150
+weight: 150
+sections_weight: 150
+draft: false
+aliases: [/templates/rss/]
+toc: true
+---
+
+## RSS Template Lookup Order
+
- ### Main RSS
++See [Template Lookup Order](/templates/lookup-order/) for the complete reference.
+
+{{% note "Hugo Ships with an RSS Template" %}}
+Hugo ships with its own [RSS 2.0 template](#the-embedded-rss-xml). The embedded template will be sufficient for most use cases.
+{{% /note %}}
+
+RSS pages are of the type `Page` and have all the [page variables](/variables/page/) available to use in the templates.
+
+### Section RSS
+
+A [section’s][section] RSS will be rendered at `/<SECTION>/index.xml` (e.g., http://spf13.com/project/index.xml).
+
+Hugo provides the ability for you to define any RSS type you wish and can have different RSS files for each section and taxonomy.
+
+## Lookup Order for RSS Templates
+
- 1. `/layouts/rss.xml`
- 2. `/layouts/_default/rss.xml`
- 3. Embedded rss.xml
-
- ### Section RSS
-
- 1. `/layouts/section/<SECTION>.rss.xml`
- 2. `/layouts/_default/rss.xml`
- 3. `/themes/<THEME>/layouts/section/<SECTION>.rss.xml`
- 4. `/themes/<THEME>/layouts/_default/rss.xml`
- 5. Embedded rss.xml
-
- ### Taxonomy RSS
-
- 1. `/layouts/taxonomy/<SINGULAR>.rss.xml`
- 2. `/layouts/_default/rss.xml`
- 3. `/themes/<THEME>/layouts/taxonomy/<SINGULAR>.rss.xml`
- 4. `/themes/<THEME>/layouts/_default/rss.xml`
- 5. Embedded rss.xml
++The table below shows the RSS template lookup order for the different page kinds. The first listing shows the lookup order when running with a theme (`demoTheme`).
+
- ```
++{{< datatable-filtered "output" "layouts" "OutputFormat == RSS" "Example" "OutputFormat" "Suffix" "Template Lookup Order" >}}
+
+## Configure RSS
+
+By default, Hugo will create an unlimited number of RSS entries. You can limit the number of articles included in the built-in RSS templates by assigning a numeric value to `rssLimit:` field in your project's [`config` file][config].
+
+The following values will also be included in the RSS output if specified in your site’s configuration:
+
- ```
++```toml
+languageCode = "en-us"
+copyright = "This work is licensed under a Creative Commons Attribution-ShareAlike 4.0 International License."
+
+[author]
+ name = "My Name Here"
+```
+
+## The Embedded rss.xml
+
+This is the default RSS template that ships with Hugo. It adheres to the [RSS 2.0 Specification][RSS 2.0].
+
- In your `header.html` template, you can specify your RSS feed in your `<head></head>` tag like this:
++```xml
+<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
+ <channel>
+ <title>{{ if eq .Title .Site.Title }}{{ .Site.Title }}{{ else }}{{ with .Title }}{{.}} on {{ end }}{{ .Site.Title }}{{ end }}</title>
+ <link>{{ .Permalink }}</link>
+ <description>Recent content {{ if ne .Title .Site.Title }}{{ with .Title }}in {{.}} {{ end }}{{ end }}on {{ .Site.Title }}</description>
+ <generator>Hugo -- gohugo.io</generator>{{ with .Site.LanguageCode }}
+ <language>{{.}}</language>{{end}}{{ with .Site.Author.email }}
+ <managingEditor>{{.}}{{ with $.Site.Author.name }} ({{.}}){{end}}</managingEditor>{{end}}{{ with .Site.Author.email }}
+ <webMaster>{{.}}{{ with $.Site.Author.name }} ({{.}}){{end}}</webMaster>{{end}}{{ with .Site.Copyright }}
+ <copyright>{{.}}</copyright>{{end}}{{ if not .Date.IsZero }}
+ <lastBuildDate>{{ .Date.Format "Mon, 02 Jan 2006 15:04:05 -0700" | safeHTML }}</lastBuildDate>{{ end }}
+ {{ with .OutputFormats.Get "RSS" }}
+ {{ printf "<atom:link href=%q rel=\"self\" type=%q />" .Permalink .MediaType | safeHTML }}
+ {{ end }}
+ {{ range .Data.Pages }}
+ <item>
+ <title>{{ .Title }}</title>
+ <link>{{ .Permalink }}</link>
+ <pubDate>{{ .Date.Format "Mon, 02 Jan 2006 15:04:05 -0700" | safeHTML }}</pubDate>
+ {{ with .Site.Author.email }}<author>{{.}}{{ with $.Site.Author.name }} ({{.}}){{end}}</author>{{end}}
+ <guid>{{ .Permalink }}</guid>
+ <description>{{ .Summary | html }}</description>
+ </item>
+ {{ end }}
+ </channel>
+</rss>
+```
+
+{{% warning "XML Header" %}}
+Hugo will automatically add the following header line to this file on render. Please do *not* include this in the template as it's not valid HTML.
+```
+<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
+```
+{{% /warning %}}
+
+## Reference your RSS Feed in `<head>`
+
- {{ if .RSSLink }}
- <link href="{{ .RSSLink }}" rel="alternate" type="application/rss+xml" title="{{ .Site.Title }}" />
- <link href="{{ .RSSLink }}" rel="feed" type="application/rss+xml" title="{{ .Site.Title }}" />
- {{ end }}
++In your `header.html` template, you can specify your RSS feed in your `<head></head>` tag using Hugo's [Output Formats][Output Formats] like this:
+
+```
- ...with the auto-discovery link specified by the line with `rel="alternate"`.
-
- The `.RSSLink` will render the appropriate RSS feed URL for the section, whether it's everything, posts in a section, or a taxonomy.
-
- If you reference your RSS link, be sure to specify the MIME type with `type="application/rss+xml"`.
++{{ range .AlternativeOutputFormats -}}
++ <link rel="{{ .Rel }}" type="{{ .MediaType.Type }}" href="{{ .Permalink | safeURL }}" title="{{ $.Site.Title }}">
++{{ end -}}
+```
+
- <a href="{{ .URL }}" type="application/rss+xml" target="_blank">{{ .SomeText }}</a>
++If you only want the RSS link, you can query the formats:
+
+```
-
++{{ with .OutputFormats.Get "rss" -}}
++ <link rel="{{ .Rel }}" type="{{ .MediaType.Type }}" href="{{ .Permalink | safeURL }}" title="{{ $.Site.Title }}">
++{{ end -}
+```
++
+[config]: /getting-started/configuration/
+[embedded]: #the-embedded-rss-xml
+[RSS 2.0]: http://cyber.law.harvard.edu/rss/rss.html "RSS 2.0 Specification"
+[section]: /content-management/sections/
++[Output Formats]: /templates/output-formats/#link-to-output-formats
--- /dev/null
- * [Hugoidx](https://github.com/blevesearch/hugoidx) is an experimental application to create a search index. It's built on top of [Bleve](http://www.blevesearch.com/).
+---
+title: Search for your Hugo Website
+linktitle: Search
+description: See some of the open-source and commercial search options for your newly created Hugo website.
+date: 2017-02-01
+publishdate: 2017-02-01
+lastmod: 2017-02-26
+categories: [developer tools]
+keywords: [search,tools]
+menu:
+ docs:
+ parent: "tools"
+ weight: 60
+weight: 60
+sections_weight: 60
+draft: false
+aliases: []
+toc: true
+---
+
+A static website with a dynamic search function? Yes. As alternatives to embeddable scripts from Google or other search engines, you can provide your visitors a custom search by indexing your content files directly.
+
+* [GitHub Gist for Hugo Workflow](https://gist.github.com/sebz/efddfc8fdcb6b480f567). This gist contains a simple workflow to create a search index for your static website. It uses a simple Grunt script to index all your content files and [lunr.js](http://lunrjs.com/) to serve the search results.
+* [hugo-lunr](https://www.npmjs.com/package/hugo-lunr). A simple way to add site search to your static Hugo site using [lunr.js](http://lunrjs.com/). Hugo-lunr will create an index file of any html and markdown documents in your Hugo project.
+* [hugo-lunr-zh](https://www.npmjs.com/package/hugo-lunr-zh). A bit like Hugo-lunr, but Hugo-lunr-zh can help you seperate the Chinese keywords.
++* [Github Gist for Fuse.js integration](https://gist.github.com/eddiewebb/735feb48f50f0ddd65ae5606a1cb41ae). This gist demonstrates how to leverage Hugo's existing build time processing to generate a searchable JSON index used by [Fuse.js](http://fusejs.io/) on the client side. Although this gist uses Fuse.js for fuzzy matching, any client side search tool capable of reading JSON indexes will work. Does not require npm, grunt or other build-time tools except Hugo!
+
+## Commercial Search Services
+
+* [Algolia](https://www.algolia.com/)'s Search API makes it easy to deliver a great search experience in your apps and websites. Algolia Search provides hosted full-text, numerical, faceted, and geolocalized search.
--- /dev/null
-
+---
+title: Frequently Asked Questions
+linktitle: FAQ
+description: Solutions to some common Hugo problems.
+date: 2018-02-10
+categories: [troubleshooting]
+menu:
+ docs:
+ parent: "troubleshooting"
+keywords: [faqs]
+weight: 2
+toc: true
+aliases: [/faq/]
+---
+
+{{% note %}}
+**Note:** The answers/solutions presented below are short, and may not be note be enough to solve your problem. Visit [Hugo Discourse](https://discourse.gohugo.io/) and use the search. It that does not help, start a new topic and ask your questions.
+{{% /note %}}
+
++## Can I set configuration variables via OS environment?
++
++Yes you can! See [Configure with Environment Variables](/getting-started/configuration/#configure-with-environment-variables).
++
+## How do I schedule posts?
+
+1. Set `publishDate` in the page [Front Matter](/content-management/front-matter/) to a date in the future.
+2. Build and publish at intervals.
+
+How to automate the "publish at intervals" part depends on your situation:
+
+* If you deploy from your own PC/server, you can automate with [Cron](https://en.wikipedia.org/wiki/Cron) or similar.
+* If your site is hosted on a service similar to [Netlify](https://www.netlify.com/) you can use a service such as [ifttt](https://ifttt.com/date_and_time) to schedule the updates.
+
+Also see this Twitter thread:
+
+{{< tweet 962380712027590657 >}}
+
+## Can I use the latest Hugo version on Netlify?
+
+Yes you can! Read [this](/hosting-and-deployment/hosting-on-netlify/#configure-hugo-version-in-netlify).
--- /dev/null
- : The singular name of the taxonomy (e.g., `tags => `tag`)
+---
+title: Taxonomy Variables
+linktitle:
+description: Taxonomy pages are of type `Page` and have all page-, site-, and list-level variables available to them. However, taxonomy terms templates have additional variables available to their templates.
+date: 2017-02-01
+publishdate: 2017-02-01
+lastmod: 2017-02-01
+categories: [variables and params]
+keywords: [taxonomies,terms]
+draft: false
+menu:
+ docs:
+ parent: "variables"
+ weight: 30
+weight: 30
+sections_weight: 30
+aliases: []
+toc: true
+---
+
+## Taxonomy Terms Page Variables
+
+[Taxonomy terms pages][taxonomytemplates] are of the type `Page` and have the following additional variables.
+
+For example, the following fields would be available in `layouts/_defaults/terms.html`, depending on how you organize your [taxonomy templates][taxonomytemplates]:
+
+.Data.Singular
- The `.Site.Taxonomies` variable holds all the taxonomies defined site-wide. `.Site.Taxonomies` is a map of the taxonomy name to a list of its values (e.g., `"tags" -> ["tag1", "tag2", "tag3"]``). Each value, though, is not a string but rather a *Taxonomy variable*.
++: The singular name of the taxonomy (e.g., `tags => tag`)
+
+.Data.Plural
+: The plural name of the taxonomy (e.g., `tags => tags`)
+
+.Data.Pages
+: The list of pages in the taxonomy
+
+.Data.Terms
+: The taxonomy itself
+
+.Data.Terms.Alphabetical
+: The taxonomy terms alphabetized
+
+.Data.Terms.ByCount
+: The Terms ordered by popularity
+
+Note that `.Data.Terms.Alphabetical` and `.Data.Terms.ByCount` can also be reversed:
+
+* `.Data.Terms.Alphabetical.Reverse`
+* `.Data.Terms.ByCount.Reverse`
+
+## Use `.Site.Taxonomies` Outside of Taxonomy Templates
+
- [taxonomytemplates]: /templates/taxonomy-templates/
++The `.Site.Taxonomies` variable holds all the taxonomies defined site-wide. `.Site.Taxonomies` is a map of the taxonomy name to a list of its values (e.g., `"tags" -> ["tag1", "tag2", "tag3"]`). Each value, though, is not a string but rather a *Taxonomy variable*.
+
+## The `.Taxonomy` Variable
+
+The `.Taxonomy` variable, available, for example, as `.Site.Taxonomies.tags`, contains the list of tags (values) and, for each tag, their corresponding content pages.
+
+### Example Usage of `.Site.Taxonomies`
+
+The following [partial template][partials] will list all your site's taxonomies, each of their keys, and all the content assigned to each of the keys. For more examples of how to order and render your taxonomies, see [Taxonomy Templates][taxonomytemplates].
+
+{{< code file="all-taxonomies-keys-and-pages.html" download="all-taxonomies-keys-and-pages.html" >}}
+<section>
+ <ul>
+ {{ range $taxonomyname, $taxonomy := .Site.Taxonomies }}
+ <li><a href="{{ "/" | relLangURL}}{{ $taxonomyname | urlize }}">{{ $taxonomyname }}</a>
+ <ul>
+ {{ range $key, $value := $taxonomy }}
+ <li> {{ $key }} </li>
+ <ul>
+ {{ range $value.Pages }}
+ <li><a href="{{ .Permalink}}"> {{ .LinkTitle }} </a> </li>
+ {{ end }}
+ </ul>
+ {{ end }}
+ </ul>
+ </li>
+ {{ end }}
+ </ul>
+</section>
+{{< /code >}}
+
+[partials]: /templates/partials/
++[taxonomytemplates]: /templates/taxonomy-templates/
--- /dev/null
- "layouts/page/index.html.html",
- "layouts/page/home.html.html",
- "layouts/page/list.html.html",
- "layouts/page/index.html",
- "layouts/page/home.html",
- "layouts/page/list.html",
+{
+ "media": {
+ "types": [
+ {
+ "type": "application/javascript",
+ "string": "application/javascript+js",
+ "mainType": "application",
+ "subType": "javascript",
+ "suffix": "js",
+ "delimiter": "."
+ },
+ {
+ "type": "application/json",
+ "string": "application/json+json",
+ "mainType": "application",
+ "subType": "json",
+ "suffix": "json",
+ "delimiter": "."
+ },
+ {
+ "type": "application/rss",
+ "string": "application/rss+xml",
+ "mainType": "application",
+ "subType": "rss",
+ "suffix": "xml",
+ "delimiter": "."
+ },
+ {
+ "type": "application/xml",
+ "string": "application/xml+xml",
+ "mainType": "application",
+ "subType": "xml",
+ "suffix": "xml",
+ "delimiter": "."
+ },
+ {
+ "type": "text/calendar",
+ "string": "text/calendar+ics",
+ "mainType": "text",
+ "subType": "calendar",
+ "suffix": "ics",
+ "delimiter": "."
+ },
+ {
+ "type": "text/css",
+ "string": "text/css+css",
+ "mainType": "text",
+ "subType": "css",
+ "suffix": "css",
+ "delimiter": "."
+ },
+ {
+ "type": "text/csv",
+ "string": "text/csv+csv",
+ "mainType": "text",
+ "subType": "csv",
+ "suffix": "csv",
+ "delimiter": "."
+ },
+ {
+ "type": "text/html",
+ "string": "text/html+html",
+ "mainType": "text",
+ "subType": "html",
+ "suffix": "html",
+ "delimiter": "."
+ },
+ {
+ "type": "text/plain",
+ "string": "text/plain+txt",
+ "mainType": "text",
+ "subType": "plain",
+ "suffix": "txt",
+ "delimiter": "."
+ }
+ ]
+ },
+ "output": {
+ "formats": [
+ {
+ "MediaType": "text/html+html",
+ "name": "AMP",
+ "mediaType": {
+ "type": "text/html",
+ "string": "text/html+html",
+ "mainType": "text",
+ "subType": "html",
+ "suffix": "html",
+ "delimiter": "."
+ },
+ "path": "amp",
+ "baseName": "index",
+ "rel": "amphtml",
+ "protocol": "",
+ "isPlainText": false,
+ "isHTML": true,
+ "noUgly": false,
+ "notAlternative": false
+ },
+ {
+ "MediaType": "text/css+css",
+ "name": "CSS",
+ "mediaType": {
+ "type": "text/css",
+ "string": "text/css+css",
+ "mainType": "text",
+ "subType": "css",
+ "suffix": "css",
+ "delimiter": "."
+ },
+ "path": "",
+ "baseName": "styles",
+ "rel": "stylesheet",
+ "protocol": "",
+ "isPlainText": true,
+ "isHTML": false,
+ "noUgly": false,
+ "notAlternative": true
+ },
+ {
+ "MediaType": "text/csv+csv",
+ "name": "CSV",
+ "mediaType": {
+ "type": "text/csv",
+ "string": "text/csv+csv",
+ "mainType": "text",
+ "subType": "csv",
+ "suffix": "csv",
+ "delimiter": "."
+ },
+ "path": "",
+ "baseName": "index",
+ "rel": "alternate",
+ "protocol": "",
+ "isPlainText": true,
+ "isHTML": false,
+ "noUgly": false,
+ "notAlternative": false
+ },
+ {
+ "MediaType": "text/calendar+ics",
+ "name": "Calendar",
+ "mediaType": {
+ "type": "text/calendar",
+ "string": "text/calendar+ics",
+ "mainType": "text",
+ "subType": "calendar",
+ "suffix": "ics",
+ "delimiter": "."
+ },
+ "path": "",
+ "baseName": "index",
+ "rel": "alternate",
+ "protocol": "webcal://",
+ "isPlainText": true,
+ "isHTML": false,
+ "noUgly": false,
+ "notAlternative": false
+ },
+ {
+ "MediaType": "text/html+html",
+ "name": "HTML",
+ "mediaType": {
+ "type": "text/html",
+ "string": "text/html+html",
+ "mainType": "text",
+ "subType": "html",
+ "suffix": "html",
+ "delimiter": "."
+ },
+ "path": "",
+ "baseName": "index",
+ "rel": "canonical",
+ "protocol": "",
+ "isPlainText": false,
+ "isHTML": true,
+ "noUgly": false,
+ "notAlternative": false
+ },
+ {
+ "MediaType": "application/json+json",
+ "name": "JSON",
+ "mediaType": {
+ "type": "application/json",
+ "string": "application/json+json",
+ "mainType": "application",
+ "subType": "json",
+ "suffix": "json",
+ "delimiter": "."
+ },
+ "path": "",
+ "baseName": "index",
+ "rel": "alternate",
+ "protocol": "",
+ "isPlainText": true,
+ "isHTML": false,
+ "noUgly": false,
+ "notAlternative": false
+ },
+ {
+ "MediaType": "application/rss+xml",
+ "name": "RSS",
+ "mediaType": {
+ "type": "application/rss",
+ "string": "application/rss+xml",
+ "mainType": "application",
+ "subType": "rss",
+ "suffix": "xml",
+ "delimiter": "."
+ },
+ "path": "",
+ "baseName": "index",
+ "rel": "alternate",
+ "protocol": "",
+ "isPlainText": false,
+ "isHTML": false,
+ "noUgly": true,
+ "notAlternative": false
+ }
+ ],
+ "layouts": [
+ {
+ "Example": "Single page in \"posts\" section",
+ "Kind": "page",
+ "OutputFormat": "HTML",
+ "Suffix": "html",
+ "Template Lookup Order": [
+ "layouts/posts/single.html.html",
+ "layouts/posts/single.html",
+ "layouts/_default/single.html.html",
+ "layouts/_default/single.html"
+ ]
+ },
+ {
+ "Example": "Single page in \"posts\" section with layout set",
+ "Kind": "page",
+ "OutputFormat": "HTML",
+ "Suffix": "html",
+ "Template Lookup Order": [
+ "layouts/posts/demolayout.html.html",
+ "layouts/posts/single.html.html",
+ "layouts/posts/demolayout.html",
+ "layouts/posts/single.html",
+ "layouts/_default/demolayout.html.html",
+ "layouts/_default/single.html.html",
+ "layouts/_default/demolayout.html",
+ "layouts/_default/single.html"
+ ]
+ },
+ {
+ "Example": "Single page in \"posts\" section with theme",
+ "Kind": "page",
+ "OutputFormat": "HTML",
+ "Suffix": "html",
+ "Template Lookup Order": [
+ "layouts/posts/single.html.html",
+ "demoTheme/layouts/posts/single.html.html",
+ "layouts/posts/single.html",
+ "demoTheme/layouts/posts/single.html",
+ "layouts/_default/single.html.html",
+ "demoTheme/layouts/_default/single.html.html",
+ "layouts/_default/single.html",
+ "demoTheme/layouts/_default/single.html"
+ ]
+ },
+ {
+ "Example": "AMP single page",
+ "Kind": "page",
+ "OutputFormat": "AMP",
+ "Suffix": "html",
+ "Template Lookup Order": [
+ "layouts/posts/single.amp.html",
+ "layouts/posts/single.html",
+ "layouts/_default/single.amp.html",
+ "layouts/_default/single.html"
+ ]
+ },
+ {
+ "Example": "AMP single page, French language",
+ "Kind": "page",
+ "OutputFormat": "AMP",
+ "Suffix": "html",
+ "Template Lookup Order": [
+ "layouts/posts/single.fr.amp.html",
+ "layouts/posts/single.amp.html",
+ "layouts/posts/single.fr.html",
+ "layouts/posts/single.html",
+ "layouts/_default/single.fr.amp.html",
+ "layouts/_default/single.amp.html",
+ "layouts/_default/single.fr.html",
+ "layouts/_default/single.html"
+ ]
+ },
+ {
+ "Example": "Home page",
+ "Kind": "home",
+ "OutputFormat": "HTML",
+ "Suffix": "html",
+ "Template Lookup Order": [
- "layouts/page/demolayout.html.html",
- "layouts/page/index.html.html",
- "layouts/page/home.html.html",
- "layouts/page/list.html.html",
- "layouts/page/demolayout.html",
- "layouts/page/index.html",
- "layouts/page/home.html",
- "layouts/page/list.html",
+ "layouts/index.html.html",
+ "layouts/home.html.html",
+ "layouts/list.html.html",
+ "layouts/index.html",
+ "layouts/home.html",
+ "layouts/list.html",
+ "layouts/_default/index.html.html",
+ "layouts/_default/home.html.html",
+ "layouts/_default/list.html.html",
+ "layouts/_default/index.html",
+ "layouts/_default/home.html",
+ "layouts/_default/list.html"
+ ]
+ },
+ {
+ "Example": "Home page with type set",
+ "Kind": "home",
+ "OutputFormat": "HTML",
+ "Suffix": "html",
+ "Template Lookup Order": [
+ "layouts/demotype/index.html.html",
+ "layouts/demotype/home.html.html",
+ "layouts/demotype/list.html.html",
+ "layouts/demotype/index.html",
+ "layouts/demotype/home.html",
+ "layouts/demotype/list.html",
+ "layouts/index.html.html",
+ "layouts/home.html.html",
+ "layouts/list.html.html",
+ "layouts/index.html",
+ "layouts/home.html",
+ "layouts/list.html",
+ "layouts/_default/index.html.html",
+ "layouts/_default/home.html.html",
+ "layouts/_default/list.html.html",
+ "layouts/_default/index.html",
+ "layouts/_default/home.html",
+ "layouts/_default/list.html"
+ ]
+ },
+ {
+ "Example": "Home page with layout set",
+ "Kind": "home",
+ "OutputFormat": "HTML",
+ "Suffix": "html",
+ "Template Lookup Order": [
- "layouts/page/index.html.html",
- "demoTheme/layouts/page/index.html.html",
- "layouts/page/home.html.html",
- "demoTheme/layouts/page/home.html.html",
- "layouts/page/list.html.html",
- "demoTheme/layouts/page/list.html.html",
- "layouts/page/index.html",
- "demoTheme/layouts/page/index.html",
- "layouts/page/home.html",
- "demoTheme/layouts/page/home.html",
- "layouts/page/list.html",
- "demoTheme/layouts/page/list.html",
+ "layouts/demolayout.html.html",
+ "layouts/index.html.html",
+ "layouts/home.html.html",
+ "layouts/list.html.html",
+ "layouts/demolayout.html",
+ "layouts/index.html",
+ "layouts/home.html",
+ "layouts/list.html",
+ "layouts/_default/demolayout.html.html",
+ "layouts/_default/index.html.html",
+ "layouts/_default/home.html.html",
+ "layouts/_default/list.html.html",
+ "layouts/_default/demolayout.html",
+ "layouts/_default/index.html",
+ "layouts/_default/home.html",
+ "layouts/_default/list.html"
+ ]
+ },
+ {
+ "Example": "Home page with theme",
+ "Kind": "home",
+ "OutputFormat": "HTML",
+ "Suffix": "html",
+ "Template Lookup Order": [
- "layouts/page/index.fr.amp.html",
- "layouts/page/home.fr.amp.html",
- "layouts/page/list.fr.amp.html",
- "layouts/page/index.amp.html",
- "layouts/page/home.amp.html",
- "layouts/page/list.amp.html",
- "layouts/page/index.fr.html",
- "layouts/page/home.fr.html",
- "layouts/page/list.fr.html",
- "layouts/page/index.html",
- "layouts/page/home.html",
- "layouts/page/list.html",
+ "layouts/index.html.html",
+ "demoTheme/layouts/index.html.html",
+ "layouts/home.html.html",
+ "demoTheme/layouts/home.html.html",
+ "layouts/list.html.html",
+ "demoTheme/layouts/list.html.html",
+ "layouts/index.html",
+ "demoTheme/layouts/index.html",
+ "layouts/home.html",
+ "demoTheme/layouts/home.html",
+ "layouts/list.html",
+ "demoTheme/layouts/list.html",
+ "layouts/_default/index.html.html",
+ "demoTheme/layouts/_default/index.html.html",
+ "layouts/_default/home.html.html",
+ "demoTheme/layouts/_default/home.html.html",
+ "layouts/_default/list.html.html",
+ "demoTheme/layouts/_default/list.html.html",
+ "layouts/_default/index.html",
+ "demoTheme/layouts/_default/index.html",
+ "layouts/_default/home.html",
+ "demoTheme/layouts/_default/home.html",
+ "layouts/_default/list.html",
+ "demoTheme/layouts/_default/list.html"
+ ]
+ },
+ {
+ "Example": "AMP home, French language\"",
+ "Kind": "home",
+ "OutputFormat": "AMP",
+ "Suffix": "html",
+ "Template Lookup Order": [
- "layouts/page/index.json.json",
- "layouts/page/home.json.json",
- "layouts/page/list.json.json",
- "layouts/page/index.json",
- "layouts/page/home.json",
- "layouts/page/list.json",
+ "layouts/index.fr.amp.html",
+ "layouts/home.fr.amp.html",
+ "layouts/list.fr.amp.html",
+ "layouts/index.amp.html",
+ "layouts/home.amp.html",
+ "layouts/list.amp.html",
+ "layouts/index.fr.html",
+ "layouts/home.fr.html",
+ "layouts/list.fr.html",
+ "layouts/index.html",
+ "layouts/home.html",
+ "layouts/list.html",
+ "layouts/_default/index.fr.amp.html",
+ "layouts/_default/home.fr.amp.html",
+ "layouts/_default/list.fr.amp.html",
+ "layouts/_default/index.amp.html",
+ "layouts/_default/home.amp.html",
+ "layouts/_default/list.amp.html",
+ "layouts/_default/index.fr.html",
+ "layouts/_default/home.fr.html",
+ "layouts/_default/list.fr.html",
+ "layouts/_default/index.html",
+ "layouts/_default/home.html",
+ "layouts/_default/list.html"
+ ]
+ },
+ {
+ "Example": "JSON home",
+ "Kind": "home",
+ "OutputFormat": "JSON",
+ "Suffix": "json",
+ "Template Lookup Order": [
- "Example": "RSS home",
+ "layouts/index.json.json",
+ "layouts/home.json.json",
+ "layouts/list.json.json",
+ "layouts/index.json",
+ "layouts/home.json",
+ "layouts/list.json",
+ "layouts/_default/index.json.json",
+ "layouts/_default/home.json.json",
+ "layouts/_default/list.json.json",
+ "layouts/_default/index.json",
+ "layouts/_default/home.json",
+ "layouts/_default/list.json"
+ ]
+ },
+ {
- "layouts/page/index.rss.xml",
- "layouts/page/home.rss.xml",
- "layouts/page/rss.xml",
- "layouts/page/list.rss.xml",
- "layouts/page/index.xml",
- "layouts/page/home.xml",
- "layouts/page/list.xml",
++ "Example": "RSS home with theme",
+ "Kind": "home",
+ "OutputFormat": "RSS",
+ "Suffix": "xml",
+ "Template Lookup Order": [
- "Examples": []
+ "layouts/index.rss.xml",
++ "demoTheme/layouts/index.rss.xml",
+ "layouts/home.rss.xml",
++ "demoTheme/layouts/home.rss.xml",
+ "layouts/rss.xml",
++ "demoTheme/layouts/rss.xml",
+ "layouts/list.rss.xml",
++ "demoTheme/layouts/list.rss.xml",
+ "layouts/index.xml",
++ "demoTheme/layouts/index.xml",
+ "layouts/home.xml",
++ "demoTheme/layouts/home.xml",
+ "layouts/list.xml",
++ "demoTheme/layouts/list.xml",
+ "layouts/_default/index.rss.xml",
++ "demoTheme/layouts/_default/index.rss.xml",
+ "layouts/_default/home.rss.xml",
++ "demoTheme/layouts/_default/home.rss.xml",
+ "layouts/_default/rss.xml",
++ "demoTheme/layouts/_default/rss.xml",
+ "layouts/_default/list.rss.xml",
++ "demoTheme/layouts/_default/list.rss.xml",
+ "layouts/_default/index.xml",
++ "demoTheme/layouts/_default/index.xml",
+ "layouts/_default/home.xml",
++ "demoTheme/layouts/_default/home.xml",
++ "layouts/_default/list.xml",
++ "demoTheme/layouts/_default/list.xml",
++ "layouts/_internal/_default/rss.xml"
++ ]
++ },
++ {
++ "Example": "RSS section posts",
++ "Kind": "section",
++ "OutputFormat": "RSS",
++ "Suffix": "xml",
++ "Template Lookup Order": [
++ "layouts/posts/section.rss.xml",
++ "layouts/posts/rss.xml",
++ "layouts/posts/list.rss.xml",
++ "layouts/posts/section.xml",
++ "layouts/posts/list.xml",
++ "layouts/section/section.rss.xml",
++ "layouts/section/rss.xml",
++ "layouts/section/list.rss.xml",
++ "layouts/section/section.xml",
++ "layouts/section/list.xml",
++ "layouts/_default/section.rss.xml",
++ "layouts/_default/rss.xml",
++ "layouts/_default/list.rss.xml",
++ "layouts/_default/section.xml",
++ "layouts/_default/list.xml",
++ "layouts/_internal/_default/rss.xml"
++ ]
++ },
++ {
++ "Example": "Taxonomy list in categories",
++ "Kind": "taxonomy",
++ "OutputFormat": "RSS",
++ "Suffix": "xml",
++ "Template Lookup Order": [
++ "layouts/categories/category.rss.xml",
++ "layouts/categories/taxonomy.rss.xml",
++ "layouts/categories/rss.xml",
++ "layouts/categories/list.rss.xml",
++ "layouts/categories/category.xml",
++ "layouts/categories/taxonomy.xml",
++ "layouts/categories/list.xml",
++ "layouts/taxonomy/category.rss.xml",
++ "layouts/taxonomy/taxonomy.rss.xml",
++ "layouts/taxonomy/rss.xml",
++ "layouts/taxonomy/list.rss.xml",
++ "layouts/taxonomy/category.xml",
++ "layouts/taxonomy/taxonomy.xml",
++ "layouts/taxonomy/list.xml",
++ "layouts/category/category.rss.xml",
++ "layouts/category/taxonomy.rss.xml",
++ "layouts/category/rss.xml",
++ "layouts/category/list.rss.xml",
++ "layouts/category/category.xml",
++ "layouts/category/taxonomy.xml",
++ "layouts/category/list.xml",
++ "layouts/_default/category.rss.xml",
++ "layouts/_default/taxonomy.rss.xml",
++ "layouts/_default/rss.xml",
++ "layouts/_default/list.rss.xml",
++ "layouts/_default/category.xml",
++ "layouts/_default/taxonomy.xml",
++ "layouts/_default/list.xml",
++ "layouts/_internal/_default/rss.xml"
++ ]
++ },
++ {
++ "Example": "Taxonomy terms in categories",
++ "Kind": "taxonomyTerm",
++ "OutputFormat": "RSS",
++ "Suffix": "xml",
++ "Template Lookup Order": [
++ "layouts/categories/category.terms.rss.xml",
++ "layouts/categories/terms.rss.xml",
++ "layouts/categories/rss.xml",
++ "layouts/categories/list.rss.xml",
++ "layouts/categories/category.terms.xml",
++ "layouts/categories/terms.xml",
++ "layouts/categories/list.xml",
++ "layouts/taxonomy/category.terms.rss.xml",
++ "layouts/taxonomy/terms.rss.xml",
++ "layouts/taxonomy/rss.xml",
++ "layouts/taxonomy/list.rss.xml",
++ "layouts/taxonomy/category.terms.xml",
++ "layouts/taxonomy/terms.xml",
++ "layouts/taxonomy/list.xml",
++ "layouts/category/category.terms.rss.xml",
++ "layouts/category/terms.rss.xml",
++ "layouts/category/rss.xml",
++ "layouts/category/list.rss.xml",
++ "layouts/category/category.terms.xml",
++ "layouts/category/terms.xml",
++ "layouts/category/list.xml",
++ "layouts/_default/category.terms.rss.xml",
++ "layouts/_default/terms.rss.xml",
++ "layouts/_default/rss.xml",
++ "layouts/_default/list.rss.xml",
++ "layouts/_default/category.terms.xml",
++ "layouts/_default/terms.xml",
+ "layouts/_default/list.xml",
+ "layouts/_internal/_default/rss.xml"
+ ]
+ },
+ {
+ "Example": "Section list for \"posts\" section",
+ "Kind": "section",
+ "OutputFormat": "HTML",
+ "Suffix": "html",
+ "Template Lookup Order": [
+ "layouts/posts/posts.html.html",
+ "layouts/posts/section.html.html",
+ "layouts/posts/list.html.html",
+ "layouts/posts/posts.html",
+ "layouts/posts/section.html",
+ "layouts/posts/list.html",
+ "layouts/section/posts.html.html",
+ "layouts/section/section.html.html",
+ "layouts/section/list.html.html",
+ "layouts/section/posts.html",
+ "layouts/section/section.html",
+ "layouts/section/list.html",
+ "layouts/_default/posts.html.html",
+ "layouts/_default/section.html.html",
+ "layouts/_default/list.html.html",
+ "layouts/_default/posts.html",
+ "layouts/_default/section.html",
+ "layouts/_default/list.html"
+ ]
+ },
+ {
+ "Example": "Section list for \"posts\" section with type set to \"blog\"",
+ "Kind": "section",
+ "OutputFormat": "HTML",
+ "Suffix": "html",
+ "Template Lookup Order": [
+ "layouts/blog/posts.html.html",
+ "layouts/blog/section.html.html",
+ "layouts/blog/list.html.html",
+ "layouts/blog/posts.html",
+ "layouts/blog/section.html",
+ "layouts/blog/list.html",
+ "layouts/posts/posts.html.html",
+ "layouts/posts/section.html.html",
+ "layouts/posts/list.html.html",
+ "layouts/posts/posts.html",
+ "layouts/posts/section.html",
+ "layouts/posts/list.html",
+ "layouts/section/posts.html.html",
+ "layouts/section/section.html.html",
+ "layouts/section/list.html.html",
+ "layouts/section/posts.html",
+ "layouts/section/section.html",
+ "layouts/section/list.html",
+ "layouts/_default/posts.html.html",
+ "layouts/_default/section.html.html",
+ "layouts/_default/list.html.html",
+ "layouts/_default/posts.html",
+ "layouts/_default/section.html",
+ "layouts/_default/list.html"
+ ]
+ },
+ {
+ "Example": "Section list for \"posts\" section with layout set to \"demoLayout\"",
+ "Kind": "section",
+ "OutputFormat": "HTML",
+ "Suffix": "html",
+ "Template Lookup Order": [
+ "layouts/posts/demolayout.html.html",
+ "layouts/posts/posts.html.html",
+ "layouts/posts/section.html.html",
+ "layouts/posts/list.html.html",
+ "layouts/posts/demolayout.html",
+ "layouts/posts/posts.html",
+ "layouts/posts/section.html",
+ "layouts/posts/list.html",
+ "layouts/section/demolayout.html.html",
+ "layouts/section/posts.html.html",
+ "layouts/section/section.html.html",
+ "layouts/section/list.html.html",
+ "layouts/section/demolayout.html",
+ "layouts/section/posts.html",
+ "layouts/section/section.html",
+ "layouts/section/list.html",
+ "layouts/_default/demolayout.html.html",
+ "layouts/_default/posts.html.html",
+ "layouts/_default/section.html.html",
+ "layouts/_default/list.html.html",
+ "layouts/_default/demolayout.html",
+ "layouts/_default/posts.html",
+ "layouts/_default/section.html",
+ "layouts/_default/list.html"
+ ]
+ },
+ {
+ "Example": "Taxonomy list in categories",
+ "Kind": "taxonomy",
+ "OutputFormat": "HTML",
+ "Suffix": "html",
+ "Template Lookup Order": [
+ "layouts/categories/category.html.html",
+ "layouts/categories/taxonomy.html.html",
+ "layouts/categories/list.html.html",
+ "layouts/categories/category.html",
+ "layouts/categories/taxonomy.html",
+ "layouts/categories/list.html",
+ "layouts/taxonomy/category.html.html",
+ "layouts/taxonomy/taxonomy.html.html",
+ "layouts/taxonomy/list.html.html",
+ "layouts/taxonomy/category.html",
+ "layouts/taxonomy/taxonomy.html",
+ "layouts/taxonomy/list.html",
+ "layouts/category/category.html.html",
+ "layouts/category/taxonomy.html.html",
+ "layouts/category/list.html.html",
+ "layouts/category/category.html",
+ "layouts/category/taxonomy.html",
+ "layouts/category/list.html",
+ "layouts/_default/category.html.html",
+ "layouts/_default/taxonomy.html.html",
+ "layouts/_default/list.html.html",
+ "layouts/_default/category.html",
+ "layouts/_default/taxonomy.html",
+ "layouts/_default/list.html"
+ ]
+ },
+ {
+ "Example": "Taxonomy term in categories",
+ "Kind": "taxonomyTerm",
+ "OutputFormat": "HTML",
+ "Suffix": "html",
+ "Template Lookup Order": [
+ "layouts/categories/category.terms.html.html",
+ "layouts/categories/terms.html.html",
+ "layouts/categories/list.html.html",
+ "layouts/categories/category.terms.html",
+ "layouts/categories/terms.html",
+ "layouts/categories/list.html",
+ "layouts/taxonomy/category.terms.html.html",
+ "layouts/taxonomy/terms.html.html",
+ "layouts/taxonomy/list.html.html",
+ "layouts/taxonomy/category.terms.html",
+ "layouts/taxonomy/terms.html",
+ "layouts/taxonomy/list.html",
+ "layouts/category/category.terms.html.html",
+ "layouts/category/terms.html.html",
+ "layouts/category/list.html.html",
+ "layouts/category/category.terms.html",
+ "layouts/category/terms.html",
+ "layouts/category/list.html",
+ "layouts/_default/category.terms.html.html",
+ "layouts/_default/terms.html.html",
+ "layouts/_default/list.html.html",
+ "layouts/_default/category.terms.html",
+ "layouts/_default/terms.html",
+ "layouts/_default/list.html"
+ ]
+ }
+ ]
+ },
+ "tpl": {
+ "funcs": {
+ "cast": {
+ "ToFloat": {
+ "Description": "ToFloat converts the given value to a float.",
+ "Args": [
+ "v"
+ ],
+ "Aliases": [
+ "float"
+ ],
+ "Examples": [
+ [
+ "{{ \"1234\" | float | printf \"%T\" }}",
+ "float64"
+ ]
+ ]
+ },
+ "ToInt": {
+ "Description": "ToInt converts the given value to an int.",
+ "Args": [
+ "v"
+ ],
+ "Aliases": [
+ "int"
+ ],
+ "Examples": [
+ [
+ "{{ \"1234\" | int | printf \"%T\" }}",
+ "int"
+ ]
+ ]
+ },
+ "ToString": {
+ "Description": "ToString converts the given value to a string.",
+ "Args": [
+ "v"
+ ],
+ "Aliases": [
+ "string"
+ ],
+ "Examples": [
+ [
+ "{{ 1234 | string | printf \"%T\" }}",
+ "string"
+ ]
+ ]
+ }
+ },
+ "compare": {
+ "Conditional": {
+ "Description": "Conditional can be used as a ternary operator.\nIt returns a if condition, else b.",
+ "Args": [
+ "condition",
+ "a",
+ "b"
+ ],
+ "Aliases": [
+ "cond"
+ ],
+ "Examples": [
+ [
+ "{{ cond (eq (add 2 2) 4) \"2+2 is 4\" \"what?\" | safeHTML }}",
+ "2+2 is 4"
+ ]
+ ]
+ },
+ "Default": {
+ "Description": "Default checks whether a given value is set and returns a default value if it\nis not. \"Set\" in this context means non-zero for numeric types and times;\nnon-zero length for strings, arrays, slices, and maps;\nany boolean or struct value; or non-nil for any other types.",
+ "Args": [
+ "dflt",
+ "given"
+ ],
+ "Aliases": [
+ "default"
+ ],
+ "Examples": [
+ [
+ "{{ \"Hugo Rocks!\" | default \"Hugo Rules!\" }}",
+ "Hugo Rocks!"
+ ],
+ [
+ "{{ \"\" | default \"Hugo Rules!\" }}",
+ "Hugo Rules!"
+ ]
+ ]
+ },
+ "Eq": {
+ "Description": "Eq returns the boolean truth of arg1 == arg2.",
+ "Args": [
+ "x",
+ "y"
+ ],
+ "Aliases": [
+ "eq"
+ ],
+ "Examples": [
+ [
+ "{{ if eq .Section \"blog\" }}current{{ end }}",
+ "current"
+ ]
+ ]
+ },
+ "Ge": {
+ "Description": "Ge returns the boolean truth of arg1 \u003e= arg2.",
+ "Args": [
+ "a",
+ "b"
+ ],
+ "Aliases": [
+ "ge"
+ ],
++ "Examples": [
++ [
++ "{{ if ge .Hugo.Version \"0.36\" }}Reasonable new Hugo version!{{ end }}",
++ "Reasonable new Hugo version!"
++ ]
++ ]
+ },
+ "Gt": {
+ "Description": "Gt returns the boolean truth of arg1 \u003e arg2.",
+ "Args": [
+ "a",
+ "b"
+ ],
+ "Aliases": [
+ "gt"
+ ],
+ "Examples": []
+ },
+ "Le": {
+ "Description": "Le returns the boolean truth of arg1 \u003c= arg2.",
+ "Args": [
+ "a",
+ "b"
+ ],
+ "Aliases": [
+ "le"
+ ],
+ "Examples": []
+ },
+ "Lt": {
+ "Description": "Lt returns the boolean truth of arg1 \u003c arg2.",
+ "Args": [
+ "a",
+ "b"
+ ],
+ "Aliases": [
+ "lt"
+ ],
+ "Examples": []
+ },
+ "Ne": {
+ "Description": "Ne returns the boolean truth of arg1 != arg2.",
+ "Args": [
+ "x",
+ "y"
+ ],
+ "Aliases": [
+ "ne"
+ ],
+ "Examples": []
+ }
+ },
+ "collections": {
+ "After": {
+ "Description": "After returns all the items after the first N in a rangeable list.",
+ "Args": [
+ "index",
+ "seq"
+ ],
+ "Aliases": [
+ "after"
+ ],
+ "Examples": []
+ },
+ "Apply": {
+ "Description": "Apply takes a map, array, or slice and returns a new slice with the function fname applied over it.",
+ "Args": [
+ "seq",
+ "fname",
+ "args"
+ ],
+ "Aliases": [
+ "apply"
+ ],
+ "Examples": []
+ },
+ "Delimit": {
+ "Description": "Delimit takes a given sequence and returns a delimited HTML string.\nIf last is passed to the function, it will be used as the final delimiter.",
+ "Args": [
+ "seq",
+ "delimiter",
+ "last"
+ ],
+ "Aliases": [
+ "delimit"
+ ],
+ "Examples": [
+ [
+ "{{ delimit (slice \"A\" \"B\" \"C\") \", \" \" and \" }}",
+ "A, B and C"
+ ]
+ ]
+ },
+ "Dictionary": {
+ "Description": "Dictionary creates a map[string]interface{} from the given parameters by\nwalking the parameters and treating them as key-value pairs. The number\nof parameters must be even.",
+ "Args": [
+ "values"
+ ],
+ "Aliases": [
+ "dict"
+ ],
+ "Examples": []
+ },
+ "EchoParam": {
+ "Description": "EchoParam returns a given value if it is set; otherwise, it returns an\nempty string.",
+ "Args": [
+ "a",
+ "key"
+ ],
+ "Aliases": [
+ "echoParam"
+ ],
+ "Examples": [
+ [
+ "{{ echoParam .Params \"langCode\" }}",
+ "en"
+ ]
+ ]
+ },
+ "First": {
+ "Description": "First returns the first N items in a rangeable list.",
+ "Args": [
+ "limit",
+ "seq"
+ ],
+ "Aliases": [
+ "first"
+ ],
+ "Examples": []
+ },
+ "In": {
+ "Description": "In returns whether v is in the set l. l may be an array or slice.",
+ "Args": [
+ "l",
+ "v"
+ ],
+ "Aliases": [
+ "in"
+ ],
+ "Examples": [
+ [
+ "{{ if in \"this string contains a substring\" \"substring\" }}Substring found!{{ end }}",
+ "Substring found!"
+ ]
+ ]
+ },
+ "Index": {
+ "Description": "Index returns the result of indexing its first argument by the following\narguments. Thus \"index x 1 2 3\" is, in Go syntax, x[1][2][3]. Each\nindexed item must be a map, slice, or array.\n\nCopied from Go stdlib src/text/template/funcs.go.\n\nWe deviate from the stdlib due to https://github.com/golang/go/issues/14751.\n\nTODO(moorereason): merge upstream changes.",
+ "Args": [
+ "item",
+ "indices"
+ ],
+ "Aliases": [
+ "index"
+ ],
+ "Examples": []
+ },
+ "Intersect": {
+ "Description": "Intersect returns the common elements in the given sets, l1 and l2. l1 and\nl2 must be of the same type and may be either arrays or slices.",
+ "Args": [
+ "l1",
+ "l2"
+ ],
+ "Aliases": [
+ "intersect"
+ ],
+ "Examples": []
+ },
+ "IsSet": {
+ "Description": "IsSet returns whether a given array, channel, slice, or map has a key\ndefined.",
+ "Args": [
+ "a",
+ "key"
+ ],
+ "Aliases": [
+ "isSet",
+ "isset"
+ ],
+ "Examples": []
+ },
+ "KeyVals": {
+ "Description": "KeyVals creates a key and values wrapper.",
+ "Args": [
+ "key",
+ "vals"
+ ],
+ "Aliases": [
+ "keyVals"
+ ],
+ "Examples": [
+ [
+ "{{ keyVals \"key\" \"a\" \"b\" }}",
+ "key: [a b]"
+ ]
+ ]
+ },
+ "Last": {
+ "Description": "Last returns the last N items in a rangeable list.",
+ "Args": [
+ "limit",
+ "seq"
+ ],
+ "Aliases": [
+ "last"
+ ],
+ "Examples": []
+ },
+ "Querify": {
+ "Description": "Querify encodes the given parameters in URL-encoded form (\"bar=baz\u0026foo=quux\") sorted by key.",
+ "Args": [
+ "params"
+ ],
+ "Aliases": [
+ "querify"
+ ],
+ "Examples": [
+ [
+ "{{ (querify \"foo\" 1 \"bar\" 2 \"baz\" \"with spaces\" \"qux\" \"this\u0026that=those\") | safeHTML }}",
+ "bar=2\u0026baz=with+spaces\u0026foo=1\u0026qux=this%26that%3Dthose"
+ ],
+ [
+ "\u003ca href=\"https://www.google.com?{{ (querify \"q\" \"test\" \"page\" 3) | safeURL }}\"\u003eSearch\u003c/a\u003e",
+ "\u003ca href=\"https://www.google.com?page=3\u0026amp;q=test\"\u003eSearch\u003c/a\u003e"
+ ]
+ ]
+ },
+ "Seq": {
+ "Description": "Seq creates a sequence of integers. It's named and used as GNU's seq.\n\nExamples:\n 3 =\u003e 1, 2, 3\n 1 2 4 =\u003e 1, 3\n -3 =\u003e -1, -2, -3\n 1 4 =\u003e 1, 2, 3, 4\n 1 -2 =\u003e 1, 0, -1, -2",
+ "Args": [
+ "args"
+ ],
+ "Aliases": [
+ "seq"
+ ],
+ "Examples": [
+ [
+ "{{ seq 3 }}",
+ "[1 2 3]"
+ ]
+ ]
+ },
+ "Shuffle": {
+ "Description": "Shuffle returns the given rangeable list in a randomised order.",
+ "Args": [
+ "seq"
+ ],
+ "Aliases": [
+ "shuffle"
+ ],
+ "Examples": []
+ },
+ "Slice": {
+ "Description": "Slice returns a slice of all passed arguments.",
+ "Args": [
+ "args"
+ ],
+ "Aliases": [
+ "slice"
+ ],
+ "Examples": [
+ [
+ "{{ slice \"B\" \"C\" \"A\" | sort }}",
+ "[A B C]"
+ ]
+ ]
+ },
+ "Sort": {
+ "Description": "Sort returns a sorted sequence.",
+ "Args": [
+ "seq",
+ "args"
+ ],
+ "Aliases": [
+ "sort"
+ ],
+ "Examples": []
+ },
+ "Union": {
+ "Description": "Union returns the union of the given sets, l1 and l2. l1 and\nl2 must be of the same type and may be either arrays or slices.\nIf l1 and l2 aren't of the same type then l1 will be returned.\nIf either l1 or l2 is nil then the non-nil list will be returned.",
+ "Args": [
+ "l1",
+ "l2"
+ ],
+ "Aliases": [
+ "union"
+ ],
+ "Examples": [
+ [
+ "{{ union (slice 1 2 3) (slice 3 4 5) }}",
+ "[1 2 3 4 5]"
+ ]
+ ]
+ },
+ "Uniq": {
+ "Description": "Uniq takes in a slice or array and returns a slice with subsequent\nduplicate elements removed.",
+ "Args": [
+ "l"
+ ],
+ "Aliases": [
+ "uniq"
+ ],
+ "Examples": [
+ [
+ "{{ slice 1 2 3 2 | uniq }}",
+ "[1 2 3]"
+ ]
+ ]
+ },
+ "Where": {
+ "Description": "Where returns a filtered subset of a given data type.",
+ "Args": [
+ "seq",
+ "key",
+ "args"
+ ],
+ "Aliases": [
+ "where"
+ ],
+ "Examples": []
+ }
+ },
+ "crypto": {
+ "MD5": {
+ "Description": "MD5 hashes the given input and returns its MD5 checksum.",
+ "Args": [
+ "in"
+ ],
+ "Aliases": [
+ "md5"
+ ],
+ "Examples": [
+ [
+ "{{ md5 \"Hello world, gophers!\" }}",
+ "b3029f756f98f79e7f1b7f1d1f0dd53b"
+ ],
+ [
+ "{{ crypto.MD5 \"Hello world, gophers!\" }}",
+ "b3029f756f98f79e7f1b7f1d1f0dd53b"
+ ]
+ ]
+ },
+ "SHA1": {
+ "Description": "SHA1 hashes the given input and returns its SHA1 checksum.",
+ "Args": [
+ "in"
+ ],
+ "Aliases": [
+ "sha1"
+ ],
+ "Examples": [
+ [
+ "{{ sha1 \"Hello world, gophers!\" }}",
+ "c8b5b0e33d408246e30f53e32b8f7627a7a649d4"
+ ]
+ ]
+ },
+ "SHA256": {
+ "Description": "SHA256 hashes the given input and returns its SHA256 checksum.",
+ "Args": [
+ "in"
+ ],
+ "Aliases": [
+ "sha256"
+ ],
+ "Examples": [
+ [
+ "{{ sha256 \"Hello world, gophers!\" }}",
+ "6ec43b78da9669f50e4e422575c54bf87536954ccd58280219c393f2ce352b46"
+ ]
+ ]
+ }
+ },
+ "data": {
+ "GetCSV": {
+ "Description": "GetCSV expects a data separator and one or n-parts of a URL to a resource which\ncan either be a local or a remote one.\nThe data separator can be a comma, semi-colon, pipe, etc, but only one character.\nIf you provide multiple parts for the URL they will be joined together to the final URL.\nGetCSV returns nil or a slice slice to use in a short code.",
+ "Args": [
+ "sep",
+ "urlParts"
+ ],
+ "Aliases": [
+ "getCSV"
+ ],
+ "Examples": []
+ },
+ "GetJSON": {
+ "Description": "GetJSON expects one or n-parts of a URL to a resource which can either be a local or a remote one.\nIf you provide multiple parts they will be joined together to the final URL.\nGetJSON returns nil or parsed JSON to use in a short code.",
+ "Args": [
+ "urlParts"
+ ],
+ "Aliases": [
+ "getJSON"
+ ],
+ "Examples": []
+ }
+ },
+ "encoding": {
+ "Base64Decode": {
+ "Description": "Base64Decode returns the base64 decoding of the given content.",
+ "Args": [
+ "content"
+ ],
+ "Aliases": [
+ "base64Decode"
+ ],
+ "Examples": [
+ [
+ "{{ \"SGVsbG8gd29ybGQ=\" | base64Decode }}",
+ "Hello world"
+ ],
+ [
+ "{{ 42 | base64Encode | base64Decode }}",
+ "42"
+ ]
+ ]
+ },
+ "Base64Encode": {
+ "Description": "Base64Encode returns the base64 encoding of the given content.",
+ "Args": [
+ "content"
+ ],
+ "Aliases": [
+ "base64Encode"
+ ],
+ "Examples": [
+ [
+ "{{ \"Hello world\" | base64Encode }}",
+ "SGVsbG8gd29ybGQ="
+ ]
+ ]
+ },
+ "Jsonify": {
+ "Description": "Jsonify encodes a given object to JSON.",
+ "Args": [
+ "v"
+ ],
+ "Aliases": [
+ "jsonify"
+ ],
+ "Examples": [
+ [
+ "{{ (slice \"A\" \"B\" \"C\") | jsonify }}",
+ "[\"A\",\"B\",\"C\"]"
+ ]
+ ]
+ }
+ },
+ "fmt": {
+ "Errorf": {
+ "Description": "",
+ "Args": [
+ "format",
+ "a"
+ ],
+ "Aliases": [
+ "errorf"
+ ],
+ "Examples": [
+ [
+ "{{ errorf \"%s.\" \"failed\" }}",
+ "failed."
+ ]
+ ]
+ },
+ "Print": {
+ "Description": "Print returns string representation of the passed arguments.",
+ "Args": [
+ "a"
+ ],
+ "Aliases": [
+ "print"
+ ],
+ "Examples": [
+ [
+ "{{ print \"works!\" }}",
+ "works!"
+ ]
+ ]
+ },
+ "Printf": {
+ "Description": "Printf returns a formatted string representation of the passed arguments.",
+ "Args": [
+ "format",
+ "a"
+ ],
+ "Aliases": [
+ "printf"
+ ],
+ "Examples": [
+ [
+ "{{ printf \"%s!\" \"works\" }}",
+ "works!"
+ ]
+ ]
+ },
+ "Println": {
+ "Description": "Println returns string representation of the passed arguments ending with a newline.",
+ "Args": [
+ "a"
+ ],
+ "Aliases": [
+ "println"
+ ],
+ "Examples": [
+ [
+ "{{ println \"works!\" }}",
+ "works!\n"
+ ]
+ ]
+ }
+ },
+ "images": {
+ "Config": {
+ "Description": "Config returns the image.Config for the specified path relative to the\nworking directory.",
+ "Args": [
+ "path"
+ ],
+ "Aliases": [
+ "imageConfig"
+ ],
+ "Examples": []
+ }
+ },
+ "inflect": {
+ "Humanize": {
+ "Description": "Humanize returns the humanized form of a single parameter.\n\nIf the parameter is either an integer or a string containing an integer\nvalue, the behavior is to add the appropriate ordinal.\n\n Example: \"my-first-post\" -\u003e \"My first post\"\n Example: \"103\" -\u003e \"103rd\"\n Example: 52 -\u003e \"52nd\"",
+ "Args": [
+ "in"
+ ],
+ "Aliases": [
+ "humanize"
+ ],
+ "Examples": [
+ [
+ "{{ humanize \"my-first-post\" }}",
+ "My first post"
+ ],
+ [
+ "{{ humanize \"myCamelPost\" }}",
+ "My camel post"
+ ],
+ [
+ "{{ humanize \"52\" }}",
+ "52nd"
+ ],
+ [
+ "{{ humanize 103 }}",
+ "103rd"
+ ]
+ ]
+ },
+ "Pluralize": {
+ "Description": "Pluralize returns the plural form of a single word.",
+ "Args": [
+ "in"
+ ],
+ "Aliases": [
+ "pluralize"
+ ],
+ "Examples": [
+ [
+ "{{ \"cat\" | pluralize }}",
+ "cats"
+ ]
+ ]
+ },
+ "Singularize": {
+ "Description": "Singularize returns the singular form of a single word.",
+ "Args": [
+ "in"
+ ],
+ "Aliases": [
+ "singularize"
+ ],
+ "Examples": [
+ [
+ "{{ \"cats\" | singularize }}",
+ "cat"
+ ]
+ ]
+ }
+ },
+ "lang": {
+ "NumFmt": {
+ "Description": "NumFmt formats a number with the given precision using the\nnegative, decimal, and grouping options. The `options`\nparameter is a string consisting of `\u003cnegative\u003e \u003cdecimal\u003e \u003cgrouping\u003e`. The\ndefault `options` value is `- . ,`.\n\nNote that numbers are rounded up at 5 or greater.\nSo, with precision set to 0, 1.5 becomes `2`, and 1.4 becomes `1`.",
+ "Args": [
+ "precision",
+ "number",
+ "options"
+ ],
+ "Aliases": null,
+ "Examples": [
+ [
+ "{{ lang.NumFmt 2 12345.6789 }}",
+ "12,345.68"
+ ],
+ [
+ "{{ lang.NumFmt 2 12345.6789 \"- , .\" }}",
+ "12.345,68"
+ ],
+ [
+ "{{ lang.NumFmt 6 -12345.6789 \"- .\" }}",
+ "-12345.678900"
+ ],
+ [
+ "{{ lang.NumFmt 0 -12345.6789 \"- . ,\" }}",
+ "-12,346"
+ ],
+ [
+ "{{ -98765.4321 | lang.NumFmt 2 }}",
+ "-98,765.43"
+ ]
+ ]
+ },
+ "Translate": {
+ "Description": "Translate ...",
+ "Args": [
+ "id",
+ "args"
+ ],
+ "Aliases": [
+ "i18n",
+ "T"
+ ],
+ "Examples": []
+ }
+ },
+ "math": {
+ "Add": {
+ "Description": "Add adds two numbers.",
+ "Args": [
+ "a",
+ "b"
+ ],
+ "Aliases": [
+ "add"
+ ],
+ "Examples": [
+ [
+ "{{add 1 2}}",
+ "3"
+ ]
+ ]
+ },
+ "Ceil": {
+ "Description": "Ceil returns the least integer value greater than or equal to x.",
+ "Args": [
+ "x"
+ ],
+ "Aliases": null,
+ "Examples": [
+ [
+ "{{math.Ceil 2.1}}",
+ "3"
+ ]
+ ]
+ },
+ "Div": {
+ "Description": "Div divides two numbers.",
+ "Args": [
+ "a",
+ "b"
+ ],
+ "Aliases": [
+ "div"
+ ],
+ "Examples": [
+ [
+ "{{div 6 3}}",
+ "2"
+ ]
+ ]
+ },
+ "Floor": {
+ "Description": "Floor returns the greatest integer value less than or equal to x.",
+ "Args": [
+ "x"
+ ],
+ "Aliases": null,
+ "Examples": [
+ [
+ "{{math.Floor 1.9}}",
+ "1"
+ ]
+ ]
+ },
+ "Log": {
+ "Description": "Log returns the natural logarithm of a number.",
+ "Args": [
+ "a"
+ ],
+ "Aliases": null,
+ "Examples": [
+ [
+ "{{math.Log 1}}",
+ "0"
+ ]
+ ]
+ },
+ "Mod": {
+ "Description": "Mod returns a % b.",
+ "Args": [
+ "a",
+ "b"
+ ],
+ "Aliases": [
+ "mod"
+ ],
+ "Examples": [
+ [
+ "{{mod 15 3}}",
+ "0"
+ ]
+ ]
+ },
+ "ModBool": {
+ "Description": "ModBool returns the boolean of a % b. If a % b == 0, return true.",
+ "Args": [
+ "a",
+ "b"
+ ],
+ "Aliases": [
+ "modBool"
+ ],
+ "Examples": [
+ [
+ "{{modBool 15 3}}",
+ "true"
+ ]
+ ]
+ },
+ "Mul": {
+ "Description": "Mul multiplies two numbers.",
+ "Args": [
+ "a",
+ "b"
+ ],
+ "Aliases": [
+ "mul"
+ ],
+ "Examples": [
+ [
+ "{{mul 2 3}}",
+ "6"
+ ]
+ ]
+ },
+ "Round": {
+ "Description": "Round returns the nearest integer, rounding half away from zero.",
+ "Args": [
+ "x"
+ ],
+ "Aliases": null,
+ "Examples": [
+ [
+ "{{math.Round 1.5}}",
+ "2"
+ ]
+ ]
+ },
+ "Sub": {
+ "Description": "Sub subtracts two numbers.",
+ "Args": [
+ "a",
+ "b"
+ ],
+ "Aliases": [
+ "sub"
+ ],
+ "Examples": [
+ [
+ "{{sub 3 2}}",
+ "1"
+ ]
+ ]
+ }
+ },
+ "os": {
+ "FileExists": {
+ "Description": "FileExists checks whether a file exists under the given path.",
+ "Args": [
+ "i"
+ ],
+ "Aliases": [
+ "fileExists"
+ ],
+ "Examples": [
+ [
+ "{{ fileExists \"foo.txt\" }}",
+ "false"
+ ]
+ ]
+ },
+ "Getenv": {
+ "Description": "Getenv retrieves the value of the environment variable named by the key.\nIt returns the value, which will be empty if the variable is not present.",
+ "Args": [
+ "key"
+ ],
+ "Aliases": [
+ "getenv"
+ ],
+ "Examples": []
+ },
+ "ReadDir": {
+ "Description": "ReadDir lists the directory contents relative to the configured WorkingDir.",
+ "Args": [
+ "i"
+ ],
+ "Aliases": [
+ "readDir"
+ ],
+ "Examples": [
+ [
+ "{{ range (readDir \".\") }}{{ .Name }}{{ end }}",
+ "README.txt"
+ ]
+ ]
+ },
+ "ReadFile": {
+ "Description": "ReadFile reads the file named by filename relative to the configured WorkingDir.\nIt returns the contents as a string.\nThere is an upper size limit set at 1 megabytes.",
+ "Args": [
+ "i"
+ ],
+ "Aliases": [
+ "readFile"
+ ],
+ "Examples": [
+ [
+ "{{ readFile \"README.txt\" }}",
+ "Hugo Rocks!"
+ ]
+ ]
+ }
+ },
+ "partials": {
+ "Include": {
+ "Description": "Include executes the named partial and returns either a string,\nwhen the partial is a text/template, or template.HTML when html/template.",
+ "Args": [
+ "name",
+ "contextList"
+ ],
+ "Aliases": [
+ "partial"
+ ],
+ "Examples": [
+ [
+ "{{ partial \"header.html\" . }}",
+ "\u003ctitle\u003eHugo Rocks!\u003c/title\u003e"
+ ]
+ ]
+ },
+ "IncludeCached": {
+ "Description": "IncludeCached executes and caches partial templates. An optional variant\nstring parameter (a string slice actually, but be only use a variadic\nargument to make it optional) can be passed so that a given partial can have\nmultiple uses. The cache is created with name+variant as the key.",
+ "Args": [
+ "name",
+ "context",
+ "variant"
+ ],
+ "Aliases": [
+ "partialCached"
+ ],
+ "Examples": []
+ }
+ },
+ "safe": {
+ "CSS": {
+ "Description": "CSS returns a given string as html/template CSS content.",
+ "Args": [
+ "a"
+ ],
+ "Aliases": [
+ "safeCSS"
+ ],
+ "Examples": [
+ [
+ "{{ \"Bat\u0026Man\" | safeCSS | safeCSS }}",
+ "Bat\u0026amp;Man"
+ ]
+ ]
+ },
+ "HTML": {
+ "Description": "HTML returns a given string as html/template HTML content.",
+ "Args": [
+ "a"
+ ],
+ "Aliases": [
+ "safeHTML"
+ ],
+ "Examples": [
+ [
+ "{{ \"Bat\u0026Man\" | safeHTML | safeHTML }}",
+ "Bat\u0026Man"
+ ],
+ [
+ "{{ \"Bat\u0026Man\" | safeHTML }}",
+ "Bat\u0026Man"
+ ]
+ ]
+ },
+ "HTMLAttr": {
+ "Description": "HTMLAttr returns a given string as html/template HTMLAttr content.",
+ "Args": [
+ "a"
+ ],
+ "Aliases": [
+ "safeHTMLAttr"
+ ],
+ "Examples": []
+ },
+ "JS": {
+ "Description": "JS returns the given string as a html/template JS content.",
+ "Args": [
+ "a"
+ ],
+ "Aliases": [
+ "safeJS"
+ ],
+ "Examples": [
+ [
+ "{{ \"(1*2)\" | safeJS | safeJS }}",
+ "(1*2)"
+ ]
+ ]
+ },
+ "JSStr": {
+ "Description": "JSStr returns the given string as a html/template JSStr content.",
+ "Args": [
+ "a"
+ ],
+ "Aliases": [
+ "safeJSStr"
+ ],
+ "Examples": []
+ },
+ "SanitizeURL": {
+ "Description": "SanitizeURL returns a given string as html/template URL content.",
+ "Args": [
+ "a"
+ ],
+ "Aliases": [
+ "sanitizeURL",
+ "sanitizeurl"
+ ],
+ "Examples": []
+ },
+ "URL": {
+ "Description": "URL returns a given string as html/template URL content.",
+ "Args": [
+ "a"
+ ],
+ "Aliases": [
+ "safeURL"
+ ],
+ "Examples": [
+ [
+ "{{ \"http://gohugo.io\" | safeURL | safeURL }}",
+ "http://gohugo.io"
+ ]
+ ]
+ }
+ },
+ "strings": {
+ "Chomp": {
+ "Description": "Chomp returns a copy of s with all trailing newline characters removed.",
+ "Args": [
+ "s"
+ ],
+ "Aliases": [
+ "chomp"
+ ],
+ "Examples": [
+ [
+ "{{chomp \"\u003cp\u003eBlockhead\u003c/p\u003e\\n\" | safeHTML }}",
+ "\u003cp\u003eBlockhead\u003c/p\u003e"
+ ]
+ ]
+ },
+ "Contains": {
+ "Description": "",
+ "Args": null,
+ "Aliases": null,
+ "Examples": null
+ },
+ "ContainsAny": {
+ "Description": "",
+ "Args": null,
+ "Aliases": null,
+ "Examples": null
+ },
+ "CountRunes": {
+ "Description": "CountRunes returns the number of runes in s, excluding whitepace.",
+ "Args": [
+ "s"
+ ],
+ "Aliases": [
+ "countrunes"
+ ],
+ "Examples": []
+ },
+ "CountWords": {
+ "Description": "CountWords returns the approximate word count in s.",
+ "Args": [
+ "s"
+ ],
+ "Aliases": [
+ "countwords"
+ ],
+ "Examples": []
+ },
+ "FindRE": {
+ "Description": "FindRE returns a list of strings that match the regular expression. By default all matches\nwill be included. The number of matches can be limited with an optional third parameter.",
+ "Args": [
+ "expr",
+ "content",
+ "limit"
+ ],
+ "Aliases": [
+ "findRE"
+ ],
+ "Examples": [
+ [
+ "{{ findRE \"[G|g]o\" \"Hugo is a static side generator written in Go.\" \"1\" }}",
+ "[go]"
+ ]
+ ]
+ },
+ "HasPrefix": {
+ "Description": "HasPrefix tests whether the input s begins with prefix.",
+ "Args": [
+ "s",
+ "prefix"
+ ],
+ "Aliases": [
+ "hasPrefix"
+ ],
+ "Examples": [
+ [
+ "{{ hasPrefix \"Hugo\" \"Hu\" }}",
+ "true"
+ ],
+ [
+ "{{ hasPrefix \"Hugo\" \"Fu\" }}",
+ "false"
+ ]
+ ]
+ },
+ "HasSuffix": {
+ "Description": "",
+ "Args": null,
+ "Aliases": null,
+ "Examples": null
+ },
+ "Replace": {
+ "Description": "Replace returns a copy of the string s with all occurrences of old replaced\nwith new.",
+ "Args": [
+ "s",
+ "old",
+ "new"
+ ],
+ "Aliases": [
+ "replace"
+ ],
+ "Examples": [
+ [
+ "{{ replace \"Batman and Robin\" \"Robin\" \"Catwoman\" }}",
+ "Batman and Catwoman"
+ ]
+ ]
+ },
+ "ReplaceRE": {
+ "Description": "ReplaceRE returns a copy of s, replacing all matches of the regular\nexpression pattern with the replacement text repl.",
+ "Args": [
+ "pattern",
+ "repl",
+ "s"
+ ],
+ "Aliases": [
+ "replaceRE"
+ ],
+ "Examples": []
+ },
+ "SliceString": {
+ "Description": "SliceString slices a string by specifying a half-open range with\ntwo indices, start and end. 1 and 4 creates a slice including elements 1 through 3.\nThe end index can be omitted, it defaults to the string's length.",
+ "Args": [
+ "a",
+ "startEnd"
+ ],
+ "Aliases": [
+ "slicestr"
+ ],
+ "Examples": [
+ [
+ "{{slicestr \"BatMan\" 0 3}}",
+ "Bat"
+ ],
+ [
+ "{{slicestr \"BatMan\" 3}}",
+ "Man"
+ ]
+ ]
+ },
+ "Split": {
+ "Description": "Split slices an input string into all substrings separated by delimiter.",
+ "Args": [
+ "a",
+ "delimiter"
+ ],
+ "Aliases": [
+ "split"
+ ],
+ "Examples": []
+ },
+ "Substr": {
+ "Description": "Substr extracts parts of a string, beginning at the character at the specified\nposition, and returns the specified number of characters.\n\nIt normally takes two parameters: start and length.\nIt can also take one parameter: start, i.e. length is omitted, in which case\nthe substring starting from start until the end of the string will be returned.\n\nTo extract characters from the end of the string, use a negative start number.\n\nIn addition, borrowing from the extended behavior described at http://php.net/substr,\nif length is given and is negative, then that many characters will be omitted from\nthe end of string.",
+ "Args": [
+ "a",
+ "nums"
+ ],
+ "Aliases": [
+ "substr"
+ ],
+ "Examples": [
+ [
+ "{{substr \"BatMan\" 0 -3}}",
+ "Bat"
+ ],
+ [
+ "{{substr \"BatMan\" 3 3}}",
+ "Man"
+ ]
+ ]
+ },
+ "Title": {
+ "Description": "Title returns a copy of the input s with all Unicode letters that begin words\nmapped to their title case.",
+ "Args": [
+ "s"
+ ],
+ "Aliases": [
+ "title"
+ ],
+ "Examples": [
+ [
+ "{{title \"Bat man\"}}",
+ "Bat Man"
+ ],
+ [
+ "{{title \"somewhere over the rainbow\"}}",
+ "Somewhere Over the Rainbow"
+ ]
+ ]
+ },
+ "ToLower": {
+ "Description": "ToLower returns a copy of the input s with all Unicode letters mapped to their\nlower case.",
+ "Args": [
+ "s"
+ ],
+ "Aliases": [
+ "lower"
+ ],
+ "Examples": [
+ [
+ "{{lower \"BatMan\"}}",
+ "batman"
+ ]
+ ]
+ },
+ "ToUpper": {
+ "Description": "ToUpper returns a copy of the input s with all Unicode letters mapped to their\nupper case.",
+ "Args": [
+ "s"
+ ],
+ "Aliases": [
+ "upper"
+ ],
+ "Examples": [
+ [
+ "{{upper \"BatMan\"}}",
+ "BATMAN"
+ ]
+ ]
+ },
+ "Trim": {
+ "Description": "Trim returns a string with all leading and trailing characters defined\ncontained in cutset removed.",
+ "Args": [
+ "s",
+ "cutset"
+ ],
+ "Aliases": [
+ "trim"
+ ],
+ "Examples": [
+ [
+ "{{ trim \"++Batman--\" \"+-\" }}",
+ "Batman"
+ ]
+ ]
+ },
+ "TrimLeft": {
+ "Description": "TrimLeft returns a slice of the string s with all leading characters\ncontained in cutset removed.",
+ "Args": [
+ "cutset",
+ "s"
+ ],
+ "Aliases": null,
+ "Examples": [
+ [
+ "{{ \"aabbaa\" | strings.TrimLeft \"a\" }}",
+ "bbaa"
+ ]
+ ]
+ },
+ "TrimPrefix": {
+ "Description": "TrimPrefix returns s without the provided leading prefix string. If s doesn't\nstart with prefix, s is returned unchanged.",
+ "Args": [
+ "prefix",
+ "s"
+ ],
+ "Aliases": null,
+ "Examples": [
+ [
+ "{{ \"aabbaa\" | strings.TrimPrefix \"a\" }}",
+ "abbaa"
+ ],
+ [
+ "{{ \"aabbaa\" | strings.TrimPrefix \"aa\" }}",
+ "bbaa"
+ ]
+ ]
+ },
+ "TrimRight": {
+ "Description": "TrimRight returns a slice of the string s with all trailing characters\ncontained in cutset removed.",
+ "Args": [
+ "cutset",
+ "s"
+ ],
+ "Aliases": null,
+ "Examples": [
+ [
+ "{{ \"aabbaa\" | strings.TrimRight \"a\" }}",
+ "aabb"
+ ]
+ ]
+ },
+ "TrimSuffix": {
+ "Description": "TrimSuffix returns s without the provided trailing suffix string. If s\ndoesn't end with suffix, s is returned unchanged.",
+ "Args": [
+ "suffix",
+ "s"
+ ],
+ "Aliases": null,
+ "Examples": [
+ [
+ "{{ \"aabbaa\" | strings.TrimSuffix \"a\" }}",
+ "aabba"
+ ],
+ [
+ "{{ \"aabbaa\" | strings.TrimSuffix \"aa\" }}",
+ "aabb"
+ ]
+ ]
+ },
+ "Truncate": {
+ "Description": "Truncate truncates a given string to the specified length.",
+ "Args": [
+ "a",
+ "options"
+ ],
+ "Aliases": [
+ "truncate"
+ ],
+ "Examples": [
+ [
+ "{{ \"this is a very long text\" | truncate 10 \" ...\" }}",
+ "this is a ..."
+ ],
+ [
+ "{{ \"With [Markdown](/markdown) inside.\" | markdownify | truncate 14 }}",
+ "With \u003ca href=\"/markdown\"\u003eMarkdown …\u003c/a\u003e"
+ ]
+ ]
+ }
+ },
+ "time": {
+ "AsTime": {
+ "Description": "AsTime converts the textual representation of the datetime string into\na time.Time interface.",
+ "Args": [
+ "v"
+ ],
+ "Aliases": null,
+ "Examples": [
+ [
+ "{{ (time \"2015-01-21\").Year }}",
+ "2015"
+ ]
+ ]
+ },
+ "Duration": {
+ "Description": "Duration converts the given number to a time.Duration.\nUnit is one of nanosecond/ns, microsecond/us/µs, millisecond/ms, second/s, minute/m or hour/h.",
+ "Args": [
+ "unit",
+ "number"
+ ],
+ "Aliases": [
+ "duration"
+ ],
+ "Examples": [
+ [
+ "{{ mul 60 60 | duration \"second\" }}",
+ "1h0m0s"
+ ]
+ ]
+ },
+ "Format": {
+ "Description": "Format converts the textual representation of the datetime string into\nthe other form or returns it of the time.Time value. These are formatted\nwith the layout string",
+ "Args": [
+ "layout",
+ "v"
+ ],
+ "Aliases": [
+ "dateFormat"
+ ],
+ "Examples": [
+ [
+ "dateFormat: {{ dateFormat \"Monday, Jan 2, 2006\" \"2015-01-21\" }}",
+ "dateFormat: Wednesday, Jan 21, 2015"
+ ]
+ ]
+ },
+ "Now": {
+ "Description": "Now returns the current local time.",
+ "Args": null,
+ "Aliases": [
+ "now"
+ ],
+ "Examples": []
+ },
+ "ParseDuration": {
+ "Description": "ParseDuration parses a duration string.\nA duration string is a possibly signed sequence of\ndecimal numbers, each with optional fraction and a unit suffix,\nsuch as \"300ms\", \"-1.5h\" or \"2h45m\".\nValid time units are \"ns\", \"us\" (or \"µs\"), \"ms\", \"s\", \"m\", \"h\".\nSee https://golang.org/pkg/time/#ParseDuration",
+ "Args": [
+ "in"
+ ],
+ "Aliases": null,
+ "Examples": [
+ [
+ "{{ \"1h12m10s\" | time.ParseDuration }}",
+ "1h12m10s"
+ ]
+ ]
+ }
+ },
+ "transform": {
+ "Emojify": {
+ "Description": "Emojify returns a copy of s with all emoji codes replaced with actual emojis.\n\nSee http://www.emoji-cheat-sheet.com/",
+ "Args": [
+ "s"
+ ],
+ "Aliases": [
+ "emojify"
+ ],
+ "Examples": [
+ [
+ "{{ \"I :heart: Hugo\" | emojify }}",
+ "I ❤️ Hugo"
+ ]
+ ]
+ },
+ "HTMLEscape": {
+ "Description": "HTMLEscape returns a copy of s with reserved HTML characters escaped.",
+ "Args": [
+ "s"
+ ],
+ "Aliases": [
+ "htmlEscape"
+ ],
+ "Examples": [
+ [
+ "{{ htmlEscape \"Cathal Garvey \u0026 The Sunshine Band \u003ccathal@foo.bar\u003e\" | safeHTML}}",
+ "Cathal Garvey \u0026amp; The Sunshine Band \u0026lt;cathal@foo.bar\u0026gt;"
+ ],
+ [
+ "{{ htmlEscape \"Cathal Garvey \u0026 The Sunshine Band \u003ccathal@foo.bar\u003e\"}}",
+ "Cathal Garvey \u0026amp;amp; The Sunshine Band \u0026amp;lt;cathal@foo.bar\u0026amp;gt;"
+ ],
+ [
+ "{{ htmlEscape \"Cathal Garvey \u0026 The Sunshine Band \u003ccathal@foo.bar\u003e\" | htmlUnescape | safeHTML }}",
+ "Cathal Garvey \u0026 The Sunshine Band \u003ccathal@foo.bar\u003e"
+ ]
+ ]
+ },
+ "HTMLUnescape": {
+ "Description": "HTMLUnescape returns a copy of with HTML escape requences converted to plain\ntext.",
+ "Args": [
+ "s"
+ ],
+ "Aliases": [
+ "htmlUnescape"
+ ],
+ "Examples": [
+ [
+ "{{ htmlUnescape \"Cathal Garvey \u0026amp; The Sunshine Band \u0026lt;cathal@foo.bar\u0026gt;\" | safeHTML}}",
+ "Cathal Garvey \u0026 The Sunshine Band \u003ccathal@foo.bar\u003e"
+ ],
+ [
+ "{{\"Cathal Garvey \u0026amp;amp; The Sunshine Band \u0026amp;lt;cathal@foo.bar\u0026amp;gt;\" | htmlUnescape | htmlUnescape | safeHTML}}",
+ "Cathal Garvey \u0026 The Sunshine Band \u003ccathal@foo.bar\u003e"
+ ],
+ [
+ "{{\"Cathal Garvey \u0026amp;amp; The Sunshine Band \u0026amp;lt;cathal@foo.bar\u0026amp;gt;\" | htmlUnescape | htmlUnescape }}",
+ "Cathal Garvey \u0026amp; The Sunshine Band \u0026lt;cathal@foo.bar\u0026gt;"
+ ],
+ [
+ "{{ htmlUnescape \"Cathal Garvey \u0026amp; The Sunshine Band \u0026lt;cathal@foo.bar\u0026gt;\" | htmlEscape | safeHTML }}",
+ "Cathal Garvey \u0026amp; The Sunshine Band \u0026lt;cathal@foo.bar\u0026gt;"
+ ]
+ ]
+ },
+ "Highlight": {
+ "Description": "Highlight returns a copy of s as an HTML string with syntax\nhighlighting applied.",
+ "Args": [
+ "s",
+ "lang",
+ "opts"
+ ],
+ "Aliases": [
+ "highlight"
+ ],
+ "Examples": []
+ },
+ "Markdownify": {
+ "Description": "Markdownify renders a given input from Markdown to HTML.",
+ "Args": [
+ "s"
+ ],
+ "Aliases": [
+ "markdownify"
+ ],
+ "Examples": [
+ [
+ "{{ .Title | markdownify}}",
+ "\u003cstrong\u003eBatMan\u003c/strong\u003e"
+ ]
+ ]
+ },
+ "Plainify": {
+ "Description": "Plainify returns a copy of s with all HTML tags removed.",
+ "Args": [
+ "s"
+ ],
+ "Aliases": [
+ "plainify"
+ ],
+ "Examples": [
+ [
+ "{{ plainify \"Hello \u003cstrong\u003eworld\u003c/strong\u003e, gophers!\" }}",
+ "Hello world, gophers!"
+ ]
+ ]
++ },
++ "Remarshal": {
++ "Description": "Remarshal is used in the Hugo documentation to convert configuration\nexamples from YAML to JSON, TOML (and possibly the other way around).\nThe is primarily a helper for the Hugo docs site.\nIt is not a general purpose YAML to TOML converter etc., and may\nchange without notice if it serves a purpose in the docs.\nFormat is one of json, yaml or toml.",
++ "Args": [
++ "format",
++ "data"
++ ],
++ "Aliases": null,
++ "Examples": [
++ [
++ "{{ \"title = \\\"Hello World\\\"\" | transform.Remarshal \"json\" | safeHTML }}",
++ "{\n \"title\": \"Hello World\"\n}\n"
++ ]
++ ]
+ }
+ },
+ "urls": {
+ "AbsLangURL": {
+ "Description": "AbsLangURL takes a given string and converts it to an absolute URL according\nto a page's position in the project directory structure and the current\nlanguage.",
+ "Args": [
+ "a"
+ ],
+ "Aliases": [
+ "absLangURL"
+ ],
+ "Examples": []
+ },
+ "AbsURL": {
+ "Description": "AbsURL takes a given string and converts it to an absolute URL.",
+ "Args": [
+ "a"
+ ],
+ "Aliases": [
+ "absURL"
+ ],
+ "Examples": []
+ },
+ "Parse": {
+ "Description": "",
+ "Args": null,
+ "Aliases": null,
+ "Examples": null
+ },
+ "Ref": {
+ "Description": "Ref returns the absolute URL path to a given content item.",
+ "Args": [
+ "in",
+ "refs"
+ ],
+ "Aliases": [
+ "ref"
+ ],
+ "Examples": []
+ },
+ "RelLangURL": {
+ "Description": "RelLangURL takes a given string and prepends the relative path according to a\npage's position in the project directory structure and the current language.",
+ "Args": [
+ "a"
+ ],
+ "Aliases": [
+ "relLangURL"
+ ],
+ "Examples": []
+ },
+ "RelRef": {
+ "Description": "RelRef returns the relative URL path to a given content item.",
+ "Args": [
+ "in",
+ "refs"
+ ],
+ "Aliases": [
+ "relref"
+ ],
+ "Examples": []
+ },
+ "RelURL": {
+ "Description": "RelURL takes a given string and prepends the relative path according to a\npage's position in the project directory structure.",
+ "Args": [
+ "a"
+ ],
+ "Aliases": [
+ "relURL"
+ ],
+ "Examples": []
+ },
+ "URLize": {
+ "Description": "URLize returns the given argument formatted as URL.",
+ "Args": [
+ "a"
+ ],
+ "Aliases": [
+ "urlize"
+ ],
+ "Examples": []
+ }
+ }
+ }
+ }
+}
--- /dev/null
- {{ $isHTML := strings.HasSuffix $file "html" }}
+{{ $file := .Get "file" }}
- {{ if .Get "nocode" }}{{ .Inner }}{{ else }}{{ if $isHTML }}{{- highlight .Inner "html" "" | -}}{{ else }}<pre><code>{{- .Inner | string -}}</code></pre>{{ end }}{{ end }}
++{{ $.Scratch.Set "codeLang" "" }}
++{{ $suffix := findRE "(\\.[^.]+)$" $file 1 }}
++{{ with $suffix }}
++{{ $.Scratch.Set "codeLang" (index . 0 | strings.TrimPrefix ".") }}
++{{ end }}
++{{ with .Get "codeLang" }}{{ $.Scratch.Set "codeLang" . }}{{ end }}
+<div class="code relative" id="{{ $file | urlize}}">
+ {{- with $file -}}
+ <div class="filename san-serif f6 dib lh-solid pl2 pv2">{{.}}</div>
+ {{- end -}}
+
+ {{ if ne (.Get "copy") "false" }}
+ <button class="needs-js copy bg-accent-color-dark f6 absolute top-0 right-0 lh-solid hover-bg-primary-color-dark bn white ph3 pv2" title="Copy this code to your clipboard." data-clipboard-action="copy" aria-label="copy button">
+ </button>
+ {{/* Functionality located within filesaver.js The copy here is located in the css with .copy class so it can be replaced with JS on success */}}
+ {{end}}
+ <div class="code-copy-content nt3" {{with .Get "download"}}id="{{.}}"{{end}}>
++ {{ if .Get "nocode" }}{{ $.Inner }}{{ else }}{{ with $.Scratch.Get "codeLang" }}{{- highlight $.Inner . "" | -}}{{ else }}<pre><code>{{- .Inner | string -}}</code></pre>{{ end }}{{ end }}
+ </div>
+
+</div>
--- /dev/null
- HUGO_VERSION = "0.36.1"
+[build]
+publish = "public"
+command = "hugo"
+
+[context.production.environment]
- HUGO_VERSION = "0.36.1"
++HUGO_VERSION = "0.37.1"
+HUGO_ENV = "production"
+HUGO_ENABLEGITINFO = "true"
+
+[context.split1]
+command = "hugo --enableGitInfo"
+
+[context.split1.environment]
- HUGO_VERSION = "0.36.1"
++HUGO_VERSION = "0.37.1"
+HUGO_ENV = "production"
+
+[context.deploy-preview]
+command = "hugo -b $DEPLOY_PRIME_URL"
+
+[context.deploy-preview.environment]
- HUGO_VERSION = "0.36.1"
++HUGO_VERSION = "0.37.1"
+
+[context.branch-deploy]
+command = "hugo -b $DEPLOY_PRIME_URL"
+
+[context.branch-deploy.environment]
++HUGO_VERSION = "0.37.1"
+
+[context.next.environment]
+HUGO_ENABLEGITINFO = "true"
+
--- /dev/null
- name = ""
- link = ""
- logo = ""
+[[banners]]
+name = "Forestry.io"
+link = "https://forestry.io/"
+logo = "/images/sponsors/forestry-logotype.svg"
+copy = ""
+
+[[banners]]
++name = "Linode"
++link = "https://www.linode.com/"
++logo = "/images/sponsors/linode-logo_standard_light_medium.png"
+copy = ""
+
+[[banners]]
+name = ""
+link = ""
+logo = ""
+copy = ""
--- /dev/null
- gtag('config', '{{ . }}');
+{{ with .Site.GoogleAnalytics }}
+<script async src="https://www.googletagmanager.com/gtag/js?id={{ . }}"></script>
+<script>
+ window.dataLayer = window.dataLayer || [];
+ function gtag(){dataLayer.push(arguments);}
+ gtag('js', new Date());
+
- console.log("track:", id, url)
++ {{ $site := $.Site.BaseURL | replaceRE "^https?://(www\\.)?([^/]+).*" "$2" }}
++ gtag('config', '{{ . }}', {'dimension1': '{{ $site }}', 'dimension2': '{{ getenv "BRANCH" }}'});
+
+/**
+* Function that tracks a click on an outbound link in Analytics.
+* Setting the transport method to 'beacon' lets the hit be sent
+* using 'navigator.sendBeacon' in browser that support it.
+*/
+var trackOutboundLink = function(id, url) {
+ gtag('event', 'click', {
+ 'event_category': 'outbound',
+ 'event_label': id,
+ 'transport_type': 'beacon',
+ 'event_callback': function(){document.location = url;}
+ });
+}
+
+</script>
+{{ end }}
--- /dev/null
--- /dev/null
++<?xml version="1.0" encoding="utf-8"?>\r
++<!-- Generator: Adobe Illustrator 18.1.0, SVG Export Plug-In . SVG Version: 6.00 Build 0) -->\r
++<svg version="1.1" id="レイヤー_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px"\r
++ y="0px" viewBox="0 0 397.8 535.6" enable-background="new 0 0 397.8 535.6" xml:space="preserve">\r
++<g>\r
++ <path fill="#E0DEDC" d="M68.5,64c0,0-45.3-8-56.4,40.2c-11.7,50.6,27,46.7,27,46.7L68.5,64z"/>\r
++ <g>\r
++ <path fill="#040000" stroke="#040000" stroke-width="1.3483" stroke-miterlimit="10" d="M23.9,86.2c-8.5-0.3-15.5,25.8-13.1,35.2\r
++ c0.9,3.5,10,6.3,14-3.7C27.7,110.4,34.5,86.5,23.9,86.2z"/>\r
++ <path fill="#FFFFFF" d="M17.6,94c-1.9-0.6-4,4.5-4.7,6.3c-1.8,5.3,2.1,5.1,4.4,2C18.5,100.7,19.5,94.7,17.6,94z"/>\r
++ </g>\r
++ <path fill="#B8937F" d="M46.3,487.8c5.2,7.3,41.6,6.4,46.1-1.3c4.2-7.1-21.4-14.9-30.7-16.1C47.6,468.6,42.6,482.5,46.3,487.8z"/>\r
++ <path fill="#B8937F" d="M351,446c5.2,7.3,29.4,3.7,34-4c4.2-7.1-9.3-12.2-18.6-13.4C352.3,426.8,347.3,440.7,351,446z"/>\r
++ <path fill="#8CC5E7" d="M189.6,13.4c0,0-182.1-8.9-161,217.6c6.3,68-43.8,182.8,29.2,239.8c0,0,102.1,61.7,238.9,41.5\r
++ c20-3,45.5-10,63.2-57.1c22.3-59.5,6.6-121.5-13.2-165.5c-22.3-49.7-21.2-105.8-19.6-115.3C354.3,14.2,189.6,13.4,189.6,13.4z"/>\r
++ <path fill="#8CC5E7" d="M282.3,38.8c19.2-5,32.6-10.5,43.4-5c30.5,15.7-4.9,45.4-12.4,51C302.3,93.2,268.4,42.4,282.3,38.8z"/>\r
++ <path fill="#3C89BF" d="M306,40.5c-18.8,4.2-19.6,13.7-14.8,16.4c2.8,1.6,0.8-8.1,13.6-3.8c5.2,1.7-2.5,14.3,12.1,0.2\r
++ C324.7,45.6,310.1,39.6,306,40.5z"/>\r
++ <path fill="#E0DEDC" d="M137.9,29.2c-22.9,1.7-76.1,28.5-50,94.2c9.1,23,104.6,10.3,105.8-54C194.1,42.6,158.1,27.7,137.9,29.2z"/>\r
++ <path fill="#040000" stroke="#040000" stroke-width="1.3483" stroke-miterlimit="10" d="M109.9,51.8C88.5,53.7,83.3,84,91.3,91.1\r
++ c4.5,4,20.1,8.6,28.5-19C122.5,63.3,117.8,51,109.9,51.8z"/>\r
++ <path fill="#FFFFFF" d="M101.7,57.4c-3.1-0.9-8.8,7-7.1,10.3c0.6,1.2,3.2,2.9,5.3,1.3C102.2,67.2,107.8,59.1,101.7,57.4z"/>\r
++ <path fill="#B8937F" d="M74.6,130.1C34.9,122.3,30,165,43.9,172.3c10.1,5.4,38.8-3.5,43.6-13.4C92.2,148.9,95,134.1,74.6,130.1z"/>\r
++ <path fill="#040000" d="M48,126.4c-12.5,4.3-11.8,25.4-5.1,26c7.6,0.7,21-14.7,24.2-20.9C69.5,126.9,53,124.7,48,126.4z"/>\r
++ <path fill="#E0DEDC" d="M52.5,169.9c-3.2,1.4-2.9,18.8,3.3,21.5c19.6,8.3,20.9-20.4,17.1-24.9C70,162.9,54.7,168.9,52.5,169.9z"/>\r
++ <path fill="#B8937F" d="M272,269.2c-11.2,0.5-19.7,23.3-16.9,34.3c1.5,5.9,12.9,5,11.3,9.6c-2.7,7.6,17.4,12.9,21.2,4.7\r
++ C306.9,277,282.3,268.8,272,269.2z"/>\r
++ <path fill="#B8937F" d="M251.8,497.4c-39.7-4.3-51.7,14.7-44.4,21.8c7.7,7.5,38.1,5.3,54.7,3.9\r
++ C268.7,522.6,261.8,498.5,251.8,497.4z"/>\r
++</g>\r
++</svg>\r
--- /dev/null
- <svg id="Layer_1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 296.5 76"><style>.st0{fill:none;}</style><path class="st0" d="M198 53.5c.3-.3.4-.8.4-1.4 0-.5-.1-.9-.3-1.3-.2-.3-.5-.6-.8-.7-.3-.2-.7-.3-1.1-.3-.4-.1-.8-.1-1.3-.1h-2.5v4.9h3.1c.5 0 1-.1 1.4-.3.4-.3.8-.5 1.1-.8zM29.5 34.7l-5-9.6c-.5-1-1.9-1-2.4 0L15 38.7c-.5.9.2 2 1.2 2H22v2.1c0 .5.4.9.9.9h.9c.5 0 .9-.4.9-.9v-2.1h1.7l3.1-6zM184.4 51c-.5-.6-1.1-1-1.8-1.3-.7-.3-1.5-.5-2.4-.5-.9 0-1.6.2-2.4.5-.7.3-1.3.8-1.8 1.3-.5.6-.9 1.2-1.2 1.9-.3.7-.4 1.5-.4 2.4s.1 1.6.4 2.4c.3.7.7 1.4 1.2 1.9.5.6 1.1 1 1.8 1.3.7.3 1.5.5 2.4.5.9 0 1.6-.2 2.4-.5.7-.3 1.3-.8 1.8-1.3s.9-1.2 1.2-1.9c.3-.7.4-1.5.4-2.4s-.1-1.6-.4-2.4c-.3-.6-.7-1.3-1.2-1.9zM121.4 31.6c4.2 0 6.4-2.8 6.4-8.4 0-5.6-2.1-8.5-6.3-8.5-2.1 0-3.7.7-4.8 2.1-1.1 1.4-1.6 3.5-1.6 6.3s.5 4.9 1.6 6.3c1 1.5 2.6 2.2 4.7 2.2zM151.3 15.8c-.8-.5-2.1-.8-3.8-.8h-1.6v6.8h1.7c1.7 0 2.9-.3 3.7-.8.8-.6 1.2-1.4 1.2-2.6.1-1.2-.4-2.1-1.2-2.6zM96 50.3l-3.1 7.2H99l-3-7.2zM242.1 15.8c-.8-.5-2.1-.8-3.8-.8h-1.6v6.8h1.7c1.7 0 2.9-.3 3.7-.8.8-.6 1.2-1.4 1.2-2.6.1-1.2-.3-2.1-1.2-2.6zM39.5 24.9c-.3-.5-.7-.7-1.2-.7s-.9.2-1.2.7L26.2 45.7c-.5.9.2 2 1.2 2h8.9V51c0 .5.4.9.9.9h2.3c.5 0 .9-.4.9-.9v-3.3h8.9c1 0 1.7-1.1 1.2-2l-11-20.8zM291.4 15.3c-.8 0-1.3.3-1.7.8-.3.5-.5 1.2-.5 2.2 0 2 .7 3 2.2 3 1.5 0 2.2-1 2.2-3s-.7-3-2.2-3zM266 51c-.5-.6-1.1-1-1.8-1.3-.7-.3-1.5-.5-2.4-.5-.9 0-1.6.2-2.4.5-.7.3-1.3.8-1.8 1.3-.5.6-.9 1.2-1.2 1.9-.3.7-.4 1.5-.4 2.4s.1 1.6.4 2.4c.3.7.7 1.4 1.2 1.9.5.6 1.1 1 1.8 1.3.7.3 1.5.5 2.4.5.9 0 1.6-.2 2.4-.5.7-.3 1.3-.8 1.8-1.3s.9-1.2 1.2-1.9c.3-.7.4-1.5.4-2.4s-.1-1.6-.4-2.4c-.3-.6-.7-1.3-1.2-1.9z"/><path d="M89.3 35.8h5.2v-9.9h8.5v-4.4h-8.5v-6.4h9.1v-4.4H89.3zM121.4 36.1c3.8 0 6.8-1.1 8.8-3.3 2.1-2.2 3.1-5.4 3.1-9.6 0-4.2-1-7.3-3.1-9.6-2-2.2-5-3.3-8.8-3.3s-6.8 1.1-8.9 3.3c-2.1 2.2-3.1 5.4-3.1 9.5s1 7.4 3.1 9.6c2.1 2.3 5.1 3.4 8.9 3.4zm-4.7-19.2c1.1-1.4 2.7-2.1 4.8-2.1 4.2 0 6.3 2.8 6.3 8.5 0 5.6-2.1 8.4-6.4 8.4-2.1 0-3.7-.7-4.8-2.1-1.1-1.4-1.6-3.5-1.6-6.3s.6-5 1.7-6.4zM156.7 22.2c.8-1.1 1.2-2.5 1.2-3.9 0-2.5-.8-4.4-2.4-5.6s-4.1-1.9-7.5-1.9h-7.3v25h5.3v-9.6h2.8l6 9.6h5.9c-1.1-1.6-3.6-5.3-7.4-10.9 1.4-.7 2.6-1.6 3.4-2.7zm-5.3-1.2c-.8.6-2 .8-3.7.8H146V15h1.6c1.7 0 3 .3 3.8.8.8.5 1.2 1.3 1.2 2.5 0 1.3-.4 2.1-1.2 2.7zM180.3 31.4h-9.1v-5.5h8.5v-4.4h-8.5v-6.4h9.1v-4.4h-14.4v25.1h14.4zM196.3 21.3c-1.8-.8-2.9-1.4-3.4-1.8-.5-.3-.8-.7-1-1-.2-.3-.3-.8-.3-1.2 0-.8.3-1.4.8-1.8.5-.5 1.3-.7 2.3-.7.8 0 1.7.1 2.6.3.9.2 2 .6 3.3 1.1l1.7-4.1c-1.3-.6-2.5-1-3.7-1.3-1.2-.3-2.4-.5-3.7-.5-2.6 0-4.7.6-6.2 1.9-1.5 1.3-2.3 3-2.3 5.2 0 1.2.2 2.2.7 3.1s1.1 1.6 1.8 2.3c.8.7 1.9 1.4 3.4 2.1 1.6.8 2.7 1.3 3.2 1.7.5.4.9.7 1.2 1.1.3.4.4.8.4 1.3 0 .9-.3 1.5-.9 2-.6.4-1.5.7-2.7.7-1 0-2-.2-3.2-.5-1.2-.3-2.6-.8-4.3-1.6v4.9c2.1 1 4.4 1.5 7.1 1.5 2.9 0 5.2-.7 6.8-2 1.6-1.3 2.4-3.1 2.4-5.3 0-1.6-.4-3-1.3-4.1-.8-1.1-2.4-2.2-4.7-3.3zM213.4 35.8h5.3V15.1h6.8v-4.4h-18.9v4.4h6.8zM247.5 22.2c.8-1.1 1.2-2.5 1.2-3.9 0-2.5-.8-4.4-2.4-5.6-1.6-1.2-4.1-1.9-7.5-1.9h-7.3v25h5.3v-9.6h2.8l6 9.6h5.9c-1.1-1.6-3.6-5.3-7.4-10.9 1.4-.7 2.6-1.6 3.4-2.7zm-5.3-1.2c-.8.6-2 .8-3.7.8h-1.7V15h1.6c1.7 0 3 .3 3.8.8.8.5 1.2 1.3 1.2 2.5 0 1.3-.4 2.1-1.2 2.7zM264.5 21l-5.2-10.3h-5.8l8.3 15.5v9.6h5.3V26l8.3-15.3h-5.7zM282.4 14h1.8v8.7h-1.8zM283.3 10.6c-.3 0-.6.1-.8.3-.2.2-.3.4-.3.8 0 .3.1.6.3.7s.4.3.8.3c.3 0 .6-.1.8-.3s.3-.4.3-.7c0-.3-.1-.6-.3-.8-.2-.2-.5-.3-.8-.3zM294.4 15c-.7-.8-1.7-1.2-3-1.2s-2.3.4-3 1.2c-.7.8-1.1 1.9-1.1 3.3 0 .9.2 1.7.5 2.4s.8 1.2 1.4 1.6c.6.4 1.3.5 2.1.5 1.3 0 2.3-.4 3-1.2.7-.8 1.1-1.9 1.1-3.3.1-1.4-.3-2.5-1-3.3zm-3 6.3c-1.5 0-2.2-1-2.2-3 0-1 .2-1.7.5-2.2.3-.5.9-.8 1.7-.8 1.5 0 2.2 1 2.2 3s-.7 3-2.2 3zM62.9 18L34.4 1.5c-1.1-.6-2.5-.6-3.6 0L2.3 18c-1.1.6-1.8 1.8-1.8 3.1v33c0 1.3.7 2.5 1.8 3.1l28.5 16.5c1.1.6 2.5.6 3.6 0l28.5-16.5c1.1-.6 1.8-1.8 1.8-3.1v-33c0-1.3-.7-2.5-1.8-3.1zM24.6 42.7c0 .5-.4.9-.9.9h-.9c-.5 0-.9-.4-.9-.9v-2.1h-5.8c-1 0-1.7-1.1-1.2-2L22 25c.5-1 1.9-1 2.4 0l5 9.6-3.1 6h-1.7v2.1zm24.6 5h-8.9V51c0 .5-.4.9-.9.9h-2.3c-.5 0-.9-.4-.9-.9v-3.3h-8.9c-1 0-1.7-1.1-1.2-2L37 24.9c.3-.5.7-.7 1.2-.7s.9.2 1.2.7l10.9 20.8c.5.9-.1 2-1.1 2zM95.3 48l-6.5 14.7h2l1.5-3.6h7.4l1.5 3.6h2L96.9 48h-1.6zm-2.4 9.5l3.1-7.2 2.9 7.2h-6zM119.9 61c-.7.4-1.5.5-2.4.5-.8 0-1.6-.2-2.3-.5-.7-.3-1.3-.8-1.8-1.3s-.9-1.2-1.2-1.9c-.3-.7-.4-1.5-.4-2.4 0-.8.1-1.6.4-2.3.3-.7.7-1.4 1.2-2 .5-.6 1.1-1 1.8-1.3.7-.3 1.4-.5 2.3-.5.7 0 1.4.1 2 .4.7.3 1.2.7 1.6 1.3l1.5-1.1c-.6-.8-1.4-1.4-2.3-1.8s-1.9-.5-2.9-.5c-1.1 0-2.1.2-3 .6s-1.7.9-2.4 1.6c-.7.7-1.2 1.5-1.5 2.5-.4.9-.6 2-.6 3 0 1.1.2 2.2.6 3.1.4.9.9 1.8 1.6 2.4.7.7 1.5 1.2 2.4 1.6s1.9.6 3 .6c1.2 0 2.2-.2 3.2-.6.9-.4 1.7-1.1 2.4-2l-1.3-1.1c-.5.8-1.1 1.3-1.9 1.7zM133.2 59.6h-.1l-5-11.6h-2.6v14.7h1.8V50.4l5.3 12.3h1.1l5.3-12.3v12.3h1.7V48h-2.5zM151.7 55.8c-.4-.3-.9-.6-1.4-.8-.5-.2-1.1-.4-1.7-.6-.6-.2-1.1-.4-1.5-.5-.4-.2-.7-.4-1-.6s-.4-.4-.5-.7c-.1-.3-.2-.6-.2-.9 0-.4.1-.8.3-1.1.2-.3.4-.6.7-.8.3-.2.6-.3 1-.4.4-.1.8-.1 1.1-.1.5 0 1 .1 1.5.3.5.2.9.6 1.2 1l1.4-1.2c-.5-.6-1.2-1.1-1.8-1.3-.7-.3-1.4-.4-2.3-.4-.7 0-1.3.1-1.9.3-.6.2-1.1.4-1.6.8s-.8.8-1.1 1.3c-.3.5-.4 1.1-.4 1.9 0 .6.1 1.1.3 1.6.2.4.4.8.8 1.1.3.3.7.6 1.2.8s.9.4 1.5.6c.7.2 1.2.4 1.7.6.5.2.9.4 1.2.6.3.2.6.5.7.7.2.3.2.7.2 1.1 0 .4-.1.8-.3 1.1-.2.3-.4.6-.7.8-.3.2-.6.4-1 .5-.4.1-.8.2-1.1.2-.6 0-1.2-.1-1.8-.4s-1-.7-1.3-1.2l-1.5 1.2c.2.4.5.7.9.9.3.3.7.5 1.1.6.4.2.8.3 1.2.4s.9.1 1.3.1c.7 0 1.3-.1 1.9-.3s1.2-.4 1.7-.8.9-.8 1.2-1.3c.3-.5.4-1.2.4-1.9s-.1-1.3-.4-1.8c-.2-.7-.6-1.1-1-1.4zM161.7 62.7h1.8v-6.6h6.9v-1.6h-6.9v-4.9h7.4V48h-9.2zM185.7 49.8c-.7-.7-1.5-1.2-2.4-1.6-.9-.4-2-.6-3.1-.6s-2.2.2-3.1.6c-.9.4-1.7.9-2.4 1.6-.7.7-1.2 1.5-1.6 2.5-.4.9-.6 2-.6 3.1s.2 2.1.6 3.1c.4.9.9 1.8 1.6 2.5.7.7 1.5 1.2 2.4 1.6s2 .6 3.1.6 2.2-.2 3.1-.6 1.7-.9 2.4-1.6c.7-.7 1.2-1.5 1.6-2.5.4-1 .6-2 .6-3.1s-.2-2.1-.6-3.1c-.4-1-.9-1.8-1.6-2.5zm-.2 8c-.3.7-.7 1.4-1.2 1.9s-1.1 1-1.8 1.3c-.7.3-1.5.5-2.4.5-.9 0-1.6-.2-2.4-.5-.7-.3-1.3-.8-1.8-1.3-.5-.6-.9-1.2-1.2-1.9-.3-.7-.4-1.5-.4-2.4s.1-1.6.4-2.4c.3-.7.7-1.4 1.2-1.9.5-.6 1.1-1 1.8-1.3.7-.3 1.5-.5 2.4-.5.9 0 1.6.2 2.4.5.7.3 1.3.8 1.8 1.3s.9 1.2 1.2 1.9c.3.7.4 1.5.4 2.4s-.1 1.6-.4 2.4zM199.3 54.7c.7-.7 1-1.5 1-2.6 0-.9-.2-1.6-.5-2.2-.3-.5-.8-.9-1.4-1.2s-1.2-.5-1.9-.5-1.4-.1-2.1-.1h-3.8v14.7h1.7v-6.6h2.2l4 6.6h2.1l-4.2-6.8c1.3-.2 2.3-.6 2.9-1.3zm-5.3-.2h-1.6v-4.9h2.5c.4 0 .9 0 1.3.1s.8.2 1.1.3c.3.2.6.4.8.7.2.3.3.7.3 1.3 0 .6-.1 1.1-.4 1.4-.3.3-.6.6-1.1.7-.4.2-.9.2-1.4.3-.6.1-1.1.1-1.5.1zM218.7 54.3h-7.8V48h-1.8v14.7h1.8v-6.8h7.8v6.8h1.8V48h-1.8zM233.5 56.9c0 .6-.1 1.2-.2 1.7-.1.6-.3 1-.6 1.5s-.7.8-1.2 1c-.5.3-1.1.4-1.8.4s-1.3-.1-1.8-.4c-.5-.3-.9-.6-1.2-1-.3-.4-.5-.9-.6-1.5-.1-.6-.2-1.1-.2-1.7V48h-1.7v9.1c0 .8.1 1.6.3 2.3s.5 1.4 1 1.9c.4.5 1 1 1.7 1.3.7.3 1.6.5 2.6.5s1.9-.2 2.6-.5c.7-.3 1.3-.8 1.7-1.3.4-.5.8-1.2 1-1.9s.3-1.5.3-2.3V48h-1.7v8.9zM246.2 56.1h3.4v4.5c-.5.3-1.1.5-1.8.6-.7.1-1.3.2-1.9.2-.9 0-1.7-.2-2.5-.5s-1.4-.7-1.9-1.3-.9-1.2-1.2-1.9c-.3-.7-.4-1.6-.4-2.4 0-.9.1-1.7.4-2.5.3-.7.7-1.4 1.2-1.9s1.2-1 1.9-1.3 1.5-.5 2.4-.5c.7 0 1.5.1 2.2.4.7.3 1.3.7 1.8 1.2l1.3-1.4c-.7-.7-1.5-1.2-2.4-1.5s-1.8-.4-2.8-.4c-1.1 0-2.1.2-3.1.6-1 .4-1.8.9-2.5 1.6-.7.7-1.3 1.5-1.7 2.4-.4.9-.6 2-.6 3.2 0 1.2.2 2.2.6 3.2.4.9.9 1.8 1.6 2.4s1.5 1.2 2.5 1.6c1 .4 2 .6 3.2.6 1 0 1.9-.1 2.8-.3.9-.2 1.8-.6 2.7-1v-7.2h-5.1v1.6zM267.3 49.8c-.7-.7-1.5-1.2-2.4-1.6-.9-.4-2-.6-3.1-.6s-2.2.2-3.1.6c-.9.4-1.7.9-2.4 1.6-.7.7-1.2 1.5-1.6 2.5-.4.9-.6 2-.6 3.1s.2 2.1.6 3.1c.4.9.9 1.8 1.6 2.5.7.7 1.5 1.2 2.4 1.6s2 .6 3.1.6 2.2-.2 3.1-.6 1.7-.9 2.4-1.6c.7-.7 1.2-1.5 1.6-2.5.4-1 .6-2 .6-3.1s-.2-2.1-.6-3.1c-.3-1-.9-1.8-1.6-2.5zm-.1 8c-.3.7-.7 1.4-1.2 1.9s-1.1 1-1.8 1.3c-.7.3-1.5.5-2.4.5-.9 0-1.6-.2-2.4-.5-.7-.3-1.3-.8-1.8-1.3-.5-.6-.9-1.2-1.2-1.9-.3-.7-.4-1.5-.4-2.4s.1-1.6.4-2.4c.3-.7.7-1.4 1.2-1.9.5-.6 1.1-1 1.8-1.3.7-.3 1.5-.5 2.4-.5.9 0 1.6.2 2.4.5.7.3 1.3.8 1.8 1.3s.9 1.2 1.2 1.9c.3.7.4 1.5.4 2.4s-.1 1.6-.4 2.4z"/></svg>
++<svg id="Layer_1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 395.8 102"><style>.st0{fill:#181919}</style><path class="st0" d="M98.7 34.3L80 53V41.7l24.3-24.3-5.6-5.7L80 30.4V.6h-8v29.8L53.3 11.7l-5.6 5.7L72 41.7V53L53.3 34.4 31.9 12.9V.6h-8v12.3L-.4 37.2l5.6 5.7 18.7-18.7v11.4L-.4 59.8l5.6 5.7 18.7-18.6v55.5h8V46.8l18.6 18.7 5.7-5.7-24.3-24.3V24.2l18.6 18.7L72 64.3v38.1h8V64.3L104.3 40zM126.8 53.1h6.9V37.2h16.8V31h-16.8V20.9h17.9v-6.1h-24.8zM190.2 19.1c-1.8-1.8-3.9-3.1-6.4-4-2.5-.9-5.2-1.4-8.2-1.3-3 0-5.7.5-8.1 1.4-2.5 1-4.6 2.3-6.4 4.1-1.8 1.8-3.2 3.9-4.2 6.4-1 2.5-1.5 5.3-1.5 8.4 0 3 .5 5.7 1.5 8.2 1 2.5 2.4 4.6 4.2 6.3 1.8 1.7 3.9 3.1 6.4 4.1 2.5 1 5.2 1.4 8.1 1.4 3 0 5.7-.6 8.2-1.5 2.5-1 4.6-2.4 6.4-4.1 1.8-1.8 3.2-3.9 4.2-6.3 1-2.5 1.5-5.2 1.5-8.2 0-3.1-.5-5.8-1.5-8.3-1-2.7-2.4-4.8-4.2-6.6zm-2.3 20.2c-.6 1.7-1.5 3.2-2.7 4.5-1.2 1.3-2.5 2.3-4.2 3-1.6.7-3.4 1.1-5.4 1.1-2 0-3.8-.4-5.4-1.1-1.6-.7-3-1.7-4.1-3-1.2-1.3-2-2.8-2.7-4.5-.6-1.7-.9-3.6-.9-5.7 0-1.9.3-3.7.9-5.4.6-1.7 1.5-3.1 2.7-4.4 1.2-1.2 2.5-2.2 4.1-2.9 1.6-.7 3.4-1.1 5.4-1.1 2 0 3.8.3 5.4 1.1 1.6.7 3 1.7 4.2 2.9 1.2 1.2 2 2.7 2.7 4.4.6 1.7 1 3.4 1 5.4-.1 2.1-.4 4-1 5.7zM226.5 32.7c1.5-1.9 2.3-4.2 2.3-7 0-2.2-.4-3.9-1.2-5.4-.8-1.4-1.9-2.5-3.2-3.4-1.3-.8-2.9-1.4-4.6-1.8-1.7-.3-3.5-.5-5.3-.5h-13.3v38.3h6.8V36.8h5l8.9 16.2h8.2l-10.2-16.9c2.9-.4 5.1-1.5 6.6-3.4zm-10.3-1.8c-1 .1-1.9.1-2.9.1H208V20.6h5.9c.9 0 1.8.1 2.7.2.9.1 1.8.3 2.5.7.8.3 1.4.9 1.8 1.5.5.7.7 1.6.7 2.7 0 1.3-.3 2.2-.8 2.9-.5.7-1.2 1.2-2 1.6-.7.4-1.6.6-2.6.7zM241.6 36.5h17.6v-6.2h-17.6v-9.4h18.6v-6.1h-25.4v38.3h26.4v-6.2h-19.6zM286.8 33c-1.3-.8-2.8-1.5-4.4-1.9-1.6-.5-3-1-4.4-1.5-1.3-.5-2.5-1.1-3.4-1.8-.9-.7-1.4-1.7-1.4-3 0-.9.2-1.6.5-2.2.4-.6.8-1.1 1.4-1.5.6-.4 1.3-.7 2-.9.7-.2 1.5-.3 2.3-.3 1.3 0 2.6.2 3.8.7 1.2.5 2.2 1.3 2.9 2.3l5-5.2c-1.5-1.4-3.2-2.4-5.1-3-1.9-.6-3.8-.9-5.9-.9-1.8 0-3.5.2-5.2.7-1.7.5-3.2 1.2-4.5 2.1-1.3 1-2.4 2.2-3.2 3.6-.8 1.4-1.2 3.2-1.2 5.1 0 2.3.5 4.1 1.4 5.4.9 1.4 2 2.4 3.3 3.2 1.3.8 2.8 1.5 4.4 1.9 1.6.5 3 1 4.4 1.5 1.3.5 2.5 1.2 3.4 1.9.9.8 1.4 1.8 1.4 3.2 0 .9-.2 1.6-.6 2.3-.4.7-.9 1.2-1.6 1.7-.7.4-1.4.8-2.2 1-.8.2-1.6.3-2.4.3-1.5 0-2.9-.3-4.3-1.1s-2.4-1.7-3.3-2.9l-5.1 5c1.6 1.9 3.5 3.2 5.7 4 2.2.8 4.5 1.2 6.9 1.2 1.9 0 3.7-.3 5.4-.8 1.7-.5 3.2-1.3 4.5-2.3 1.3-1 2.3-2.3 3.1-3.8.8-1.5 1.1-3.3 1.1-5.4 0-2.3-.5-4.1-1.3-5.5-.9-1.1-2-2.2-3.4-3.1zM294.4 20.9h11.7v32.2h6.8V20.9h11.8v-6.1h-30.3zM356 32.7c1.5-1.9 2.3-4.2 2.3-7 0-2.2-.4-3.9-1.2-5.4-.8-1.4-1.9-2.5-3.2-3.4-1.3-.8-2.9-1.4-4.6-1.8-1.7-.3-3.5-.5-5.3-.5h-13.3v38.3h6.8V36.8h5l8.9 16.2h8.2l-10.2-16.9c2.9-.4 5-1.5 6.6-3.4zm-10.3-1.8c-1 .1-1.9.1-2.9.1h-5.3V20.6h5.9c.9 0 1.8.1 2.7.2.9.1 1.8.3 2.5.7.8.3 1.4.9 1.8 1.5.5.7.7 1.6.7 2.7 0 1.3-.3 2.2-.8 2.9-.5.7-1.2 1.2-2 1.6-.7.4-1.6.6-2.6.7zM387.1 14.8L377.6 30l-9.4-15.2h-8.6L374 36.7v16.4h6.8V36.7l14.4-21.9z"/><g><path class="st0" d="M136 67.6h2.4l9 21.1h-2.9l-2.1-5.2h-10.5l-2.2 5.2h-2.8l9.1-21.1zm1.1 3.2l-4.4 10.4h8.6l-4.2-10.4zM173.1 72c-.6-.9-1.4-1.5-2.4-1.9s-1.9-.6-2.9-.6c-1.2 0-2.2.2-3.2.7s-1.8 1.1-2.5 1.9c-.7.8-1.3 1.7-1.7 2.8s-.6 2.2-.6 3.3c0 1.2.2 2.4.6 3.4.4 1.1.9 2 1.7 2.8.7.8 1.5 1.4 2.5 1.9s2.1.7 3.3.7c1.3 0 2.4-.3 3.5-.8 1-.5 1.9-1.2 2.6-2.2l1.9 1.6c-1 1.3-2.1 2.2-3.4 2.8-1.3.6-2.9.9-4.5.9-1.5 0-2.9-.3-4.2-.8-1.3-.6-2.4-1.3-3.4-2.3-1-1-1.7-2.1-2.3-3.5-.5-1.3-.8-2.8-.8-4.4 0-1.5.3-3 .8-4.3s1.3-2.5 2.2-3.5 2.1-1.8 3.4-2.4c1.3-.6 2.7-.9 4.3-.9 1.4 0 2.8.3 4.1.8 1.3.5 2.4 1.4 3.3 2.5l-2.3 1.5zM179.3 67.6h3.7l7.1 16.5h.1l7.2-16.5h3.6v21.1h-2.5V71h-.1l-7.6 17.7h-1.5L181.9 71h-.1v17.7h-2.5V67.6zM216.3 71.3c-.4-.7-1-1.2-1.7-1.5-.7-.3-1.4-.5-2.2-.5-.6 0-1.1.1-1.6.2s-1 .3-1.4.6c-.4.3-.8.6-1 1.1-.3.5-.4 1-.4 1.6 0 .5.1.9.2 1.3s.4.7.7 1c.3.3.8.6 1.4.8.6.3 1.3.5 2.1.8.8.3 1.6.5 2.4.8.8.3 1.4.7 2 1.1.6.5 1.1 1 1.4 1.7.3.7.5 1.5.5 2.6s-.2 2-.6 2.7c-.4.8-1 1.4-1.7 1.9s-1.5.9-2.4 1.1-1.8.4-2.8.4c-.6 0-1.2-.1-1.8-.2-.6-.1-1.2-.3-1.8-.5-.6-.2-1.1-.5-1.6-.9s-.9-.8-1.3-1.4l2.1-1.8c.5.8 1.1 1.4 1.9 1.8.8.4 1.7.6 2.6.6.5 0 1.1-.1 1.6-.2s1-.4 1.5-.7c.4-.3.8-.7 1.1-1.1.3-.5.4-1 .4-1.6 0-.7-.1-1.2-.3-1.6-.2-.4-.6-.8-1-1.1-.5-.3-1-.6-1.7-.8-.7-.2-1.5-.5-2.4-.8-.8-.2-1.4-.5-2.1-.8-.6-.3-1.2-.7-1.7-1.1-.5-.4-.8-1-1.1-1.6-.3-.6-.4-1.4-.4-2.2 0-1 .2-1.9.6-2.6.4-.8.9-1.4 1.6-1.9.7-.5 1.4-.9 2.3-1.1.9-.3 1.7-.4 2.7-.4 1.2 0 2.3.2 3.3.5 1 .4 1.9 1 2.6 1.9l-2 1.9zM231.1 67.6h13.1v2.3h-10.6v7h9.8v2.3h-9.8v9.5h-2.5V67.6zM257.5 89.2c-1.6 0-3.1-.3-4.4-.8-1.3-.6-2.5-1.3-3.5-2.3-1-1-1.7-2.2-2.3-3.5s-.8-2.8-.8-4.4c0-1.6.3-3.1.8-4.4.5-1.4 1.3-2.5 2.3-3.5 1-1 2.1-1.8 3.5-2.3 1.3-.6 2.8-.8 4.4-.8 1.6 0 3.1.3 4.4.8 1.3.6 2.5 1.3 3.5 2.3 1 1 1.7 2.2 2.3 3.5.5 1.4.8 2.8.8 4.4 0 1.6-.3 3.1-.8 4.4s-1.3 2.5-2.3 3.5c-1 1-2.1 1.8-3.5 2.3-1.4.6-2.8.8-4.4.8zm0-2.3c1.2 0 2.4-.2 3.4-.7 1-.5 1.9-1.1 2.6-1.9.7-.8 1.3-1.7 1.7-2.8.4-1.1.6-2.2.6-3.4 0-1.2-.2-2.3-.6-3.4-.4-1.1-1-2-1.7-2.8-.7-.8-1.6-1.4-2.6-1.9s-2.1-.7-3.4-.7c-1.2 0-2.4.2-3.4.7-1 .5-1.9 1.1-2.6 1.9-.7.8-1.3 1.7-1.7 2.8-.4 1.1-.6 2.2-.6 3.4 0 1.2.2 2.3.6 3.4.4 1.1 1 2 1.7 2.8.7.8 1.6 1.4 2.6 1.9s2.1.7 3.4.7zM272.5 67.6h5.4c1 0 2 .1 3 .2s1.9.4 2.7.8c.8.4 1.4 1 1.9 1.7.5.8.7 1.8.7 3.1 0 1.5-.5 2.8-1.4 3.7s-2.2 1.6-3.9 1.8l6 9.7h-3.1l-5.7-9.5H275v9.5h-2.5v-21zm2.5 9.3h2.2c.7 0 1.4 0 2.2-.1.7 0 1.4-.2 2.1-.4s1.1-.6 1.5-1c.4-.5.6-1.1.6-2 0-.8-.1-1.4-.4-1.8-.3-.5-.7-.8-1.2-1.1s-1-.4-1.6-.5c-.6-.1-1.2-.1-1.8-.1H275v7zM298.9 67.6h2.5v8.9h11.2v-8.9h2.5v21.1h-2.5v-9.8h-11.2v9.8h-2.5V67.6zM336.2 80.7c0 1.2-.1 2.2-.4 3.3-.3 1-.7 1.9-1.4 2.7-.6.8-1.4 1.4-2.5 1.9-1 .5-2.2.7-3.7.7s-2.7-.2-3.7-.7c-1-.5-1.8-1.1-2.5-1.9-.6-.8-1.1-1.7-1.4-2.7-.3-1-.4-2.1-.4-3.3v-13h2.5v12.7c0 .9.1 1.7.3 2.5s.5 1.5.9 2.1c.4.6 1 1.1 1.7 1.5.7.4 1.6.6 2.6.6s1.9-.2 2.6-.6 1.2-.9 1.7-1.5c.4-.6.7-1.3.9-2.1.2-.8.3-1.6.3-2.5V67.6h2.5v13.1zM359.3 87.3c-1.2.7-2.5 1.2-3.8 1.5-1.3.3-2.7.5-4.1.5-1.6 0-3.2-.3-4.5-.8-1.4-.5-2.6-1.3-3.6-2.3-1-1-1.8-2.1-2.3-3.5-.6-1.4-.8-2.9-.8-4.5 0-1.7.3-3.2.9-4.5s1.4-2.5 2.4-3.5 2.2-1.7 3.6-2.2c1.4-.5 2.8-.8 4.4-.8 1.4 0 2.7.2 4 .6s2.4 1.1 3.4 2.1l-1.9 2c-.7-.8-1.6-1.4-2.6-1.8-1-.4-2.1-.6-3.1-.6-1.2 0-2.3.2-3.4.7-1 .4-1.9 1-2.7 1.8-.8.8-1.4 1.7-1.8 2.8s-.6 2.2-.6 3.5c0 1.2.2 2.4.6 3.5s1 2 1.8 2.8c.8.8 1.7 1.4 2.8 1.8s2.3.7 3.5.7c.9 0 1.7-.1 2.7-.3.9-.2 1.8-.5 2.6-.9v-6.5h-4.9v-2.3h7.4v10.2zM374.3 89.2c-1.6 0-3.1-.3-4.4-.8-1.3-.6-2.5-1.3-3.5-2.3-1-1-1.7-2.2-2.3-3.5s-.8-2.8-.8-4.4c0-1.6.3-3.1.8-4.4.5-1.4 1.3-2.5 2.3-3.5 1-1 2.1-1.8 3.5-2.3 1.3-.6 2.8-.8 4.4-.8 1.6 0 3.1.3 4.4.8 1.3.6 2.5 1.3 3.5 2.3 1 1 1.7 2.2 2.3 3.5.5 1.4.8 2.8.8 4.4 0 1.6-.3 3.1-.8 4.4s-1.3 2.5-2.3 3.5c-1 1-2.1 1.8-3.5 2.3-1.3.6-2.8.8-4.4.8zm0-2.3c1.2 0 2.4-.2 3.4-.7 1-.5 1.9-1.1 2.6-1.9.7-.8 1.3-1.7 1.7-2.8.4-1.1.6-2.2.6-3.4 0-1.2-.2-2.3-.6-3.4-.4-1.1-1-2-1.7-2.8-.7-.8-1.6-1.4-2.6-1.9s-2.1-.7-3.4-.7c-1.2 0-2.4.2-3.4.7-1 .5-1.9 1.1-2.6 1.9-.7.8-1.3 1.7-1.7 2.8-.4 1.1-.6 2.2-.6 3.4 0 1.2.2 2.3.6 3.4.4 1.1 1 2 1.7 2.8.7.8 1.6 1.4 2.6 1.9 1.1.5 2.2.7 3.4.7z"/></g></svg>
projects / brevno-suite / hugo / commitdiff
