--- /dev/null
--- /dev/null
++{
++ "recommendations": [
++ "EditorConfig.EditorConfig",
++ "esbenp.prettier-vscode",
++ ]
++}
--- /dev/null
- description: "`merge` deep merges two maps and returns the resulting map."
+---
+title: merge
- Merge creates a copy of the final `MAP` and merges any preceding `MAP` into it in reverse order.
++description: "Returns the result of merging two or more maps."
+date: 2019-08-08
+categories: [functions]
+menu:
+ docs:
+ parent: "functions"
+keywords: [dictionary]
+signature: ["collections.Merge MAP MAP...", "merge MAP MAP..."]
+workson: []
+hugoversion: "0.56.0"
+relatedfuncs: [dict, append, reflect.IsMap, reflect.IsSlice]
+aliases: []
+---
+
- An example merging two maps.
++Returns the result of merging two or more maps from left to right. If a key already exists, `merge` updates its value. If a key is absent, `merge` inserts the value under the new key.
++
+Key handling is case-insensitive.
+
- {{ $default_params := dict "color" "blue" "width" "50%" "height" "25%" "icon" "star" }}
- {{ $user_params := dict "color" "red" "icon" "mail" "extra" (dict "duration" 2) }}
- {{ $params := merge $default_params $user_params }}
++The following examples use these map definitions:
+
+```go-html-template
- Resulting __$params__:
++{{ $m1 := dict "x" "foo" }}
++{{ $m2 := dict "x" "bar" "y" "wibble" }}
++{{ $m3 := dict "x" "baz" "y" "wobble" "z" (dict "a" "huey") }}
+```
+
- "color": "red"
- "extra":
- "duration": 2
- "height": "25%"
- "icon": "mail"
- "width": "50%"
++Example 1
++
++```go-html-template
++{{ $merged := merge $m1 $m2 $m3 }}
+
++{{ $merged.x }} --> baz
++{{ $merged.y }} --> wobble
++{{ $merged.z.a }} --> huey
+```
- Regardless of depth, merging only applies to maps. For slices, use [append]({{< ref "functions/append" >}})
++
++Example 2
++
++```go-html-template
++{{ $merged := merge $m3 $m2 $m1 }}
++
++{{ $merged.x }} --> foo
++{{ $merged.y }} --> wibble
++{{ $merged.z.a }} --> huey
++```
++
++Example 3
++
++```go-html-template
++{{ $merged := merge $m2 $m3 $m1 }}
++
++{{ $merged.x }} --> foo
++{{ $merged.y }} --> wobble
++{{ $merged.z.a }} --> huey
++```
++
++Example 4
++
++```go-html-template
++{{ $merged := merge $m1 $m3 $m2 }}
++
++{{ $merged.x }} --> bar
++{{ $merged.y }} --> wibble
++{{ $merged.z.a }} --> huey
+```
+
+{{% note %}}
++Regardless of depth, merging only applies to maps. For slices, use [append]({{< ref "functions/append" >}}).
+{{% /note %}}
--- /dev/null
- description: GitLab makes it incredibly easy to build, deploy, and host your Hugo website via their free GitLab Pages service, which provides native support for Hugo.
+---
+title: Host on GitLab
+linktitle: Host on GitLab
- [GitLab](https://gitlab.com/) makes it incredibly easy to build, deploy, and host your Hugo website via their free GitLab Pages service, which provides [native support for Hugo, as well as numerous other static site generators](https://gitlab.com/pages/hugo).
-
++description: GitLab makes it easy to build, deploy, and host your Hugo website via their free GitLab Pages service, which provides native support for Hugo.
+date: 2016-06-23
+publishdate: 2016-06-23
+lastmod: 2017-11-16
+categories: [hosting and deployment]
+keywords: [hosting,deployment,git,gitlab]
+authors: [Riku-Pekka Silvola]
+menu:
+ docs:
+ parent: "hosting-and-deployment"
+ weight: 40
+weight: 40
+sections_weight: 40
+draft: false
+toc: true
+wip: false
+aliases: [/tutorials/hosting-on-gitlab/]
+---
+
- * Completion of the Hugo [Quick Start][]
+## Assumptions
+
+* Working familiarity with Git for version control
- ## Create .gitlab-ci.yml
++* Completion of the Hugo [Quick Start]
+* A [GitLab account](https://gitlab.com/users/sign_in)
+* A Hugo website on your local machine that you are ready to publish
+
- ```
- cd your-hugo-site
- ```
++## BaseURL
+
- In the root directory of your Hugo site, create a `.gitlab-ci.yml` file. The `.gitlab-ci.yml` configures the GitLab CI on how to build your page. Simply add the content below.
++The `baseURL` in your [site configuration](/getting-started/configuration/) must reflect the full URL of your GitLab pages repository if you are using the default GitLab Pages URL (e.g., `https://<YourUsername>.gitlab.io/<your-hugo-site>/`) and not a custom domain.
++
++## Configure GitLab CI/CD
+
- image: registry.gitlab.com/pages/hugo:latest
++Define your [CI/CD](https://docs.gitlab.com/ee/ci/quick_start/) jobs by creating a `.gitlab-ci.yml` file in the root of your project.
+
+{{< code file=".gitlab-ci.yml" >}}
- only:
- - master
++image: registry.gitlab.com/pages/hugo/hugo_extended:latest
+
+variables:
+ GIT_SUBMODULE_STRATEGY: recursive
+
+pages:
+ script:
+ - hugo
+ artifacts:
+ paths:
+ - public
- All available Hugo versions are listed [here](https://gitlab.com/pages/hugo/container_registry)
++ rules:
++ - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
+{{< /code >}}
+
+{{% note %}}
- ```
++See [this list](https://gitlab.com/pages/hugo/container_registry) if you wish to use a particular Hugo version to build your site.
+{{% /note %}}
+
+## Push Your Hugo Website to GitLab
+
+Next, create a new repository on GitLab. It is *not* necessary to make the repository public. In addition, you might want to add `/public` to your .gitignore file, as there is no need to push compiled assets to GitLab or keep your output website in version control.
+
- {{% note %}}
- Make sure your `baseURL` key-value in your [site configuration](/getting-started/configuration/) reflects the full URL of your GitLab pages repository if you're using the default GitLab Pages URL (e.g., `https://<YourUsername>.gitlab.io/<your-hugo-site>/`) and not a custom domain.
- {{% /note %}}
-
++```bash
+# initialize new git repository
+git init
+
+# add /public directory to our .gitignore file
+echo "/public" >> .gitignore
+
+# commit and push code to master branch
+git add .
+git commit -m "Initial commit"
+git remote add origin https://gitlab.com/YourUsername/your-hugo-site.git
+git push -u origin master
+```
+
+## Wait for Your Page to Build
+
+That's it! You can now follow the CI agent building your page at `https://gitlab.com/<YourUsername>/<your-hugo-site>/pipelines`.
+
+After the build has passed, your new website is available at `https://<YourUsername>.gitlab.io/<your-hugo-site>/`.
+
+## Next Steps
+
+GitLab supports using custom CNAME's and TLS certificates. For more details on GitLab Pages, see the [GitLab Pages setup documentation](https://about.gitlab.com/2016/04/07/gitlab-pages-setup/).
+
+[Quick Start]: /getting-started/quick-start/
--- /dev/null
- When the `mounts` config was introduced in Hugo 0.56.0, we were careful to preserve the existing `staticDir` and similar configuration to make sure all existing sites just continued to work. But you should not have both: if you add a `mounts` section you should remove the old `staticDir` etc. settings.
+---
+title: Configure Modules
+linktitle: Configure Modules
+description: This page describes the configuration options for a module.
+date: 2019-07-24
+categories: [hugo modules]
+keywords: [themes, source, organization, directories]
+menu:
+ docs:
+ parent: "modules"
+ weight: 10
+weight: 10
+sections_weight: 10
+toc: true
+---
+
+## Module Config: Top level
+
+{{< code-toggle file="config">}}
+[module]
+noVendor = ""
+proxy = "direct"
+noProxy = "none"
+private = "*.*"
+replacements = ""
+workspace = ""
+{{< /code-toggle >}}
+
+
+noVendor {{< new-in "0.75.0" >}}
+: A optional Glob pattern matching module paths to skip when vendoring, e.g. "github.com/**"
+
+vendorClosest {{< new-in "0.81.0" >}}
+: When enabled, we will pick the vendored module closest to the module using it. The default behaviour is to pick the first. Note that there can still be only one dependency of a given module path, so once it is in use it cannot be redefined.
+
+proxy
+: Defines the proxy server to use to download remote modules. Default is `direct`, which means "git clone" and similar.
+
+noProxy
+: Comma separated glob list matching paths that should not use the proxy configured above.
+
+private
+: Comma separated glob list matching paths that should be treated as private.
+
+workspace {{< new-in "0.83.0" >}}
+The workspace file to use. This enables Go workspace mode. Note that this can also be set via OS env, e.g. `export HUGO_MODULE_WORKSPACE=/my/hugo.work` This only works with Go 1.18+.
+
+replacements {{< new-in "0.77.0" >}}
+: A comma separated (or a slice) list of module path to directory replacement mapping, e.g. `github.com/bep/myprettytheme -> ../..,github.com/bep/shortcodes -> /some/path`. This is mostly useful for temporary locally development of a module, and then it makes sense to set it as an OS environment variable, e.g: `env HUGO_MODULE_REPLACEMENTS="github.com/bep/myprettytheme -> ../.."`. Any relative path is relate to [themesDir](https://gohugo.io/getting-started/configuration/#all-configuration-settings), and absolute paths are allowed.
+
+Note that the above terms maps directly to their counterparts in Go Modules. Some of these setting may be natural to set as OS environment variables. To set the proxy server to use, as an example:
+
+```
+env HUGO_MODULE_PROXY=https://proxy.example.org hugo
+```
+
+{{< gomodules-info >}}
+
+## Module Config: hugoVersion
+
+If your module requires a particular version of Hugo to work, you can indicate that in the `module` section and the user will be warned if using a too old/new version.
+
+{{< code-toggle file="config">}}
+[module]
+[module.hugoVersion]
+ min = ""
+ max = ""
+ extended = false
+
+{{< /code-toggle >}}
+
+Any of the above can be omitted.
+
+min
+: The minimum Hugo version supported, e.g. `0.55.0`
+
+max
+: The maximum Hugo version supported, e.g. `0.55.0`
+
+extended
+: Whether the extended version of Hugo is required.
+
+## Module Config: imports
+
+{{< code-toggle file="config">}}
+[module]
+[[module.imports]]
+ path = "github.com/gohugoio/hugoTestModules1_linux/modh1_2_1v"
+ ignoreConfig = false
+ ignoreImports = false
+ disable = false
+[[module.imports]]
+ path = "my-shortcodes"
+{{< /code-toggle >}}
+
+path
+: Can be either a valid Go Module module path, e.g. `github.com/gohugoio/myShortcodes`, or the directory name for the module as stored in your themes folder.
+
+ignoreConfig
+: If enabled, any module configuration file, e.g. `config.toml`, will not be loaded. Note that this will also stop the loading of any transitive module dependencies.
+
+ignoreImports {{< new-in "0.80.0" >}}
+: If enabled, module imports will not be followed.
+
+disable
+: Set to `true` to disable the module while keeping any version info in the `go.*` files.
+
+noMounts {{< new-in "0.84.2" >}}
+: Do not mount any folder in this import.
+
+noVendor
+: Never vendor this import (only allowed in main project).
+
+{{< gomodules-info >}}
+
+
+## Module Config: mounts
+
+{{% note %}}
++When the `mounts` config was introduced in Hugo 0.56.0, we were careful to preserve the existing `contentDir`, `staticDir`, and similar configuration to make sure all existing sites just continued to work. But you should not have both: if you add a `mounts` section you should remove the old `contentDir`, `staticDir`, etc. settings.
+{{% /note %}}
+
+{{% warning %}}
+When you add a mount, the default mount for the concerned target root is ignored: be sure to explicitly add it.
+{{% /warning %}}
+
+**Default mounts**
+{{< code-toggle file="config">}}
+[module]
+[[module.mounts]]
+ source="content"
+ target="content"
+[[module.mounts]]
+ source="static"
+ target="static"
+[[module.mounts]]
+ source="layouts"
+ target="layouts"
+[[module.mounts]]
+ source="data"
+ target="data"
+[[module.mounts]]
+ source="assets"
+ target="assets"
+[[module.mounts]]
+ source="i18n"
+ target="i18n"
+[[module.mounts]]
+ source="archetypes"
+ target="archetypes"
+{{< /code-toggle >}}
+
+source
+: The source directory of the mount. For the main project, this can be either project-relative or absolute and even a symbolic link. For other modules it must be project-relative.
+
+target
+: Where it should be mounted into Hugo's virtual filesystem. It must start with one of Hugo's component folders: `static`, `content`, `layouts`, `data`, `assets`, `i18n`, or `archetypes`. E.g. `content/blog`.
+
+lang
+: The language code, e.g. "en". Only relevant for `content` mounts, and `static` mounts when in multihost mode.
+
+includeFiles (string or slice)
+: One or more [glob](https://github.com/gobwas/glob) patterns matching files or directories to include. If `excludeFiles` is not set, the files matching `includeFiles` will be the files mounted.
+
+The glob patterns are matched to the filenames starting from the `source` root, they should have Unix styled slashes even on Windows, `/` matches the mount root and `**` can be used as a super-asterisk to match recursively down all directories, e.g `/posts/**.jpg`.
+
+The search is case-insensitive.
+
+{{< new-in "0.89.0" >}}
+
+excludeFiles (string or slice)
+: One or more glob patterns matching files to exclude.
+
--- /dev/null
- : used in situations only relevant for `HTML`-type formats; e.g., page aliases.
+---
+title: Custom Output Formats
+linktitle: Custom Output Formats
+description: Hugo can output content in multiple formats, including calendar events, e-book formats, Google AMP, and JSON search indexes, or any custom text format.
+date: 2017-03-22
+publishdate: 2017-03-22
+lastmod: 2019-12-11
+categories: [templates]
+keywords: ["amp","outputs","rss"]
+menu:
+ docs:
+ parent: "templates"
+ weight: 18
+weight: 18
+sections_weight: 18
+draft: false
+aliases: [/templates/outputs/,/extras/output-formats/,/content-management/custom-outputs/]
+toc: true
+---
+
+This page describes how to properly configure your site with the media types and output formats, as well as where to create your templates for your custom outputs.
+
+## Media Types
+
+A [media type][] (also known as *MIME type* and *content type*) is a two-part identifier for file formats and format contents transmitted on the Internet.
+
+This is the full set of built-in media types in Hugo:
+
+{{< datatable "media" "types" "type" "suffixes" >}}
+
+**Note:**
+
+* It is possible to add custom media types or change the defaults; e.g., if you want to change the suffix for `text/html` to `asp`.
+* `Suffixes` are the values that will be used for URLs and filenames for that media type in Hugo.
+* The `Type` is the identifier that must be used when defining new/custom `Output Formats` (see below).
+* The full set of media types will be registered in Hugo's built-in development server to make sure they are recognized by the browser.
+
+To add or modify a media type, define it in a `mediaTypes` section in your [site configuration][config], either for all sites or for a given language.
+
+{{< code-toggle file="config" >}}
+[mediaTypes]
+ [mediaTypes."text/enriched"]
+ suffixes = ["enr"]
+ [mediaTypes."text/html"]
+ suffixes = ["asp"]
+{{</ code-toggle >}}
+
+The above example adds one new media type, `text/enriched`, and changes the suffix for the built-in `text/html` media type.
+
+**Note:** these media types are configured for **your output formats**. If you want to redefine one of Hugo's default output formats (e.g. `HTML`), you also need to redefine the media type. So, if you want to change the suffix of the `HTML` output format from `html` (default) to `htm`:
+
+```toml
+[mediaTypes]
+[mediaTypes."text/html"]
+suffixes = ["htm"]
+
+# Redefine HTML to update its media type.
+[outputFormats]
+[outputFormats.HTML]
+mediaType = "text/html"
+```
+
+**Note** that for the above to work, you also need to add an `outputs` definition in your site config.
+
+## Output Format Definitions
+
+Given a media type and some additional configuration, you get an **Output Format**.
+
+This is the full set of Hugo's built-in output formats:
+
+{{< datatable "output" "formats" "name" "mediaType" "path" "baseName" "rel" "protocol" "isPlainText" "isHTML" "noUgly" "permalinkable" >}}
+
+* A page can be output in as many output formats as you want, and you can have an infinite amount of output formats defined **as long as they resolve to a unique path on the file system**. In the above table, the best example of this is `AMP` vs. `HTML`. `AMP` has the value `amp` for `Path` so it doesn't overwrite the `HTML` version; e.g. we can now have both `/index.html` and `/amp/index.html`.
+* The `MediaType` must match the `Type` of an already defined media type.
+* You can define new output formats or redefine built-in output formats; e.g., if you want to put `AMP` pages in a different path.
+
+To add or modify an output format, define it in an `outputFormats` section in your site's [configuration file](/getting-started/configuration/), either for all sites or for a given language.
+
+{{< code-toggle file="config" >}}
+[outputFormats.MyEnrichedFormat]
+mediaType = "text/enriched"
+baseName = "myindex"
+isPlainText = true
+protocol = "bep://"
+{{</ code-toggle >}}
+
+The above example is fictional, but if used for the homepage on a site with `baseURL` `https://example.org`, it will produce a plain text homepage with the URL `bep://example.org/myindex.enr`.
+
+### Configure Output Formats
+
+The following is the full list of configuration options for output formats and their default values:
+
+`name`
+: the output format identifier. This is used to define what output format(s) you want for your pages.
+
+`mediaType`
+: this must match the `Type` of a defined media type.
+
+`path`
+: sub path to save the output files.
+
+`baseName`
+: the base filename for the list filenames (homepage, etc.). **Default:** `index`.
+
+`rel`
+: can be used to create `rel` values in `link` tags. **Default:** `alternate`.
+
+`protocol`
+: will replace the "http://" or "https://" in your `baseURL` for this output format.
+
+`isPlainText`
+: use Go's plain text templates parser for the templates. **Default:** `false`.
+
+`isHTML`
++: used in situations only relevant for `HTML`-type formats; e.g., page aliases. **Default:** `false`.
+
+`noUgly`
+: used to turn off ugly URLs If `uglyURLs` is set to `true` in your site. **Default:** `false`.
+
+`notAlternative`
+: enable if it doesn't make sense to include this format in an `AlternativeOutputFormats` format listing on `Page` (e.g., with `CSS`). Note that we use the term *alternative* and not *alternate* here, as it does not necessarily replace the other format. **Default:** `false`.
+
+`permalinkable`
+: make `.Permalink` and `.RelPermalink` return the rendering Output Format rather than main ([see below](#link-to-output-formats)). This is enabled by default for `HTML` and `AMP`. **Default:** `false`.
+
+`weight`
+: Setting this to a non-zero value will be used as the first sort criteria.
+
+## Output Formats for Pages
+
+A `Page` in Hugo can be rendered to multiple *output formats* on the file
+system.
+
+### Default Output Formats
+Every `Page` has a [`Kind`][page_kinds] attribute, and the default Output
+Formats are set based on that.
+
+| Kind | Default Output Formats |
+|--------------- |----------------------- |
+| `page` | HTML |
+| `home` | HTML, RSS |
+| `section` | HTML, RSS |
+| `taxonomy` | HTML, RSS |
+| `term` | HTML, RSS |
+
+### Customizing Output Formats
+
+This can be changed by defining an `outputs` list of output formats in either
+the `Page` front matter or in the site configuration (either for all sites or
+per language).
+
+Example from site config file:
+
+{{< code-toggle file="config" >}}
+[outputs]
+ home = ["HTML", "AMP", "RSS"]
+ page = ["HTML"]
+{{</ code-toggle >}}
+
+
+Note that in the above examples, the *output formats* for `section`,
+`taxonomy` and `term` will stay at their default value `["HTML",
+"RSS"]`.
+
+{{< new-in "0.73.0" >}} We have fixed the before confusing page kinds used for taxonomies (see the listing below) to be in line with the terms used when we talk about taxonomies. We have been careful to avoid site breakage, and you should get an ERROR in the console if you need to adjust your `outputs` section.
+
+{{% page-kinds %}}
+
+* The `outputs` definition is per [`Page` `Kind`][page_kinds] (`page`, `home`, `section`, `taxonomy`, or `term`).
+* The names (e.g. `HTML`, `AMP`) used must match the `Name` of a defined *Output Format*.
+ * These names are case insensitive.
+* These can be overridden per `Page` in the front matter of content files.
+
+The following is an example of `YAML` front matter in a content file that defines output formats for the rendered `Page`:
+
+```yaml
+---
+date: "2016-03-19"
+outputs:
+- html
+- amp
+- json
+---
+```
+
+## List Output formats
+
+Each `Page` has both an `.OutputFormats` (all formats, including the current) and an `.AlternativeOutputFormats` variable, the latter of which is useful for creating a `link rel` list in your site's `<head>`:
+
+```go-html-template
+{{ range .AlternativeOutputFormats -}}
+<link rel="{{ .Rel }}" type="{{ .MediaType.Type }}" href="{{ .Permalink | safeURL }}">
+{{ end -}}
+```
+
+## Link to Output Formats
+
+`.Permalink` and `.RelPermalink` on `Page` will return the first output format defined for that page (usually `HTML` if nothing else is defined). This is regardless of the template file they are being called from.
+
+__from `single.json.json`:__
+```go-html-template
+{{ .RelPermalink }} > /that-page/
+{{ with .OutputFormats.Get "json" -}}
+{{ .RelPermalink }} > /that-page/index.json
+{{- end }}
+```
+
+In order for them to return the output format of the current template file instead, the given output format should have its `permalinkable` setting set to true.
+
+__Same template file as above with json output format's `permalinkable` set to true:__
+
+```go-html-template
+{{ .RelPermalink }} > /that-page/index.json
+{{ with .OutputFormats.Get "html" -}}
+{{ .RelPermalink }} > /that-page/
+{{- end }}
+```
+
+From content files, you can use the [`ref` or `relref` shortcodes](/content-management/shortcodes/#ref-and-relref):
+
+```go-html-template
+[Neat]({{</* ref "blog/neat.md" "amp" */>}})
+[Who]({{</* relref "about.md#who" "amp" */>}})
+```
+
+## Templates for Your Output Formats
+
+A new output format needs a corresponding template in order to render anything useful.
+
+{{% note %}}
+The key distinction for Hugo versions 0.20 and newer is that Hugo looks at an output format's `Name` and MediaType's `Suffixes` when choosing the template used to render a given `Page`.
+{{% /note %}}
+
+The following table shows examples of different output formats, the suffix used, and Hugo's respective template [lookup order][]. All of the examples in the table can:
+
+* Use a [base template][base].
+* Include [partial templates][partials]
+
+{{< datatable "output" "layouts" "Example" "OutputFormat" "Suffix" "Template Lookup Order" >}}
+
+Hugo will now also detect the media type and output format of partials, if possible, and use that information to decide if the partial should be parsed as a plain text template or not.
+
+Hugo will look for the name given, so you can name it whatever you want. But if you want it treated as plain text, you should use the file suffix and, if needed, the name of the Output Format. The pattern is as follows:
+
+```
+[partial name].[OutputFormat].[suffix]
+```
+
+The partial below is a plain text template (Output Format is `CSV`, and since this is the only output format with the suffix `csv`, we don't need to include the Output Format's `Name`):
+
+```
+{{ partial "mytextpartial.csv" . }}
+```
+
+[base]: /templates/base/
+[config]: /getting-started/configuration/
+[lookup order]: /templates/lookup/
+[media type]: https://en.wikipedia.org/wiki/Media_type
+[partials]: /templates/partials/
+[page_kinds]: /templates/section-templates/#page-kinds
--- /dev/null
- Most of the commands for **Hugo Modules** requires a newer version of Go installed (see https://golang.org/dl/) and the relevant VCS client (e.g. Git, see https://git-scm.com/downloads/ ). If you have an "older" site running on Netlify, you may have to set GO_VERSION to 1.12 in your Environment settings.
+{{ $text := `
++Most of the commands for **Hugo Modules** require a newer version of Go installed (see https://golang.org/dl/) and the relevant VCS client (e.g. Git, see https://git-scm.com/downloads/ ). If you have an "older" site running on Netlify, you may have to set GO_VERSION to 1.12 in your Environment settings.
+
+For more information about Go Modules, see:
+
+* https://github.com/golang/go/wiki/Modules
+* https://blog.golang.org/using-go-modules
+` }}
+
+<aside class="admonition note">
+ <div class="note-icon">
+ {{partial "svg/exclamation.svg" (dict "size" "20px" ) }}
+ </div>
+ <div class="admonition-content">
+ {{- $text | markdownify -}}
+ </div>
+</aside>
projects / brevno-suite / hugo / commitdiff