Fix tests for Go 1.21.1

Fixes #11450
commands/gen: Remove default highlight style
2026-08-31 10:42:38 +00:00 · 2023-09-14 12:35:55 +02:00 · 2023-09-14 12:08:52 +02:00 · 2023-09-12 11:50:31 +02:00 · 2023-09-12 10:48:04 +02:00 · 2023-09-11 11:38:24 +02:00
822 changed files with 15707 additions and 30272 deletions
@@ -5,7 +5,12 @@ assignees: ''
 about: Create a report to help us improve
 ---

-  
+<!--
+Please do not use the issue queue for questions or troubleshooting. Unless you are certain that your issue is a software defect, use the forum:
+
+https://discourse.gohugo.io
+-->
+
 <!-- Please answer these questions before submitting your issue. Thanks! -->

 ### What version of Hugo are you using (`hugo version`)?
@@ -0,0 +1,73 @@
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+name: TestDartSassV1
+env:
+    GOPROXY: https://proxy.golang.org
+    GO111MODULE: on
+    DART_SASS_VERSION: 1.62.1
+    DART_SASS_SHA_LINUX: 3574da75a7322a539034648b8ff84ff2cca162eb924d72b663d718cd3936f075
+permissions:
+  contents: read
+jobs:
+  test:
+    strategy:
+      matrix:
+        go-version: [1.21.x]
+        os: [ubuntu-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab
+    - name: Install Go
+      uses: actions/setup-go@fac708d6674e30b6ba41289acaab6d4b75aa0753
+      with:
+        go-version: ${{ matrix.go-version }}
+        check-latest: true
+        cache: true
+        cache-dependency-path: |
+          **/go.sum
+          **/go.mod
+    - name: Install Ruby
+      uses: ruby/setup-ruby@ee2113536afb7f793eed4ce60e8d3b26db912da4
+      with:
+        ruby-version: '2.7' 
+        bundler-cache: true #
+    - name: Install Python
+      uses: actions/setup-python@3105fb18c05ddd93efea5f9e0bef7a03a6e9e7df
+      with:
+        python-version: '3.x'
+    - name: Install Mage
+      run: go install github.com/magefile/mage@v1.15.0
+    - name: Install asciidoctor
+      uses: reitzig/actions-asciidoctor@7570212ae20b63653481675fb1ff62d1073632b0
+    - name: Install docutils
+      run: |
+        pip install docutils
+        rst2html.py --version
+    - if: matrix.os == 'ubuntu-latest'
+      name: Install pandoc on Linux
+      run: |
+          sudo apt-get update -y
+          sudo apt-get install -y pandoc
+    - if: matrix.os == 'macos-latest'
+      run: |
+        brew install pandoc
+    - if: matrix.os == 'windows-latest'
+      run: |
+        Choco-Install -PackageName pandoc
+    - run: pandoc -v
+    - name: Install dart-sass-embedded Linux
+      run: |
+        echo "Install Dart Sass version ${DART_SASS_VERSION} ..."
+        curl -LJO "https://github.com/sass/dart-sass-embedded/releases/download/${DART_SASS_VERSION}/sass_embedded-${DART_SASS_VERSION}-linux-x64.tar.gz";
+        echo "${DART_SASS_SHA_LINUX}  sass_embedded-${DART_SASS_VERSION}-linux-x64.tar.gz" | sha256sum -c;
+        tar -xvf "sass_embedded-${DART_SASS_VERSION}-linux-x64.tar.gz";
+        echo "$GITHUB_WORKSPACE/sass_embedded/" >> $GITHUB_PATH
+    - name: Check
+      run: |
+        dart-sass-embedded --version
+        mage -v check;
+      env:
+        HUGO_BUILD_TAGS: extended
@@ -6,17 +6,17 @@ name: Test
 env:
    GOPROXY: https://proxy.golang.org
    GO111MODULE: on
-    DART_SASS_VERSION: 1.56.2
-    DART_SASS_SHA_LINUX: 9e4f455f7b8619959d7878af2862383be58392eb963a14ff87cc512c03701e2a
-    DART_SASS_SHA_MACOS: 5992e979e2c30ec363f8e338822bb2b4443c74232b3340501a76180f5652cb09
-    DART_SASS_SHA_WINDOWS: 8d3d9117c54840e3e6a4919e43acf75ea52f28a64fc87a8e29d80ec72ee36cfb
+    SASS_VERSION: 1.63.2
+    DART_SASS_SHA_LINUX: 3ea33c95ad5c35fda6e9a0956199eef38a398f496cfb8750e02479d7d1dd42af
+    DART_SASS_SHA_MACOS: 11c70f259836b250b44a9cb57fed70e030f21f45069b467d371685855f1eb4f0
+    DART_SASS_SHA_WINDOWS: cd8cd36a619dd8e27f93d3186c52d70eb7d69472aa6c85f5094b29693e773f64
 permissions:
  contents: read
 jobs:
  test:
    strategy:
      matrix:
-        go-version: [1.19.x, 1.20.x]
+        go-version: [1.20.x,1.21.x]
        os: [ubuntu-latest, macos-latest, windows-latest]
    runs-on: ${{ matrix.os }}
    steps:
@@ -34,7 +34,7 @@ jobs:
    - name: Install Ruby
      uses: ruby/setup-ruby@ee2113536afb7f793eed4ce60e8d3b26db912da4
      with:
-        ruby-version: '2.7' 
+        ruby-version: '2.7'
        bundler-cache: true #
    - name: Install Python
      uses: actions/setup-python@3105fb18c05ddd93efea5f9e0bef7a03a6e9e7df
@@ -64,31 +64,33 @@ jobs:
      run: |
        Choco-Install -PackageName mingw -ArgumentList "--version","12.2.0","--allow-downgrade"
    - if: matrix.os == 'ubuntu-latest'
-      name: Install dart-sass-embedded Linux
+      name: Install dart-sass Linux
      run: |
-        echo "Install Dart Sass version ${DART_SASS_VERSION} ..."
-        curl -LJO "https://github.com/sass/dart-sass-embedded/releases/download/${DART_SASS_VERSION}/sass_embedded-${DART_SASS_VERSION}-linux-x64.tar.gz";
-        echo "${DART_SASS_SHA_LINUX}  sass_embedded-${DART_SASS_VERSION}-linux-x64.tar.gz" | sha256sum -c;
-        tar -xvf "sass_embedded-${DART_SASS_VERSION}-linux-x64.tar.gz";
-        echo "$GITHUB_WORKSPACE/sass_embedded/" >> $GITHUB_PATH
+        echo "Install Dart Sass version ${SASS_VERSION} ..."
+        curl -LJO "https://github.com/sass/dart-sass/releases/download/${SASS_VERSION}/dart-sass-${SASS_VERSION}-linux-x64.tar.gz";
+        echo "${DART_SASS_SHA_LINUX}  dart-sass-${SASS_VERSION}-linux-x64.tar.gz" | sha256sum -c;
+        tar -xvf "dart-sass-${SASS_VERSION}-linux-x64.tar.gz";
+        echo "$GOBIN"
+        echo "$GITHUB_WORKSPACE/dart-sass/" >> $GITHUB_PATH
    - if: matrix.os == 'macos-latest'
-      name: Install dart-sass-embedded MacOS
+      name: Install dart-sass MacOS
      run: |
-        echo "Install Dart Sass version ${DART_SASS_VERSION} ..."
-        curl -LJO "https://github.com/sass/dart-sass-embedded/releases/download/${DART_SASS_VERSION}/sass_embedded-${DART_SASS_VERSION}-macos-x64.tar.gz";
-        echo "${DART_SASS_SHA_MACOS}  sass_embedded-${DART_SASS_VERSION}-macos-x64.tar.gz" | shasum -a 256 -c;
-        tar -xvf "sass_embedded-${DART_SASS_VERSION}-macos-x64.tar.gz";
-        echo "$GITHUB_WORKSPACE/sass_embedded/" >> $GITHUB_PATH
+        echo "Install Dart Sass version ${SASS_VERSION} ..."
+        curl -LJO "https://github.com/sass/dart-sass/releases/download/${SASS_VERSION}/dart-sass-${SASS_VERSION}-macos-x64.tar.gz";
+        echo "${DART_SASS_SHA_MACOS}  dart-sass-${SASS_VERSION}-macos-x64.tar.gz" | shasum -a 256 -c;
+        tar -xvf "dart-sass-${SASS_VERSION}-macos-x64.tar.gz";
+        echo "$GITHUB_WORKSPACE/dart-sass/" >> $GITHUB_PATH
    - if: matrix.os == 'windows-latest'
-      name: Install dart-sass-embedded Windows
+      name: Install dart-sass Windows
      run: |
-        echo "Install Dart Sass version ${env:DART_SASS_VERSION} ..."
-        curl -LJO "https://github.com/sass/dart-sass-embedded/releases/download/${env:DART_SASS_VERSION}/sass_embedded-${env:DART_SASS_VERSION}-windows-x64.zip";
-        Expand-Archive -Path "sass_embedded-${env:DART_SASS_VERSION}-windows-x64.zip" -DestinationPath .;
-        echo  "$env:GITHUB_WORKSPACE/sass_embedded/" | Out-File -FilePath $Env:GITHUB_PATH -Encoding utf-8 -Append
+        echo "Install Dart Sass version ${env:SASS_VERSION} ..."
+        curl -LJO "https://github.com/sass/dart-sass/releases/download/${env:SASS_VERSION}/dart-sass-${env:SASS_VERSION}-windows-x64.zip";
+        Expand-Archive -Path "dart-sass-${env:SASS_VERSION}-windows-x64.zip" -DestinationPath .;
+        echo  "$env:GITHUB_WORKSPACE/dart-sass/" | Out-File -FilePath $Env:GITHUB_PATH -Encoding utf-8 -Append
    - if: matrix.os != 'windows-latest'
      name: Check
      run: |
+        sass --version;
        mage -v check;
      env:
        HUGO_BUILD_TAGS: extended
@@ -99,3 +101,13 @@ jobs:
        mage -v test;
      env:
        HUGO_BUILD_TAGS: extended
+    - name: Build tags
+      run: |
+        go install -tags extended,nodeploy
+    - if: matrix.os == 'ubuntu-latest'
+      name: Build for dragonfly
+      run: |
+        go install
+      env:
+        GOARCH: amd64
+        GOOS: dragonfly
@@ -2,7 +2,7 @@
 # Twitter:      https://twitter.com/gohugoio
 # Website:      https://gohugo.io/

-FROM golang:1.19-alpine AS build
+FROM golang:1.21-alpine AS build

 # Optionally set HUGO_BUILD_TAGS to "extended" or "nodeploy" when building like so:
 #   docker build --build-arg HUGO_BUILD_TAGS=extended .
@@ -26,7 +26,7 @@ RUN mage hugo && mage install

 # ---

-FROM alpine:3.16
+FROM alpine:3.18

 COPY --from=build /go/bin/hugo /usr/bin/hugo

@@ -1,243 +1,290 @@
+[bep]: https://github.com/bep
+[bugs]: https://github.com/gohugoio/hugo/issues?q=is%3Aopen+is%3Aissue+label%3ABug
+[contributing]: CONTRIBUTING.md
+[create a proposal]: https://github.com/gohugoio/hugo/issues/new?labels=Proposal%2C+NeedsTriage&template=feature_request.md
+[documentation repository]: https://github.com/gohugoio/hugoDocs
+[documentation]: https://gohugo.io/documentation
+[dragonfly bsd, freebsd, netbsd, and openbsd]: https://gohugo.io/installation/bsd
+[forum]: https://discourse.gohugo.io
+[friends]: https://github.com/gohugoio/hugo/graphs/contributors
+[go]: https://go.dev/
+[hugo modules]: https://gohugo.io/hugo-modules/
+[installation]: https://gohugo.io/installation
+[issue queue]: https://github.com/gohugoio/hugo/issues
+[linux]: https://gohugo.io/installation/linux
+[macos]: https://gohugo.io/installation/macos
+[prebuilt binary]: https://github.com/gohugoio/hugo/releases/latest
+[requesting help]: https://discourse.gohugo.io/t/requesting-help/9132
+[spf13]: https://github.com/spf13
+[static site generator]: https://en.wikipedia.org/wiki/Static_site_generator
+[support]: https://discourse.gohugo.io
+[themes]: https://themes.gohugo.io/
+[twitter]: https://twitter.com/gohugoio
+[website]: https://gohugo.io
+[windows]: https://gohugo.io/installation/windows
+
 <a href="https://gohugo.io/"><img src="https://raw.githubusercontent.com/gohugoio/gohugoioTheme/master/static/images/hugo-logo-wide.svg?sanitize=true" alt="Hugo" width="565"></a>

-A Fast and Flexible Static Site Generator built with love by [bep](https://github.com/bep), [spf13](https://spf13.com/) and [friends](https://github.com/gohugoio/hugo/graphs/contributors) in [Go](https://go.dev/).
+A fast and flexible static site generator built with love by [bep], [spf13], and [friends] in [Go].

-[Website](https://gohugo.io) |
-[Forum](https://discourse.gohugo.io) |
-[Documentation](https://gohugo.io/getting-started/) |
-[Installation Guide](https://gohugo.io/getting-started/installing/) |
-[Contribution Guide](CONTRIBUTING.md) |
-[Twitter](https://twitter.com/gohugoio)
+---

 [![GoDoc](https://godoc.org/github.com/gohugoio/hugo?status.svg)](https://godoc.org/github.com/gohugoio/hugo)
 [![Tests on Linux, MacOS and Windows](https://github.com/gohugoio/hugo/workflows/Test/badge.svg)](https://github.com/gohugoio/hugo/actions?query=workflow%3ATest)
 [![Go Report Card](https://goreportcard.com/badge/github.com/gohugoio/hugo)](https://goreportcard.com/report/github.com/gohugoio/hugo)

-* [Overview](#overview)
-* [Banner Sponsors](#banner-sponsors)
-* [Supported Architectures](#supported-architectures)
-* [Choose How to Install](#choose-how-to-install)
-   * [Install Hugo as Your Site Generator (Binary Install)](#install-hugo-as-your-site-generator-binary-install)
-   * [Build and Install the Binary from Source (Using the Go toolchain)](#build-and-install-the-binary-from-source-using-the-go-toolchain)
-* [The Hugo Documentation](#the-hugo-documentation)
-* [Contributing to Hugo](#contributing-code-to-hugo)
-* [Dependencies](#dependencies)
+[Website] | [Installation] | [Documentation] | [Support] | [Contributing] | [Twitter]

 ## Overview

-Hugo is a static HTML and CSS website generator written in [Go](https://go.dev/).
-It is optimized for speed, ease of use, and configurability.
-Hugo takes a directory with content and templates and renders them into a full HTML website.
+Hugo is a [static site generator] written in [Go], optimized for speed and designed for flexibility. With its advanced templating system and fast asset pipelines, Hugo renders a complete site in seconds, often less.

-Hugo relies on Markdown files with front matter for metadata, and you can run Hugo from any directory.
-This works well for shared hosts and other systems where you don’t have a privileged account.
+Due to its flexible framework, multilingual support, and powerful taxonomy system, Hugo is widely used to create:

-Hugo renders a typical website of moderate size in a fraction of a second.
-A good rule of thumb is that each piece of content renders in around 1 millisecond.
+- Corporate, government, nonprofit, education, news, event, and project sites
+- Documentation sites
+- Image portfolios
+- Landing pages
+- Business, professional, and personal blogs
+- Resumes and CVs

-Hugo is designed to work well for any kind of website including blogs, tumbles, and docs.
+Use Hugo's embedded web server during development to instantly see changes to content, structure, behavior, and presentation. Then deploy the site to your host, or push changes to your Git provider for automated builds and deployment.
+
+Hugo's fast asset pipelines include:
+
+- CSS bundling &ndash; transpilation (Sass), tree shaking, minification, source maps, SRI hashing, and PostCSS integration
+- JavaScript bundling &ndash; transpilation (TypeScript, JSX), tree shaking, minification, source maps, and SRI hashing
+- Image processing &ndash; convert, resize, crop, rotate,  adjust colors, apply filters, overlay text and images, and extract EXIF data
+
+And with [Hugo Modules], you can share content, assets, data, translations, themes, templates, and configuration with other projects via public or private Git repositories.
+
+## Sponsors

-## Banner Sponsors
 <p>&nbsp;</p>
 <p float="left">
  <a href="https://www.linode.com/?utm_campaign=hugosponsor&utm_medium=banner&utm_source=hugogithub" target="_blank"><img src="https://raw.githubusercontent.com/gohugoio/gohugoioTheme/master/assets/images/sponsors/linode-logo_standard_light_medium.png" width="200" alt="Linode"></a>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
+  <a href="https://cloudcannon.com/hugo-cms/?utm_campaign=HugoSponsorship&utm_source=sponsor&utm_content=gohugo" target="_blank"><img src="https://raw.githubusercontent.com/gohugoio/gohugoioTheme/master/assets/images/sponsors/cloudcannon-blue.svg" width="220" alt="CloudCannon"></a>
 <p>&nbsp;</p>

-## Supported Architectures
+## Installation

-Currently, we provide pre-built Hugo binaries for Windows, Linux, FreeBSD, NetBSD, DragonFly BSD, OpenBSD, macOS (Darwin), and [Android](https://gist.github.com/bep/a0d8a26cf6b4f8bc992729b8e50b480b) for x64, i386 and ARM architectures.
+Install Hugo from a [prebuilt binary], package manager, or package repository. Please see the installation instructions for your operating system:

-Hugo may also be compiled from source wherever the Go compiler tool chain can run, e.g. for other operating systems including Plan 9 and Solaris.
+- [macOS]
+- [Linux]
+- [Windows]
+- [DragonFly BSD, FreeBSD, NetBSD, and OpenBSD]

-**Complete documentation is available at [Hugo Documentation](https://gohugo.io/getting-started/).**
+## Build from source

-## Choose How to Install
+Hugo is available in two editions: standard and extended. With the extended edition you can:

-If you want to use Hugo as your site generator, simply install the Hugo binaries.
+- Encode to the WebP format when processing images. You can decode WebP images with either edition.
+- Transpile Sass to CSS using the embedded LibSass transpiler. The extended edition is not required to use the Dart Sass transpiler.

-To contribute to the Hugo source code or documentation, you should [fork the Hugo GitHub project](https://github.com/gohugoio/hugo#fork-destination-box) and clone it to your local machine.
+Prerequisites to build Hugo from source:

-Finally, you can install the Hugo source code with `go`, build the binaries yourself, and run Hugo that way.
-Building the binaries is an easy task for an experienced `go` getter.
+- Standard edition: Go 1.19 or later
+- Extended edition: Go 1.19 or later, and GCC

-### Install Hugo as Your Site Generator (Binary Install)
+Build the standard edition:

-Use the [installation instructions in the Hugo documentation](https://gohugo.io/getting-started/installing/).
-
-### Build and Install the Binary from Source (Using the Go toolchain)
-
-#### Prerequisite Tools
-
-* [Go (we test it with the last 2 major versions; but note that Hugo 0.95.0 only builds with >= Go 1.18.)](https://golang.org/dl/)
-
-#### Fetch from GitHub
-
-To fetch, build and install from the Github source:
-
-```bash
+```text
 go install github.com/gohugoio/hugo@latest
 ```

-If you want to compile with Sass/SCSS support use `-tags extended` and make sure `CGO_ENABLED=1` is set in your go environment. If you don't want to have CGO enabled, you may use the following command to temporarily enable CGO only for hugo compilation:
+Build the extended edition:

-```bash
+```text
 CGO_ENABLED=1 go install -tags extended github.com/gohugoio/hugo@latest
 ```

-## The Hugo Documentation
+## Documentation

-The Hugo documentation now lives in its own repository, see https://github.com/gohugoio/hugoDocs. But we do keep a version of that documentation as a `git subtree` in this repository. To build the sub folder `/docs` as a Hugo site, you need to clone this repo:
+Hugo's [documentation] includes installation instructions, a quick start guide, conceptual explanations, reference information, and examples.

-```bash
-git clone git@github.com:gohugoio/hugo.git
-```
-## Contributing code to Hugo
+Please submit documentation issues and pull requests to the [documentation repository].
+
+## Support
+
+Please **do not use the issue queue** for questions or troubleshooting. Unless you are certain that your issue is a software defect, use the [forum].
+
+Hugo’s [forum] is an active community of users and developers who answer questions, share knowledge, and provide examples. A quick search of over 20,000 topics will often answer your question. Please be sure to read about [requesting help] before asking your first question.
+
+## Contributing
+
+You can contribute to the Hugo project by:
+
+- Answering questions on the [forum]
+- Improving the [documentation]
+- Monitoring the [issue queue]
+- Creating or improving [themes]
+- Squashing [bugs]
+
+Please submit documentation issues and pull requests to the [documentation repository].
+
+If you have an idea for an enhancement or new feature, create a new topic on the [forum] in the "Feature" category. This will help you to:
+
+- Determine if the capability already exists
+- Measure interest
+- Refine the concept
+
+If there is sufficient interest, [create a proposal]. Do not submit a pull request until the project lead accepts the proposal.

 For a complete guide to contributing to Hugo, see the [Contribution Guide](CONTRIBUTING.md).

-We welcome contributions to Hugo of any kind including documentation, themes,
-organization, tutorials, blog posts, bug reports, issues, feature requests,
-feature implementations, pull requests, answering questions on the forum,
-helping to manage issues, etc.
-
-The Hugo community and maintainers are [very active](https://github.com/gohugoio/hugo/pulse/monthly) and helpful, and the project benefits greatly from this activity.
-
-## Asking Support Questions
-
-We have an active [discussion forum](https://discourse.gohugo.io) where users and developers can ask questions.
-Please don't use the GitHub issue tracker to ask questions.
-
-## Reporting Issues
-
-If you believe you have found a defect in Hugo or its documentation, use
-the GitHub issue tracker to report the problem to the Hugo maintainers.
-If you're not sure if it's a bug or not, start by asking in the [discussion forum](https://discourse.gohugo.io).
-When reporting the issue, please provide the version of Hugo in use (`hugo version`).
-
 ## Dependencies

-Hugo stands on the shoulder of many great open source libraries.
+Hugo stands on the shoulders of great open source libraries. Run `hugo env --logLevel info` to display a list of dependencies.

-If you run `hugo env -v` you will get a complete and up to date list.
+<details>
+<summary>See current dependencies</summary>

-In Hugo 0.111.2 that list is, in lexical order:
-
-```
-cloud.google.com/go/compute="v1.6.1"
-cloud.google.com/go/iam="v0.3.0"
-cloud.google.com/go/storage="v1.22.0"
-cloud.google.com/go="v0.101.0"
-github.com/Azure/azure-pipeline-go="v0.2.3"
-github.com/Azure/azure-storage-blob-go="v0.14.0"
-github.com/Azure/go-autorest/autorest/adal="v0.9.15"
-github.com/Azure/go-autorest/autorest/date="v0.3.0"
-github.com/Azure/go-autorest/autorest="v0.11.20"
-github.com/Azure/go-autorest/logger="v0.2.1"
-github.com/Azure/go-autorest/tracing="v0.6.0"
+```text
+cloud.google.com/go/compute/metadata="v0.2.3"
+cloud.google.com/go/iam="v1.1.0"
+cloud.google.com/go/storage="v1.30.1"
+cloud.google.com/go="v0.110.2"
+github.com/Azure/azure-sdk-for-go/sdk/azcore="v1.6.1"
+github.com/Azure/azure-sdk-for-go/sdk/azidentity="v1.3.0"
+github.com/Azure/azure-sdk-for-go/sdk/internal="v1.3.0"
+github.com/Azure/azure-sdk-for-go/sdk/storage/azblob="v1.0.0"
+github.com/Azure/go-autorest/autorest/to="v0.4.0"
+github.com/AzureAD/microsoft-authentication-library-for-go="v1.0.0"
 github.com/BurntSushi/locker="v0.0.0-20171006230638-a6e239ea1c69"
 github.com/PuerkitoBio/purell="v1.1.1"
 github.com/PuerkitoBio/urlesc="v0.0.0-20170810143723-de5bf2ad4578"
-github.com/alecthomas/chroma/v2="v2.5.0"
+github.com/alecthomas/chroma/v2="v2.7.0"
 github.com/armon/go-radix="v1.0.0"
-github.com/aws/aws-sdk-go-v2/config="v1.7.0"
-github.com/aws/aws-sdk-go-v2/credentials="v1.4.0"
-github.com/aws/aws-sdk-go-v2/feature/ec2/imds="v1.5.0"
-github.com/aws/aws-sdk-go-v2/internal/ini="v1.2.2"
-github.com/aws/aws-sdk-go-v2/service/internal/presigned-url="v1.3.0"
-github.com/aws/aws-sdk-go-v2/service/sso="v1.4.0"
-github.com/aws/aws-sdk-go-v2/service/sts="v1.7.0"
-github.com/aws/aws-sdk-go-v2="v1.9.0"
-github.com/aws/aws-sdk-go="v1.43.5"
-github.com/aws/smithy-go="v1.8.0"
-github.com/bep/clock="v0.3.0"
+github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream="v1.4.10"
+github.com/aws/aws-sdk-go-v2/config="v1.18.27"
+github.com/aws/aws-sdk-go-v2/credentials="v1.13.26"
+github.com/aws/aws-sdk-go-v2/feature/ec2/imds="v1.13.4"
+github.com/aws/aws-sdk-go-v2/feature/s3/manager="v1.11.70"
+github.com/aws/aws-sdk-go-v2/internal/configsources="v1.1.34"
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2="v2.4.28"
+github.com/aws/aws-sdk-go-v2/internal/ini="v1.3.35"
+github.com/aws/aws-sdk-go-v2/internal/v4a="v1.0.26"
+github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding="v1.9.11"
+github.com/aws/aws-sdk-go-v2/service/internal/checksum="v1.1.29"
+github.com/aws/aws-sdk-go-v2/service/internal/presigned-url="v1.9.28"
+github.com/aws/aws-sdk-go-v2/service/internal/s3shared="v1.14.3"
+github.com/aws/aws-sdk-go-v2/service/s3="v1.35.0"
+github.com/aws/aws-sdk-go-v2/service/sso="v1.12.12"
+github.com/aws/aws-sdk-go-v2/service/ssooidc="v1.14.12"
+github.com/aws/aws-sdk-go-v2/service/sts="v1.19.2"
+github.com/aws/aws-sdk-go-v2="v1.18.1"
+github.com/aws/aws-sdk-go="v1.44.284"
+github.com/aws/smithy-go="v1.13.5"
+github.com/bep/clocks="v0.5.0"
 github.com/bep/debounce="v1.2.0"
 github.com/bep/gitmap="v1.1.2"
 github.com/bep/goat="v0.5.0"
-github.com/bep/godartsass="v0.16.0"
-github.com/bep/golibsass="v1.1.0"
+github.com/bep/godartsass/v2="v2.0.0"
+github.com/bep/godartsass="v1.2.0"
+github.com/bep/golibsass="v1.1.1"
 github.com/bep/gowebp="v0.2.0"
 github.com/bep/lazycache="v0.2.0"
+github.com/bep/logg="v0.2.0"
+github.com/bep/mclib="v1.20400.20402"
 github.com/bep/overlayfs="v0.6.0"
+github.com/bep/simplecobra="v0.3.2"
 github.com/bep/tmc="v0.5.1"
 github.com/clbanning/mxj/v2="v2.5.7"
-github.com/cli/safeexec="v1.0.0"
+github.com/cli/safeexec="v1.0.1"
 github.com/cpuguy83/go-md2man/v2="v2.0.2"
 github.com/disintegration/gift="v1.2.1"
-github.com/dlclark/regexp2="v1.7.0"
-github.com/dustin/go-humanize="v1.0.0"
-github.com/evanw/esbuild="v0.17.0"
-github.com/frankban/quicktest="v1.14.4"
+github.com/dlclark/regexp2="v1.10.0"
+github.com/dustin/go-humanize="v1.0.1"
+github.com/evanw/esbuild="v0.18.5"
+github.com/fatih/color="v1.15.0"
+github.com/frankban/quicktest="v1.14.5"
 github.com/fsnotify/fsnotify="v1.6.0"
-github.com/getkin/kin-openapi="v0.110.0"
+github.com/getkin/kin-openapi="v0.118.0"
 github.com/ghodss/yaml="v1.0.0"
-github.com/go-openapi/jsonpointer="v0.19.5"
-github.com/go-openapi/swag="v0.19.5"
-github.com/gobuffalo/flect="v0.3.0"
+github.com/go-openapi/jsonpointer="v0.19.6"
+github.com/go-openapi/swag="v0.22.3"
+github.com/gobuffalo/flect="v1.0.2"
 github.com/gobwas/glob="v0.2.3"
 github.com/gohugoio/go-i18n/v2="v2.1.3-0.20210430103248-4c28c89f8013"
 github.com/gohugoio/locales="v0.14.0"
 github.com/gohugoio/localescompressed="v1.0.1"
-github.com/golang-jwt/jwt/v4="v4.0.0"
+github.com/golang-jwt/jwt/v4="v4.5.0"
 github.com/golang/groupcache="v0.0.0-20210331224755-41bb18bfe9da"
-github.com/golang/protobuf="v1.5.2"
+github.com/golang/protobuf="v1.5.3"
 github.com/google/go-cmp="v0.5.9"
+github.com/google/s2a-go="v0.1.4"
 github.com/google/uuid="v1.3.0"
 github.com/google/wire="v0.5.0"
-github.com/googleapis/gax-go/v2="v2.3.0"
-github.com/googleapis/go-type-adapters="v1.0.0"
+github.com/googleapis/enterprise-certificate-proxy="v0.2.5"
+github.com/googleapis/gax-go/v2="v2.11.0"
 github.com/gorilla/websocket="v1.5.0"
-github.com/hairyhenderson/go-codeowners="v0.2.3-0.20201026200250-cdc7c0759690"
+github.com/hairyhenderson/go-codeowners="v0.3.0"
 github.com/hashicorp/golang-lru/v2="v2.0.1"
 github.com/invopop/yaml="v0.1.0"
 github.com/jdkato/prose="v1.2.1"
 github.com/jmespath/go-jmespath="v0.4.0"
+github.com/josharian/intern="v1.0.0"
 github.com/kr/pretty="v0.3.1"
 github.com/kr/text="v0.2.0"
-github.com/kyokomi/emoji/v2="v2.2.11"
-github.com/mailru/easyjson="v0.0.0-20190626092158-b2ccc519800e"
+github.com/kylelemons/godebug="v1.1.0"
+github.com/kyokomi/emoji/v2="v2.2.12"
+github.com/mailru/easyjson="v0.7.7"
 github.com/marekm4/color-extractor="v1.2.0"
-github.com/mattn/go-ieproxy="v0.0.1"
-github.com/mattn/go-isatty="v0.0.17"
+github.com/mattn/go-colorable="v0.1.13"
+github.com/mattn/go-isatty="v0.0.19"
 github.com/mattn/go-runewidth="v0.0.9"
 github.com/mitchellh/hashstructure="v1.1.0"
 github.com/mitchellh/mapstructure="v1.5.0"
 github.com/mohae/deepcopy="v0.0.0-20170929034955-c48cc78d4826"
 github.com/muesli/smartcrop="v0.3.0"
-github.com/niklasfasching/go-org="v1.6.5"
+github.com/niklasfasching/go-org="v1.7.0"
 github.com/olekukonko/tablewriter="v0.0.5"
-github.com/pelletier/go-toml/v2="v2.0.6"
-github.com/rogpeppe/go-internal="v1.9.0"
+github.com/pelletier/go-toml/v2="v2.0.8"
+github.com/perimeterx/marshmallow="v1.1.4"
+github.com/pkg/browser="v0.0.0-20210911075715-681adbf594b8"
+github.com/pkg/errors="v0.9.1"
+github.com/rogpeppe/go-internal="v1.10.1-0.20230508101108-a4f6fabd84c5"
 github.com/russross/blackfriday/v2="v2.1.0"
 github.com/rwcarlsen/goexif="v0.0.0-20190401172101-9e8deecbddbd"
 github.com/sanity-io/litter="v1.5.5"
+github.com/sass/dart-sass/compiler="1.63.6"
+github.com/sass/dart-sass/implementation="1.63.6"
+github.com/sass/dart-sass/protocol="2.1.0"
 github.com/sass/libsass="3.6.5"
-github.com/spf13/afero="v1.9.3"
-github.com/spf13/cast="v1.5.0"
-github.com/spf13/cobra="v1.6.1"
+github.com/spf13/afero="v1.9.5"
+github.com/spf13/cast="v1.5.1"
+github.com/spf13/cobra="v1.7.0"
 github.com/spf13/fsync="v0.9.0"
-github.com/spf13/jwalterweatherman="v1.1.0"
 github.com/spf13/pflag="v1.0.5"
-github.com/tdewolff/minify/v2="v2.12.4"
-github.com/tdewolff/parse/v2="v2.6.5"
+github.com/tdewolff/minify/v2="v2.12.7"
+github.com/tdewolff/parse/v2="v2.6.6"
 github.com/webmproject/libwebp="v1.2.4"
 github.com/yuin/goldmark="v1.5.4"
 go.opencensus.io="v0.24.0"
-go.uber.org/atomic="v1.10.0"
-gocloud.dev="v0.24.0"
-golang.org/x/crypto="v0.3.0"
-golang.org/x/exp="v0.0.0-20221031165847-c99f073a8326"
-golang.org/x/image="v0.5.0"
-golang.org/x/net="v0.7.0"
-golang.org/x/oauth2="v0.2.0"
-golang.org/x/sync="v0.1.0"
-golang.org/x/sys="v0.5.0"
-golang.org/x/text="v0.7.0"
-golang.org/x/tools="v0.4.0"
+go.uber.org/atomic="v1.11.0"
+go.uber.org/automaxprocs="v1.5.2"
+gocloud.dev="v0.30.0"
+golang.org/x/crypto="v0.10.0"
+golang.org/x/exp="v0.0.0-20230321023759-10a507213a29"
+golang.org/x/image="v0.8.0"
+golang.org/x/mod="v0.10.0"
+golang.org/x/net="v0.11.0"
+golang.org/x/oauth2="v0.9.0"
+golang.org/x/sync="v0.3.0"
+golang.org/x/sys="v0.9.0"
+golang.org/x/text="v0.10.0"
+golang.org/x/tools="v0.9.3"
 golang.org/x/xerrors="v0.0.0-20220907171357-04be3eba64a2"
-google.golang.org/api="v0.76.0"
-google.golang.org/genproto="v0.0.0-20220426171045-31bebdecfb46"
-google.golang.org/grpc="v1.46.0"
-google.golang.org/protobuf="v1.28.1"
+google.golang.org/api="v0.128.0"
+google.golang.org/appengine="v1.6.7"
+google.golang.org/genproto/googleapis/api="v0.0.0-20230530153820-e85fd2cbaebc"
+google.golang.org/genproto/googleapis/rpc="v0.0.0-20230530153820-e85fd2cbaebc"
+google.golang.org/genproto="v0.0.0-20230530153820-e85fd2cbaebc"
+google.golang.org/grpc="v1.56.0"
+google.golang.org/protobuf="v1.30.0"
 gopkg.in/yaml.v2="v2.4.0"
 gopkg.in/yaml.v3="v3.0.1"
+software.sslmate.com/src/go-pkcs12="v0.2.0"
 ```
+</details>
@@ -1,2 +1,2 @@
-// Package cache contains the differenct cache implementations.
+// Package cache contains the different cache implementations.
 package cache
@@ -51,6 +51,9 @@ type Cache struct {
 	pruneAllRootDir string

 	nlocker *lockTracker
+
+	initOnce sync.Once
+	initErr  error
 }

 type lockTracker struct {
@@ -103,9 +106,23 @@ func (l *lockedFile) Close() error {
 	return l.File.Close()
 }

+func (c *Cache) init() error {
+	c.initOnce.Do(func() {
+		// Create the base dir if it does not exist.
+		if err := c.Fs.MkdirAll("", 0777); err != nil && !os.IsExist(err) {
+			c.initErr = err
+		}
+	})
+	return c.initErr
+}
+
 // WriteCloser returns a transactional writer into the cache.
 // It's important that it's closed when done.
 func (c *Cache) WriteCloser(id string) (ItemInfo, io.WriteCloser, error) {
+	if err := c.init(); err != nil {
+		return ItemInfo{}, nil, err
+	}
+
 	id = cleanID(id)
 	c.nlocker.Lock(id)

@@ -130,6 +147,10 @@ func (c *Cache) WriteCloser(id string) (ItemInfo, io.WriteCloser, error) {
 func (c *Cache) ReadOrCreate(id string,
 	read func(info ItemInfo, r io.ReadSeeker) error,
 	create func(info ItemInfo, w io.WriteCloser) error) (info ItemInfo, err error) {
+	if err := c.init(); err != nil {
+		return ItemInfo{}, err
+	}
+
 	id = cleanID(id)

 	c.nlocker.Lock(id)
@@ -163,6 +184,9 @@ func (c *Cache) ReadOrCreate(id string,
 // be invoked and the result cached.
 // This method is protected by a named lock using the given id as identifier.
 func (c *Cache) GetOrCreate(id string, create func() (io.ReadCloser, error)) (ItemInfo, io.ReadCloser, error) {
+	if err := c.init(); err != nil {
+		return ItemInfo{}, nil, err
+	}
 	id = cleanID(id)

 	c.nlocker.Lock(id)
@@ -197,6 +221,9 @@ func (c *Cache) GetOrCreate(id string, create func() (io.ReadCloser, error)) (It

 // GetOrCreateBytes is the same as GetOrCreate, but produces a byte slice.
 func (c *Cache) GetOrCreateBytes(id string, create func() ([]byte, error)) (ItemInfo, []byte, error) {
+	if err := c.init(); err != nil {
+		return ItemInfo{}, nil, err
+	}
 	id = cleanID(id)

 	c.nlocker.Lock(id)
@@ -232,6 +259,9 @@ func (c *Cache) GetOrCreateBytes(id string, create func() ([]byte, error)) (Item

 // GetBytes gets the file content with the given id from the cache, nil if none found.
 func (c *Cache) GetBytes(id string) (ItemInfo, []byte, error) {
+	if err := c.init(); err != nil {
+		return ItemInfo{}, nil, err
+	}
 	id = cleanID(id)

 	c.nlocker.Lock(id)
@@ -250,6 +280,9 @@ func (c *Cache) GetBytes(id string) (ItemInfo, []byte, error) {

 // Get gets the file with the given id from the cache, nil if none found.
 func (c *Cache) Get(id string) (ItemInfo, io.ReadCloser, error) {
+	if err := c.init(); err != nil {
+		return ItemInfo{}, nil, err
+	}
 	id = cleanID(id)

 	c.nlocker.Lock(id)
@@ -347,10 +380,6 @@ func NewCaches(p *helpers.PathSpec) (Caches, error) {

 		baseDir := v.DirCompiled

-		if err := cfs.MkdirAll(baseDir, 0777); err != nil && !os.IsExist(err) {
-			return nil, err
-		}
-
 		bfs := afero.NewBasePathFs(cfs, baseDir)

 		var pruneAllRootDir string
@@ -81,7 +81,7 @@ type FileCacheConfig struct {
 	// Max age of cache entries in this cache. Any items older than this will
 	// be removed and not returned from the cache.
 	// A negative value means forever, 0 means cache is disabled.
-	// Hugo is leninent with what types it accepts here, but we recommend using
+	// Hugo is lenient with what types it accepts here, but we recommend using
 	// a duration string, a sequence of  decimal numbers, each with optional fraction and a unit suffix,
 	// such as "300ms", "1.5h" or "2h45m".
 	// Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h".
@@ -93,7 +93,7 @@ type FileCacheConfig struct {

 	// Will resources/_gen will get its own composite filesystem that
 	// also checks any theme.
-	IsResourceDir bool
+	IsResourceDir bool `json:"-"`
 }

 // GetJSONCache gets the file cache for getJSON.
@@ -53,6 +53,9 @@ func (c *Cache) Prune(force bool) (int, error) {
 	if c.pruneAllRootDir != "" {
 		return c.pruneRootDir(force)
 	}
+	if err := c.init(); err != nil {
+		return 0, err
+	}

 	counter := 0

@@ -117,6 +120,9 @@ func (c *Cache) Prune(force bool) (int, error) {
 }

 func (c *Cache) pruneRootDir(force bool) (int, error) {
+	if err := c.init(); err != nil {
+		return 0, err
+	}
 	info, err := c.Fs.Stat(c.pruneAllRootDir)
 	if err != nil {
 		if herrors.IsNotExist(err) {
@@ -16,11 +16,10 @@ package filecache_test
 import (
 	"path/filepath"

-	jww "github.com/spf13/jwalterweatherman"
-
 	"testing"
 	"time"

+	"github.com/bep/logg"
 	qt "github.com/frankban/quicktest"
 	"github.com/gohugoio/hugo/htesting"
 	"github.com/gohugoio/hugo/hugolib"
@@ -80,7 +79,7 @@ iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAA
 `

 	b := hugolib.NewIntegrationTestBuilder(
-		hugolib.IntegrationTestConfig{T: t, TxtarString: files, Running: true, RunGC: true, NeedsOsFS: true, LogLevel: jww.LevelInfo},
+		hugolib.IntegrationTestConfig{T: t, TxtarString: files, Running: true, RunGC: true, NeedsOsFS: true, LogLevel: logg.LevelInfo},
 	).Build()

 	b.Assert(b.GCCount, qt.Equals, 0)
@@ -18,20 +18,21 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"log"
 	"os"
 	"os/signal"
 	"path/filepath"
+	"strings"
 	"sync"
 	"sync/atomic"
 	"syscall"
 	"time"

-	jww "github.com/spf13/jwalterweatherman"
-
 	"go.uber.org/automaxprocs/maxprocs"

-	"github.com/bep/clock"
+	"github.com/bep/clocks"
 	"github.com/bep/lazycache"
+	"github.com/bep/logg"
 	"github.com/bep/overlayfs"
 	"github.com/bep/simplecobra"

@@ -109,13 +110,10 @@ type rootCommand struct {
 	environment string

 	// Common build flags.
-	baseURL              string
-	gc                   bool
-	poll                 string
-	panicOnWarning       bool
-	forceSyncStatic      bool
-	printPathWarnings    bool
-	printUnusedTemplates bool
+	baseURL         string
+	gc              bool
+	poll            string
+	forceSyncStatic bool

 	// Profile flags (for debugging of performance problems)
 	cpuprofile   string
@@ -124,17 +122,20 @@ type rootCommand struct {
 	traceprofile string
 	printm       bool

-	// TODO(bep) var vs string
-	logging        bool
-	verbose        bool
-	verboseLog     bool
-	debug          bool
-	quiet          bool
+	logLevel string
+
+	verbose bool
+	debug   bool
+	quiet   bool
+
 	renderToMemory bool

 	cfgFile string
 	cfgDir  string
-	logFile string
+}
+
+func (r *rootCommand) isVerbose() bool {
+	return r.logger.Level() <= logg.LevelInfo
 }

 func (r *rootCommand) Build(cd *simplecobra.Commandeer, bcfg hugolib.BuildCfg, cfg config.Provider) (*hugolib.HugoSites, error) {
@@ -172,7 +173,7 @@ func (r *rootCommand) ConfigFromConfig(key int32, oldConf *commonConfig) (*commo

 		if !configs.Base.C.Clock.IsZero() {
 			// TODO(bep) find a better place for this.
-			htime.Clock = clock.Start(configs.Base.C.Clock)
+			htime.Clock = clocks.Start(configs.Base.C.Clock)
 		}

 		return &commonConfig{
@@ -239,11 +240,11 @@ func (r *rootCommand) ConfigFromProvider(key int32, cfg config.Provider) (*commo
 		renderStaticToDisk := cfg.GetBool("renderStaticToDisk")

 		sourceFs := hugofs.Os
-		var desinationFs afero.Fs
+		var destinationFs afero.Fs
 		if cfg.GetBool("renderToDisk") {
-			desinationFs = hugofs.Os
+			destinationFs = hugofs.Os
 		} else {
-			desinationFs = afero.NewMemMapFs()
+			destinationFs = afero.NewMemMapFs()
 			if renderStaticToDisk {
 				// Hybrid, render dynamic content to Root.
 				cfg.Set("publishDirDynamic", "/")
@@ -254,7 +255,7 @@ func (r *rootCommand) ConfigFromProvider(key int32, cfg config.Provider) (*commo
 			}
 		}

-		fs := hugofs.NewFromSourceAndDestination(sourceFs, desinationFs, cfg)
+		fs := hugofs.NewFromSourceAndDestination(sourceFs, destinationFs, cfg)

 		if renderStaticToDisk {
 			dynamicFs := fs.PublishDir
@@ -282,10 +283,10 @@ func (r *rootCommand) ConfigFromProvider(key int32, cfg config.Provider) (*commo

 		if !base.C.Clock.IsZero() {
 			// TODO(bep) find a better place for this.
-			htime.Clock = clock.Start(configs.Base.C.Clock)
+			htime.Clock = clocks.Start(configs.Base.C.Clock)
 		}

-		if base.LogPathWarnings {
+		if base.PrintPathWarnings {
 			// Note that we only care about the "dynamic creates" here,
 			// so skip the static fs.
 			fs.PublishDir = hugofs.NewCreateCountingFs(fs.PublishDir)
@@ -307,7 +308,7 @@ func (r *rootCommand) ConfigFromProvider(key int32, cfg config.Provider) (*commo

 func (r *rootCommand) HugFromConfig(conf *commonConfig) (*hugolib.HugoSites, error) {
 	h, _, err := r.hugoSites.GetOrCreate(r.configVersionID.Load(), func(key int32) (*hugolib.HugoSites, error) {
-		depsCfg := deps.DepsCfg{Configs: conf.configs, Fs: conf.fs, Logger: r.logger}
+		depsCfg := deps.DepsCfg{Configs: conf.configs, Fs: conf.fs, LogOut: r.logger.Out(), LogLevel: r.logger.Level()}
 		return hugolib.NewHugoSites(depsCfg)
 	})
 	return h, err
@@ -319,7 +320,7 @@ func (r *rootCommand) Hugo(cfg config.Provider) (*hugolib.HugoSites, error) {
 		if err != nil {
 			return nil, err
 		}
-		depsCfg := deps.DepsCfg{Configs: conf.configs, Fs: conf.fs, Logger: r.logger}
+		depsCfg := deps.DepsCfg{Configs: conf.configs, Fs: conf.fs, LogOut: r.logger.Out(), LogLevel: r.logger.Level()}
 		return hugolib.NewHugoSites(depsCfg)
 	})
 	return h, err
@@ -389,6 +390,9 @@ func (r *rootCommand) PreRun(cd, runner *simplecobra.Commandeer) error {
 	if r.quiet {
 		r.Out = io.Discard
 	}
+	// Used by mkcert (server).
+	log.SetOutput(r.Out)
+
 	r.Printf = func(format string, v ...interface{}) {
 		if !r.quiet {
 			fmt.Fprintf(r.Out, format, v...)
@@ -406,7 +410,6 @@ func (r *rootCommand) PreRun(cd, runner *simplecobra.Commandeer) error {
 		return err
 	}

-	loggers.PanicOnWarning.Store(r.panicOnWarning)
 	r.commonConfigs = lazycache.New[int32, *commonConfig](lazycache.Options{MaxEntries: 5})
 	r.hugoSites = lazycache.New[int32, *hugolib.HugoSites](lazycache.Options{MaxEntries: 5})

@@ -414,48 +417,48 @@ func (r *rootCommand) PreRun(cd, runner *simplecobra.Commandeer) error {
 }

 func (r *rootCommand) createLogger(running bool) (loggers.Logger, error) {
-	var (
-		logHandle       = io.Discard
-		logThreshold    = jww.LevelWarn
-		outHandle       = r.Out
-		stdoutThreshold = jww.LevelWarn
-	)
+	level := logg.LevelWarn

-	if r.verboseLog || r.logging || (r.logFile != "") {
-		var err error
-		if r.logFile != "" {
-			logHandle, err = os.OpenFile(r.logFile, os.O_RDWR|os.O_APPEND|os.O_CREATE, 0666)
-			if err != nil {
-				return nil, fmt.Errorf("Failed to open log file %q: %s", r.logFile, err)
-			}
-		} else {
-			logHandle, err = os.CreateTemp("", "hugo")
-			if err != nil {
-				return nil, err
-			}
+	if r.logLevel != "" {
+		switch strings.ToLower(r.logLevel) {
+		case "debug":
+			level = logg.LevelDebug
+		case "info":
+			level = logg.LevelInfo
+		case "warn", "warning":
+			level = logg.LevelWarn
+		case "error":
+			level = logg.LevelError
+		default:
+			return nil, fmt.Errorf("invalid log level: %q, must be one of debug, warn, info or error", r.logLevel)
+		}
+	} else {
+		if r.verbose {
+			helpers.Deprecated("--verbose", "use --logLevel info", false)
+			level = logg.LevelInfo
 		}
-	} else if r.verbose {
-		stdoutThreshold = jww.LevelInfo
-	}

-	if r.debug {
-		stdoutThreshold = jww.LevelDebug
-	}
-
-	if r.verboseLog {
-		logThreshold = jww.LevelInfo
 		if r.debug {
-			logThreshold = jww.LevelDebug
+			helpers.Deprecated("--debug", "use --logLevel debug", false)
+			level = logg.LevelDebug
 		}
 	}

-	loggers.InitGlobalLogger(stdoutThreshold, logThreshold, outHandle, logHandle)
-	helpers.InitLoggers()
-	return loggers.NewLogger(stdoutThreshold, logThreshold, outHandle, logHandle, running), nil
+	optsLogger := loggers.Options{
+		Distinct:    true,
+		Level:       level,
+		Stdout:      r.Out,
+		Stderr:      r.Out,
+		StoreErrors: running,
+	}
+
+	return loggers.New(optsLogger), nil
+
 }

 func (r *rootCommand) Reset() {
 	r.logger.Reset()
+	loggers.Log().Reset()
 }

 // IsTestRun reports whether the command is running as a test.
@@ -494,15 +497,10 @@ Complete documentation is available at https://gohugo.io/.`

 	cmd.PersistentFlags().BoolVarP(&r.verbose, "verbose", "v", false, "verbose output")
 	cmd.PersistentFlags().BoolVarP(&r.debug, "debug", "", false, "debug output")
-	cmd.PersistentFlags().BoolVar(&r.logging, "log", false, "enable Logging")
-	cmd.PersistentFlags().StringVar(&r.logFile, "logFile", "", "log File path (if set, logging enabled automatically)")
-	cmd.PersistentFlags().BoolVar(&r.verboseLog, "verboseLog", false, "verbose logging")
+	cmd.PersistentFlags().StringVar(&r.logLevel, "logLevel", "", "log level (debug|info|warn|error)")
 	cmd.Flags().BoolVarP(&r.buildWatch, "watch", "w", false, "watch filesystem for changes and recreate as needed")
 	cmd.Flags().BoolVar(&r.renderToMemory, "renderToMemory", false, "render to memory (only useful for benchmark testing)")

-	// Set bash-completion
-	_ = cmd.PersistentFlags().SetAnnotation("logFile", cobra.BashCompFilenameExt, []string{})
-
 	// Configure local flags
 	applyLocalFlagsBuild(cmd, r)

@@ -517,7 +515,7 @@ Complete documentation is available at https://gohugo.io/.`
 func applyLocalFlagsBuildConfig(cmd *cobra.Command, r *rootCommand) {
 	cmd.Flags().StringSliceP("theme", "t", []string{}, "themes to use (located in /themes/THEMENAME/)")
 	cmd.Flags().StringVarP(&r.baseURL, "baseURL", "b", "", "hostname (and path) to the root, e.g. https://spf13.com/")
-	cmd.Flags().StringP("cacheDir", "", "", "filesystem path to cache directory. Defaults: $TMPDIR/hugo_cache/")
+	cmd.Flags().StringP("cacheDir", "", "", "filesystem path to cache directory")
 	_ = cmd.Flags().SetAnnotation("cacheDir", cobra.BashCompSubdirsInDir, []string{})
 	cmd.Flags().StringP("contentDir", "c", "", "filesystem path to content directory")
 	_ = cmd.Flags().SetAnnotation("theme", cobra.BashCompSubdirsInDir, []string{"themes"})
@@ -536,7 +534,7 @@ func applyLocalFlagsBuild(cmd *cobra.Command, r *rootCommand) {
 	cmd.Flags().StringP("layoutDir", "l", "", "filesystem path to layout directory")
 	cmd.Flags().BoolVar(&r.gc, "gc", false, "enable to run some cleanup tasks (remove unused cache files) after the build")
 	cmd.Flags().StringVar(&r.poll, "poll", "", "set this to a poll interval, e.g --poll 700ms, to use a poll based approach to watch for file system changes")
-	cmd.Flags().BoolVar(&r.panicOnWarning, "panicOnWarning", false, "panic on first WARNING log")
+	cmd.Flags().Bool("panicOnWarning", false, "panic on first WARNING log")
 	cmd.Flags().Bool("templateMetrics", false, "display metrics about template executions")
 	cmd.Flags().Bool("templateMetricsHints", false, "calculate some improvement hints when combined with --templateMetrics")
 	cmd.Flags().BoolVar(&r.forceSyncStatic, "forceSyncStatic", false, "copy all files when static is changed.")
@@ -544,8 +542,8 @@ func applyLocalFlagsBuild(cmd *cobra.Command, r *rootCommand) {
 	cmd.Flags().BoolP("noChmod", "", false, "don't sync permission mode of files")
 	cmd.Flags().BoolP("noBuildLock", "", false, "don't create .hugo_build.lock file")
 	cmd.Flags().BoolP("printI18nWarnings", "", false, "print missing translations")
-	cmd.Flags().BoolVarP(&r.printPathWarnings, "printPathWarnings", "", false, "print warnings on duplicate target paths etc.")
-	cmd.Flags().BoolVarP(&r.printUnusedTemplates, "printUnusedTemplates", "", false, "print warnings on unused templates.")
+	cmd.Flags().BoolP("printPathWarnings", "", false, "print warnings on duplicate target paths etc.")
+	cmd.Flags().BoolP("printUnusedTemplates", "", false, "print warnings on unused templates.")
 	cmd.Flags().StringVarP(&r.cpuprofile, "profile-cpu", "", "", "write cpu profile to `file`")
 	cmd.Flags().StringVarP(&r.memprofile, "profile-mem", "", "", "write memory profile to `file`")
 	cmd.Flags().BoolVarP(&r.printm, "printMemoryUsage", "", false, "print memory usage to screen at intervals")
@@ -23,6 +23,7 @@ import (
 	"time"

 	"github.com/bep/simplecobra"
+	"github.com/gohugoio/hugo/common/maps"
 	"github.com/gohugoio/hugo/config/allconfig"
 	"github.com/gohugoio/hugo/modules"
 	"github.com/gohugoio/hugo/parser"
@@ -92,6 +93,7 @@ func (c *configCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, arg
 		if err := json.Unmarshal(buf.Bytes(), &m); err != nil {
 			return err
 		}
+		maps.ConvertFloat64WithNoDecimalsToInt(m)
 		switch format {
 		case "yaml":
 			return parser.InterfaceToConfig(m, metadecoders.YAML, os.Stdout)
@@ -212,7 +214,7 @@ func (c *configMountsCommand) Run(ctx context.Context, cd *simplecobra.Commandee
 	}

 	for _, m := range conf.configs.Modules {
-		if err := parser.InterfaceToConfig(&configModMounts{m: m, verbose: r.verbose}, metadecoders.JSON, os.Stdout); err != nil {
+		if err := parser.InterfaceToConfig(&configModMounts{m: m, verbose: r.isVerbose()}, metadecoders.JSON, os.Stdout); err != nil {
 			return err
 		}
 	}
@@ -84,7 +84,7 @@ type convertCommand struct {
 	r *rootCommand
 	h *hugolib.HugoSites

-	// Commmands.
+	// Commands.
 	commands []simplecobra.Commander
 }

@@ -110,6 +110,7 @@ See convert's subcommands toJSON, toTOML and toYAML for more information.`
 	cmd.PersistentFlags().StringVarP(&c.outputDir, "output", "o", "", "filesystem path to write files to")
 	cmd.PersistentFlags().BoolVar(&c.unsafe, "unsafe", false, "enable less safe operations, please backup first")

+	cmd.RunE = nil
 	return nil
 }

@@ -140,7 +141,7 @@ func (c *convertCommand) convertAndSavePage(p page.Page, site *hugolib.Site, tar

 	errMsg := fmt.Errorf("error processing file %q", p.File().Path())

-	site.Log.Infoln("ttempting to convert", p.File().Filename())
+	site.Log.Infoln("attempting to convert", p.File().Filename())

 	f := p.File()
 	file, err := f.FileInfo().Meta().Open()
@@ -52,7 +52,7 @@ documentation.
 			if err != nil {
 				return err
 			}
-			deployer, err := deploy.New(h.Configs.GetFirstLanguageConfig(), h.PathSpec.PublishFs)
+			deployer, err := deploy.New(h.Configs.GetFirstLanguageConfig(), h.Log, h.PathSpec.PublishFs)
 			if err != nil {
 				return err
 			}
@@ -63,9 +63,9 @@ documentation.
 			cmd.Flags().Bool("confirm", false, "ask for confirmation before making changes to the target")
 			cmd.Flags().Bool("dryRun", false, "dry run")
 			cmd.Flags().Bool("force", false, "force upload of all files")
-			cmd.Flags().Bool("invalidateCDN", true, "invalidate the CDN cache listed in the deployment target")
-			cmd.Flags().Int("maxDeletes", 256, "maximum # of files to delete, or -1 to disable")
-			cmd.Flags().Int("workers", 10, "number of workers to transfer files. defaults to 10")
+			cmd.Flags().Bool("invalidateCDN", deploy.DefaultConfig.InvalidateCDN, "invalidate the CDN cache listed in the deployment target")
+			cmd.Flags().Int("maxDeletes", deploy.DefaultConfig.MaxDeletes, "maximum # of files to delete, or -1 to disable")
+			cmd.Flags().Int("workers", deploy.DefaultConfig.Workers, "number of workers to transfer files. defaults to 10")
 		},
 	}
 }
@@ -30,8 +30,9 @@
 package commands

 import (
-	"errors"
+	"context"

+	"github.com/bep/simplecobra"
 	"github.com/spf13/cobra"
 )

@@ -32,7 +32,7 @@ func newEnvCommand() simplecobra.Commander {
 			r.Printf("GOARCH=%q\n", runtime.GOARCH)
 			r.Printf("GOVERSION=%q\n", runtime.Version())

-			if r.verbose {
+			if r.isVerbose() {
 				deps := hugo.GetDependencyList()
 				for _, dep := range deps {
 					r.Printf("%s\n", dep)
@@ -14,6 +14,7 @@
 package commands

 import (
+	"bytes"
 	"context"
 	"encoding/json"
 	"fmt"
@@ -30,8 +31,11 @@ import (
 	"github.com/gohugoio/hugo/docshelper"
 	"github.com/gohugoio/hugo/helpers"
 	"github.com/gohugoio/hugo/hugofs"
+	"github.com/gohugoio/hugo/hugolib"
+	"github.com/gohugoio/hugo/parser"
 	"github.com/spf13/cobra"
 	"github.com/spf13/cobra/doc"
+	"gopkg.in/yaml.v2"
 )

 func newGenCommand() *genCommand {
@@ -72,7 +76,7 @@ See https://xyproto.github.io/splash/docs/all.html for a preview of the availabl
 			},
 			withc: func(cmd *cobra.Command, r *rootCommand) {
 				cmd.PersistentFlags().StringVar(&style, "style", "friendly", "highlighter style (see https://xyproto.github.io/splash/docs/)")
-				cmd.PersistentFlags().StringVar(&highlightStyle, "highlightStyle", "bg:#ffffcc", "style used for highlighting lines (see https://github.com/alecthomas/chroma)")
+				cmd.PersistentFlags().StringVar(&highlightStyle, "highlightStyle", "", "style used for highlighting lines (see https://github.com/alecthomas/chroma)")
 				cmd.PersistentFlags().StringVar(&linesStyle, "linesStyle", "", "style used for line numbers (see https://github.com/alecthomas/chroma)")
 			},
 		}
@@ -132,7 +136,7 @@ url: %s
 			long: `Generate Markdown documentation for the Hugo CLI.
 			This command is, mostly, used to create up-to-date documentation
 	of Hugo's command-line interface for https://gohugo.io/.
-	
+
 	It creates one Markdown file per command with front matter suitable
 	for rendering in Hugo.`,
 			run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
@@ -186,18 +190,36 @@ url: %s
 			run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
 				r.Println("Generate docs data to", docsHelperTarget)

-				targetFile := filepath.Join(docsHelperTarget, "docs.json")
+				var buf bytes.Buffer
+				jsonEnc := json.NewEncoder(&buf)
+
+				configProvider := func() docshelper.DocProvider {
+					conf := hugolib.DefaultConfig()
+					conf.CacheDir = "" // The default value does not make sense in the docs.
+					defaultConfig := parser.LowerCaseCamelJSONMarshaller{Value: conf}
+					return docshelper.DocProvider{"config": defaultConfig}
+				}
+
+				docshelper.AddDocProviderFunc(configProvider)
+				if err := jsonEnc.Encode(docshelper.GetDocProvider()); err != nil {
+					return err
+				}
+
+				// Decode the JSON to a map[string]interface{} and then unmarshal it again to the correct format.
+				var m map[string]interface{}
+				if err := json.Unmarshal(buf.Bytes(), &m); err != nil {
+					return err
+				}
+
+				targetFile := filepath.Join(docsHelperTarget, "docs.yaml")

 				f, err := os.Create(targetFile)
 				if err != nil {
 					return err
 				}
 				defer f.Close()
-
-				enc := json.NewEncoder(f)
-				enc.SetIndent("", "  ")
-
-				if err := enc.Encode(docshelper.GetDocProvider()); err != nil {
+				yamlEnc := yaml.NewEncoder(f)
+				if err := yamlEnc.Encode(m); err != nil {
 					return err
 				}

@@ -243,6 +265,8 @@ func (c *genCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, args [
 func (c *genCommand) Init(cd *simplecobra.Commandeer) error {
 	cmd := cd.CobraCommand
 	cmd.Short = "A collection of several useful generators."
+
+	cmd.RunE = nil
 	return nil
 }

@@ -14,7 +14,6 @@
 package commands

 import (
-	"bytes"
 	"errors"
 	"fmt"
 	"log"
@@ -24,8 +23,6 @@ import (

 	"github.com/bep/simplecobra"
 	"github.com/gohugoio/hugo/config"
-	"github.com/gohugoio/hugo/helpers"
-	"github.com/spf13/afero"
 	"github.com/spf13/pflag"
 )

@@ -79,22 +76,19 @@ func flagsToCfgWithAdditionalConfigBase(cd *simplecobra.Commandeer, cfg config.P

 	// Flags with a different name in the config.
 	keyMap := map[string]string{
-		"minify":            "minifyOutput",
-		"destination":       "publishDir",
-		"printI18nWarnings": "logI18nWarnings",
-		"printPathWarnings": "logPathWarnings",
-		"editor":            "newContentEditor",
+		"minify":      "minifyOutput",
+		"destination": "publishDir",
+		"editor":      "newContentEditor",
 	}

 	// Flags that we for some reason don't want to expose in the site config.
 	internalKeySet := map[string]bool{
-		"quiet":             true,
-		"verbose":           true,
-		"watch":             true,
-		"disableLiveReload": true,
-		"liveReloadPort":    true,
-		"renderToMemory":    true,
-		"clock":             true,
+		"quiet":          true,
+		"verbose":        true,
+		"watch":          true,
+		"liveReloadPort": true,
+		"renderToMemory": true,
+		"clock":          true,
 	}

 	cmd := cd.CobraCommand
@@ -126,11 +120,3 @@ func mkdir(x ...string) {
 		log.Fatal(err)
 	}
 }
-
-func touchFile(fs afero.Fs, filename string) {
-	mkdir(filepath.Dir(filename))
-	err := helpers.WriteToDisk(filename, bytes.NewReader([]byte{}), fs)
-	if err != nil {
-		log.Fatal(err)
-	}
-}
@@ -26,11 +26,13 @@ import (
 	"sync"
 	"time"

+	"github.com/bep/logg"
 	"github.com/bep/simplecobra"
 	"github.com/fsnotify/fsnotify"
 	"github.com/gohugoio/hugo/common/herrors"
 	"github.com/gohugoio/hugo/common/htime"
 	"github.com/gohugoio/hugo/common/hugo"
+	"github.com/gohugoio/hugo/common/loggers"
 	"github.com/gohugoio/hugo/common/maps"
 	"github.com/gohugoio/hugo/common/terminal"
 	"github.com/gohugoio/hugo/common/types"
@@ -41,9 +43,7 @@ import (
 	"github.com/gohugoio/hugo/hugolib/filesystems"
 	"github.com/gohugoio/hugo/livereload"
 	"github.com/gohugoio/hugo/resources/page"
-	"github.com/gohugoio/hugo/tpl"
 	"github.com/gohugoio/hugo/watcher"
-	"github.com/spf13/afero"
 	"github.com/spf13/fsync"
 	"golang.org/x/sync/errgroup"
 	"golang.org/x/sync/semaphore"
@@ -68,7 +68,6 @@ type hugoBuilder struct {
 	onConfigLoaded func(reloaded bool) error

 	fastRenderMode     bool
-	buildWatch         bool
 	showErrorInBrowser bool

 	errState hugoBuilderErrState
@@ -131,7 +130,7 @@ func (e *hugoBuilderErrState) wasErr() bool {
 }

 func (c *hugoBuilder) errCount() int {
-	return int(c.r.logger.LogCounters().ErrorCounter.Count())
+	return c.r.logger.LoggCount(logg.LevelError) + loggers.Log().LoggCount(logg.LevelError)
 }

 // getDirList provides NewWatcher() with a list of directories to watch for changes.
@@ -363,7 +362,7 @@ func (c *hugoBuilder) newWatcher(pollIntervalStr string, dirList ...string) (*wa
 		configFiles = conf.configs.LoadingInfo.ConfigFiles
 	})

-	c.r.logger.Println("Watching for config changes in", strings.Join(configFiles, ", "))
+	c.r.Println("Watching for config changes in", strings.Join(configFiles, ", "))
 	for _, configFile := range configFiles {
 		watcher.Add(configFile)
 		configSet[configFile] = true
@@ -418,25 +417,6 @@ func (c *hugoBuilder) build() error {
 			return err
 		}

-		if c.r.printPathWarnings {
-			hugofs.WalkFilesystems(h.Fs.PublishDir, func(fs afero.Fs) bool {
-				if dfs, ok := fs.(hugofs.DuplicatesReporter); ok {
-					dupes := dfs.ReportDuplicates()
-					if dupes != "" {
-						c.r.logger.Warnln("Duplicate target paths:", dupes)
-					}
-				}
-				return false
-			})
-		}
-
-		if c.r.printUnusedTemplates {
-			unusedTemplates := h.Tmpl().(tpl.UnusedTemplatesProvider).UnusedTemplates()
-			for _, unusedTemplate := range unusedTemplates {
-				c.r.logger.Warnf("Template %s is unused, source file %s", unusedTemplate.Name(), unusedTemplate.Filename())
-			}
-		}
-
 		h.PrintProcessingStats(os.Stdout)
 		c.r.Println()
 	}
@@ -461,6 +441,7 @@ func (c *hugoBuilder) copyStatic() (map[string]uint64, error) {
 }

 func (c *hugoBuilder) copyStaticTo(sourceFs *filesystems.SourceFilesystem) (uint64, error) {
+	infol := c.r.logger.InfoCommand("copy static")
 	publishDir := helpers.FilePathSeparator

 	if sourceFs.PublishFolder != "" {
@@ -484,13 +465,13 @@ func (c *hugoBuilder) copyStaticTo(sourceFs *filesystems.SourceFilesystem) (uint
 	syncer.SrcFs = fs

 	if syncer.Delete {
-		c.r.logger.Infoln("removing all files from destination that don't exist in static dirs")
+		infol.Logf("removing all files from destination that don't exist in static dirs")

 		syncer.DeleteFilter = func(f os.FileInfo) bool {
 			return f.IsDir() && strings.HasPrefix(f.Name(), ".")
 		}
 	}
-	c.r.logger.Infoln("syncing static files to", publishDir)
+	infol.Logf("syncing static files to %s", publishDir)

 	// because we are using a baseFs (to get the union right).
 	// set sync src to root
@@ -545,14 +526,13 @@ func (c *hugoBuilder) fullBuild(noBuildLock bool) error {
 		langCount map[string]uint64
 	)

-	if !c.r.quiet {
-		fmt.Println("Start building sites … ")
-		fmt.Println(hugo.BuildVersionString())
-		if terminal.IsTerminal(os.Stdout) {
-			defer func() {
-				fmt.Print(showCursor + clearLine)
-			}()
-		}
+	c.r.logger.Println("Start building sites … ")
+	c.r.logger.Println(hugo.BuildVersionString())
+	c.r.logger.Println()
+	if terminal.IsTerminal(os.Stdout) {
+		defer func() {
+			fmt.Print(showCursor + clearLine)
+		}()
 	}

 	copyStaticFunc := func() error {
@@ -1011,7 +991,7 @@ func (c *hugoBuilder) loadConfig(cd *simplecobra.Commandeer, running bool) error
 	cfg.Set("internal", maps.Params{
 		"running": running,
 		"watch":   watch,
-		"verbose": c.r.verbose,
+		"verbose": c.r.isVerbose(),
 	})

 	conf, err := c.r.ConfigFromProvider(c.r.configVersionID.Load(), flagsToCfg(cd, cfg))
@@ -1062,8 +1042,8 @@ func (c *hugoBuilder) rebuildSites(events []fsnotify.Event) error {
 	if c.fastRenderMode {
 		c.withConf(func(conf *commonConfig) {
 			// Make sure we always render the home pages
-			for _, l := range conf.configs.Languages {
-				langPath := h.GetLangSubDir(l.Lang)
+			for _, l := range conf.configs.ConfigLangs() {
+				langPath := l.LanguagePrefix()
 				if langPath != "" {
 					langPath = langPath + "/"
 				}
@@ -19,12 +19,11 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"log"
 	"os"
 	"path/filepath"
 	"regexp"

-	jww "github.com/spf13/jwalterweatherman"
-
 	"strconv"
 	"strings"
 	"time"
@@ -97,6 +96,7 @@ func (c *importCommand) Init(cd *simplecobra.Commandeer) error {

 Import requires a subcommand, e.g. ` + "`hugo import jekyll jekyll_root_path target_path`."

+	cmd.RunE = nil
 	return nil
 }

@@ -299,7 +299,7 @@ func (c *importCommand) convertJekyllMetaData(m any, postName string, postDate t
 }

 func (c *importCommand) convertJekyllPost(path, relPath, targetDir string, draft bool) error {
-	jww.TRACE.Println("Converting", path)
+	log.Println("Converting", path)

 	filename := filepath.Base(path)
 	postDate, postName, err := c.parseJekyllFilename(filename)
@@ -308,7 +308,7 @@ func (c *importCommand) convertJekyllPost(path, relPath, targetDir string, draft
 		return nil
 	}

-	jww.TRACE.Println(filename, postDate, postName)
+	log.Println(filename, postDate, postName)

 	targetFile := filepath.Join(targetDir, relPath)
 	targetParentDir := filepath.Dir(targetFile)
@@ -367,7 +367,7 @@ func (c *importCommand) copyJekyllFilesAndFolders(jekyllRoot, dest string, jekyl
 				if _, ok := jekyllPostDirs[entry.Name()]; !ok {
 					err = hugio.CopyDir(fs, sfp, dfp, nil)
 					if err != nil {
-						jww.ERROR.Println(err)
+						c.r.logger.Errorln(err)
 					}
 				}
 			}
@@ -388,7 +388,7 @@ func (c *importCommand) copyJekyllFilesAndFolders(jekyllRoot, dest string, jekyl
 			if !isExcept && entry.Name()[0] != '.' && entry.Name()[0] != '_' {
 				err = hugio.CopyFile(fs, sfp, dfp)
 				if err != nil {
-					jww.ERROR.Println(err)
+					c.r.logger.Errorln(err)
 				}
 			}
 		}
@@ -469,9 +469,12 @@ func (c *importCommand) importFromJekyll(args []string) error {
 	}

 	c.r.Println("Congratulations!", fileCount, "post(s) imported!")
-	c.r.Println("Now, start Hugo by yourself:\n" +
-		"$ git clone https://github.com/spf13/herring-cove.git " + args[1] + "/themes/herring-cove")
-	c.r.Println("$ cd " + args[1] + "\n$ hugo server --theme=herring-cove")
+	c.r.Println("Now, start Hugo by yourself:\n")
+	c.r.Println("cd " + args[1])
+	c.r.Println("git init")
+	c.r.Println("git submodule add https://github.com/theNewDynamic/gohugo-theme-ananke themes/ananke")
+	c.r.Println("echo \"theme = 'ananke'\" > hugo.toml")
+	c.r.Println("hugo server")

 	return nil
 }
@@ -182,6 +182,7 @@ func (c *listCommand) Init(cd *simplecobra.Commandeer) error {

 List requires a subcommand, e.g. hugo list drafts`

+	cmd.RunE = nil
 	return nil
 }

@@ -224,7 +224,7 @@ Run "go help get" for more information. All flags available for "go get" is also
 				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
 					// We currently just pass on the flags we get to Go and
 					// need to do the flag handling manually.
-					if len(args) == 1 && args[0] == "-h" {
+					if len(args) == 1 && (args[0] == "-h" || args[0] == "--help") {
 						return errHelp
 					}

@@ -16,19 +16,14 @@ package commands
 import (
 	"bytes"
 	"context"
-	"errors"
-	"fmt"
 	"path/filepath"
 	"strings"

 	"github.com/bep/simplecobra"
-	"github.com/gohugoio/hugo/common/htime"
+	"github.com/gohugoio/hugo/common/paths"
 	"github.com/gohugoio/hugo/config"
 	"github.com/gohugoio/hugo/create"
-	"github.com/gohugoio/hugo/helpers"
-	"github.com/gohugoio/hugo/parser"
-	"github.com/gohugoio/hugo/parser/metadecoders"
-	"github.com/spf13/afero"
+	"github.com/gohugoio/hugo/create/skeletons"
 	"github.com/spf13/cobra"
 )

@@ -47,16 +42,16 @@ func newNewCommand() *newCommand {
 				use:   "content [path]",
 				short: "Create new content for your site",
 				long: `Create a new content file and automatically set the date and title.
-		It will guess which kind of file to create based on the path provided.
-		
-		You can also specify the kind with ` + "`-k KIND`" + `.
-		
-		If archetypes are provided in your theme or site, they will be used.
-		
-		Ensure you run this within the root directory of your site.`,
+It will guess which kind of file to create based on the path provided.
+
+You can also specify the kind with ` + "`-k KIND`" + `.
+
+If archetypes are provided in your theme or site, they will be used.
+
+Ensure you run this within the root directory of your site.`,
 				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
 					if len(args) < 1 {
-						return errors.New("path needs to be provided")
+						return newUserError("path needs to be provided")
 					}
 					h, err := r.Hugo(flagsToCfg(cd, nil))
 					if err != nil {
@@ -82,7 +77,7 @@ The new site will have the correct structure, but no content or theme yet.
 Use ` + "`hugo new [contentPath]`" + ` to create new content.`,
 				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
 					if len(args) < 1 {
-						return errors.New("path needs to be provided")
+						return newUserError("path needs to be provided")
 					}
 					createpath, err := filepath.Abs(filepath.Clean(args[0]))
 					if err != nil {
@@ -99,152 +94,49 @@ Use ` + "`hugo new [contentPath]`" + ` to create new content.`,
 					}
 					sourceFs := conf.fs.Source

-					archeTypePath := filepath.Join(createpath, "archetypes")
-					dirs := []string{
-						archeTypePath,
-						filepath.Join(createpath, "assets"),
-						filepath.Join(createpath, "content"),
-						filepath.Join(createpath, "data"),
-						filepath.Join(createpath, "layouts"),
-						filepath.Join(createpath, "static"),
-						filepath.Join(createpath, "themes"),
+					err = skeletons.CreateSite(createpath, sourceFs, force, format)
+					if err != nil {
+						return err
 					}

-					if exists, _ := helpers.Exists(createpath, sourceFs); exists {
-						if isDir, _ := helpers.IsDir(createpath, sourceFs); !isDir {
-							return errors.New(createpath + " already exists but not a directory")
-						}
-
-						isEmpty, _ := helpers.IsEmpty(createpath, sourceFs)
-
-						switch {
-						case !isEmpty && !force:
-							return errors.New(createpath + " already exists and is not empty. See --force.")
-
-						case !isEmpty && force:
-							all := append(dirs, filepath.Join(createpath, "hugo."+format))
-							for _, path := range all {
-								if exists, _ := helpers.Exists(path, sourceFs); exists {
-									return errors.New(path + " already exists")
-								}
-							}
-						}
-					}
-
-					for _, dir := range dirs {
-						if err := sourceFs.MkdirAll(dir, 0777); err != nil {
-							return fmt.Errorf("failed to create dir: %w", err)
-						}
-					}
-
-					c.newSiteCreateConfig(sourceFs, createpath, format)
-
-					// Create a default archetype file.
-					helpers.SafeWriteToDisk(filepath.Join(archeTypePath, "default.md"),
-						strings.NewReader(create.DefaultArchetypeTemplateTemplate), sourceFs)
-
-					r.Printf("Congratulations! Your new Hugo site is created in %s.\n\n", createpath)
-					r.Println(c.newSiteNextStepsText())
+					r.Printf("Congratulations! Your new Hugo site was created in %s.\n\n", createpath)
+					r.Println(c.newSiteNextStepsText(createpath, format))

 					return nil
 				},
 				withc: func(cmd *cobra.Command, r *rootCommand) {
 					cmd.Flags().BoolVarP(&force, "force", "f", false, "init inside non-empty directory")
+					cmd.Flags().StringVar(&format, "format", "toml", "preferred file format (toml, yaml or json)")
 				},
 			},
 			&simpleCommand{
 				name:  "theme",
-				use:   "theme [path]",
-				short: "Create a new site (skeleton)",
-				long: `Create a new site in the provided directory.
-The new site will have the correct structure, but no content or theme yet.
-Use ` + "`hugo new [contentPath]`" + ` to create new content.`,
+				use:   "theme [name]",
+				short: "Create a new theme (skeleton)",
+				long: `Create a new theme (skeleton) called [name] in ./themes.
+New theme is a skeleton. Please add content to the touched files. Add your
+name to the copyright line in the license and adjust the theme.toml file
+according to your needs.`,
 				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-					h, err := r.Hugo(flagsToCfg(cd, nil))
+					if len(args) < 1 {
+						return newUserError("theme name needs to be provided")
+					}
+					cfg := config.New()
+					cfg.Set("publishDir", "public")
+
+					conf, err := r.ConfigFromProvider(r.configVersionID.Load(), flagsToCfg(cd, cfg))
 					if err != nil {
 						return err
 					}
-					ps := h.PathSpec
-					sourceFs := ps.Fs.Source
-					themesDir := h.Configs.LoadingInfo.BaseConfig.ThemesDir
-					createpath := ps.AbsPathify(filepath.Join(themesDir, args[0]))
-					r.Println("Creating theme at", createpath)
+					sourceFs := conf.fs.Source
+					createpath := paths.AbsPathify(conf.configs.Base.WorkingDir, filepath.Join(conf.configs.Base.ThemesDir, args[0]))
+					r.Println("Creating new theme in", createpath)

-					if x, _ := helpers.Exists(createpath, sourceFs); x {
-						return errors.New(createpath + " already exists")
-					}
-
-					for _, filename := range []string{
-						"index.html",
-						"404.html",
-						"_default/list.html",
-						"_default/single.html",
-						"partials/head.html",
-						"partials/header.html",
-						"partials/footer.html",
-					} {
-						touchFile(sourceFs, filepath.Join(createpath, "layouts", filename))
-					}
-
-					baseofDefault := []byte(`<!DOCTYPE html>
-<html>
-    {{- partial "head.html" . -}}
-    <body>
-        {{- partial "header.html" . -}}
-        <div id="content">
-        {{- block "main" . }}{{- end }}
-        </div>
-        {{- partial "footer.html" . -}}
-    </body>
-</html>
-`)
-
-					err = helpers.WriteToDisk(filepath.Join(createpath, "layouts", "_default", "baseof.html"), bytes.NewReader(baseofDefault), sourceFs)
+					err = skeletons.CreateTheme(createpath, sourceFs)
 					if err != nil {
 						return err
 					}

-					mkdir(createpath, "archetypes")
-
-					archDefault := []byte("+++\n+++\n")
-
-					err = helpers.WriteToDisk(filepath.Join(createpath, "archetypes", "default.md"), bytes.NewReader(archDefault), sourceFs)
-					if err != nil {
-						return err
-					}
-
-					mkdir(createpath, "static", "js")
-					mkdir(createpath, "static", "css")
-
-					by := []byte(`The MIT License (MIT)
-
-Copyright (c) ` + htime.Now().Format("2006") + ` YOUR_NAME_HERE
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software is furnished to do so,
-subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-`)
-
-					err = helpers.WriteToDisk(filepath.Join(createpath, "LICENSE"), bytes.NewReader(by), sourceFs)
-					if err != nil {
-						return err
-					}
-
-					c.createThemeMD(ps.Fs.Source, createpath)
-
 					return nil
 				},
 			},
@@ -284,6 +176,8 @@ You can also specify the kind with ` + "`-k KIND`" + `.
 If archetypes are provided in your theme or site, they will be used.

 Ensure you run this within the root directory of your site.`
+
+	cmd.RunE = nil
 	return nil
 }

@@ -292,77 +186,25 @@ func (c *newCommand) PreRun(cd, runner *simplecobra.Commandeer) error {
 	return nil
 }

-func (c *newCommand) newSiteCreateConfig(fs afero.Fs, inpath string, kind string) (err error) {
-	in := map[string]string{
-		"baseURL":      "http://example.org/",
-		"title":        "My New Hugo Site",
-		"languageCode": "en-us",
-	}
-
-	var buf bytes.Buffer
-	err = parser.InterfaceToConfig(in, metadecoders.FormatFromString(kind), &buf)
-	if err != nil {
-		return err
-	}
-
-	return helpers.WriteToDisk(filepath.Join(inpath, "hugo."+kind), &buf, fs)
-}
-
-func (c *newCommand) newSiteNextStepsText() string {
+func (c *newCommand) newSiteNextStepsText(path string, format string) string {
+	format = strings.ToLower(format)
 	var nextStepsText bytes.Buffer

-	nextStepsText.WriteString(`Just a few more steps and you're ready to go:
+	nextStepsText.WriteString(`Just a few more steps...

-1. Download a theme into the same-named folder.
-   Choose a theme from https://themes.gohugo.io/ or
-   create your own with the "hugo new theme <THEMENAME>" command.
-2. Perhaps you want to add some content. You can add single files
-   with "hugo new `)
+1. Change the current directory to ` + path + `.
+2. Create or install a theme:
+   - Create a new theme with the command "hugo new theme <THEMENAME>"
+   - Install a theme from https://themes.gohugo.io/
+3. Edit hugo.` + format + `, setting the "theme" property to the theme name.
+4. Create new content with the command "hugo new content `)

 	nextStepsText.WriteString(filepath.Join("<SECTIONNAME>", "<FILENAME>.<FORMAT>"))

 	nextStepsText.WriteString(`".
-3. Start the built-in live server via "hugo server".
+5. Start the embedded web server with the command "hugo server --buildDrafts".

-Visit https://gohugo.io/ for quickstart guide and full documentation.`)
+See documentation at https://gohugo.io/.`)

 	return nextStepsText.String()
 }
-
-func (c *newCommand) createThemeMD(fs afero.Fs, inpath string) (err error) {
-
-	by := []byte(`# theme.toml template for a Hugo theme
-# See https://github.com/gohugoio/hugoThemes#themetoml for an example
-
-name = "` + strings.Title(helpers.MakeTitle(filepath.Base(inpath))) + `"
-license = "MIT"
-licenselink = "https://github.com/yourname/yourtheme/blob/master/LICENSE"
-description = ""
-homepage = "http://example.com/"
-tags = []
-features = []
-min_version = "0.112.6"
-
-[author]
-  name = ""
-  homepage = ""
-
-# If porting an existing theme
-[original]
-  name = ""
-  homepage = ""
-  repo = ""
-`)
-
-	err = helpers.WriteToDisk(filepath.Join(inpath, "theme.toml"), bytes.NewReader(by), fs)
-	if err != nil {
-		return
-	}
-
-	err = helpers.WriteToDisk(filepath.Join(inpath, "hugo.toml"), strings.NewReader("# Theme config.\n"), fs)
-	if err != nil {
-		return
-	}
-
-	return nil
-}
@@ -16,11 +16,13 @@ package commands
 import (
 	"bytes"
 	"context"
+	"crypto/tls"
+	"crypto/x509"
 	"encoding/json"
+	"encoding/pem"
 	"errors"
 	"fmt"
 	"io"
-	"io/ioutil"
 	"net"
 	"net/http"
 	"net/url"
@@ -28,6 +30,8 @@ import (
 	"sync"
 	"sync/atomic"

+	"github.com/bep/mclib"
+
 	"os/signal"
 	"path"
 	"path/filepath"
@@ -55,13 +59,13 @@ import (
 	"github.com/gohugoio/hugo/transform"
 	"github.com/gohugoio/hugo/transform/livereloadinject"
 	"github.com/spf13/afero"
+	"github.com/spf13/cobra"
 	"github.com/spf13/fsync"
 	"golang.org/x/sync/errgroup"
 	"golang.org/x/sync/semaphore"
 )

 var (
-	logErrorRe                    = regexp.MustCompile(`(?s)ERROR \d{4}/\d{2}/\d{2} \d{2}:\d{2}:\d{2} `)
 	logDuplicateTemplateExecuteRe = regexp.MustCompile(`: template: .*?:\d+:\d+: executing ".*?"`)
 	logDuplicateTemplateParseRe   = regexp.MustCompile(`: template: .*?:\d+:\d*`)
 )
@@ -97,13 +101,38 @@ func newHugoBuilder(r *rootCommand, s *serverCommand, onConfigLoaded ...func(rel
 }

 func newServerCommand() *serverCommand {
-	var c *serverCommand
-	c = &serverCommand{
+	// Flags.
+	var uninstall bool
+
+	c := &serverCommand{
 		quit: make(chan bool),
+		commands: []simplecobra.Commander{
+			&simpleCommand{
+				name:  "trust",
+				short: "Install the local CA in the system trust store.",
+				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
+					action := "-install"
+					if uninstall {
+						action = "-uninstall"
+					}
+					os.Args = []string{action}
+					return mclib.RunMain()
+				},
+				withc: func(cmd *cobra.Command, r *rootCommand) {
+					cmd.Flags().BoolVar(&uninstall, "uninstall", false, "Uninstall the local CA (but do not delete it).")
+
+				},
+			},
+		},
 	}
+
 	return c
 }

+func (c *serverCommand) Commands() []simplecobra.Commander {
+	return c.commands
+}
+
 type countingStatFs struct {
 	afero.Fs
 	statCounter uint64
@@ -423,6 +452,9 @@ type serverCommand struct {
 	navigateToChanged   bool
 	serverAppend        bool
 	serverInterface     string
+	tlsCertFile         string
+	tlsKeyFile          string
+	tlsAuto             bool
 	serverPort          int
 	liveReloadPort      int
 	serverWatch         bool
@@ -432,23 +464,11 @@ type serverCommand struct {
 	disableBrowserError bool
 }

-func (c *serverCommand) Commands() []simplecobra.Commander {
-	return c.commands
-}
-
 func (c *serverCommand) Name() string {
 	return "server"
 }

 func (c *serverCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, args []string) error {
-	err := func() error {
-		defer c.r.timeTrack(time.Now(), "Built")
-		err := c.build()
-		return err
-	}()
-	if err != nil {
-		return err
-	}

 	// Watch runs its own server as part of the routine
 	if c.serverWatch {
@@ -472,6 +492,15 @@ func (c *serverCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, arg

 	}

+	err := func() error {
+		defer c.r.timeTrack(time.Now(), "Built")
+		err := c.build()
+		return err
+	}()
+	if err != nil {
+		return err
+	}
+
 	return c.serve()
 }

@@ -480,8 +509,6 @@ func (c *serverCommand) Init(cd *simplecobra.Commandeer) error {
 	cmd.Short = "A high performance webserver"
 	cmd.Long = `Hugo provides its own webserver which builds and serves the site.
 While hugo server is high performance, it is a webserver with limited options.
-Many run it in production, but the standard behavior is for people to use it
-in development and use a more full featured server such as Nginx or Caddy.

 'hugo server' will avoid writing the rendered and served content to disk,
 preferring to store it in memory.
@@ -495,6 +522,9 @@ of a second, you will be able to save and see your changes nearly instantly.`
 	cmd.Flags().IntVarP(&c.serverPort, "port", "p", 1313, "port on which the server will listen")
 	cmd.Flags().IntVar(&c.liveReloadPort, "liveReloadPort", -1, "port for live reloading (i.e. 443 in HTTPS proxy situations)")
 	cmd.Flags().StringVarP(&c.serverInterface, "bind", "", "127.0.0.1", "interface to which the server will bind")
+	cmd.Flags().StringVarP(&c.tlsCertFile, "tlsCertFile", "", "", "path to TLS certificate file")
+	cmd.Flags().StringVarP(&c.tlsKeyFile, "tlsKeyFile", "", "", "path to TLS key file")
+	cmd.Flags().BoolVar(&c.tlsAuto, "tlsAuto", false, "generate and use locally-trusted certificates.")
 	cmd.Flags().BoolVarP(&c.serverWatch, "watch", "w", true, "watch filesystem for changes and recreate as needed")
 	cmd.Flags().BoolVar(&c.noHTTPCache, "noHTTPCache", false, "prevent HTTP caching")
 	cmd.Flags().BoolVarP(&c.serverAppend, "appendPort", "", true, "append port to baseURL")
@@ -508,6 +538,9 @@ of a second, you will be able to save and see your changes nearly instantly.`
 	cmd.Flags().String("memstats", "", "log memory usage to this file")
 	cmd.Flags().String("meminterval", "100ms", "interval to poll memory usage (requires --memstats), valid time units are \"ns\", \"us\" (or \"µs\"), \"ms\", \"s\", \"m\", \"h\".")

+	cmd.Flags().SetAnnotation("tlsCertFile", cobra.BashCompSubdirsInDir, []string{})
+	cmd.Flags().SetAnnotation("tlsKeyFile", cobra.BashCompSubdirsInDir, []string{})
+
 	r := cd.Root.Command.(*rootCommand)
 	applyLocalFlagsBuild(cmd, r)

@@ -525,7 +558,14 @@ func (c *serverCommand) PreRun(cd, runner *simplecobra.Commandeer) error {
 				if err := c.createServerPorts(cd); err != nil {
 					return err
 				}
+
+				if (c.tlsCertFile == "" || c.tlsKeyFile == "") && c.tlsAuto {
+					c.withConfE(func(conf *commonConfig) error {
+						return c.createCertificates(conf)
+					})
+				}
 			}
+
 			if err := c.setBaseURLsInConfig(); err != nil {
 				return err
 			}
@@ -611,8 +651,8 @@ func (c *serverCommand) getErrorWithContext() any {

 	m := make(map[string]any)

-	//xwm["Error"] = errors.New(cleanErrorLog(removeErrorPrefixFromLog(c.r.logger.Errors())))
-	m["Error"] = errors.New(cleanErrorLog(removeErrorPrefixFromLog(c.r.logger.Errors())))
+	m["Error"] = cleanErrorLog(c.r.logger.Errors())
+
 	m["Version"] = hugo.BuildVersionString()
 	ferrors := herrors.UnwrapFileErrorsWithErrorContext(c.errState.buildErr())
 	m["Files"] = ferrors
@@ -620,6 +660,78 @@ func (c *serverCommand) getErrorWithContext() any {
 	return m
 }

+func (c *serverCommand) createCertificates(conf *commonConfig) error {
+	hostname := "localhost"
+	if c.r.baseURL != "" {
+		u, err := url.Parse(c.r.baseURL)
+		if err != nil {
+			return err
+		}
+		hostname = u.Hostname()
+	}
+
+	// For now, store these in the Hugo cache dir.
+	// Hugo should probably introduce some concept of a less temporary application directory.
+	keyDir := filepath.Join(conf.configs.LoadingInfo.BaseConfig.CacheDir, "_mkcerts")
+
+	// Create the directory if it doesn't exist.
+	if _, err := os.Stat(keyDir); os.IsNotExist(err) {
+		if err := os.MkdirAll(keyDir, 0777); err != nil {
+			return err
+		}
+	}
+
+	c.tlsCertFile = filepath.Join(keyDir, fmt.Sprintf("%s.pem", hostname))
+	c.tlsKeyFile = filepath.Join(keyDir, fmt.Sprintf("%s-key.pem", hostname))
+
+	// Check if the certificate already exists and is valid.
+	certPEM, err := os.ReadFile(c.tlsCertFile)
+	if err == nil {
+		rootPem, err := os.ReadFile(filepath.Join(mclib.GetCAROOT(), "rootCA.pem"))
+		if err == nil {
+			if err := c.verifyCert(rootPem, certPEM, hostname); err == nil {
+				c.r.Println("Using existing", c.tlsCertFile, "and", c.tlsKeyFile)
+				return nil
+			}
+		}
+	}
+
+	c.r.Println("Creating TLS certificates in", keyDir)
+
+	// Yes, this is unfortunate, but it's currently the only way to use Mkcert as a library.
+	os.Args = []string{"-cert-file", c.tlsCertFile, "-key-file", c.tlsKeyFile, hostname}
+	return mclib.RunMain()
+
+}
+
+func (c *serverCommand) verifyCert(rootPEM, certPEM []byte, name string) error {
+	roots := x509.NewCertPool()
+	ok := roots.AppendCertsFromPEM(rootPEM)
+	if !ok {
+		return fmt.Errorf("failed to parse root certificate")
+	}
+
+	block, _ := pem.Decode(certPEM)
+	if block == nil {
+		return fmt.Errorf("failed to parse certificate PEM")
+	}
+	cert, err := x509.ParseCertificate(block.Bytes)
+	if err != nil {
+		return fmt.Errorf("failed to parse certificate: %v", err.Error())
+	}
+
+	opts := x509.VerifyOptions{
+		DNSName: name,
+		Roots:   roots,
+	}
+
+	if _, err := cert.Verify(opts); err != nil {
+		return fmt.Errorf("failed to verify certificate: %v", err.Error())
+	}
+
+	return nil
+}
+
 func (c *serverCommand) createServerPorts(cd *simplecobra.Commandeer) error {
 	flags := cd.CobraCommand.Flags()
 	var cerr error
@@ -662,36 +774,40 @@ func (c *serverCommand) createServerPorts(cd *simplecobra.Commandeer) error {

 // fixURL massages the baseURL into a form needed for serving
 // all pages correctly.
-func (c *serverCommand) fixURL(baseURL, s string, port int) (string, error) {
+func (c *serverCommand) fixURL(baseURLFromConfig, baseURLFromFlag string, port int) (string, error) {
+	certsSet := (c.tlsCertFile != "" && c.tlsKeyFile != "") || c.tlsAuto
 	useLocalhost := false
-	if s == "" {
-		s = baseURL
+	baseURL := baseURLFromFlag
+	if baseURL == "" {
+		baseURL = baseURLFromConfig
 		useLocalhost = true
 	}

-	if !strings.HasSuffix(s, "/") {
-		s = s + "/"
+	if !strings.HasSuffix(baseURL, "/") {
+		baseURL = baseURL + "/"
 	}

 	// do an initial parse of the input string
-	u, err := url.Parse(s)
+	u, err := url.Parse(baseURL)
 	if err != nil {
 		return "", err
 	}

 	// if no Host is defined, then assume that no schema or double-slash were
 	// present in the url.  Add a double-slash and make a best effort attempt.
-	if u.Host == "" && s != "/" {
-		s = "//" + s
+	if u.Host == "" && baseURL != "/" {
+		baseURL = "//" + baseURL

-		u, err = url.Parse(s)
+		u, err = url.Parse(baseURL)
 		if err != nil {
 			return "", err
 		}
 	}

 	if useLocalhost {
-		if u.Scheme == "https" {
+		if certsSet {
+			u.Scheme = "https"
+		} else if u.Scheme == "https" {
 			u.Scheme = "http"
 		}
 		u.Host = "localhost"
@@ -742,6 +858,9 @@ func (c *serverCommand) serve() error {
 			return err
 		}

+		// We need the server to share the same logger as the Hugo build (for error counts etc.)
+		c.r.logger = h.Log
+
 		if isMultiHost {
 			for _, l := range conf.configs.ConfigLangs() {
 				baseURLs = append(baseURLs, l.BaseURL().String())
@@ -808,10 +927,22 @@ func (c *serverCommand) serve() error {

 	for i := range baseURLs {
 		mu, listener, serverURL, endpoint, err := srv.createEndpoint(i)
-		srv := &http.Server{
-			Addr:    endpoint,
-			Handler: mu,
+		var srv *http.Server	
+		if c.tlsCertFile != "" && c.tlsKeyFile != "" {
+			srv = &http.Server{
+				Addr:    endpoint,
+				Handler: mu,
+				TLSConfig: &tls.Config{
+					MinVersion: tls.VersionTLS12,
+				},
+			}
+		} else {
+			srv = &http.Server{
+				Addr:    endpoint,
+				Handler: mu,
+			}
 		}
+
 		servers = append(servers, srv)

 		if doLiveReload {
@@ -823,9 +954,13 @@ func (c *serverCommand) serve() error {
 			mu.HandleFunc(u.Path+"/livereload.js", livereload.ServeJS)
 			mu.HandleFunc(u.Path+"/livereload", livereload.Handler)
 		}
-		c.r.Printf("Web Server is available at %s (bind address %s)\n", serverURL, c.serverInterface)
+		c.r.Printf("Web Server is available at %s (bind address %s) %s\n", serverURL, c.serverInterface, roots[i])
 		wg1.Go(func() error {
-			err = srv.Serve(listener)
+			if c.tlsCertFile != "" && c.tlsKeyFile != "" {
+				err = srv.ServeTLS(listener, c.tlsCertFile, c.tlsKeyFile)
+			} else {
+				err = srv.Serve(listener)
+			}
 			if err != nil && err != http.ErrServerClosed {
 				return err
 			}
@@ -848,7 +983,7 @@ func (c *serverCommand) serve() error {
 			if err != nil {
 				return err
 			}
-			err = ioutil.WriteFile(readyFile, b, 0777)
+			err = os.WriteFile(readyFile, b, 0777)
 			if err != nil {
 				return err
 			}
@@ -931,8 +1066,7 @@ func (s *staticSyncer) syncsStaticEvents(staticEvents []fsnotify.Event) error {
 			}
 		})

-		// prevent spamming the log on changes
-		logger := helpers.NewDistinctErrorLogger()
+		logger := s.c.r.logger

 		for _, ev := range staticEvents {
 			// Due to our approach of layering both directories and the content's rendered output
@@ -1071,10 +1205,6 @@ func pickOneWriteOrCreatePath(events []fsnotify.Event) string {
 	return name
 }

-func removeErrorPrefixFromLog(content string) string {
-	return logErrorRe.ReplaceAllLiteralString(content, "")
-}
-
 func formatByteCount(b uint64) string {
 	const unit = 1000
 	if b < unit {
@@ -1,79 +0,0 @@
-// Copyright 2023 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package commands
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/bep/simplecobra"
-	"github.com/spf13/cobra"
-)
-
-func newSimpleTemplateCommand() simplecobra.Commander {
-	return &simpleCommand{
-		name: "template",
-		run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-
-			return nil
-		},
-		withc: func(cmd *cobra.Command, r *rootCommand) {
-
-		},
-	}
-
-}
-
-func newTemplateCommand() *templateCommand {
-	return &templateCommand{
-		commands: []simplecobra.Commander{},
-	}
-
-}
-
-type templateCommand struct {
-	r *rootCommand
-
-	commands []simplecobra.Commander
-}
-
-func (c *templateCommand) Commands() []simplecobra.Commander {
-	return c.commands
-}
-
-func (c *templateCommand) Name() string {
-	return "template"
-}
-
-func (c *templateCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, args []string) error {
-	conf, err := c.r.ConfigFromProvider(c.r.configVersionID.Load(), flagsToCfg(cd, nil))
-	if err != nil {
-		return err
-	}
-	fmt.Println("templateCommand.Run", conf)
-
-	return nil
-}
-
-func (c *templateCommand) Init(cd *simplecobra.Commandeer) error {
-	cmd := cd.CobraCommand
-	cmd.Short = "Print the site configuration"
-	cmd.Long = `Print the site configuration, both default and custom settings.`
-	return nil
-}
-
-func (c *templateCommand) PreRun(cd, runner *simplecobra.Commandeer) error {
-	c.r = cd.Root.Command.(*rootCommand)
-	return nil
-}
@@ -22,29 +22,64 @@ import (
 // If length of from is one and the only element is a slice of same type as to,
 // it will be appended.
 func Append(to any, from ...any) (any, error) {
+	if len(from) == 0 {
+		return to, nil
+	}
 	tov, toIsNil := indirect(reflect.ValueOf(to))

 	toIsNil = toIsNil || to == nil
 	var tot reflect.Type

 	if !toIsNil {
+		if tov.Kind() == reflect.Slice {
+			// Create a copy of tov, so we don't modify the original.
+			c := reflect.MakeSlice(tov.Type(), tov.Len(), tov.Len()+len(from))
+			reflect.Copy(c, tov)
+			tov = c
+		}
+
 		if tov.Kind() != reflect.Slice {
 			return nil, fmt.Errorf("expected a slice, got %T", to)
 		}

 		tot = tov.Type().Elem()
+		if tot.Kind() == reflect.Slice {
+			totvt := tot.Elem()
+			fromvs := make([]reflect.Value, len(from))
+			for i, f := range from {
+				fromv := reflect.ValueOf(f)
+				fromt := fromv.Type()
+				if fromt.Kind() == reflect.Slice {
+					fromt = fromt.Elem()
+				}
+				if totvt != fromt {
+					return nil, fmt.Errorf("cannot append slice of %s to slice of %s", fromt, totvt)
+				} else {
+					fromvs[i] = fromv
+				}
+			}
+			return reflect.Append(tov, fromvs...).Interface(), nil
+
+		}
+
 		toIsNil = tov.Len() == 0

 		if len(from) == 1 {
 			fromv := reflect.ValueOf(from[0])
+			if !fromv.IsValid() {
+				// from[0] is nil
+				return appendToInterfaceSliceFromValues(tov, fromv)
+			}
+			fromt := fromv.Type()
+			if fromt.Kind() == reflect.Slice {
+				fromt = fromt.Elem()
+			}
 			if fromv.Kind() == reflect.Slice {
 				if toIsNil {
 					// If we get nil []string, we just return the []string
 					return from[0], nil
 				}

-				fromt := reflect.TypeOf(from[0]).Elem()
-
 				// If we get []string []string, we append the from slice to to
 				if tot == fromt {
 					return reflect.AppendSlice(tov, fromv).Interface(), nil
@@ -52,6 +87,7 @@ func Append(to any, from ...any) (any, error) {
 					// Fall back to a []interface{} slice.
 					return appendToInterfaceSliceFromValues(tov, fromv)
 				}
+
 			}
 		}
 	}
@@ -62,7 +98,7 @@ func Append(to any, from ...any) (any, error) {

 	for _, f := range from {
 		fv := reflect.ValueOf(f)
-		if !fv.Type().AssignableTo(tot) {
+		if !fv.IsValid() || !fv.Type().AssignableTo(tot) {
 			// Fall back to a []interface{} slice.
 			tov, _ := indirect(reflect.ValueOf(to))
 			return appendToInterfaceSlice(tov, from...)
@@ -77,6 +113,10 @@ func appendToInterfaceSliceFromValues(slice1, slice2 reflect.Value) ([]any, erro
 	var tos []any

 	for _, slice := range []reflect.Value{slice1, slice2} {
+		if !slice.IsValid() {
+			tos = append(tos, nil)
+			continue
+		}
 		for i := 0; i < slice.Len(); i++ {
 			tos = append(tos, slice.Index(i).Interface())
 		}
@@ -24,7 +24,7 @@ func TestAppend(t *testing.T) {
 	t.Parallel()
 	c := qt.New(t)

-	for _, test := range []struct {
+	for i, test := range []struct {
 		start    any
 		addend   []any
 		expected any
@@ -74,6 +74,9 @@ func TestAppend(t *testing.T) {
 			[]any{"c"},
 			false,
 		},
+		{[]string{"a", "b"}, []any{nil}, []any{"a", "b", nil}},
+		{[]string{"a", "b"}, []any{nil, "d", nil}, []any{"a", "b", nil, "d", nil}},
+		{[]any{"a", nil, "c"}, []any{"d", nil, "f"}, []any{"a", nil, "c", "d", nil, "f"}},
 	} {

 		result, err := Append(test.start, test.addend...)
@@ -85,6 +88,59 @@ func TestAppend(t *testing.T) {
 		}

 		c.Assert(err, qt.IsNil)
-		c.Assert(result, qt.DeepEquals, test.expected)
+		c.Assert(result, qt.DeepEquals, test.expected, qt.Commentf("test: [%d] %v", i, test))
 	}
 }
+
+// #11093
+func TestAppendToMultiDimensionalSlice(t *testing.T) {
+	t.Parallel()
+	c := qt.New(t)
+
+	for _, test := range []struct {
+		to       any
+		from     []any
+		expected any
+	}{
+		{[][]string{{"a", "b"}},
+			[]any{[]string{"c", "d"}},
+			[][]string{
+				{"a", "b"},
+				{"c", "d"},
+			},
+		},
+		{[][]string{{"a", "b"}},
+			[]any{[]string{"c", "d"}, []string{"e", "f"}},
+			[][]string{
+				{"a", "b"},
+				{"c", "d"},
+				{"e", "f"},
+			},
+		},
+		{[][]string{{"a", "b"}},
+			[]any{[]int{1, 2}},
+			false,
+		},
+	} {
+		result, err := Append(test.to, test.from...)
+		if b, ok := test.expected.(bool); ok && !b {
+			c.Assert(err, qt.Not(qt.IsNil))
+		} else {
+			c.Assert(err, qt.IsNil)
+			c.Assert(result, qt.DeepEquals, test.expected)
+		}
+	}
+
+}
+
+func TestAppendShouldMakeACopyOfTheInputSlice(t *testing.T) {
+	t.Parallel()
+	c := qt.New(t)
+	slice := make([]string, 0, 100)
+	slice = append(slice, "a", "b")
+	result, err := Append(slice, "c")
+	c.Assert(err, qt.IsNil)
+	slice[0] = "d"
+	c.Assert(result, qt.DeepEquals, []string{"a", "b", "c"})
+	c.Assert(slice, qt.DeepEquals, []string{"d", "b"})
+}
@@ -33,7 +33,7 @@ type LineMatcher struct {
 }

 // LineMatcherFn is used to match a line with an error.
-// It returns the column number or 0 if the line was found, but column could not be determinde. Returns -1 if no line match.
+// It returns the column number or 0 if the line was found, but column could not be determined. Returns -1 if no line match.
 type LineMatcherFn func(m LineMatcher) int

 // SimpleLineMatcher simply matches by line number.
@@ -59,11 +59,34 @@ func GetGID() uint64 {
 	return n
 }

+// IsFeatureNotAvailableError returns true if the given error is or contains a FeatureNotAvailableError.
+func IsFeatureNotAvailableError(err error) bool {
+	return errors.Is(err, &FeatureNotAvailableError{})
+}
+
 // ErrFeatureNotAvailable denotes that a feature is unavailable.
 //
 // We will, at least to begin with, make some Hugo features (SCSS with libsass) optional,
 // and this error is used to signal those situations.
-var ErrFeatureNotAvailable = errors.New("this feature is not available in your current Hugo version, see https://goo.gl/YMrWcn for more information")
+var ErrFeatureNotAvailable = &FeatureNotAvailableError{Cause: errors.New("this feature is not available in your current Hugo version, see https://goo.gl/YMrWcn for more information")}
+
+// FeatureNotAvailableError is an error type used to signal that a feature is not available.
+type FeatureNotAvailableError struct {
+	Cause error
+}
+
+func (e *FeatureNotAvailableError) Unwrap() error {
+	return e.Cause
+}
+
+func (e *FeatureNotAvailableError) Error() string {
+	return e.Cause.Error()
+}
+
+func (e *FeatureNotAvailableError) Is(target error) bool {
+	_, ok := target.(*FeatureNotAvailableError)
+	return ok
+}

 // Must panics if err != nil.
 func Must(err error) {
@@ -14,6 +14,7 @@
 package herrors

 import (
+	"errors"
 	"fmt"
 	"testing"

@@ -34,3 +35,12 @@ func TestIsNotExist(t *testing.T) {
 	// os.IsNotExist returns false for wrapped errors.
 	c.Assert(IsNotExist(fmt.Errorf("foo: %w", afero.ErrFileNotFound)), qt.Equals, true)
 }
+
+func TestIsFeatureNotAvailableError(t *testing.T) {
+	c := qt.New(t)
+
+	c.Assert(IsFeatureNotAvailableError(ErrFeatureNotAvailable), qt.Equals, true)
+	c.Assert(IsFeatureNotAvailableError(&FeatureNotAvailableError{}), qt.Equals, true)
+	c.Assert(IsFeatureNotAvailableError(errors.New("asdf")), qt.Equals, false)
+
+}
@@ -15,11 +15,14 @@ package herrors

 import (
 	"encoding/json"
+
+	godartsassv1 "github.com/bep/godartsass"
+
 	"fmt"
 	"io"
 	"path/filepath"

-	"github.com/bep/godartsass"
+	"github.com/bep/godartsass/v2"
 	"github.com/bep/golibsass/libsass/libsasserrors"
 	"github.com/gohugoio/hugo/common/paths"
 	"github.com/gohugoio/hugo/common/text"
@@ -145,6 +148,8 @@ func (e *fileError) causeString() string {
 	// Avoid repeating the file info in the error message.
 	case godartsass.SassError:
 		return v.Message
+	case godartsassv1.SassError:
+		return v.Message
 	case libsasserrors.Error:
 		return v.Message
 	default:
@@ -292,7 +297,7 @@ func extractFileTypePos(err error) (string, text.Position) {
 	}

 	// The error type from the minifier contains line number and column number.
-	if line, col := exctractLineNumberAndColumnNumber(err); line >= 0 {
+	if line, col := extractLineNumberAndColumnNumber(err); line >= 0 {
 		pos.LineNumber = line
 		pos.ColumnNumber = col
 		return fileType, pos
@@ -364,7 +369,7 @@ func extractOffsetAndType(e error) (int, string) {
 	}
 }

-func exctractLineNumberAndColumnNumber(e error) (int, int) {
+func extractLineNumberAndColumnNumber(e error) (int, int) {
 	switch v := e.(type) {
 	case *parse.Error:
 		return v.Line, v.Column
@@ -385,6 +390,13 @@ func extractPosition(e error) (pos text.Position) {
 		pos.Filename = filename
 		pos.Offset = start.Offset
 		pos.ColumnNumber = start.Column
+	case godartsassv1.SassError:
+		span := v.Span
+		start := span.Start
+		filename, _ := paths.UrlToFilename(span.Url)
+		pos.Filename = filename
+		pos.Offset = start.Offset
+		pos.ColumnNumber = start.Column
 	case libsasserrors.Error:
 		pos.Filename = v.File
 		pos.LineNumber = v.Line
@@ -118,7 +118,7 @@ func SafeCommand(name string, arg ...string) (*exec.Cmd, error) {
 	return exec.Command(bin, arg...), nil
 }

-// Exec encorces a security policy for commands run via os/exec.
+// Exec enforces a security policy for commands run via os/exec.
 type Exec struct {
 	sc security.Config

@@ -15,7 +15,9 @@ package hstrings

 import (
 	"fmt"
+	"regexp"
 	"strings"
+	"sync"

 	"github.com/gohugoio/hugo/compare"
 )
@@ -55,3 +57,45 @@ func EqualAny(a string, b ...string) bool {
 	}
 	return false
 }
+
+// regexpCache represents a cache of regexp objects protected by a mutex.
+type regexpCache struct {
+	mu sync.RWMutex
+	re map[string]*regexp.Regexp
+}
+
+func (rc *regexpCache) getOrCompileRegexp(pattern string) (re *regexp.Regexp, err error) {
+	var ok bool
+
+	if re, ok = rc.get(pattern); !ok {
+		re, err = regexp.Compile(pattern)
+		if err != nil {
+			return nil, err
+		}
+		rc.set(pattern, re)
+	}
+
+	return re, nil
+}
+
+func (rc *regexpCache) get(key string) (re *regexp.Regexp, ok bool) {
+	rc.mu.RLock()
+	re, ok = rc.re[key]
+	rc.mu.RUnlock()
+	return
+}
+
+func (rc *regexpCache) set(key string, re *regexp.Regexp) {
+	rc.mu.Lock()
+	rc.re[key] = re
+	rc.mu.Unlock()
+}
+
+var reCache = regexpCache{re: make(map[string]*regexp.Regexp)}
+
+// GetOrCompileRegexp retrieves a regexp object from the cache based upon the pattern.
+// If the pattern is not found in the cache, the pattern is compiled and added to
+// the cache.
+func GetOrCompileRegexp(pattern string) (re *regexp.Regexp, err error) {
+	return reCache.getOrCompileRegexp(pattern)
+}
@@ -14,6 +14,7 @@
 package hstrings

 import (
+	"regexp"
 	"testing"

 	qt "github.com/frankban/quicktest"
@@ -34,3 +35,24 @@ func TestStringEqualFold(t *testing.T) {
 	c.Assert(StringEqualFold(s1).Eq("b"), qt.Equals, false)

 }
+
+func TestGetOrCompileRegexp(t *testing.T) {
+	c := qt.New(t)
+
+	re, err := GetOrCompileRegexp(`\d+`)
+	c.Assert(err, qt.IsNil)
+	c.Assert(re.MatchString("123"), qt.Equals, true)
+
+}
+
+func BenchmarkGetOrCompileRegexp(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		GetOrCompileRegexp(`\d+`)
+	}
+}
+
+func BenchmarkCompileRegexp(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		regexp.MustCompile(`\d+`)
+	}
+}
@@ -0,0 +1,83 @@
+// Copyright 2022 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package htime_test
+
+import (
+	"testing"
+
+	"github.com/gohugoio/hugo/hugolib"
+)
+
+// Issue #11267
+func TestApplyWithContext(t *testing.T) {
+	t.Parallel()
+
+	files := `
+-- config.toml --
+defaultContentLanguage = 'it'
+-- layouts/index.html --
+{{ $dates := slice
+  "2022-01-03"
+  "2022-02-01"
+  "2022-03-02"
+  "2022-04-07"
+  "2022-05-06"
+  "2022-06-04"
+  "2022-07-03"
+  "2022-08-01"
+  "2022-09-06"
+  "2022-10-05"
+  "2022-11-03"
+  "2022-12-02"
+}}
+{{ range $dates }}
+	{{ . | time.Format "month: _January_ weekday: _Monday_" }}
+	{{ . | time.Format "month: _Jan_ weekday: _Mon_" }}
+{{ end }}
+  `
+
+	b := hugolib.NewIntegrationTestBuilder(
+		hugolib.IntegrationTestConfig{
+			T:           t,
+			TxtarString: files,
+		},
+	).Build()
+
+	b.AssertFileContent("public/index.html", `
+month: _gennaio_ weekday: _lunedì_
+month: _gen_ weekday: _lun_
+month: _febbraio_ weekday: _martedì_
+month: _feb_ weekday: _mar_
+month: _marzo_ weekday: _mercoledì_
+month: _mar_ weekday: _mer_
+month: _aprile_ weekday: _giovedì_
+month: _apr_ weekday: _gio_
+month: _maggio_ weekday: _venerdì_
+month: _mag_ weekday: _ven_
+month: _giugno_ weekday: _sabato_
+month: _giu_ weekday: _sab_
+month: _luglio_ weekday: _domenica_
+month: _lug_ weekday: _dom_
+month: _agosto_ weekday: _lunedì_
+month: _ago_ weekday: _lun_
+month: _settembre_ weekday: _martedì_
+month: _set_ weekday: _mar_
+month: _ottobre_ weekday: _mercoledì_
+month: _ott_ weekday: _mer_
+month: _novembre_ weekday: _giovedì_
+month: _nov_ weekday: _gio_
+month: _dicembre_ weekday: _venerdì_
+month: _dic_ weekday: _ven_
+`)
+}
@@ -18,7 +18,7 @@ import (
 	"strings"
 	"time"

-	"github.com/bep/clock"
+	"github.com/bep/clocks"
 	"github.com/spf13/cast"

 	"github.com/gohugoio/locales"
@@ -75,7 +75,7 @@ var (
 		"December",
 	}

-	Clock = clock.System()
+	Clock = clocks.System()
 )

 func NewTimeFormatter(ltr locales.Translator) TimeFormatter {
@@ -124,12 +124,15 @@ func (f TimeFormatter) Format(t time.Time, layout string) string {
 	monthIdx := t.Month() - 1 // Month() starts at 1.
 	dayIdx := t.Weekday()

-	s = strings.ReplaceAll(s, longMonthNames[monthIdx], f.ltr.MonthWide(t.Month()))
-	if !strings.Contains(s, f.ltr.MonthWide(t.Month())) {
+	if strings.Contains(layout, "January") {
+		s = strings.ReplaceAll(s, longMonthNames[monthIdx], f.ltr.MonthWide(t.Month()))
+	} else if strings.Contains(layout, "Jan") {
 		s = strings.ReplaceAll(s, shortMonthNames[monthIdx], f.ltr.MonthAbbreviated(t.Month()))
 	}
-	s = strings.ReplaceAll(s, longDayNames[dayIdx], f.ltr.WeekdayWide(t.Weekday()))
-	if !strings.Contains(s, f.ltr.WeekdayWide(t.Weekday())) {
+
+	if strings.Contains(layout, "Monday") {
+		s = strings.ReplaceAll(s, longDayNames[dayIdx], f.ltr.WeekdayWide(t.Weekday()))
+	} else if strings.Contains(layout, "Mon") {
 		s = strings.ReplaceAll(s, shortDayNames[dayIdx], f.ltr.WeekdayAbbreviated(t.Weekday()))
 	}

@@ -22,9 +22,13 @@ import (
 	"sort"
 	"strings"
 	"sync"
+
+	godartsassv1 "github.com/bep/godartsass"
+	"github.com/mitchellh/mapstructure"
+
 	"time"

-	"github.com/bep/godartsass"
+	"github.com/bep/godartsass/v2"
 	"github.com/gohugoio/hugo/common/hexec"
 	"github.com/gohugoio/hugo/hugofs/files"

@@ -238,7 +242,10 @@ func GetDependencyListNonGo() []string {
 	}

 	if dartSass := dartSassVersion(); dartSass.ProtocolVersion != "" {
-		const dartSassPath = "github.com/sass/dart-sass-embedded"
+		var dartSassPath = "github.com/sass/dart-sass-embedded"
+		if IsDartSassV2() {
+			dartSassPath = "github.com/sass/dart-sass"
+		}
 		deps = append(deps,
 			formatDep(dartSassPath+"/protocol", dartSass.ProtocolVersion),
 			formatDep(dartSassPath+"/compiler", dartSass.CompilerVersion),
@@ -283,11 +290,46 @@ type Dependency struct {
 }

 func dartSassVersion() godartsass.DartSassVersion {
-	// This is also duplicated in the dartsass package.
-	const dartSassEmbeddedBinaryName = "dart-sass-embedded"
-	if !hexec.InPath(dartSassEmbeddedBinaryName) {
+	if DartSassBinaryName == "" {
 		return godartsass.DartSassVersion{}
 	}
-	v, _ := godartsass.Version(dartSassEmbeddedBinaryName)
-	return v
+	if IsDartSassV2() {
+		v, _ := godartsass.Version(DartSassBinaryName)
+		return v
+	}
+
+	v, _ := godartsassv1.Version(DartSassBinaryName)
+	var vv godartsass.DartSassVersion
+	mapstructure.WeakDecode(v, &vv)
+	return vv
+}
+
+// DartSassBinaryName is the name of the Dart Sass binary to use.
+// TODO(beop) find a better place for this.
+var DartSassBinaryName string
+
+func init() {
+	DartSassBinaryName = os.Getenv("DART_SASS_BINARY")
+	if DartSassBinaryName == "" {
+		for _, name := range dartSassBinaryNamesV2 {
+			if hexec.InPath(name) {
+				DartSassBinaryName = name
+				break
+			}
+		}
+		if DartSassBinaryName == "" {
+			if hexec.InPath(dartSassBinaryNameV1) {
+				DartSassBinaryName = dartSassBinaryNameV1
+			}
+		}
+	}
+}
+
+var (
+	dartSassBinaryNameV1  = "dart-sass-embedded"
+	dartSassBinaryNamesV2 = []string{"dart-sass", "sass"}
+)
+
+func IsDartSassV2() bool {
+	return !strings.Contains(DartSassBinaryName, "embedded")
 }
@@ -17,7 +17,7 @@ package hugo
 // This should be the only one.
 var CurrentVersion = Version{
 	Major:      0,
-	Minor:      112,
-	PatchLevel: 6,
-	Suffix:     "",
+	Minor:      119,
+	PatchLevel: 0,
+	Suffix:     "-DEV",
 }
@@ -0,0 +1,106 @@
+// Copyright 2023 The Hugo Authors. All rights reserved.
+// Some functions in this file (see comments) is based on the Go source code,
+// copyright The Go Authors and  governed by a BSD-style license.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// package loggers contains some basic logging setup.
+package loggers
+
+import (
+	"fmt"
+	"io"
+	"strings"
+	"sync"
+
+	"github.com/bep/logg"
+
+	"github.com/fatih/color"
+)
+
+var bold = color.New(color.Bold)
+
+// levelColor mapping.
+var levelColor = [...]*color.Color{
+	logg.LevelDebug: color.New(color.FgWhite),
+	logg.LevelInfo:  color.New(color.FgBlue),
+	logg.LevelWarn:  color.New(color.FgYellow),
+	logg.LevelError: color.New(color.FgRed),
+}
+
+// levelString mapping.
+var levelString = [...]string{
+	logg.LevelDebug: "DEBUG",
+	logg.LevelInfo:  "INFO ",
+	logg.LevelWarn:  "WARN ",
+	logg.LevelError: "ERROR",
+}
+
+// newDefaultHandler handler.
+func newDefaultHandler(outWriter, errWriter io.Writer) logg.Handler {
+	return &defaultHandler{
+		outWriter: outWriter,
+		errWriter: errWriter,
+		Padding:   0,
+	}
+}
+
+// Default Handler implementation.
+// Based on https://github.com/apex/log/blob/master/handlers/cli/cli.go
+type defaultHandler struct {
+	mu        sync.Mutex
+	outWriter io.Writer // Defaults to os.Stdout.
+	errWriter io.Writer // Defaults to os.Stderr.
+
+	Padding int
+}
+
+// HandleLog implements logg.Handler.
+func (h *defaultHandler) HandleLog(e *logg.Entry) error {
+	color := levelColor[e.Level]
+	level := levelString[e.Level]
+
+	h.mu.Lock()
+	defer h.mu.Unlock()
+
+	var w io.Writer
+	if e.Level > logg.LevelInfo {
+		w = h.errWriter
+	} else {
+		w = h.outWriter
+	}
+
+	var prefix string
+	for _, field := range e.Fields {
+		if field.Name == FieldNameCmd {
+			prefix = fmt.Sprint(field.Value)
+			break
+		}
+	}
+
+	if prefix != "" {
+		prefix = prefix + ": "
+	}
+
+	color.Fprintf(w, "%s %s%s", fmt.Sprintf("%*s", h.Padding+1, level), color.Sprint(prefix), e.Message)
+
+	for _, field := range e.Fields {
+		if strings.HasPrefix(field.Name, reservedFieldNamePrefix) {
+			continue
+		}
+		fmt.Fprintf(w, " %s %v", color.Sprint(field.Name), field.Value)
+	}
+
+	fmt.Fprintln(w)
+
+	return nil
+}
@@ -0,0 +1,158 @@
+// Copyright 2023 The Hugo Authors. All rights reserved.
+// Some functions in this file (see comments) is based on the Go source code,
+// copyright The Go Authors and  governed by a BSD-style license.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package loggers
+
+import (
+	"fmt"
+	"strings"
+	"sync"
+
+	"github.com/bep/logg"
+	"github.com/gohugoio/hugo/identity"
+)
+
+// PanicOnWarningHook panics on warnings.
+var PanicOnWarningHook = func(e *logg.Entry) error {
+	if e.Level != logg.LevelWarn {
+		return nil
+	}
+	panic(e.Message)
+}
+
+func newLogLevelCounter() *logLevelCounter {
+	return &logLevelCounter{
+		counters: make(map[logg.Level]int),
+	}
+}
+
+func newLogOnceHandler(threshold logg.Level) *logOnceHandler {
+	return &logOnceHandler{
+		threshold: threshold,
+		seen:      make(map[uint64]bool),
+	}
+}
+
+func newStopHandler(h ...logg.Handler) *stopHandler {
+	return &stopHandler{
+		handlers: h,
+	}
+}
+
+func newSuppressStatementsHandler(statements map[string]bool) *suppressStatementsHandler {
+	return &suppressStatementsHandler{
+		statements: statements,
+	}
+}
+
+type logLevelCounter struct {
+	mu       sync.RWMutex
+	counters map[logg.Level]int
+}
+
+func (h *logLevelCounter) HandleLog(e *logg.Entry) error {
+	h.mu.Lock()
+	defer h.mu.Unlock()
+	h.counters[e.Level]++
+	return nil
+}
+
+var stopError = fmt.Errorf("stop")
+
+type logOnceHandler struct {
+	threshold logg.Level
+	mu        sync.Mutex
+	seen      map[uint64]bool
+}
+
+func (h *logOnceHandler) HandleLog(e *logg.Entry) error {
+	if e.Level < h.threshold {
+		// We typically only want to enable this for warnings and above.
+		// The common use case is that many go routines may log the same error.
+		return nil
+	}
+	h.mu.Lock()
+	defer h.mu.Unlock()
+	hash := identity.HashUint64(e.Level, e.Message, e.Fields)
+	if h.seen[hash] {
+		return stopError
+	}
+	h.seen[hash] = true
+	return nil
+}
+
+func (h *logOnceHandler) reset() {
+	h.mu.Lock()
+	defer h.mu.Unlock()
+	h.seen = make(map[uint64]bool)
+}
+
+type stopHandler struct {
+	handlers []logg.Handler
+}
+
+// HandleLog implements logg.Handler.
+func (h *stopHandler) HandleLog(e *logg.Entry) error {
+	for _, handler := range h.handlers {
+		if err := handler.HandleLog(e); err != nil {
+			if err == stopError {
+				return nil
+			}
+			return err
+		}
+	}
+	return nil
+}
+
+type suppressStatementsHandler struct {
+	statements map[string]bool
+}
+
+func (h *suppressStatementsHandler) HandleLog(e *logg.Entry) error {
+	for _, field := range e.Fields {
+		if field.Name == FieldNameStatementID {
+			if h.statements[field.Value.(string)] {
+				return stopError
+			}
+		}
+	}
+	return nil
+}
+
+// replacer creates a new log handler that does string replacement in log messages.
+func replacer(repl *strings.Replacer) logg.Handler {
+	return logg.HandlerFunc(func(e *logg.Entry) error {
+		e.Message = repl.Replace(e.Message)
+		for i, field := range e.Fields {
+			if s, ok := field.Value.(string); ok {
+				e.Fields[i].Value = repl.Replace(s)
+			}
+		}
+		return nil
+	})
+}
+
+// whiteSpaceTrimmer creates a new log handler that trims whitespace from log messages and string fields.
+func whiteSpaceTrimmer() logg.Handler {
+	return logg.HandlerFunc(func(e *logg.Entry) error {
+		e.Message = strings.TrimSpace(e.Message)
+		for i, field := range e.Fields {
+			if s, ok := field.Value.(string); ok {
+				e.Fields[i].Value = strings.TrimSpace(s)
+			}
+		}
+		return nil
+	})
+}
@@ -0,0 +1,90 @@
+// Copyright 2023 The Hugo Authors. All rights reserved.
+// Some functions in this file (see comments) is based on the Go source code,
+// copyright The Go Authors and  governed by a BSD-style license.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package loggers
+
+import (
+	"fmt"
+	"io"
+	"strings"
+	"sync"
+
+	"github.com/bep/logg"
+)
+
+// newNoColoursHandler creates a new NoColoursHandler
+func newNoColoursHandler(outWriter, errWriter io.Writer, noLevelPrefix bool, predicate func(*logg.Entry) bool) *noColoursHandler {
+	if predicate == nil {
+		predicate = func(e *logg.Entry) bool { return true }
+	}
+	return &noColoursHandler{
+		noLevelPrefix: noLevelPrefix,
+		outWriter:     outWriter,
+		errWriter:     errWriter,
+		predicate:     predicate,
+	}
+}
+
+type noColoursHandler struct {
+	mu            sync.Mutex
+	outWriter     io.Writer // Defaults to os.Stdout.
+	errWriter     io.Writer // Defaults to os.Stderr.
+	predicate     func(*logg.Entry) bool
+	noLevelPrefix bool
+}
+
+func (h *noColoursHandler) HandleLog(e *logg.Entry) error {
+	if !h.predicate(e) {
+		return nil
+	}
+	h.mu.Lock()
+	defer h.mu.Unlock()
+
+	var w io.Writer
+	if e.Level > logg.LevelInfo {
+		w = h.errWriter
+	} else {
+		w = h.outWriter
+	}
+
+	var prefix string
+	for _, field := range e.Fields {
+		if field.Name == FieldNameCmd {
+			prefix = fmt.Sprint(field.Value)
+			break
+		}
+	}
+
+	if prefix != "" {
+		prefix = prefix + ": "
+	}
+
+	if h.noLevelPrefix {
+		fmt.Fprintf(w, "%s%s", prefix, e.Message)
+	} else {
+		fmt.Fprintf(w, "%s %s%s", levelString[e.Level], prefix, e.Message)
+	}
+
+	for _, field := range e.Fields {
+		if strings.HasPrefix(field.Name, reservedFieldNamePrefix) {
+			continue
+		}
+		fmt.Fprintf(w, " %s %q", field.Name, field.Value)
+
+	}
+	fmt.Fprintln(w)
+
+	return nil
+}
@@ -1,63 +0,0 @@
-// Copyright 2020 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package loggers
-
-import (
-	"fmt"
-)
-
-// IgnorableLogger is a logger that ignores certain log statements.
-type IgnorableLogger interface {
-	Logger
-	Errorsf(statementID, format string, v ...any)
-	Apply(logger Logger) IgnorableLogger
-}
-
-type ignorableLogger struct {
-	Logger
-	statements map[string]bool
-}
-
-// NewIgnorableLogger wraps the given logger and ignores the log statement IDs given.
-func NewIgnorableLogger(logger Logger, statements map[string]bool) IgnorableLogger {
-	if statements == nil {
-		statements = make(map[string]bool)
-	}
-	return ignorableLogger{
-		Logger:     logger,
-		statements: statements,
-	}
-}
-
-// Errorsf logs statementID as an ERROR if not configured as ignoreable.
-func (l ignorableLogger) Errorsf(statementID, format string, v ...any) {
-	if l.statements[statementID] {
-		// Ignore.
-		return
-	}
-	ignoreMsg := fmt.Sprintf(`
-If you feel that this should not be logged as an ERROR, you can ignore it by adding this to your site config:
-ignoreErrors = [%q]`, statementID)
-
-	format += ignoreMsg
-
-	l.Errorf(format, v...)
-}
-
-func (l ignorableLogger) Apply(logger Logger) IgnorableLogger {
-	return ignorableLogger{
-		Logger:     logger,
-		statements: l.statements,
-	}
-}
@@ -0,0 +1,317 @@
+// Copyright 2023 The Hugo Authors. All rights reserved.
+// Some functions in this file (see comments) is based on the Go source code,
+// copyright The Go Authors and  governed by a BSD-style license.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package loggers
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"strings"
+	"time"
+
+	"github.com/bep/logg"
+	"github.com/bep/logg/handlers/multi"
+	"github.com/gohugoio/hugo/common/terminal"
+)
+
+var (
+	reservedFieldNamePrefix = "__h_field_"
+	// FieldNameCmd is the name of the field that holds the command name.
+	FieldNameCmd = reservedFieldNamePrefix + "_cmd"
+	// Used to suppress statements.
+	FieldNameStatementID = reservedFieldNamePrefix + "__h_field_statement_id"
+)
+
+// Options defines options for the logger.
+type Options struct {
+	Level              logg.Level
+	Stdout             io.Writer
+	Stderr             io.Writer
+	Distinct           bool
+	StoreErrors        bool
+	HandlerPost        func(e *logg.Entry) error
+	SuppressStatements map[string]bool
+}
+
+// New creates a new logger with the given options.
+func New(opts Options) Logger {
+	if opts.Stdout == nil {
+		opts.Stdout = os.Stdout
+	}
+	if opts.Stderr == nil {
+		opts.Stderr = os.Stdout
+	}
+	if opts.Level == 0 {
+		opts.Level = logg.LevelWarn
+	}
+
+	var logHandler logg.Handler
+	if terminal.PrintANSIColors(os.Stdout) {
+		logHandler = newDefaultHandler(opts.Stdout, opts.Stderr)
+	} else {
+		logHandler = newNoColoursHandler(opts.Stdout, opts.Stderr, false, nil)
+	}
+
+	errorsw := &strings.Builder{}
+	logCounters := newLogLevelCounter()
+	handlers := []logg.Handler{
+		whiteSpaceTrimmer(),
+		logHandler,
+		logCounters,
+	}
+
+	if opts.HandlerPost != nil {
+		var hookHandler logg.HandlerFunc = func(e *logg.Entry) error {
+			opts.HandlerPost(e)
+			return nil
+		}
+		handlers = append(handlers, hookHandler)
+	}
+
+	if opts.StoreErrors {
+		h := newNoColoursHandler(io.Discard, errorsw, true, func(e *logg.Entry) bool {
+			return e.Level >= logg.LevelError
+		})
+
+		handlers = append(handlers, h)
+	}
+
+	logHandler = multi.New(handlers...)
+
+	var logOnce *logOnceHandler
+	if opts.Distinct {
+		logOnce = newLogOnceHandler(logg.LevelWarn)
+		logHandler = newStopHandler(logOnce, logHandler)
+	}
+
+	if opts.SuppressStatements != nil && len(opts.SuppressStatements) > 0 {
+		logHandler = newStopHandler(newSuppressStatementsHandler(opts.SuppressStatements), logHandler)
+	}
+
+	logger := logg.New(
+		logg.Options{
+			Level:   opts.Level,
+			Handler: logHandler,
+		},
+	)
+
+	l := logger.WithLevel(opts.Level)
+
+	reset := func() {
+		logCounters.mu.Lock()
+		defer logCounters.mu.Unlock()
+		logCounters.counters = make(map[logg.Level]int)
+		errorsw.Reset()
+		if logOnce != nil {
+			logOnce.reset()
+		}
+	}
+
+	return &logAdapter{
+		logCounters: logCounters,
+		errors:      errorsw,
+		reset:       reset,
+		out:         opts.Stdout,
+		level:       opts.Level,
+		logger:      logger,
+		debugl:      l.WithLevel(logg.LevelDebug),
+		infol:       l.WithLevel(logg.LevelInfo),
+		warnl:       l.WithLevel(logg.LevelWarn),
+		errorl:      l.WithLevel(logg.LevelError),
+	}
+}
+
+// NewDefault creates a new logger with the default options.
+func NewDefault() Logger {
+	opts := Options{
+		Distinct: true,
+		Level:    logg.LevelWarn,
+		Stdout:   os.Stdout,
+		Stderr:   os.Stdout,
+	}
+	return New(opts)
+}
+
+func LevelLoggerToWriter(l logg.LevelLogger) io.Writer {
+	return logWriter{l: l}
+}
+
+type Logger interface {
+	Debugf(format string, v ...any)
+	Debugln(v ...any)
+	Error() logg.LevelLogger
+	Errorf(format string, v ...any)
+	Errorln(v ...any)
+	Errors() string
+	Errorsf(id, format string, v ...any)
+	Info() logg.LevelLogger
+	InfoCommand(command string) logg.LevelLogger
+	Infof(format string, v ...any)
+	Infoln(v ...any)
+	Level() logg.Level
+	LoggCount(logg.Level) int
+	Logger() logg.Logger
+	Out() io.Writer
+	Printf(format string, v ...any)
+	Println(v ...any)
+	PrintTimerIfDelayed(start time.Time, name string)
+	Reset()
+	Warn() logg.LevelLogger
+	WarnCommand(command string) logg.LevelLogger
+	Warnf(format string, v ...any)
+	Warnln(v ...any)
+	Deprecatef(fail bool, format string, v ...any)
+}
+
+type logAdapter struct {
+	logCounters *logLevelCounter
+	errors      *strings.Builder
+	reset       func()
+	out         io.Writer
+	level       logg.Level
+	logger      logg.Logger
+	debugl      logg.LevelLogger
+	infol       logg.LevelLogger
+	warnl       logg.LevelLogger
+	errorl      logg.LevelLogger
+}
+
+func (l *logAdapter) Debugf(format string, v ...any) {
+	l.debugl.Logf(format, v...)
+}
+
+func (l *logAdapter) Debugln(v ...any) {
+	l.debugl.Logf(l.sprint(v...))
+}
+
+func (l *logAdapter) Info() logg.LevelLogger {
+	return l.infol
+}
+
+func (l *logAdapter) InfoCommand(command string) logg.LevelLogger {
+	return l.infol.WithField(FieldNameCmd, command)
+}
+
+func (l *logAdapter) Infof(format string, v ...any) {
+	l.infol.Logf(format, v...)
+}
+
+func (l *logAdapter) Infoln(v ...any) {
+	l.infol.Logf(l.sprint(v...))
+}
+
+func (l *logAdapter) Level() logg.Level {
+	return l.level
+}
+
+func (l *logAdapter) LoggCount(level logg.Level) int {
+	l.logCounters.mu.RLock()
+	defer l.logCounters.mu.RUnlock()
+	return l.logCounters.counters[level]
+}
+
+func (l *logAdapter) Logger() logg.Logger {
+	return l.logger
+}
+
+func (l *logAdapter) Out() io.Writer {
+	return l.out
+}
+
+// PrintTimerIfDelayed prints a time statement to the FEEDBACK logger
+// if considerable time is spent.
+func (l *logAdapter) PrintTimerIfDelayed(start time.Time, name string) {
+	elapsed := time.Since(start)
+	milli := int(1000 * elapsed.Seconds())
+	if milli < 500 {
+		return
+	}
+	l.Printf("%s in %v ms", name, milli)
+}
+
+func (l *logAdapter) Printf(format string, v ...any) {
+	// Add trailing newline if not present.
+	if !strings.HasSuffix(format, "\n") {
+		format += "\n"
+	}
+	fmt.Fprintf(l.out, format, v...)
+}
+
+func (l *logAdapter) Println(v ...any) {
+	fmt.Fprintln(l.out, v...)
+}
+
+func (l *logAdapter) Reset() {
+	l.reset()
+}
+
+func (l *logAdapter) Warn() logg.LevelLogger {
+	return l.warnl
+}
+
+func (l *logAdapter) Warnf(format string, v ...any) {
+	l.warnl.Logf(format, v...)
+}
+
+func (l *logAdapter) WarnCommand(command string) logg.LevelLogger {
+	return l.warnl.WithField(FieldNameCmd, command)
+}
+
+func (l *logAdapter) Warnln(v ...any) {
+	l.warnl.Logf(l.sprint(v...))
+}
+
+func (l *logAdapter) Error() logg.LevelLogger {
+	return l.errorl
+}
+
+func (l *logAdapter) Errorf(format string, v ...any) {
+	l.errorl.Logf(format, v...)
+}
+
+func (l *logAdapter) Errorln(v ...any) {
+	l.errorl.Logf(l.sprint(v...))
+}
+
+func (l *logAdapter) Errors() string {
+	return l.errors.String()
+}
+
+func (l *logAdapter) Errorsf(id, format string, v ...any) {
+	l.errorl.WithField(FieldNameStatementID, id).Logf(format, v...)
+}
+
+func (l *logAdapter) sprint(v ...any) string {
+	return strings.TrimRight(fmt.Sprintln(v...), "\n")
+}
+
+func (l *logAdapter) Deprecatef(fail bool, format string, v ...any) {
+	format = "DEPRECATED: " + format
+	if fail {
+		l.errorl.Logf(format, v...)
+	} else {
+		l.warnl.Logf(format, v...)
+	}
+}
+
+type logWriter struct {
+	l logg.LevelLogger
+}
+
+func (w logWriter) Write(p []byte) (n int, err error) {
+	w.l.Log(logg.String(string(p)))
+	return len(p), nil
+}
@@ -0,0 +1,156 @@
+// Copyright 2023 The Hugo Authors. All rights reserved.
+// Some functions in this file (see comments) is based on the Go source code,
+// copyright The Go Authors and  governed by a BSD-style license.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package loggers_test
+
+import (
+	"io"
+	"strings"
+	"testing"
+
+	"github.com/bep/logg"
+	qt "github.com/frankban/quicktest"
+	"github.com/gohugoio/hugo/common/loggers"
+)
+
+func TestLogDistinct(t *testing.T) {
+	c := qt.New(t)
+
+	opts := loggers.Options{
+		Distinct:    true,
+		StoreErrors: true,
+		Stdout:      io.Discard,
+		Stderr:      io.Discard,
+	}
+
+	l := loggers.New(opts)
+
+	for i := 0; i < 10; i++ {
+		l.Errorln("error 1")
+		l.Errorln("error 2")
+		l.Warnln("warn 1")
+	}
+	c.Assert(strings.Count(l.Errors(), "error 1"), qt.Equals, 1)
+	c.Assert(l.LoggCount(logg.LevelError), qt.Equals, 2)
+	c.Assert(l.LoggCount(logg.LevelWarn), qt.Equals, 1)
+}
+
+func TestHookLast(t *testing.T) {
+	c := qt.New(t)
+
+	opts := loggers.Options{
+		HandlerPost: func(e *logg.Entry) error {
+			panic(e.Message)
+		},
+		Stdout: io.Discard,
+		Stderr: io.Discard,
+	}
+
+	l := loggers.New(opts)
+
+	c.Assert(func() { l.Warnln("warn 1") }, qt.PanicMatches, "warn 1")
+}
+
+func TestOptionStoreErrors(t *testing.T) {
+	c := qt.New(t)
+
+	var sb strings.Builder
+
+	opts := loggers.Options{
+		StoreErrors: true,
+		Stderr:      &sb,
+		Stdout:      &sb,
+	}
+
+	l := loggers.New(opts)
+	l.Errorln("error 1")
+	l.Errorln("error 2")
+
+	errorsStr := l.Errors()
+
+	c.Assert(errorsStr, qt.Contains, "error 1")
+	c.Assert(errorsStr, qt.Not(qt.Contains), "ERROR")
+
+	c.Assert(sb.String(), qt.Contains, "error 1")
+	c.Assert(sb.String(), qt.Contains, "ERROR")
+
+}
+
+func TestLogCount(t *testing.T) {
+	c := qt.New(t)
+
+	opts := loggers.Options{
+		StoreErrors: true,
+	}
+
+	l := loggers.New(opts)
+	l.Errorln("error 1")
+	l.Errorln("error 2")
+	l.Warnln("warn 1")
+
+	c.Assert(l.LoggCount(logg.LevelError), qt.Equals, 2)
+	c.Assert(l.LoggCount(logg.LevelWarn), qt.Equals, 1)
+	c.Assert(l.LoggCount(logg.LevelInfo), qt.Equals, 0)
+}
+
+func TestSuppressStatements(t *testing.T) {
+	c := qt.New(t)
+
+	opts := loggers.Options{
+		StoreErrors: true,
+		SuppressStatements: map[string]bool{
+			"error-1": true,
+		},
+	}
+
+	l := loggers.New(opts)
+	l.Error().WithField(loggers.FieldNameStatementID, "error-1").Logf("error 1")
+	l.Errorln("error 2")
+
+	errorsStr := l.Errors()
+
+	c.Assert(errorsStr, qt.Not(qt.Contains), "error 1")
+	c.Assert(errorsStr, qt.Contains, "error 2")
+	c.Assert(l.LoggCount(logg.LevelError), qt.Equals, 1)
+
+}
+
+func TestReset(t *testing.T) {
+	c := qt.New(t)
+
+	opts := loggers.Options{
+		StoreErrors: true,
+		Distinct:    true,
+		Stdout:      io.Discard,
+		Stderr:      io.Discard,
+	}
+
+	l := loggers.New(opts)
+
+	for i := 0; i < 3; i++ {
+		l.Errorln("error 1")
+		l.Errorln("error 2")
+		l.Errorln("error 1")
+		c.Assert(l.LoggCount(logg.LevelError), qt.Equals, 2)
+
+		l.Reset()
+
+		errorsStr := l.Errors()
+
+		c.Assert(errorsStr, qt.Equals, "")
+		c.Assert(l.LoggCount(logg.LevelError), qt.Equals, 0)
+
+	}
+}
@@ -0,0 +1,53 @@
+// Copyright 2023 The Hugo Authors. All rights reserved.
+// Some functions in this file (see comments) is based on the Go source code,
+// copyright The Go Authors and  governed by a BSD-style license.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package loggers
+
+import (
+	"sync"
+
+	"github.com/bep/logg"
+)
+
+func InitGlobalLogger(panicOnWarnings bool) {
+	logMu.Lock()
+	defer logMu.Unlock()
+	var logHookLast func(e *logg.Entry) error
+	if panicOnWarnings {
+		logHookLast = PanicOnWarningHook
+	}
+
+	log = New(
+		Options{
+			Distinct:    true,
+			HandlerPost: logHookLast,
+		},
+	)
+}
+
+var logMu sync.Mutex
+
+func Log() Logger {
+	logMu.Lock()
+	defer logMu.Unlock()
+	return log
+}
+
+// The global logger.
+var log Logger
+
+func init() {
+	InitGlobalLogger(false)
+}
@@ -1,355 +0,0 @@
-// Copyright 2020 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package loggers
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"log"
-	"os"
-	"regexp"
-	"runtime"
-	"sync/atomic"
-	"time"
-
-	"github.com/gohugoio/hugo/common/terminal"
-
-	jww "github.com/spf13/jwalterweatherman"
-)
-
-var (
-	// Counts ERROR logs to the global jww logger.
-	GlobalErrorCounter *jww.Counter
-	PanicOnWarning     atomic.Bool
-)
-
-func init() {
-	GlobalErrorCounter = &jww.Counter{}
-	jww.SetLogListeners(jww.LogCounter(GlobalErrorCounter, jww.LevelError))
-}
-
-func LoggerToWriterWithPrefix(logger *log.Logger, prefix string) io.Writer {
-	return prefixWriter{
-		logger: logger,
-		prefix: prefix,
-	}
-}
-
-type prefixWriter struct {
-	logger *log.Logger
-	prefix string
-}
-
-func (w prefixWriter) Write(p []byte) (n int, err error) {
-	w.logger.Printf("%s: %s", w.prefix, p)
-	return len(p), nil
-}
-
-type Logger interface {
-	Printf(format string, v ...any)
-	Println(v ...any)
-	PrintTimerIfDelayed(start time.Time, name string)
-	Debug() *log.Logger
-	Debugf(format string, v ...any)
-	Debugln(v ...any)
-	Info() *log.Logger
-	Infof(format string, v ...any)
-	Infoln(v ...any)
-	Warn() *log.Logger
-	Warnf(format string, v ...any)
-	Warnln(v ...any)
-	Error() *log.Logger
-	Errorf(format string, v ...any)
-	Errorln(v ...any)
-	Errors() string
-
-	Out() io.Writer
-
-	Reset()
-
-	// Used in tests.
-	LogCounters() *LogCounters
-}
-
-type LogCounters struct {
-	ErrorCounter *jww.Counter
-	WarnCounter  *jww.Counter
-}
-
-type logger struct {
-	*jww.Notepad
-
-	// The writer that represents stdout.
-	// Will be io.Discard when in quiet mode.
-	out io.Writer
-
-	logCounters *LogCounters
-
-	// This is only set in server mode.
-	errors *bytes.Buffer
-}
-
-func (l *logger) Printf(format string, v ...any) {
-	l.FEEDBACK.Printf(format, v...)
-}
-
-func (l *logger) Println(v ...any) {
-	l.FEEDBACK.Println(v...)
-}
-
-func (l *logger) Debug() *log.Logger {
-	return l.DEBUG
-}
-
-func (l *logger) Debugf(format string, v ...any) {
-	l.DEBUG.Printf(format, v...)
-}
-
-func (l *logger) Debugln(v ...any) {
-	l.DEBUG.Println(v...)
-}
-
-func (l *logger) Infof(format string, v ...any) {
-	l.INFO.Printf(format, v...)
-}
-
-func (l *logger) Infoln(v ...any) {
-	l.INFO.Println(v...)
-}
-
-func (l *logger) Info() *log.Logger {
-	return l.INFO
-}
-
-const panicOnWarningMessage = "Warning trapped. Remove the --panicOnWarning flag to continue."
-
-func (l *logger) Warnf(format string, v ...any) {
-	l.WARN.Printf(format, v...)
-	if PanicOnWarning.Load() {
-		panic(panicOnWarningMessage)
-	}
-}
-
-func (l *logger) Warnln(v ...any) {
-	l.WARN.Println(v...)
-	if PanicOnWarning.Load() {
-		panic(panicOnWarningMessage)
-	}
-}
-
-func (l *logger) Warn() *log.Logger {
-	return l.WARN
-}
-
-func (l *logger) Errorf(format string, v ...any) {
-	l.ERROR.Printf(format, v...)
-}
-
-func (l *logger) Errorln(v ...any) {
-	l.ERROR.Println(v...)
-}
-
-func (l *logger) Error() *log.Logger {
-	return l.ERROR
-}
-
-func (l *logger) LogCounters() *LogCounters {
-	return l.logCounters
-}
-
-func (l *logger) Out() io.Writer {
-	return l.out
-}
-
-// PrintTimerIfDelayed prints a time statement to the FEEDBACK logger
-// if considerable time is spent.
-func (l *logger) PrintTimerIfDelayed(start time.Time, name string) {
-	elapsed := time.Since(start)
-	milli := int(1000 * elapsed.Seconds())
-	if milli < 500 {
-		return
-	}
-	l.Printf("%s in %v ms", name, milli)
-}
-
-func (l *logger) PrintTimer(start time.Time, name string) {
-	elapsed := time.Since(start)
-	milli := int(1000 * elapsed.Seconds())
-	l.Printf("%s in %v ms", name, milli)
-}
-
-func (l *logger) Errors() string {
-	if l.errors == nil {
-		return ""
-	}
-	return ansiColorRe.ReplaceAllString(l.errors.String(), "")
-}
-
-// Reset resets the logger's internal state.
-func (l *logger) Reset() {
-	l.logCounters.ErrorCounter.Reset()
-	if l.errors != nil {
-		l.errors.Reset()
-	}
-}
-
-// NewLogger creates a new Logger for the given thresholds
-func NewLogger(stdoutThreshold, logThreshold jww.Threshold, outHandle, logHandle io.Writer, saveErrors bool) Logger {
-	return newLogger(stdoutThreshold, logThreshold, outHandle, logHandle, saveErrors)
-}
-
-// NewDebugLogger is a convenience function to create a debug logger.
-func NewDebugLogger() Logger {
-	return NewBasicLogger(jww.LevelDebug)
-}
-
-// NewWarningLogger is a convenience function to create a warning logger.
-func NewWarningLogger() Logger {
-	return NewBasicLogger(jww.LevelWarn)
-}
-
-// NewInfoLogger is a convenience function to create a info logger.
-func NewInfoLogger() Logger {
-	return NewBasicLogger(jww.LevelInfo)
-}
-
-// NewErrorLogger is a convenience function to create an error logger.
-func NewErrorLogger() Logger {
-	return NewBasicLogger(jww.LevelError)
-}
-
-// NewBasicLogger creates a new basic logger writing to Stdout.
-func NewBasicLogger(t jww.Threshold) Logger {
-	return newLogger(t, jww.LevelError, os.Stdout, io.Discard, false)
-}
-
-// NewBasicLoggerForWriter creates a new basic logger writing to w.
-func NewBasicLoggerForWriter(t jww.Threshold, w io.Writer) Logger {
-	return newLogger(t, jww.LevelError, w, io.Discard, false)
-}
-
-// RemoveANSIColours removes all ANSI colours from the given string.
-func RemoveANSIColours(s string) string {
-	return ansiColorRe.ReplaceAllString(s, "")
-}
-
-var (
-	ansiColorRe = regexp.MustCompile("(?s)\\033\\[\\d*(;\\d*)*m")
-	errorRe     = regexp.MustCompile("^(ERROR|FATAL|WARN)")
-)
-
-type ansiCleaner struct {
-	w io.Writer
-}
-
-func (a ansiCleaner) Write(p []byte) (n int, err error) {
-	return a.w.Write(ansiColorRe.ReplaceAll(p, []byte("")))
-}
-
-type labelColorizer struct {
-	w io.Writer
-}
-
-func (a labelColorizer) Write(p []byte) (n int, err error) {
-	replaced := errorRe.ReplaceAllStringFunc(string(p), func(m string) string {
-		switch m {
-		case "ERROR", "FATAL":
-			return terminal.Error(m)
-		case "WARN":
-			return terminal.Warning(m)
-		default:
-			return m
-		}
-	})
-	// io.MultiWriter will abort if we return a bigger write count than input
-	// bytes, so we lie a little.
-	_, err = a.w.Write([]byte(replaced))
-	return len(p), err
-}
-
-// InitGlobalLogger initializes the global logger, used in some rare cases.
-func InitGlobalLogger(stdoutThreshold, logThreshold jww.Threshold, outHandle, logHandle io.Writer) {
-	outHandle, logHandle = getLogWriters(outHandle, logHandle)
-
-	jww.SetStdoutOutput(outHandle)
-	jww.SetLogOutput(logHandle)
-	jww.SetLogThreshold(logThreshold)
-	jww.SetStdoutThreshold(stdoutThreshold)
-}
-
-func getLogWriters(outHandle, logHandle io.Writer) (io.Writer, io.Writer) {
-	isTerm := terminal.PrintANSIColors(os.Stdout)
-	if logHandle != io.Discard && isTerm {
-		// Remove any Ansi coloring from log output
-		logHandle = ansiCleaner{w: logHandle}
-	}
-
-	if isTerm {
-		outHandle = labelColorizer{w: outHandle}
-	}
-
-	return outHandle, logHandle
-}
-
-type fatalLogWriter int
-
-func (s fatalLogWriter) Write(p []byte) (n int, err error) {
-	trace := make([]byte, 1500)
-	runtime.Stack(trace, true)
-	fmt.Printf("\n===========\n\n%s\n", trace)
-	os.Exit(-1)
-
-	return 0, nil
-}
-
-var fatalLogListener = func(t jww.Threshold) io.Writer {
-	if t != jww.LevelError {
-		// Only interested in ERROR
-		return nil
-	}
-
-	return new(fatalLogWriter)
-}
-
-func newLogger(stdoutThreshold, logThreshold jww.Threshold, outHandle, logHandle io.Writer, saveErrors bool) *logger {
-	errorCounter := &jww.Counter{}
-	warnCounter := &jww.Counter{}
-	outHandle, logHandle = getLogWriters(outHandle, logHandle)
-
-	listeners := []jww.LogListener{jww.LogCounter(errorCounter, jww.LevelError), jww.LogCounter(warnCounter, jww.LevelWarn)}
-	var errorBuff *bytes.Buffer
-	if saveErrors {
-		errorBuff = new(bytes.Buffer)
-		errorCapture := func(t jww.Threshold) io.Writer {
-			if t != jww.LevelError {
-				// Only interested in ERROR
-				return nil
-			}
-			return errorBuff
-		}
-
-		listeners = append(listeners, errorCapture)
-	}
-
-	return &logger{
-		Notepad: jww.NewNotepad(stdoutThreshold, logThreshold, outHandle, logHandle, "", log.Ldate|log.Ltime, listeners...),
-		out:     outHandle,
-		logCounters: &LogCounters{
-			ErrorCounter: errorCounter,
-			WarnCounter:  warnCounter,
-		},
-		errors: errorBuff,
-	}
-}
@@ -1,60 +0,0 @@
-// Copyright 2018 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package loggers
-
-import (
-	"bytes"
-	"fmt"
-	"log"
-	"testing"
-
-	qt "github.com/frankban/quicktest"
-)
-
-func TestLogger(t *testing.T) {
-	c := qt.New(t)
-	l := NewWarningLogger()
-
-	l.Errorln("One error")
-	l.Errorln("Two error")
-	l.Warnln("A warning")
-
-	c.Assert(l.LogCounters().ErrorCounter.Count(), qt.Equals, uint64(2))
-}
-
-func TestLoggerToWriterWithPrefix(t *testing.T) {
-	c := qt.New(t)
-
-	var b bytes.Buffer
-
-	logger := log.New(&b, "", 0)
-
-	w := LoggerToWriterWithPrefix(logger, "myprefix")
-
-	fmt.Fprint(w, "Hello Hugo!")
-
-	c.Assert(b.String(), qt.Equals, "myprefix: Hello Hugo!\n")
-}
-
-func TestRemoveANSIColours(t *testing.T) {
-	c := qt.New(t)
-
-	c.Assert(RemoveANSIColours(""), qt.Equals, "")
-	c.Assert(RemoveANSIColours("\033[31m"), qt.Equals, "")
-	c.Assert(RemoveANSIColours("\033[31mHello"), qt.Equals, "Hello")
-	c.Assert(RemoveANSIColours("\033[31mHello\033[0m"), qt.Equals, "Hello")
-	c.Assert(RemoveANSIColours("\033[31mHello\033[0m World"), qt.Equals, "Hello World")
-	c.Assert(RemoveANSIColours("\033[31mHello\033[0m World\033[31m!"), qt.Equals, "Hello World!")
-	c.Assert(RemoveANSIColours("\x1b[90m 5 |"), qt.Equals, " 5 |")
-}
@@ -210,3 +210,28 @@ func (r KeyRenamer) renamePath(parentKeyPath string, m map[string]any) {
 		}
 	}
 }
+
+// ConvertFloat64WithNoDecimalsToInt converts float64 values with no decimals to int recursively.
+func ConvertFloat64WithNoDecimalsToInt(m map[string]any) {
+	for k, v := range m {
+		switch vv := v.(type) {
+		case float64:
+			if v == float64(int64(vv)) {
+				m[k] = int64(vv)
+			}
+		case map[string]any:
+			ConvertFloat64WithNoDecimalsToInt(vv)
+		case []any:
+			for i, vvv := range vv {
+				switch vvvv := vvv.(type) {
+				case float64:
+					if vvv == float64(int64(vvvv)) {
+						vv[i] = int64(vvvv)
+					}
+				case map[string]any:
+					ConvertFloat64WithNoDecimalsToInt(vvvv)
+				}
+			}
+		}
+	}
+}
@@ -209,7 +209,7 @@ func extractFilename(in, ext, base, pathSeparator string) (name string) {
 		// return the filename minus the extension (and the ".")
 		name = base[:strings.LastIndex(base, ".")]
 	} else {
-		// no extension case so just return base, which willi
+		// no extension case so just return base, which will
 		// be the filename
 		name = base
 	}
@@ -45,6 +45,7 @@ import (
 	"github.com/gohugoio/hugo/output"
 	"github.com/gohugoio/hugo/related"
 	"github.com/gohugoio/hugo/resources/images"
+	"github.com/gohugoio/hugo/resources/kinds"
 	"github.com/gohugoio/hugo/resources/page"
 	"github.com/gohugoio/hugo/resources/page/pagemeta"
 	"github.com/spf13/afero"
@@ -57,12 +58,11 @@ type InternalConfig struct {
 	// Server mode?
 	Running bool

-	Quiet             bool
-	Verbose           bool
-	Clock             string
-	Watch             bool
-	DisableLiveReload bool
-	LiveReloadPort    int
+	Quiet          bool
+	Verbose        bool
+	Clock          string
+	Watch          bool
+	LiveReloadPort int
 }

 // All non-params config keys for language.
@@ -150,7 +150,7 @@ type Config struct {
 	Minify minifiers.MinifyConfig `mapstructure:"-"`

 	// Permalink configuration.
-	Permalinks map[string]string `mapstructure:"-"`
+	Permalinks map[string]map[string]string `mapstructure:"-"`

 	// Taxonomy configuration.
 	Taxonomies map[string]string `mapstructure:"-"`
@@ -191,6 +191,22 @@ type configCompiler interface {
 func (c Config) cloneForLang() *Config {
 	x := c
 	x.C = nil
+	copyStringSlice := func(in []string) []string {
+		if in == nil {
+			return nil
+		}
+		out := make([]string, len(in))
+		copy(out, in)
+		return out
+	}
+
+	// Copy all the slices to avoid sharing.
+	x.DisableKinds = copyStringSlice(x.DisableKinds)
+	x.DisableLanguages = copyStringSlice(x.DisableLanguages)
+	x.MainSections = copyStringSlice(x.MainSections)
+	x.IgnoreErrors = copyStringSlice(x.IgnoreErrors)
+	x.IgnoreFiles = copyStringSlice(x.IgnoreFiles)
+	x.Theme = copyStringSlice(x.Theme)

 	// Collapse all static dirs to one.
 	x.StaticDir = x.staticDirs()
@@ -224,9 +240,14 @@ func (c *Config) CompileConfig(logger loggers.Logger) error {
 	disabledKinds := make(map[string]bool)
 	for _, kind := range c.DisableKinds {
 		kind = strings.ToLower(kind)
-		if kind == "taxonomyterm" {
+		if newKind := kinds.IsDeprecatedAndReplacedWith(kind); newKind != "" {
+			logger.Deprecatef(false, "Kind %q used in disableKinds is deprecated, use %q instead.", kind, newKind)
 			// Legacy config.
-			kind = "term"
+			kind = newKind
+		}
+		if kinds.GetKindAny(kind) == "" {
+			logger.Warnf("Unknown kind %q in disableKinds configuration.", kind)
+			continue
 		}
 		disabledKinds[kind] = true
 	}
@@ -234,9 +255,17 @@ func (c *Config) CompileConfig(logger loggers.Logger) error {
 	isRssDisabled := disabledKinds["rss"]
 	outputFormats := c.OutputFormats.Config
 	for kind, formats := range c.Outputs {
+		if newKind := kinds.IsDeprecatedAndReplacedWith(kind); newKind != "" {
+			logger.Deprecatef(false, "Kind %q used in outputs configuration is deprecated, use %q instead.", kind, newKind)
+			kind = newKind
+		}
 		if disabledKinds[kind] {
 			continue
 		}
+		if kinds.GetKindAny(kind) == "" {
+			logger.Warnf("Unknown kind %q in outputs configuration.", kind)
+			continue
+		}
 		for _, format := range formats {
 			if isRssDisabled && format == "rss" {
 				// Legacy config.
@@ -258,6 +287,14 @@ func (c *Config) CompileConfig(logger loggers.Logger) error {
 		}
 		disabledLangs[lang] = true
 	}
+	for lang, language := range c.Languages {
+		if language.Disabled {
+			disabledLangs[lang] = true
+			if lang == c.DefaultContentLanguage {
+				return fmt.Errorf("cannot disable default content language %q", lang)
+			}
+		}
+	}

 	ignoredErrors := make(map[string]bool)
 	for _, err := range c.IgnoreErrors {
@@ -408,10 +445,10 @@ type RootConfig struct {
 	// Copyright information.
 	Copyright string

-	// The language to apply to content without any Clolanguage indicator.
+	// The language to apply to content without any language indicator.
 	DefaultContentLanguage string

-	// By defefault, we put the default content language in the root and the others below their language ID, e.g. /no/.
+	// By default, we put the default content language in the root and the others below their language ID, e.g. /no/.
 	// Set this to true to put all languages below their language ID.
 	DefaultContentLanguageInSubdir bool

@@ -430,6 +467,9 @@ type RootConfig struct {
 	// Disable the injection of the Hugo generator tag on the home page.
 	DisableHugoGeneratorInject bool

+	// Disable live reloading in server mode.
+	DisableLiveReload bool
+
 	// Enable replacement in Pages' Content of Emoji shortcodes with their equivalent Unicode characters.
 	// <docsmeta>{"identifiers": ["Content", "Unicode"] }</docsmeta>
 	EnableEmoji bool
@@ -468,11 +508,8 @@ type RootConfig struct {
 	// Enable to print greppable placeholders (on the form "[i18n] TRANSLATIONID") for missing translation strings.
 	EnableMissingTranslationPlaceholders bool

-	// Enable to print warnings for missing translation strings.
-	LogI18nWarnings bool
-
-	// ENable to print warnings for multiple files published to the same destination.
-	LogPathWarnings bool
+	// Enable to panic on warning log entries. This may make it easier to detect the source.
+	PanicOnWarning bool

 	// The configured environment. Default is "development" for server and "production" for build.
 	Environment string
@@ -506,6 +543,12 @@ type RootConfig struct {
 	// Whether to track and print unused templates during the build.
 	PrintUnusedTemplates bool

+	// Enable to print warnings for missing translation strings.
+	PrintI18nWarnings bool
+
+	// ENable to print warnings for multiple files published to the same destination.
+	PrintPathWarnings bool
+
 	// URL to be used as a placeholder when a page reference cannot be found in ref or relref. Is used as-is.
 	RefLinksNotFoundURL string

@@ -526,7 +569,7 @@ type RootConfig struct {
 	// See Modules for more a more flexible way to load themes.
 	Theme []string

-	// Timeout for generating page contents, specified as a duration or in milliseconds.
+	// Timeout for generating page contents, specified as a duration or in seconds.
 	Timeout string

 	// The time zone (or location), e.g. Europe/Oslo, used to parse front matter dates without such information and in the time function.
@@ -700,7 +743,8 @@ func fromLoadConfigResult(fs afero.Fs, logger loggers.Logger, res config.LoadCon
 	cfg := res.Cfg

 	all := &Config{}
-	err := decodeConfigFromParams(fs, bcfg, cfg, all, nil)
+
+	err := decodeConfigFromParams(fs, logger, bcfg, cfg, all, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -787,12 +831,14 @@ func fromLoadConfigResult(fs afero.Fs, logger loggers.Logger, res config.LoadCon

 			// Create a copy of the complete config and replace the root keys with the language specific ones.
 			clone := all.cloneForLang()
-			if err := decodeConfigFromParams(fs, bcfg, mergedConfig, clone, differentRootKeys); err != nil {
+
+			if err := decodeConfigFromParams(fs, logger, bcfg, mergedConfig, clone, differentRootKeys); err != nil {
 				return nil, fmt.Errorf("failed to decode config for language %q: %w", k, err)
 			}
 			if err := clone.CompileConfig(logger); err != nil {
 				return nil, err
 			}
+
 			langConfigMap[k] = clone
 		case maps.ParamsMergeStrategy:
 		default:
@@ -840,6 +886,10 @@ func fromLoadConfigResult(fs afero.Fs, logger loggers.Logger, res config.LoadCon

 	bcfg.PublishDir = all.PublishDir
 	res.BaseConfig = bcfg
+	all.CommonDirs.CacheDir = bcfg.CacheDir
+	for _, l := range langConfigs {
+		l.CommonDirs.CacheDir = bcfg.CacheDir
+	}

 	cm := &Configs{
 		Base:                  all,
@@ -854,7 +904,7 @@ func fromLoadConfigResult(fs afero.Fs, logger loggers.Logger, res config.LoadCon
 	return cm, nil
 }

-func decodeConfigFromParams(fs afero.Fs, bcfg config.BaseConfig, p config.Provider, target *Config, keys []string) error {
+func decodeConfigFromParams(fs afero.Fs, logger loggers.Logger, bcfg config.BaseConfig, p config.Provider, target *Config, keys []string) error {

 	var decoderSetups []decodeWeight

@@ -867,7 +917,7 @@ func decodeConfigFromParams(fs afero.Fs, bcfg config.BaseConfig, p config.Provid
 			if v, found := allDecoderSetups[key]; found {
 				decoderSetups = append(decoderSetups, v)
 			} else {
-				return fmt.Errorf("unknown config key %q", key)
+				logger.Warnf("Skip unknown config key %q", key)
 			}
 		}
 	}
@@ -904,11 +954,11 @@ func createDefaultOutputFormats(allFormats output.Formats) map[string][]string {
 	}

 	m := map[string][]string{
-		page.KindPage:     {htmlOut.Name},
-		page.KindHome:     defaultListTypes,
-		page.KindSection:  defaultListTypes,
-		page.KindTerm:     defaultListTypes,
-		page.KindTaxonomy: defaultListTypes,
+		kinds.KindPage:     {htmlOut.Name},
+		kinds.KindHome:     defaultListTypes,
+		kinds.KindSection:  defaultListTypes,
+		kinds.KindTerm:     defaultListTypes,
+		kinds.KindTaxonomy: defaultListTypes,
 	}

 	// May be disabled
@@ -49,10 +49,11 @@ type decodeConfig struct {
 }

 type decodeWeight struct {
-	key         string
-	decode      func(decodeWeight, decodeConfig) error
-	getCompiler func(c *Config) configCompiler
-	weight      int
+	key                  string
+	decode               func(decodeWeight, decodeConfig) error
+	getCompiler          func(c *Config) configCompiler
+	weight               int
+	internalOrDeprecated bool // Hide it from the docs.
 }

 var allDecoderSetups = map[string]decodeWeight{
@@ -138,8 +139,8 @@ var allDecoderSetups = map[string]decodeWeight{
 			return err
 		},
 	},
-	"mediaTypes": {
-		key: "mediaTypes",
+	"mediatypes": {
+		key: "mediatypes",
 		decode: func(d decodeWeight, p decodeConfig) error {
 			var err error
 			p.c.MediaTypes, err = media.DecodeTypes(p.p.GetStringMap(d.key))
@@ -150,7 +151,7 @@ var allDecoderSetups = map[string]decodeWeight{
 		key: "outputs",
 		decode: func(d decodeWeight, p decodeConfig) error {
 			defaults := createDefaultOutputFormats(p.c.OutputFormats.Config)
-			m := p.p.GetStringMap("outputs")
+			m := maps.CleanConfigStringMap(p.p.GetStringMap("outputs"))
 			p.c.Outputs = make(map[string][]string)
 			for k, v := range m {
 				s := types.ToStringSlicePreserveString(v)
@@ -168,8 +169,8 @@ var allDecoderSetups = map[string]decodeWeight{
 			return nil
 		},
 	},
-	"outputFormats": {
-		key: "outputFormats",
+	"outputformats": {
+		key: "outputformats",
 		decode: func(d decodeWeight, p decodeConfig) error {
 			var err error
 			p.c.OutputFormats, err = output.DecodeConfig(p.c.MediaTypes.Config, p.p.Get(d.key))
@@ -206,8 +207,9 @@ var allDecoderSetups = map[string]decodeWeight{
 	"permalinks": {
 		key: "permalinks",
 		decode: func(d decodeWeight, p decodeConfig) error {
-			p.c.Permalinks = maps.CleanConfigStringMapString(p.p.GetStringMapString(d.key))
-			return nil
+			var err error
+			p.c.Permalinks, err = page.DecodePermalinksConfig(p.p.GetStringMap(d.key))
+			return err
 		},
 	},
 	"sitemap": {
@@ -238,7 +240,7 @@ var allDecoderSetups = map[string]decodeWeight{
 			} else {
 				p.c.Related = related.DefaultConfig
 				if _, found := p.c.Taxonomies["tag"]; found {
-					p.c.Related.Add(related.IndexConfig{Name: "tags", Weight: 80})
+					p.c.Related.Add(related.IndexConfig{Name: "tags", Weight: 80, Type: related.TypeBasic})
 				}
 			}
 			return nil
@@ -336,16 +338,18 @@ var allDecoderSetups = map[string]decodeWeight{
 	"author": {
 		key: "author",
 		decode: func(d decodeWeight, p decodeConfig) error {
-			p.c.Author = p.p.GetStringMap(d.key)
+			p.c.Author = maps.CleanConfigStringMap(p.p.GetStringMap(d.key))
 			return nil
 		},
+		internalOrDeprecated: true,
 	},
 	"social": {
 		key: "social",
 		decode: func(d decodeWeight, p decodeConfig) error {
-			p.c.Social = p.p.GetStringMapString(d.key)
+			p.c.Social = maps.CleanConfigStringMapString(p.p.GetStringMapString(d.key))
 			return nil
 		},
+		internalOrDeprecated: true,
 	},
 	"uglyurls": {
 		key: "uglyurls",
@@ -361,11 +365,29 @@ var allDecoderSetups = map[string]decodeWeight{
 			}
 			return nil
 		},
+		internalOrDeprecated: true,
 	},
 	"internal": {
 		key: "internal",
 		decode: func(d decodeWeight, p decodeConfig) error {
 			return mapstructure.WeakDecode(p.p.GetStringMap(d.key), &p.c.Internal)
 		},
+		internalOrDeprecated: true,
 	},
 }
+
+func init() {
+	for k, v := range allDecoderSetups {
+		// Verify that k and v.key is all lower case.
+		if k != strings.ToLower(k) {
+			panic(fmt.Sprintf("key %q is not lower case", k))
+		}
+		if v.key != strings.ToLower(v.key) {
+			panic(fmt.Sprintf("key %q is not lower case", v.key))
+		}
+
+		if k != v.key {
+			panic(fmt.Sprintf("key %q is not the same as the map key %q", k, v.key))
+		}
+	}
+}
@@ -41,6 +41,16 @@ func (c ConfigLanguage) LanguagesDefaultFirst() langs.Languages {
 	return c.m.LanguagesDefaultFirst
 }

+func (c ConfigLanguage) LanguagePrefix() string {
+	if c.DefaultContentLanguageInSubdir() && c.DefaultContentLanguage() == c.Language().Lang {
+		return c.Language().Lang
+	}
+	if !c.IsMultiLingual() || c.DefaultContentLanguage() == c.Language().Lang {
+		return ""
+	}
+	return c.Language().Lang
+}
+
 func (c ConfigLanguage) BaseURL() urls.BaseURL {
 	return c.config.C.BaseURL
 }
@@ -130,7 +140,7 @@ func (c ConfigLanguage) GetConfigSection(s string) any {
 		return c.config.Permalinks
 	case "minify":
 		return c.config.Minify
-	case "activeModules":
+	case "allModules":
 		return c.m.Modules
 	case "deployment":
 		return c.config.Deployment
@@ -199,8 +209,8 @@ func (c ConfigLanguage) EnableMissingTranslationPlaceholders() bool {
 	return c.config.EnableMissingTranslationPlaceholders
 }

-func (c ConfigLanguage) LogI18nWarnings() bool {
-	return c.config.LogI18nWarnings
+func (c ConfigLanguage) PrintI18nWarnings() bool {
+	return c.config.PrintI18nWarnings
 }

 func (c ConfigLanguage) CreateTitle(s string) string {
@@ -1,4 +1,4 @@
-// Copyright 2021 The Hugo Authors. All rights reserved.
+// Copyright 2023 The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -11,10 +11,11 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

-package config
+package allconfig

 import (
 	"github.com/gohugoio/hugo/common/maps"
+	"github.com/gohugoio/hugo/config"
 	"github.com/gohugoio/hugo/docshelper"
 )

@@ -22,8 +23,11 @@ import (
 func init() {
 	docsProvider := func() docshelper.DocProvider {

-		cfg := New()
-		for _, configRoot := range ConfigRootKeys {
+		cfg := config.New()
+		for configRoot, v := range allDecoderSetups {
+			if v.internalOrDeprecated {
+				continue
+			}
 			cfg.Set(configRoot, make(maps.Params))
 		}
 		lang := maps.Params{
@@ -38,7 +42,7 @@ func init() {
 		configHelpers := map[string]any{
 			"mergeStrategy": cfg.Get(""),
 		}
-		return docshelper.DocProvider{"config": configHelpers}
+		return docshelper.DocProvider{"config_helpers": configHelpers}
 	}

 	docshelper.AddDocProviderFunc(docsProvider)
@@ -69,3 +69,21 @@ Title: {{ .Title }}
 	b.Assert(modConf.Mounts[1].Lang, qt.Equals, "sv")

 }
+
+func TestConfigAliases(t *testing.T) {
+
+	files := `
+-- hugo.toml --
+baseURL = "https://example.com"
+logI18nWarnings = true
+logPathWarnings = true
+`
+	b := hugolib.NewIntegrationTestBuilder(
+		hugolib.IntegrationTestConfig{T: t, TxtarString: files},
+	).Build()
+
+	conf := b.H.Configs.Base
+
+	b.Assert(conf.PrintI18nWarnings, qt.Equals, true)
+	b.Assert(conf.PrintPathWarnings, qt.Equals, true)
+}
@@ -34,6 +34,7 @@ import (
 	hglob "github.com/gohugoio/hugo/hugofs/glob"
 	"github.com/gohugoio/hugo/modules"
 	"github.com/gohugoio/hugo/parser/metadecoders"
+	"github.com/gohugoio/hugo/tpl"
 	"github.com/spf13/afero"
 )

@@ -45,7 +46,7 @@ func LoadConfig(d ConfigSourceDescriptor) (*Configs, error) {
 	}

 	if d.Logger == nil {
-		d.Logger = loggers.NewErrorLogger()
+		d.Logger = loggers.NewDefault()
 	}

 	l := &configLoader{ConfigSourceDescriptor: d, cfg: config.New()}
@@ -78,17 +79,22 @@ func LoadConfig(d ConfigSourceDescriptor) (*Configs, error) {
 		if err := configs.transientErr(); err != nil {
 			return nil, fmt.Errorf("failed to create config from modules config: %w", err)
 		}
+		configs.LoadingInfo.ConfigFiles = append(configs.LoadingInfo.ConfigFiles, l.ModulesConfigFiles...)
 	} else if err := configs.transientErr(); err != nil {
 		return nil, fmt.Errorf("failed to create config: %w", err)
 	}

-	configs.Modules = moduleConfig.ActiveModules
+	configs.Modules = moduleConfig.AllModules
 	configs.ModulesClient = modulesClient

 	if err := configs.Init(); err != nil {
 		return nil, fmt.Errorf("failed to init config: %w", err)
 	}

+	// This is unfortunate, but these are global settings.
+	tpl.SetSecurityAllowActionJSTmpl(configs.Base.Security.GoTemplates.AllowActionJSTmpl)
+	loggers.InitGlobalLogger(configs.Base.PanicOnWarning)
+
 	return configs, nil

 }
@@ -134,7 +140,11 @@ type configLoader struct {

 // Handle some legacy values.
 func (l configLoader) applyConfigAliases() error {
-	aliases := []types.KeyValueStr{{Key: "taxonomies", Value: "indexes"}}
+	aliases := []types.KeyValueStr{
+		{Key: "indexes", Value: "taxonomies"},
+		{Key: "logI18nWarnings", Value: "printI18nWarnings"},
+		{Key: "logPathWarnings", Value: "printPathWarnings"},
+	}

 	for _, alias := range aliases {
 		if l.cfg.IsSet(alias.Key) {
@@ -284,17 +294,45 @@ func (l configLoader) applyOsEnvOverrides(environ []string) error {
 			} else {
 				l.cfg.Set(env.Key, val)
 			}
-		} else if nestedKey != "" {
-			owner[nestedKey] = env.Value
 		} else {
-			// The container does not exist yet.
-			l.cfg.Set(strings.ReplaceAll(env.Key, delim, "."), env.Value)
+			if nestedKey != "" {
+				owner[nestedKey] = env.Value
+			} else {
+				var val any
+				key := strings.ReplaceAll(env.Key, delim, ".")
+				_, ok := allDecoderSetups[key]
+				if ok {
+					// A map.
+					if v, err := metadecoders.Default.UnmarshalStringTo(env.Value, map[string]interface{}{}); err == nil {
+						val = v
+					}
+				}
+				if val == nil {
+					// A string.
+					val = l.envStringToVal(key, env.Value)
+				}
+				l.cfg.Set(key, val)
+			}
 		}
 	}

 	return nil
 }

+func (l *configLoader) envStringToVal(k, v string) any {
+	switch k {
+	case "disablekinds", "disablelanguages":
+		if strings.Contains(v, ",") {
+			return strings.Split(v, ",")
+		} else {
+			return strings.Fields(v)
+		}
+	default:
+		return v
+	}
+
+}
+
 func (l *configLoader) loadConfigMain(d ConfigSourceDescriptor) (config.LoadConfigResult, modules.ModulesConfig, error) {
 	var res config.LoadConfigResult

@@ -433,7 +471,7 @@ func (l *configLoader) loadModules(configs *Configs) (modules.ModulesConfig, *mo
 	ex := hexec.New(conf.Security)

 	hook := func(m *modules.ModulesConfig) error {
-		for _, tc := range m.ActiveModules {
+		for _, tc := range m.AllModules {
 			if len(tc.ConfigFilenames()) > 0 {
 				if tc.Watch() {
 					l.ModulesConfigFiles = append(l.ModulesConfigFiles, tc.ConfigFilenames()...)
@@ -19,6 +19,7 @@ import (
 	"sort"
 	"strings"

+	"github.com/bep/logg"
 	"github.com/gobwas/glob"
 	"github.com/gohugoio/hugo/common/loggers"
 	"github.com/gohugoio/hugo/common/types"
@@ -81,7 +82,7 @@ type LoadConfigResult struct {

 var defaultBuild = BuildConfig{
 	UseResourceCacheWhen: "fallback",
-	WriteStats:           false,
+	BuildStats:           BuildStats{},

 	CacheBusters: []CacheBuster{
 		{
@@ -96,7 +97,7 @@ var defaultBuild = BuildConfig{
 			Source: `(postcss|tailwind)\.config\.js`,
 			Target: cssTargetCachebusterRe,
 		},
-		// This is deliberatly coarse grained; it will cache bust resources with "json" in the cache key when js files changes, which is good.
+		// This is deliberately coarse grained; it will cache bust resources with "json" in the cache key when js files changes, which is good.
 		{
 			Source: `assets/.*\.(.*)$`,
 			Target: `$1`,
@@ -110,9 +111,10 @@ type BuildConfig struct {

 	// When enabled, will collect and write a hugo_stats.json with some build
 	// related aggregated data (e.g. CSS class names).
-	WriteStats bool
+	// Note that this was a bool <= v0.115.0.
+	BuildStats BuildStats

-	// Can be used to toggle off writing of the intellinsense /assets/jsconfig.js
+	// Can be used to toggle off writing of the IntelliSense /assets/jsconfig.js
 	// file.
 	NoJSConfigInAssets bool

@@ -120,6 +122,21 @@ type BuildConfig struct {
 	CacheBusters []CacheBuster
 }

+// BuildStats configures if and what to write to the hugo_stats.json file.
+type BuildStats struct {
+	Enable         bool
+	DisableTags    bool
+	DisableClasses bool
+	DisableIDs     bool
+}
+
+func (w BuildStats) Enabled() bool {
+	if !w.Enable {
+		return false
+	}
+	return !w.DisableTags || !w.DisableClasses || !w.DisableIDs
+}
+
 func (b BuildConfig) clone() BuildConfig {
 	b.CacheBusters = append([]CacheBuster{}, b.CacheBusters...)
 	return b
@@ -131,7 +148,7 @@ func (b BuildConfig) UseResourceCache(err error) bool {
 	}

 	if b.UseResourceCacheWhen == "fallback" {
-		return err == herrors.ErrFeatureNotAvailable
+		return herrors.IsFeatureNotAvailableError(err)
 	}

 	return true
@@ -170,14 +187,22 @@ func (b *BuildConfig) CompileConfig(logger loggers.Logger) error {

 func DecodeBuildConfig(cfg Provider) BuildConfig {
 	m := cfg.GetStringMap("build")
+
 	b := defaultBuild.clone()
 	if m == nil {
 		return b
 	}

+	// writeStats was a bool <= v0.115.0.
+	if writeStats, ok := m["writestats"]; ok {
+		if bb, ok := writeStats.(bool); ok {
+			m["buildstats"] = BuildStats{Enable: bb}
+		}
+	}
+
 	err := mapstructure.WeakDecode(m, &b)
 	if err != nil {
-		return defaultBuild
+		return b
 	}

 	b.UseResourceCacheWhen = strings.ToLower(b.UseResourceCacheWhen)
@@ -306,13 +331,16 @@ func (c *CacheBuster) CompileConfig(logger loggers.Logger) error {
 	if c.compiledSource != nil {
 		return nil
 	}
+
 	source := c.Source
-	target := c.Target
 	sourceRe, err := regexp.Compile(source)
 	if err != nil {
 		return fmt.Errorf("failed to compile cache buster source %q: %w", c.Source, err)
 	}
+	target := c.Target
 	var compileErr error
+	debugl := logger.Logger().WithLevel(logg.LevelDebug).WithField(loggers.FieldNameCmd, "cachebuster")
+
 	c.compiledSource = func(s string) func(string) bool {
 		m := sourceRe.FindStringSubmatch(s)
 		matchString := "no match"
@@ -320,28 +348,28 @@ func (c *CacheBuster) CompileConfig(logger loggers.Logger) error {
 		if match {
 			matchString = "match!"
 		}
-		logger.Debugf("cachebuster: Matching %q with source %q: %s\n", s, source, matchString)
+		debugl.Logf("Matching %q with source %q: %s", s, source, matchString)
 		if !match {
 			return nil
 		}
 		groups := m[1:]
+		currentTarget := target
 		// Replace $1, $2 etc. in target.
-
 		for i, g := range groups {
-			target = strings.ReplaceAll(target, fmt.Sprintf("$%d", i+1), g)
+			currentTarget = strings.ReplaceAll(target, fmt.Sprintf("$%d", i+1), g)
 		}
-		targetRe, err := regexp.Compile(target)
+		targetRe, err := regexp.Compile(currentTarget)
 		if err != nil {
-			compileErr = fmt.Errorf("failed to compile cache buster target %q: %w", target, err)
+			compileErr = fmt.Errorf("failed to compile cache buster target %q: %w", currentTarget, err)
 			return nil
 		}
-		return func(s string) bool {
-			match = targetRe.MatchString(s)
+		return func(ss string) bool {
+			match = targetRe.MatchString(ss)
 			matchString := "no match"
 			if match {
 				matchString = "match!"
 			}
-			logger.Debugf("cachebuster: Matching %q with target %q: %s\n", s, target, matchString)
+			logger.Debugf("Matching %q with target %q: %s", ss, currentTarget, matchString)

 			return match
 		}
@@ -92,7 +92,7 @@ status = 301

 	s, err := DecodeServer(cfg)
 	c.Assert(err, qt.IsNil)
-	c.Assert(s.CompileConfig(loggers.NewErrorLogger()), qt.IsNil)
+	c.Assert(s.CompileConfig(loggers.NewDefault()), qt.IsNil)

 	c.Assert(s.MatchHeaders("/foo.jpg"), qt.DeepEquals, []types.KeyValueStr{
 		{Key: "X-Content-Type-Options", Value: "nosniff"},
@@ -145,7 +145,7 @@ func TestBuildConfigCacheBusters(t *testing.T) {
 	c := qt.New(t)
 	cfg := New()
 	conf := DecodeBuildConfig(cfg)
-	l := loggers.NewInfoLogger()
+	l := loggers.NewDefault()
 	c.Assert(conf.CompileConfig(l), qt.IsNil)

 	m, err := conf.MatchCacheBuster(l, "assets/foo/main.js")
@@ -164,3 +164,36 @@ func TestBuildConfigCacheBusters(t *testing.T) {
 	c.Assert(m("json"), qt.IsTrue)

 }
+
+func TestBuildConfigCacheBusterstTailwindSetup(t *testing.T) {
+	c := qt.New(t)
+	cfg := New()
+	cfg.Set("build", map[string]interface{}{
+		"cacheBusters": []map[string]string{
+			{
+				"source": "assets/watching/hugo_stats\\.json",
+				"target": "css",
+			},
+			{
+				"source": "(postcss|tailwind)\\.config\\.js",
+				"target": "css",
+			},
+			{
+				"source": "assets/.*\\.(js|ts|jsx|tsx)",
+				"target": "js",
+			},
+			{
+				"source": "assets/.*\\.(.*)$",
+				"target": "$1",
+			},
+		},
+	})
+
+	conf := DecodeBuildConfig(cfg)
+	l := loggers.NewDefault()
+	c.Assert(conf.CompileConfig(l), qt.IsNil)
+
+	m, err := conf.MatchCacheBuster(l, "assets/watching/hugo_stats.json")
+	c.Assert(err, qt.IsNil)
+	c.Assert(m("css"), qt.IsTrue)
+}
@@ -157,7 +157,7 @@ func LoadConfigFromDir(sourceFs afero.Fs, configDir, environment string) (Provid
 			if err != nil {
 				// This will be used in error reporting, use the most specific value.
 				dirnames = []string{path}
-				return fmt.Errorf("failed to unmarshl config for path %q: %w", path, err)
+				return fmt.Errorf("failed to unmarshal config for path %q: %w", path, err)
 			}

 			var keyPath []string
@@ -27,6 +27,7 @@ type AllProvider interface {
 	Language() *langs.Language
 	Languages() langs.Languages
 	LanguagesDefaultFirst() langs.Languages
+	LanguagePrefix() string
 	BaseURL() urls.BaseURL
 	BaseURLLiveReload() urls.BaseURL
 	Environment() string
@@ -57,7 +58,7 @@ type AllProvider interface {
 	EnableMissingTranslationPlaceholders() bool
 	TemplateMetrics() bool
 	TemplateMetricsHints() bool
-	LogI18nWarnings() bool
+	PrintI18nWarnings() bool
 	CreateTitle(s string) string
 	IgnoreFile(s string) bool
 	NewContentEditor() string
@@ -1,26 +0,0 @@
-// Copyright 2021 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package security
-
-import (
-	"github.com/gohugoio/hugo/docshelper"
-)
-
-func init() {
-	docsProvider := func() docshelper.DocProvider {
-
-		return docshelper.DocProvider{"config": DefaultConfig.ToSecurityMap()}
-	}
-	docshelper.AddDocProviderFunc(docsProvider)
-}
@@ -34,22 +34,22 @@ const securityConfigKey = "security"
 // DefaultConfig holds the default security policy.
 var DefaultConfig = Config{
 	Exec: Exec{
-		Allow: NewWhitelist(
-			"^dart-sass-embedded$",
-			"^go$",  // for Go Modules
-			"^npx$", // used by all Node tools (Babel, PostCSS).
+		Allow: MustNewWhitelist(
+			"^(dart-)?sass(-embedded)?$", // sass, dart-sass, dart-sass-embedded.
+			"^go$",                       // for Go Modules
+			"^npx$",                      // used by all Node tools (Babel, PostCSS).
 			"^postcss$",
 		),
 		// These have been tested to work with Hugo's external programs
 		// on Windows, Linux and MacOS.
-		OsEnv: NewWhitelist(`(?i)^((HTTPS?|NO)_PROXY|PATH(EXT)?|APPDATA|TE?MP|TERM|GO\w+)$`),
+		OsEnv: MustNewWhitelist(`(?i)^((HTTPS?|NO)_PROXY|PATH(EXT)?|APPDATA|TE?MP|TERM|GO\w+|(XDG_CONFIG_)?HOME|USERPROFILE|SSH_AUTH_SOCK|DISPLAY|LANG)$`),
 	},
 	Funcs: Funcs{
-		Getenv: NewWhitelist("^HUGO_", "^CI$"),
+		Getenv: MustNewWhitelist("^HUGO_", "^CI$"),
 	},
 	HTTP: HTTP{
-		URLs:    NewWhitelist(".*"),
-		Methods: NewWhitelist("(?i)GET|POST"),
+		URLs:    MustNewWhitelist(".*"),
+		Methods: MustNewWhitelist("(?i)GET|POST"),
 	},
 }

@@ -68,6 +68,9 @@ type Config struct {

 	// Allow inline shortcodes
 	EnableInlineShortcodes bool `json:"enableInlineShortcodes"`
+
+	// Go templates related security config.
+	GoTemplates GoTemplates `json:"goTemplates"`
 }

 // Exec holds os/exec policies.
@@ -93,6 +96,15 @@ type HTTP struct {
 	MediaTypes Whitelist `json:"mediaTypes"`
 }

+type GoTemplates struct {
+
+	// Enable to allow template actions inside bakcticks in ES6 template literals.
+	// This was blocked in Hugo 0.114.0 for security reasons and you now get errors on the form
+	// "... appears in a JS template literal" if you have this in your templates.
+	// See https://github.com/golang/go/issues/59234
+	AllowActionJSTmpl bool
+}
+
 // ToTOML converts c to TOML with [security] as the root.
 func (c Config) ToTOML() string {
 	sec := c.ToSecurityMap()
@@ -209,7 +221,7 @@ func stringSliceToWhitelistHook() mapstructure.DecodeHookFuncType {

 		wl := types.ToStringSlicePreserveString(data)

-		return NewWhitelist(wl...), nil
+		return NewWhitelist(wl...)

 	}
 }
@@ -140,7 +140,7 @@ func TestToTOML(t *testing.T) {
 	got := DefaultConfig.ToTOML()

 	c.Assert(got, qt.Equals,
-		"[security]\n  enableInlineShortcodes = false\n\n  [security.exec]\n    allow = ['^dart-sass-embedded$', '^go$', '^npx$', '^postcss$']\n    osEnv = ['(?i)^((HTTPS?|NO)_PROXY|PATH(EXT)?|APPDATA|TE?MP|TERM|GO\\w+)$']\n\n  [security.funcs]\n    getenv = ['^HUGO_', '^CI$']\n\n  [security.http]\n    methods = ['(?i)GET|POST']\n    urls = ['.*']",
+		"[security]\n  enableInlineShortcodes = false\n\n  [security.exec]\n    allow = ['^(dart-)?sass(-embedded)?$', '^go$', '^npx$', '^postcss$']\n    osEnv = ['(?i)^((HTTPS?|NO)_PROXY|PATH(EXT)?|APPDATA|TE?MP|TERM|GO\\w+|(XDG_CONFIG_)?HOME|USERPROFILE|SSH_AUTH_SOCK|DISPLAY|LANG)$']\n\n  [security.funcs]\n    getenv = ['^HUGO_', '^CI$']\n\n  [security.goTemplates]\n    AllowActionJSTmpl = false\n\n  [security.http]\n    methods = ['(?i)GET|POST']\n    urls = ['.*']",
 	)
 }

@@ -154,9 +154,6 @@ func TestDecodeConfigDefault(t *testing.T) {
 	c.Assert(pc.Exec.Allow.Accept("a"), qt.IsFalse)
 	c.Assert(pc.Exec.Allow.Accept("npx"), qt.IsTrue)
 	c.Assert(pc.Exec.Allow.Accept("Npx"), qt.IsFalse)
-	c.Assert(pc.Exec.OsEnv.Accept("a"), qt.IsFalse)
-	c.Assert(pc.Exec.OsEnv.Accept("PATH"), qt.IsTrue)
-	c.Assert(pc.Exec.OsEnv.Accept("e"), qt.IsFalse)

 	c.Assert(pc.HTTP.URLs.Accept("https://example.org"), qt.IsTrue)
 	c.Assert(pc.HTTP.Methods.Accept("POST"), qt.IsTrue)
@@ -167,6 +164,10 @@ func TestDecodeConfigDefault(t *testing.T) {

 	c.Assert(pc.Exec.OsEnv.Accept("PATH"), qt.IsTrue)
 	c.Assert(pc.Exec.OsEnv.Accept("GOROOT"), qt.IsTrue)
+	c.Assert(pc.Exec.OsEnv.Accept("HOME"), qt.IsTrue)
+	c.Assert(pc.Exec.OsEnv.Accept("SSH_AUTH_SOCK"), qt.IsTrue)
+	c.Assert(pc.Exec.OsEnv.Accept("a"), qt.IsFalse)
+	c.Assert(pc.Exec.OsEnv.Accept("e"), qt.IsFalse)
 	c.Assert(pc.Exec.OsEnv.Accept("MYSECRET"), qt.IsFalse)

 }
@@ -45,9 +45,9 @@ func (w Whitelist) MarshalJSON() ([]byte, error) {
 // NewWhitelist creates a new Whitelist from zero or more patterns.
 // An empty patterns list or a pattern with the value 'none' will create
 // a whitelist that will Accept none.
-func NewWhitelist(patterns ...string) Whitelist {
+func NewWhitelist(patterns ...string) (Whitelist, error) {
 	if len(patterns) == 0 {
-		return Whitelist{acceptNone: true}
+		return Whitelist{acceptNone: true}, nil
 	}

 	var acceptSome bool
@@ -68,7 +68,7 @@ func NewWhitelist(patterns ...string) Whitelist {
 	if !acceptSome {
 		return Whitelist{
 			acceptNone: true,
-		}
+		}, nil
 	}

 	var patternsr []*regexp.Regexp
@@ -78,10 +78,23 @@ func NewWhitelist(patterns ...string) Whitelist {
 		if p == "" {
 			continue
 		}
-		patternsr = append(patternsr, regexp.MustCompile(p))
+		re, err := regexp.Compile(p)
+		if err != nil {
+			return Whitelist{}, fmt.Errorf("failed to compile whitelist pattern %q: %w", p, err)
+		}
+		patternsr = append(patternsr, re)
 	}

-	return Whitelist{patterns: patternsr, patternsStrings: patternsStrings}
+	return Whitelist{patterns: patternsr, patternsStrings: patternsStrings}, nil
+}
+
+// MustNewWhitelist creates a new Whitelist from zero or more patterns and panics on error.
+func MustNewWhitelist(patterns ...string) Whitelist {
+	w, err := NewWhitelist(patterns...)
+	if err != nil {
+		panic(err)
+	}
+	return w
 }

 // Accept reports whether name is whitelisted.
@@ -24,21 +24,21 @@ func TestWhitelist(t *testing.T) {
 	c := qt.New(t)

 	c.Run("none", func(c *qt.C) {
-		c.Assert(NewWhitelist("none", "foo").Accept("foo"), qt.IsFalse)
-		c.Assert(NewWhitelist().Accept("foo"), qt.IsFalse)
-		c.Assert(NewWhitelist("").Accept("foo"), qt.IsFalse)
-		c.Assert(NewWhitelist("  ", " ").Accept("foo"), qt.IsFalse)
+		c.Assert(MustNewWhitelist("none", "foo").Accept("foo"), qt.IsFalse)
+		c.Assert(MustNewWhitelist().Accept("foo"), qt.IsFalse)
+		c.Assert(MustNewWhitelist("").Accept("foo"), qt.IsFalse)
+		c.Assert(MustNewWhitelist("  ", " ").Accept("foo"), qt.IsFalse)
 		c.Assert(Whitelist{}.Accept("foo"), qt.IsFalse)
 	})

 	c.Run("One", func(c *qt.C) {
-		w := NewWhitelist("^foo.*")
+		w := MustNewWhitelist("^foo.*")
 		c.Assert(w.Accept("foo"), qt.IsTrue)
 		c.Assert(w.Accept("mfoo"), qt.IsFalse)
 	})

 	c.Run("Multiple", func(c *qt.C) {
-		w := NewWhitelist("^foo.*", "^bar.*")
+		w := MustNewWhitelist("^foo.*", "^bar.*")
 		c.Assert(w.Accept("foo"), qt.IsTrue)
 		c.Assert(w.Accept("bar"), qt.IsTrue)
 		c.Assert(w.Accept("mbar"), qt.IsFalse)
@@ -41,7 +41,7 @@ func GetTestConfigs(fs afero.Fs, cfg config.Provider) *allconfig.Configs {
 		}
 	}

-	configs, err := allconfig.LoadConfig(allconfig.ConfigSourceDescriptor{Fs: fs, Flags: cfg})
+	configs, err := allconfig.LoadConfig(allconfig.ConfigSourceDescriptor{Fs: fs, Flags: cfg, Environ: []string{"EMPTY_TEST_ENVIRONMENT"}})
 	if err != nil {
 		panic(err)
 	}
@@ -42,7 +42,7 @@ const (
 	// DefaultArchetypeTemplateTemplate is the template used in 'hugo new site'
 	// and the template we use as a fall back.
 	DefaultArchetypeTemplateTemplate = `---
-title: "{{ replace .Name "-" " " | title }}"
+title: "{{ replace .File.ContentBaseName "-" " " | title }}"
 date: {{ .Date }}
 draft: true
 ---
@@ -0,0 +1,5 @@
+++
+title = '{{ replace .File.ContentBaseName "-" " " | title }}'
+date = {{ .Date }}
+draft = true
+++
@@ -0,0 +1,111 @@
+// Copyright 2023 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package skeletons
+
+import (
+	"bytes"
+	"embed"
+	"errors"
+	"io/fs"
+	"path/filepath"
+	"strings"
+
+	"github.com/gohugoio/hugo/helpers"
+	"github.com/gohugoio/hugo/parser"
+	"github.com/gohugoio/hugo/parser/metadecoders"
+	"github.com/spf13/afero"
+)
+
+//go:embed all:site/*
+var siteFs embed.FS
+
+//go:embed all:theme/*
+var themeFs embed.FS
+
+// CreateTheme creates a theme skeleton.
+func CreateTheme(createpath string, sourceFs afero.Fs) error {
+	if exists, _ := helpers.Exists(createpath, sourceFs); exists {
+		return errors.New(createpath + " already exists")
+	}
+	return copyFiles(createpath, sourceFs, themeFs)
+}
+
+// CreateSite creates a site skeleton.
+func CreateSite(createpath string, sourceFs afero.Fs, force bool, format string) error {
+	format = strings.ToLower(format)
+	if exists, _ := helpers.Exists(createpath, sourceFs); exists {
+		if isDir, _ := helpers.IsDir(createpath, sourceFs); !isDir {
+			return errors.New(createpath + " already exists but not a directory")
+		}
+
+		isEmpty, _ := helpers.IsEmpty(createpath, sourceFs)
+
+		switch {
+		case !isEmpty && !force:
+			return errors.New(createpath + " already exists and is not empty. See --force.")
+		case !isEmpty && force:
+			var all []string
+			fs.WalkDir(siteFs, ".", func(path string, d fs.DirEntry, err error) error {
+				if d.IsDir() && path != "." {
+					all = append(all, path)
+				}
+				return nil
+			})
+			all = append(all, filepath.Join(createpath, "hugo."+format))
+			for _, path := range all {
+				if exists, _ := helpers.Exists(path, sourceFs); exists {
+					return errors.New(path + " already exists")
+				}
+			}
+		}
+	}
+
+	err := newSiteCreateConfig(sourceFs, createpath, format)
+	if err != nil {
+		return err
+	}
+
+	return copyFiles(createpath, sourceFs, siteFs)
+}
+
+func copyFiles(createpath string, sourceFs afero.Fs, skeleton embed.FS) error {
+	return fs.WalkDir(skeleton, ".", func(path string, d fs.DirEntry, err error) error {
+		_, slug, _ := strings.Cut(path, "/")
+		if d.IsDir() {
+			return sourceFs.MkdirAll(filepath.Join(createpath, slug), 0777)
+		} else {
+			if filepath.Base(path) != ".gitkeep" {
+				data, _ := fs.ReadFile(skeleton, path)
+				return helpers.WriteToDisk(filepath.Join(createpath, slug), bytes.NewReader(data), sourceFs)
+			}
+			return nil
+		}
+	})
+}
+
+func newSiteCreateConfig(fs afero.Fs, createpath string, format string) (err error) {
+	in := map[string]string{
+		"baseURL":      "https://example.org/",
+		"title":        "My New Hugo Site",
+		"languageCode": "en-us",
+	}
+
+	var buf bytes.Buffer
+	err = parser.InterfaceToConfig(in, metadecoders.FormatFromString(format), &buf)
+	if err != nil {
+		return err
+	}
+
+	return helpers.WriteToDisk(filepath.Join(createpath, "hugo."+format), &buf, fs)
+}
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [year] [fullname]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
@@ -0,0 +1,7 @@
+# Theme Name
+
+## Features
+
+## Installation
+
+## Configuration
@@ -0,0 +1,5 @@
+++
+title = '{{ replace .File.ContentBaseName "-" " " | title }}'
+date = {{ .Date }}
+draft = true
+++
@@ -0,0 +1,22 @@
+body {
+  color: #222;
+  font-family: sans-serif;
+  line-height: 1.5;
+  margin: 1rem;
+  max-width: 768px;
+}
+
+header {
+  border-bottom: 1px solid #222;
+  margin-bottom: 1rem;
+}
+
+footer {
+  border-top: 1px solid #222;
+  margin-top: 1rem;
+}
+
+a {
+  color: #00e;
+  text-decoration: none;
+}
@@ -0,0 +1 @@
+console.log('This site was generated by Hugo.');
@@ -0,0 +1,9 @@
+++
+title = 'Home'
+date = 2023-01-01T08:00:00-07:00
+draft = false
+++
+
+Laborum voluptate pariatur ex culpa magna nostrud est incididunt fugiat
+pariatur do dolor ipsum enim. Consequat tempor do dolor eu. Non id id anim anim
+excepteur excepteur pariatur nostrud qui irure ullamco.
@@ -0,0 +1,7 @@
+++
+title = 'Posts'
+date = 2023-01-01T08:30:00-07:00
+draft = false
+++
+
+Tempor est exercitation ad qui pariatur quis adipisicing aliquip nisi ea consequat ipsum occaecat. Nostrud consequat ullamco laboris fugiat esse esse adipisicing velit laborum ipsum incididunt ut enim. Dolor pariatur nulla quis fugiat dolore excepteur. Aliquip ad quis aliqua enim do consequat.
@@ -0,0 +1,10 @@
+++
+title = 'Post 1'
+date = 2023-01-15T09:00:00-07:00
+draft = false
+tags = ['red']
+++
+
+Tempor proident minim aliquip reprehenderit dolor et ad anim Lorem duis sint eiusmod. Labore ut ea duis dolor. Incididunt consectetur proident qui occaecat incididunt do nisi Lorem. Tempor do laborum elit laboris excepteur eiusmod do. Eiusmod nisi excepteur ut amet pariatur adipisicing Lorem.
+
+Occaecat nulla excepteur dolore excepteur duis eiusmod ullamco officia anim in voluptate ea occaecat officia. Cillum sint esse velit ea officia minim fugiat. Elit ea esse id aliquip pariatur cupidatat id duis minim incididunt ea ea. Anim ut duis sunt nisi. Culpa cillum sit voluptate voluptate eiusmod dolor. Enim nisi Lorem ipsum irure est excepteur voluptate eu in enim nisi. Nostrud ipsum Lorem anim sint labore consequat do.
@@ -0,0 +1,10 @@
+++
+title = 'Post 2'
+date = 2023-02-15T10:00:00-07:00
+draft = false
+tags = ['red','green']
+++
+
+Anim eiusmod irure incididunt sint cupidatat. Incididunt irure irure irure nisi ipsum do ut quis fugiat consectetur proident cupidatat incididunt cillum. Dolore voluptate occaecat qui mollit laborum ullamco et. Ipsum laboris officia anim laboris culpa eiusmod ex magna ex cupidatat anim ipsum aute. Mollit aliquip occaecat qui sunt velit ut cupidatat reprehenderit enim sunt laborum. Velit veniam in officia nulla adipisicing ut duis officia.
+
+Exercitation voluptate irure in irure tempor mollit Lorem nostrud ad officia. Velit id fugiat occaecat do tempor. Sit officia Lorem aliquip eu deserunt consectetur. Aute proident deserunt in nulla aliquip dolore ipsum Lorem ut cupidatat consectetur sit sint laborum. Esse cupidatat sit sint sunt tempor exercitation deserunt. Labore dolor duis laborum est do nisi ut veniam dolor et nostrud nostrud.
@@ -0,0 +1,12 @@
+++
+title = 'Post 3'
+date = 2023-03-15T11:00:00-07:00
+draft = false
+tags = ['red','green','blue']
+++
+
+Occaecat aliqua consequat laborum ut ex aute aliqua culpa quis irure esse magna dolore quis. Proident fugiat labore eu laboris officia Lorem enim. Ipsum occaecat cillum ut tempor id sint aliqua incididunt nisi incididunt reprehenderit. Voluptate ad minim sint est aute aliquip esse occaecat tempor officia qui sunt. Aute ex ipsum id ut in est velit est laborum incididunt. Aliqua qui id do esse sunt eiusmod id deserunt eu nostrud aute sit ipsum. Deserunt esse cillum Lorem non magna adipisicing mollit amet consequat.
+
+![Bryce Canyon National Park](bryce-canyon.jpg)
+
+Sit excepteur do velit veniam mollit in nostrud laboris incididunt ea. Amet eu cillum ut reprehenderit culpa aliquip labore laborum amet sit sit duis. Laborum id proident nostrud dolore laborum reprehenderit quis mollit nulla amet veniam officia id id. Aliquip in deserunt qui magna duis qui pariatur officia sunt deserunt.
@@ -0,0 +1,23 @@
+baseURL = 'https://example.org/'
+languageCode = 'en-us'
+title = 'My New Hugo Site'
+
+[[menus.main]]
+name = 'Home'
+pageRef = '/'
+weight = 10
+
+[[menus.main]]
+name = 'Posts'
+pageRef = '/posts'
+weight = 20
+
+[[menus.main]]
+name = 'Tags'
+pageRef = '/tags'
+weight = 30
+
+[module]
+  [module.hugoVersion]
+    extended = false
+    min = "0.116.0"
@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html lang="{{ or site.Language.LanguageCode site.Language.Lang }}" dir="{{ or site.Language.LanguageDirection `ltr` }}">
+<head>
+  {{ partial "head.html" . }}
+</head>
+<body>
+  <header>
+    {{ partial "header.html" . }}
+  </header>
+  <main>
+    {{ block "main" . }}{{ end }}
+  </main>
+  <footer>
+    {{ partial "footer.html" . }}
+  </footer>
+</body>
+</html>
@@ -0,0 +1,7 @@
+{{ define "main" }}
+  {{ .Content }}
+  {{ range site.RegularPages }}
+    <h2><a href="{{ .RelPermalink }}">{{ .LinkTitle }}</a></h2>
+    {{ .Summary }}
+  {{ end }}
+{{ end }}
@@ -0,0 +1,8 @@
+{{ define "main" }}
+  <h1>{{ .Title }}</h1>
+  {{ .Content }}
+  {{ range .Pages }}
+    <h2><a href="{{ .RelPermalink }}">{{ .LinkTitle }}</a></h2>
+    {{ .Summary }}
+  {{ end }}
+{{ end }}
@@ -0,0 +1,10 @@
+{{ define "main" }}
+  <h1>{{ .Title }}</h1>
+
+  {{ $dateMachine := .Date | time.Format "2006-01-02T15:04:05-07:00" }}
+  {{ $dateHuman := .Date | time.Format ":date_long" }}
+  <time datetime="{{ $dateMachine }}">{{ $dateHuman }}</time>
+
+  {{ .Content }}
+  {{ partial "terms.html" (dict "taxonomy" "tags" "page" .) }}
+{{ end }}
@@ -0,0 +1 @@
+<p>Copyright {{ now.Year }}. All rights reserved.</p>
@@ -0,0 +1,5 @@
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, minimum-scale=1.0, initial-scale=1.0">
+<title>{{ if .IsHome }}{{ site.Title }}{{ else }}{{ printf "%s | %s" .Title site.Title }}{{ end }}</title>
+{{ partialCached "head/css.html" . }}
+{{ partialCached "head/js.html" . }}
@@ -0,0 +1,9 @@
+{{- with resources.Get "css/main.css" }}
+  {{- if eq hugo.Environment "development" }}
+    <link rel="stylesheet" href="{{ .RelPermalink }}">
+  {{- else }}
+    {{- with . | minify | fingerprint }}
+      <link rel="stylesheet" href="{{ .RelPermalink }}" integrity="{{ .Data.Integrity }}" crossorigin="anonymous">
+    {{- end }}
+  {{- end }}
+{{- end }}
@@ -0,0 +1,12 @@
+{{- with resources.Get "js/main.js" }}
+  {{- if eq hugo.Environment "development" }}
+    {{- with . | js.Build }}
+      <script src="{{ .RelPermalink }}"></script>
+    {{- end }}
+  {{- else }}
+    {{- $opts := dict "minify" true }}
+    {{- with . | js.Build $opts | fingerprint }}
+      <script src="{{ .RelPermalink }}" integrity="{{- .Data.Integrity }}" crossorigin="anonymous"></script>
+    {{- end }}
+  {{- end }}
+{{- end }}
@@ -0,0 +1,2 @@
+<h1>{{ site.Title }}</h1>
+{{ partial "menu.html" (dict "menuID" "main" "page" .) }}
@@ -0,0 +1,45 @@
+{{- /*
+Renders a menu for the given menu ID.
+
+@context {page} page The current page.
+@context {string} menuID The menu ID.
+
+@example: {{ partial "menu.html" (dict "menuID" "main" "page" .) }}
+*/}}
+
+{{- $page := .page }}
+{{- $menuID := .menuID }}
+
+{{- with index site.Menus $menuID }}
+  <nav>
+    <ul>
+      {{- partial "inline/menu/walk.html" (dict "page" $page "menuEntries" .) }}
+    </ul>
+  </nav>
+{{- end }}
+
+{{- define "partials/inline/menu/walk.html" }}
+  {{- $page := .page }}
+  {{- range .menuEntries }}
+    {{- $attrs := dict "href" .URL }}
+    {{- if $page.IsMenuCurrent .Menu . }}
+      {{- $attrs = merge $attrs (dict "class" "active" "aria-current" "page") }}
+    {{- else if $page.HasMenuCurrent .Menu .}}
+      {{- $attrs = merge $attrs (dict "class" "ancestor" "aria-current" "true") }}
+    {{- end }}
+    <li>
+      <a
+        {{- range $k, $v := $attrs }}
+          {{- with $v }}
+            {{- printf " %s=%q" $k $v | safeHTMLAttr }}
+          {{- end }}
+        {{- end -}}
+      >{{ or (T .Identifier) .Name | safeHTML }}</a>
+      {{- with .Children }}
+        <ul>
+          {{- partial "inline/menu/walk.html" (dict "page" $page "menuEntries" .) }}
+        </ul>
+      {{- end }}
+    </li>
+  {{- end }}
+{{- end }}
@@ -0,0 +1,23 @@
+{{- /*
+For a given taxonomy, renders a list of terms assigned to the page.
+
+@context {page} page The current page.
+@context {string} taxonomy The taxonony.
+
+@example: {{ partial "terms.html" (dict "taxonomy" "tags" "page" .) }}
+*/}}
+
+{{- $page := .page }}
+{{- $taxonomy := .taxonomy }}
+
+{{- with $page.GetTerms $taxonomy }}
+  {{- $label := (index . 0).Parent.LinkTitle }}
+  <div>
+    <div>{{ $label }}:</div>
+    <ul>
+      {{- range . }}
+        <li><a href="{{ .RelPermalink }}">{{ .LinkTitle }}</a></li>
+      {{- end }}
+    </ul>
+  </div>
+{{- end }}
--- a/Show More
+++ b/Show More
				`@@ -0,0 +1 @@`
				`console.log('This site was generated by Hugo.');`
				`@@ -0,0 +1 @@`
				`<p>Copyright {{ now.Year }}. All rights reserved.</p>`