all: gofmt -w -r 'interface{} -> any' .

Updates #9687

bufferpool/bufpool.go

@@ -20,7 +20,7 @@ import (
 )
 
 var bufferPool = &sync.Pool{
-	New: func() interface{} {
+	New: func() any {
 		return &bytes.Buffer{}
 	},
 }

cache/namedmemcache/named_cache.go

@@ -30,7 +30,7 @@ type Cache struct {
 }
 
 type cacheEntry struct {
-	value interface{}
+	value any
 	err   error
 }
 
@@ -55,7 +55,7 @@ func (c *Cache) Clear() {
 // create will be called and cached.
 // This method is thread safe. It also guarantees that the create func for a given
 // key is invoked only once for this cache.
-func (c *Cache) GetOrCreate(key string, create func() (interface{}, error)) (interface{}, error) {
+func (c *Cache) GetOrCreate(key string, create func() (any, error)) (any, error) {
 	c.mu.RLock()
 	entry, found := c.cache[key]
 	c.mu.RUnlock()

cache/namedmemcache/named_cache_test.go

@@ -28,7 +28,7 @@ func TestNamedCache(t *testing.T) {
 	cache := New()
 
 	counter := 0
-	create := func() (interface{}, error) {
+	create := func() (any, error) {
 		counter++
 		return counter, nil
 	}
@@ -58,8 +58,8 @@ func TestNamedCacheConcurrent(t *testing.T) {
 
 	cache := New()
 
-	create := func(i int) func() (interface{}, error) {
+	create := func(i int) func() (any, error) {
-		return func() (interface{}, error) {
+		return func() (any, error) {
 			return i, nil
 		}
 	}

codegen/methods.go

@@ -505,7 +505,7 @@ func typeName(name, pkg string) string {
 
 func uniqueNonEmptyStrings(s []string) []string {
 	var unique []string
-	set := map[string]interface{}{}
+	set := map[string]any{}
 	for _, val := range s {
 		if val == "" {
 			continue

codegen/methods_test.go

@@ -85,7 +85,7 @@ type I interface {
 	Method3(myint int, mystring string)
 	Method5() (string, error)
 	Method6() *net.IP
-	Method7() interface{}
+	Method7() any
 	Method8() herrors.ErrorContext
 	method2()
 	method9() os.FileInfo

commands/commandeer.go

@@ -120,14 +120,14 @@ func (c *commandeer) errCount() int {
 	return int(c.logger.LogCounters().ErrorCounter.Count())
 }
 
-func (c *commandeer) getErrorWithContext() interface{} {
+func (c *commandeer) getErrorWithContext() any {
 	errCount := c.errCount()
 
 	if errCount == 0 {
 		return nil
 	}
 
-	m := make(map[string]interface{})
+	m := make(map[string]any)
 
 	m["Error"] = errors.New(removeErrorPrefixFromLog(c.logger.Errors()))
 	m["Version"] = hugo.BuildVersionString()
@@ -146,7 +146,7 @@ func (c *commandeer) getErrorWithContext() interface{} {
 	return m
 }
 
-func (c *commandeer) Set(key string, value interface{}) {
+func (c *commandeer) Set(key string, value any) {
 	if c.configured {
 		panic("commandeer cannot be changed")
 	}

commands/config.go

@@ -145,13 +145,13 @@ func (m *modMounts) MarshalJSON() ([]byte, error) {
 	if m.verbose {
 		config := m.m.Config()
 		return json.Marshal(&struct {
-			Path        string                 `json:"path"`
+			Path        string              `json:"path"`
-			Version     string                 `json:"version"`
+			Version     string              `json:"version"`
-			Time        time.Time              `json:"time"`
+			Time        time.Time           `json:"time"`
-			Owner       string                 `json:"owner"`
+			Owner       string              `json:"owner"`
-			Dir         string                 `json:"dir"`
+			Dir         string              `json:"dir"`
-			Meta        map[string]interface{} `json:"meta"`
+			Meta        map[string]any      `json:"meta"`
-			HugoVersion modules.HugoVersion    `json:"hugoVersion"`
+			HugoVersion modules.HugoVersion `json:"hugoVersion"`
 
 			Mounts []modMount `json:"mounts"`
 		}{

commands/convert.go

@@ -202,7 +202,7 @@ func (cc *convertCmd) convertAndSavePage(p page.Page, site *hugolib.Site, target
 type parsedFile struct {
 	frontMatterFormat metadecoders.Format
 	frontMatterSource []byte
-	frontMatter       map[string]interface{}
+	frontMatter       map[string]any
 
 	// Everything after Front Matter
 	content []byte

commands/deploy.go

@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+//go:build !nodeploy
 // +build !nodeploy
 
 package commands

commands/helpers.go

@@ -53,15 +53,15 @@ func (c commandError) isUserError() bool {
 	return c.userError
 }
 
-func newUserError(a ...interface{}) commandError {
+func newUserError(a ...any) commandError {
 	return commandError{s: fmt.Sprintln(a...), userError: true}
 }
 
-func newSystemError(a ...interface{}) commandError {
+func newSystemError(a ...any) commandError {
 	return commandError{s: fmt.Sprintln(a...), userError: false}
 }
 
-func newSystemErrorF(format string, a ...interface{}) commandError {
+func newSystemErrorF(format string, a ...any) commandError {
 	return commandError{s: fmt.Sprintf(format, a...), userError: false}
 }
 

commands/import_jekyll.go

@@ -235,7 +235,7 @@ func (i *importCmd) createSiteFromJekyll(jekyllRoot, targetDir string, jekyllPos
 	return nil
 }
 
-func (i *importCmd) loadJekyllConfig(fs afero.Fs, jekyllRoot string) map[string]interface{} {
+func (i *importCmd) loadJekyllConfig(fs afero.Fs, jekyllRoot string) map[string]any {
 	path := filepath.Join(jekyllRoot, "_config.yml")
 
 	exists, err := helpers.Exists(path, fs)
@@ -265,7 +265,7 @@ func (i *importCmd) loadJekyllConfig(fs afero.Fs, jekyllRoot string) map[string]
 	return c
 }
 
-func (i *importCmd) createConfigFromJekyll(fs afero.Fs, inpath string, kind metadecoders.Format, jekyllConfig map[string]interface{}) (err error) {
+func (i *importCmd) createConfigFromJekyll(fs afero.Fs, inpath string, kind metadecoders.Format, jekyllConfig map[string]any) (err error) {
 	title := "My New Hugo Site"
 	baseURL := "http://example.org/"
 
@@ -285,7 +285,7 @@ func (i *importCmd) createConfigFromJekyll(fs afero.Fs, inpath string, kind meta
 		}
 	}
 
-	in := map[string]interface{}{
+	in := map[string]any{
 		"baseURL":            baseURL,
 		"title":              title,
 		"languageCode":       "en-us",
@@ -423,7 +423,7 @@ func convertJekyllPost(path, relPath, targetDir string, draft bool) error {
 	return nil
 }
 
-func convertJekyllMetaData(m interface{}, postName string, postDate time.Time, draft bool) (interface{}, error) {
+func convertJekyllMetaData(m any, postName string, postDate time.Time, draft bool) (any, error) {
 	metadata, err := maps.ToStringMapE(m)
 	if err != nil {
 		return nil, err
@@ -475,7 +475,7 @@ func convertJekyllMetaData(m interface{}, postName string, postDate time.Time, d
 	return metadata, nil
 }
 
-func convertJekyllContent(m interface{}, content string) (string, error) {
+func convertJekyllContent(m any, content string) (string, error) {
 	metadata, _ := maps.ToStringMapE(m)
 
 	lines := strings.Split(content, "\n")

commands/import_jekyll_test.go

@@ -47,44 +47,44 @@ func TestParseJekyllFilename(t *testing.T) {
 func TestConvertJekyllMetadata(t *testing.T) {
 	c := qt.New(t)
 	testDataList := []struct {
-		metadata interface{}
+		metadata any
 		postName string
 		postDate time.Time
 		draft    bool
 		expect   string
 	}{
 		{
-			map[interface{}]interface{}{},
+			map[any]any{},
 			"testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), false,
 			`{"date":"2015-10-01T00:00:00Z"}`,
 		},
 		{
-			map[interface{}]interface{}{},
+			map[any]any{},
 			"testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), true,
 			`{"date":"2015-10-01T00:00:00Z","draft":true}`,
 		},
 		{
-			map[interface{}]interface{}{"Permalink": "/permalink.html", "layout": "post"},
+			map[any]any{"Permalink": "/permalink.html", "layout": "post"},
 			"testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), false,
 			`{"date":"2015-10-01T00:00:00Z","url":"/permalink.html"}`,
 		},
 		{
-			map[interface{}]interface{}{"permalink": "/permalink.html"},
+			map[any]any{"permalink": "/permalink.html"},
 			"testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), false,
 			`{"date":"2015-10-01T00:00:00Z","url":"/permalink.html"}`,
 		},
 		{
-			map[interface{}]interface{}{"category": nil, "permalink": 123},
+			map[any]any{"category": nil, "permalink": 123},
 			"testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), false,
 			`{"date":"2015-10-01T00:00:00Z"}`,
 		},
 		{
-			map[interface{}]interface{}{"Excerpt_Separator": "sep"},
+			map[any]any{"Excerpt_Separator": "sep"},
 			"testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), false,
 			`{"date":"2015-10-01T00:00:00Z","excerpt_separator":"sep"}`,
 		},
 		{
-			map[interface{}]interface{}{"category": "book", "layout": "post", "Others": "Goods", "Date": "2015-10-01 12:13:11"},
+			map[any]any{"category": "book", "layout": "post", "Others": "Goods", "Date": "2015-10-01 12:13:11"},
 			"testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), false,
 			`{"Others":"Goods","categories":["book"],"date":"2015-10-01T12:13:11Z"}`,
 		},
@@ -102,69 +102,69 @@ func TestConvertJekyllMetadata(t *testing.T) {
 func TestConvertJekyllContent(t *testing.T) {
 	c := qt.New(t)
 	testDataList := []struct {
-		metadata interface{}
+		metadata any
 		content  string
 		expect   string
 	}{
 		{
-			map[interface{}]interface{}{},
+			map[any]any{},
 			"Test content\r\n<!-- more -->\npart2 content", "Test content\n<!--more-->\npart2 content",
 		},
 		{
-			map[interface{}]interface{}{},
+			map[any]any{},
 			"Test content\n<!-- More -->\npart2 content", "Test content\n<!--more-->\npart2 content",
 		},
 		{
-			map[interface{}]interface{}{"excerpt_separator": "<!--sep-->"},
+			map[any]any{"excerpt_separator": "<!--sep-->"},
 			"Test content\n<!--sep-->\npart2 content",
 			"---\nexcerpt_separator: <!--sep-->\n---\nTest content\n<!--more-->\npart2 content",
 		},
-		{map[interface{}]interface{}{}, "{% raw %}text{% endraw %}", "text"},
+		{map[any]any{}, "{% raw %}text{% endraw %}", "text"},
-		{map[interface{}]interface{}{}, "{%raw%} text2 {%endraw %}", "text2"},
+		{map[any]any{}, "{%raw%} text2 {%endraw %}", "text2"},
 		{
-			map[interface{}]interface{}{},
+			map[any]any{},
 			"{% highlight go %}\nvar s int\n{% endhighlight %}",
 			"{{< highlight go >}}\nvar s int\n{{< / highlight >}}",
 		},
 		{
-			map[interface{}]interface{}{},
+			map[any]any{},
 			"{% highlight go linenos hl_lines=\"1 2\" %}\nvar s string\nvar i int\n{% endhighlight %}",
 			"{{< highlight go \"linenos=table,hl_lines=1 2\" >}}\nvar s string\nvar i int\n{{< / highlight >}}",
 		},
 
 		// Octopress image tag
 		{
-			map[interface{}]interface{}{},
+			map[any]any{},
 			"{% img http://placekitten.com/890/280 %}",
 			"{{< figure src=\"http://placekitten.com/890/280\" >}}",
 		},
 		{
-			map[interface{}]interface{}{},
+			map[any]any{},
 			"{% img left http://placekitten.com/320/250 Place Kitten #2 %}",
 			"{{< figure class=\"left\" src=\"http://placekitten.com/320/250\" title=\"Place Kitten #2\" >}}",
 		},
 		{
-			map[interface{}]interface{}{},
+			map[any]any{},
 			"{% img right http://placekitten.com/300/500 150 250 'Place Kitten #3' %}",
 			"{{< figure class=\"right\" src=\"http://placekitten.com/300/500\" width=\"150\" height=\"250\" title=\"Place Kitten #3\" >}}",
 		},
 		{
-			map[interface{}]interface{}{},
+			map[any]any{},
 			"{% img right http://placekitten.com/300/500 150 250 'Place Kitten #4' 'An image of a very cute kitten' %}",
 			"{{< figure class=\"right\" src=\"http://placekitten.com/300/500\" width=\"150\" height=\"250\" title=\"Place Kitten #4\" alt=\"An image of a very cute kitten\" >}}",
 		},
 		{
-			map[interface{}]interface{}{},
+			map[any]any{},
 			"{% img http://placekitten.com/300/500 150 250 'Place Kitten #4' 'An image of a very cute kitten' %}",
 			"{{< figure src=\"http://placekitten.com/300/500\" width=\"150\" height=\"250\" title=\"Place Kitten #4\" alt=\"An image of a very cute kitten\" >}}",
 		},
 		{
-			map[interface{}]interface{}{},
+			map[any]any{},
 			"{% img right /placekitten/300/500 'Place Kitten #4' 'An image of a very cute kitten' %}",
 			"{{< figure class=\"right\" src=\"/placekitten/300/500\" title=\"Place Kitten #4\" alt=\"An image of a very cute kitten\" >}}",
 		},
 		{
-			map[interface{}]interface{}{"category": "book", "layout": "post", "Date": "2015-10-01 12:13:11"},
+			map[any]any{"category": "book", "layout": "post", "Date": "2015-10-01 12:13:11"},
 			"somecontent",
 			"---\nDate: \"2015-10-01 12:13:11\"\ncategory: book\nlayout: post\n---\nsomecontent",
 		},

commands/limit_others.go

@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+//go:build !darwin
 // +build !darwin
 
 package commands

commands/list.go

@@ -32,7 +32,7 @@ type listCmd struct {
 	*baseBuilderCmd
 }
 
-func (lc *listCmd) buildSites(config map[string]interface{}) (*hugolib.HugoSites, error) {
+func (lc *listCmd) buildSites(config map[string]any) (*hugolib.HugoSites, error) {
 	cfgInit := func(c *commandeer) error {
 		for key, value := range config {
 			c.Set(key, value)
@@ -75,7 +75,7 @@ List requires a subcommand, e.g. ` + "`hugo list drafts`.",
 			Short: "List all drafts",
 			Long:  `List all of the drafts in your content directory.`,
 			RunE: func(cmd *cobra.Command, args []string) error {
-				sites, err := cc.buildSites(map[string]interface{}{"buildDrafts": true})
+				sites, err := cc.buildSites(map[string]any{"buildDrafts": true})
 				if err != nil {
 					return newSystemError("Error building sites", err)
 				}
@@ -94,7 +94,7 @@ List requires a subcommand, e.g. ` + "`hugo list drafts`.",
 			Short: "List all posts dated in the future",
 			Long:  `List all of the posts in your content directory which will be posted in the future.`,
 			RunE: func(cmd *cobra.Command, args []string) error {
-				sites, err := cc.buildSites(map[string]interface{}{"buildFuture": true})
+				sites, err := cc.buildSites(map[string]any{"buildFuture": true})
 				if err != nil {
 					return newSystemError("Error building sites", err)
 				}
@@ -122,7 +122,7 @@ List requires a subcommand, e.g. ` + "`hugo list drafts`.",
 			Short: "List all posts already expired",
 			Long:  `List all of the posts in your content directory which has already expired.`,
 			RunE: func(cmd *cobra.Command, args []string) error {
-				sites, err := cc.buildSites(map[string]interface{}{"buildExpired": true})
+				sites, err := cc.buildSites(map[string]any{"buildExpired": true})
 				if err != nil {
 					return newSystemError("Error building sites", err)
 				}
@@ -150,7 +150,7 @@ List requires a subcommand, e.g. ` + "`hugo list drafts`.",
 			Short: "List all posts",
 			Long:  `List all of the posts in your content directory, include drafts, future and expired pages.`,
 			RunE: func(cmd *cobra.Command, args []string) error {
-				sites, err := cc.buildSites(map[string]interface{}{
+				sites, err := cc.buildSites(map[string]any{
 					"buildExpired": true,
 					"buildDrafts":  true,
 					"buildFuture":  true,

commands/nodeploy.go

@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+//go:build nodeploy
 // +build nodeploy
 
 package commands

commands/release.go

@@ -1,3 +1,4 @@
+//go:build release
 // +build release
 
 // Copyright 2017-present The Hugo Authors. All rights reserved.

commands/release_noop.go

@@ -1,3 +1,4 @@
+//go:build !release
 // +build !release
 
 // Copyright 2018 The Hugo Authors. All rights reserved.

commands/server.go

@@ -304,7 +304,7 @@ func getRootWatchDirsStr(baseDir string, watchDirs []string) string {
 type fileServer struct {
 	baseURLs      []string
 	roots         []string
-	errorTemplate func(err interface{}) (io.Reader, error)
+	errorTemplate func(err any) (io.Reader, error)
 	c             *commandeer
 	s             *serverCmd
 }
@@ -497,7 +497,7 @@ func (c *commandeer) serve(s *serverCmd) error {
 		roots:    roots,
 		c:        c,
 		s:        s,
-		errorTemplate: func(ctx interface{}) (io.Reader, error) {
+		errorTemplate: func(ctx any) (io.Reader, error) {
 			b := &bytes.Buffer{}
 			err := c.hugo().Tmpl().Execute(templ, b, ctx)
 			return b, err

common/collections/append.go

@@ -21,7 +21,7 @@ import (
 // Append appends from to a slice to and returns the resulting slice.
 // 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 interface{}, from ...interface{}) (interface{}, error) {
+func Append(to any, from ...any) (any, error) {
 	tov, toIsNil := indirect(reflect.ValueOf(to))
 
 	toIsNil = toIsNil || to == nil
@@ -73,8 +73,8 @@ func Append(to interface{}, from ...interface{}) (interface{}, error) {
 	return tov.Interface(), nil
 }
 
-func appendToInterfaceSliceFromValues(slice1, slice2 reflect.Value) ([]interface{}, error) {
+func appendToInterfaceSliceFromValues(slice1, slice2 reflect.Value) ([]any, error) {
-	var tos []interface{}
+	var tos []any
 
 	for _, slice := range []reflect.Value{slice1, slice2} {
 		for i := 0; i < slice.Len(); i++ {
@@ -85,8 +85,8 @@ func appendToInterfaceSliceFromValues(slice1, slice2 reflect.Value) ([]interface
 	return tos, nil
 }
 
-func appendToInterfaceSlice(tov reflect.Value, from ...interface{}) ([]interface{}, error) {
+func appendToInterfaceSlice(tov reflect.Value, from ...any) ([]any, error) {
-	var tos []interface{}
+	var tos []any
 
 	for i := 0; i < tov.Len(); i++ {
 		tos = append(tos, tov.Index(i).Interface())

common/collections/append_test.go

@@ -25,25 +25,25 @@ func TestAppend(t *testing.T) {
 	c := qt.New(t)
 
 	for _, test := range []struct {
-		start    interface{}
+		start    any
-		addend   []interface{}
+		addend   []any
-		expected interface{}
+		expected any
 	}{
-		{[]string{"a", "b"}, []interface{}{"c"}, []string{"a", "b", "c"}},
+		{[]string{"a", "b"}, []any{"c"}, []string{"a", "b", "c"}},
-		{[]string{"a", "b"}, []interface{}{"c", "d", "e"}, []string{"a", "b", "c", "d", "e"}},
+		{[]string{"a", "b"}, []any{"c", "d", "e"}, []string{"a", "b", "c", "d", "e"}},
-		{[]string{"a", "b"}, []interface{}{[]string{"c", "d", "e"}}, []string{"a", "b", "c", "d", "e"}},
+		{[]string{"a", "b"}, []any{[]string{"c", "d", "e"}}, []string{"a", "b", "c", "d", "e"}},
-		{[]string{"a"}, []interface{}{"b", template.HTML("c")}, []interface{}{"a", "b", template.HTML("c")}},
+		{[]string{"a"}, []any{"b", template.HTML("c")}, []any{"a", "b", template.HTML("c")}},
-		{nil, []interface{}{"a", "b"}, []string{"a", "b"}},
+		{nil, []any{"a", "b"}, []string{"a", "b"}},
-		{nil, []interface{}{nil}, []interface{}{nil}},
+		{nil, []any{nil}, []any{nil}},
-		{[]interface{}{}, []interface{}{[]string{"c", "d", "e"}}, []string{"c", "d", "e"}},
+		{[]any{}, []any{[]string{"c", "d", "e"}}, []string{"c", "d", "e"}},
 		{
 			tstSlicers{&tstSlicer{"a"}, &tstSlicer{"b"}},
-			[]interface{}{&tstSlicer{"c"}},
+			[]any{&tstSlicer{"c"}},
 			tstSlicers{&tstSlicer{"a"}, &tstSlicer{"b"}, &tstSlicer{"c"}},
 		},
 		{
 			&tstSlicers{&tstSlicer{"a"}, &tstSlicer{"b"}},
-			[]interface{}{&tstSlicer{"c"}},
+			[]any{&tstSlicer{"c"}},
 			tstSlicers{
 				&tstSlicer{"a"},
 				&tstSlicer{"b"},
@@ -52,26 +52,26 @@ func TestAppend(t *testing.T) {
 		},
 		{
 			testSlicerInterfaces{&tstSlicerIn1{"a"}, &tstSlicerIn1{"b"}},
-			[]interface{}{&tstSlicerIn1{"c"}},
+			[]any{&tstSlicerIn1{"c"}},
 			testSlicerInterfaces{&tstSlicerIn1{"a"}, &tstSlicerIn1{"b"}, &tstSlicerIn1{"c"}},
 		},
 		//https://github.com/gohugoio/hugo/issues/5361
 		{
 			[]string{"a", "b"},
-			[]interface{}{tstSlicers{&tstSlicer{"a"}, &tstSlicer{"b"}}},
+			[]any{tstSlicers{&tstSlicer{"a"}, &tstSlicer{"b"}}},
-			[]interface{}{"a", "b", &tstSlicer{"a"}, &tstSlicer{"b"}},
+			[]any{"a", "b", &tstSlicer{"a"}, &tstSlicer{"b"}},
 		},
 		{
 			[]string{"a", "b"},
-			[]interface{}{&tstSlicer{"a"}},
+			[]any{&tstSlicer{"a"}},
-			[]interface{}{"a", "b", &tstSlicer{"a"}},
+			[]any{"a", "b", &tstSlicer{"a"}},
 		},
 		// Errors
-		{"", []interface{}{[]string{"a", "b"}}, false},
+		{"", []any{[]string{"a", "b"}}, false},
 		// No string concatenation.
 		{
 			"ab",
-			[]interface{}{"c"},
+			[]any{"c"},
 			false,
 		},
 	} {

common/collections/collections.go

@@ -17,5 +17,5 @@ package collections
 
 // Grouper defines a very generic way to group items by a given key.
 type Grouper interface {
-	Group(key interface{}, items interface{}) (interface{}, error)
+	Group(key any, items any) (any, error)
 }

common/collections/slice.go

@@ -21,11 +21,11 @@ import (
 // in collections.Slice template func to get types such as Pages, PageGroups etc.
 // instead of the less useful []interface{}.
 type Slicer interface {
-	Slice(items interface{}) (interface{}, error)
+	Slice(items any) (any, error)
 }
 
 // Slice returns a slice of all passed arguments.
-func Slice(args ...interface{}) interface{} {
+func Slice(args ...any) any {
 	if len(args) == 0 {
 		return args
 	}
@@ -66,8 +66,8 @@ func Slice(args ...interface{}) interface{} {
 }
 
 // StringSliceToInterfaceSlice converts ss to []interface{}.
-func StringSliceToInterfaceSlice(ss []string) []interface{} {
+func StringSliceToInterfaceSlice(ss []string) []any {
-	result := make([]interface{}, len(ss))
+	result := make([]any, len(ss))
 	for i, s := range ss {
 		result[i] = s
 	}

common/collections/slice_test.go

@@ -46,8 +46,8 @@ type tstSlicer struct {
 	TheName string
 }
 
-func (p *tstSlicerIn1) Slice(in interface{}) (interface{}, error) {
+func (p *tstSlicerIn1) Slice(in any) (any, error) {
-	items := in.([]interface{})
+	items := in.([]any)
 	result := make(testSlicerInterfaces, len(items))
 	for i, v := range items {
 		switch vv := v.(type) {
@@ -60,8 +60,8 @@ func (p *tstSlicerIn1) Slice(in interface{}) (interface{}, error) {
 	return result, nil
 }
 
-func (p *tstSlicerIn2) Slice(in interface{}) (interface{}, error) {
+func (p *tstSlicerIn2) Slice(in any) (any, error) {
-	items := in.([]interface{})
+	items := in.([]any)
 	result := make(testSlicerInterfaces, len(items))
 	for i, v := range items {
 		switch vv := v.(type) {
@@ -82,8 +82,8 @@ func (p *tstSlicerIn2) Name() string {
 	return p.TheName
 }
 
-func (p *tstSlicer) Slice(in interface{}) (interface{}, error) {
+func (p *tstSlicer) Slice(in any) (any, error) {
-	items := in.([]interface{})
+	items := in.([]any)
 	result := make(tstSlicers, len(items))
 	for i, v := range items {
 		switch vv := v.(type) {
@@ -103,17 +103,17 @@ func TestSlice(t *testing.T) {
 	c := qt.New(t)
 
 	for i, test := range []struct {
-		args     []interface{}
+		args     []any
-		expected interface{}
+		expected any
 	}{
-		{[]interface{}{"a", "b"}, []string{"a", "b"}},
+		{[]any{"a", "b"}, []string{"a", "b"}},
-		{[]interface{}{&tstSlicer{"a"}, &tstSlicer{"b"}}, tstSlicers{&tstSlicer{"a"}, &tstSlicer{"b"}}},
+		{[]any{&tstSlicer{"a"}, &tstSlicer{"b"}}, tstSlicers{&tstSlicer{"a"}, &tstSlicer{"b"}}},
-		{[]interface{}{&tstSlicer{"a"}, "b"}, []interface{}{&tstSlicer{"a"}, "b"}},
+		{[]any{&tstSlicer{"a"}, "b"}, []any{&tstSlicer{"a"}, "b"}},
-		{[]interface{}{}, []interface{}{}},
+		{[]any{}, []any{}},
-		{[]interface{}{nil}, []interface{}{nil}},
+		{[]any{nil}, []any{nil}},
-		{[]interface{}{5, "b"}, []interface{}{5, "b"}},
+		{[]any{5, "b"}, []any{5, "b"}},
-		{[]interface{}{&tstSlicerIn1{"a"}, &tstSlicerIn2{"b"}}, testSlicerInterfaces{&tstSlicerIn1{"a"}, &tstSlicerIn2{"b"}}},
+		{[]any{&tstSlicerIn1{"a"}, &tstSlicerIn2{"b"}}, testSlicerInterfaces{&tstSlicerIn1{"a"}, &tstSlicerIn2{"b"}}},
-		{[]interface{}{&tstSlicerIn1{"a"}, &tstSlicer{"b"}}, []interface{}{&tstSlicerIn1{"a"}, &tstSlicer{"b"}}},
+		{[]any{&tstSlicerIn1{"a"}, &tstSlicer{"b"}}, []any{&tstSlicerIn1{"a"}, &tstSlicer{"b"}}},
 	} {
 		errMsg := qt.Commentf("[%d] %v", i, test.args)
 

common/herrors/errors.go

@@ -65,7 +65,7 @@ type ErrorSender interface {
 // Recover is a helper function that can be used to capture panics.
 // Put this at the top of a method/function that crashes in a template:
 //     defer herrors.Recover()
-func Recover(args ...interface{}) {
+func Recover(args ...any) {
 	if r := recover(); r != nil {
 		fmt.Println("ERR:", r)
 		args = append(args, "stacktrace from panic: \n"+string(debug.Stack()), "\n")

common/hexec/exec.go

@@ -128,7 +128,7 @@ type Exec struct {
 
 // New will fail if name is not allowed according to the configured security policy.
 // Else a configured Runner will be returned ready to be Run.
-func (e *Exec) New(name string, arg ...interface{}) (Runner, error) {
+func (e *Exec) New(name string, arg ...any) (Runner, error) {
 	if err := e.sc.CheckAllowedExec(name); err != nil {
 		return nil, err
 	}
@@ -146,8 +146,8 @@ func (e *Exec) New(name string, arg ...interface{}) (Runner, error) {
 }
 
 // Npx is a convenience method to create a Runner running npx --no-install <name> <args.
-func (e *Exec) Npx(name string, arg ...interface{}) (Runner, error) {
+func (e *Exec) Npx(name string, arg ...any) (Runner, error) {
-	arg = append(arg[:0], append([]interface{}{"--no-install", name}, arg[0:]...)...)
+	arg = append(arg[:0], append([]any{"--no-install", name}, arg[0:]...)...)
 	return e.New("npx", arg...)
 }
 
@@ -205,7 +205,7 @@ type commandeer struct {
 	env  []string
 }
 
-func (c *commandeer) command(arg ...interface{}) (*cmdWrapper, error) {
+func (c *commandeer) command(arg ...any) (*cmdWrapper, error) {
 	if c == nil {
 		return nil, nil
 	}

common/hreflect/helpers.go

@@ -62,7 +62,7 @@ func IsFloat(kind reflect.Kind) bool {
 
 // IsTruthful returns whether in represents a truthful value.
 // See IsTruthfulValue
-func IsTruthful(in interface{}) bool {
+func IsTruthful(in any) bool {
 	switch v := in.(type) {
 	case reflect.Value:
 		return IsTruthfulValue(v)

common/htime/time.go

@@ -134,7 +134,7 @@ func (f TimeFormatter) Format(t time.Time, layout string) string {
 	return s
 }
 
-func ToTimeInDefaultLocationE(i interface{}, location *time.Location) (tim time.Time, err error) {
+func ToTimeInDefaultLocationE(i any, location *time.Location) (tim time.Time, err error) {
 	switch vv := i.(type) {
 	case toml.LocalDate:
 		return vv.AsTime(location), nil

common/hugo/vars_extended.go

@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+//go:build extended
 // +build extended
 
 package hugo

common/hugo/vars_regular.go

@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+//go:build !extended
 // +build !extended
 
 package hugo

common/hugo/version.go

@@ -58,13 +58,13 @@ func (h VersionString) String() string {
 }
 
 // Compare implements the compare.Comparer interface.
-func (h VersionString) Compare(other interface{}) int {
+func (h VersionString) Compare(other any) int {
 	v := MustParseVersion(h.String())
 	return compareVersionsWithSuffix(v.Number, v.PatchLevel, v.Suffix, other)
 }
 
 // Eq implements the compare.Eqer interface.
-func (h VersionString) Eq(other interface{}) bool {
+func (h VersionString) Eq(other any) bool {
 	s, err := cast.ToStringE(other)
 	if err != nil {
 		return false
@@ -171,15 +171,15 @@ func version(version float32, patchVersion int, suffix string) string {
 // running Hugo version.
 // It returns -1 if the given version is less than, 0 if equal and 1 if greater than
 // the running version.
-func CompareVersion(version interface{}) int {
+func CompareVersion(version any) int {
 	return compareVersionsWithSuffix(CurrentVersion.Number, CurrentVersion.PatchLevel, CurrentVersion.Suffix, version)
 }
 
-func compareVersions(inVersion float32, inPatchVersion int, in interface{}) int {
+func compareVersions(inVersion float32, inPatchVersion int, in any) int {
 	return compareVersionsWithSuffix(inVersion, inPatchVersion, "", in)
 }
 
-func compareVersionsWithSuffix(inVersion float32, inPatchVersion int, suffix string, in interface{}) int {
+func compareVersionsWithSuffix(inVersion float32, inPatchVersion int, suffix string, in any) int {
 	var c int
 	switch d := in.(type) {
 	case float64:

common/loggers/ignorableLogger.go

@@ -21,7 +21,7 @@ import (
 // IgnorableLogger is a logger that ignores certain log statements.
 type IgnorableLogger interface {
 	Logger
-	Errorsf(statementID, format string, v ...interface{})
+	Errorsf(statementID, format string, v ...any)
 	Apply(logger Logger) IgnorableLogger
 }
 
@@ -43,7 +43,7 @@ func NewIgnorableLogger(logger Logger, statements ...string) IgnorableLogger {
 }
 
 // Errorsf logs statementID as an ERROR if not configured as ignoreable.
-func (l ignorableLogger) Errorsf(statementID, format string, v ...interface{}) {
+func (l ignorableLogger) Errorsf(statementID, format string, v ...any) {
 	if l.statements[statementID] {
 		// Ignore.
 		return

common/loggers/loggers.go

@@ -58,21 +58,21 @@ func (w prefixWriter) Write(p []byte) (n int, err error) {
 }
 
 type Logger interface {
-	Printf(format string, v ...interface{})
+	Printf(format string, v ...any)
-	Println(v ...interface{})
+	Println(v ...any)
 	PrintTimerIfDelayed(start time.Time, name string)
 	Debug() *log.Logger
-	Debugf(format string, v ...interface{})
+	Debugf(format string, v ...any)
-	Debugln(v ...interface{})
+	Debugln(v ...any)
 	Info() *log.Logger
-	Infof(format string, v ...interface{})
+	Infof(format string, v ...any)
-	Infoln(v ...interface{})
+	Infoln(v ...any)
 	Warn() *log.Logger
-	Warnf(format string, v ...interface{})
+	Warnf(format string, v ...any)
-	Warnln(v ...interface{})
+	Warnln(v ...any)
 	Error() *log.Logger
-	Errorf(format string, v ...interface{})
+	Errorf(format string, v ...any)
-	Errorln(v ...interface{})
+	Errorln(v ...any)
 	Errors() string
 
 	Out() io.Writer
@@ -101,11 +101,11 @@ type logger struct {
 	errors *bytes.Buffer
 }
 
-func (l *logger) Printf(format string, v ...interface{}) {
+func (l *logger) Printf(format string, v ...any) {
 	l.FEEDBACK.Printf(format, v...)
 }
 
-func (l *logger) Println(v ...interface{}) {
+func (l *logger) Println(v ...any) {
 	l.FEEDBACK.Println(v...)
 }
 
@@ -113,19 +113,19 @@ func (l *logger) Debug() *log.Logger {
 	return l.DEBUG
 }
 
-func (l *logger) Debugf(format string, v ...interface{}) {
+func (l *logger) Debugf(format string, v ...any) {
 	l.DEBUG.Printf(format, v...)
 }
 
-func (l *logger) Debugln(v ...interface{}) {
+func (l *logger) Debugln(v ...any) {
 	l.DEBUG.Println(v...)
 }
 
-func (l *logger) Infof(format string, v ...interface{}) {
+func (l *logger) Infof(format string, v ...any) {
 	l.INFO.Printf(format, v...)
 }
 
-func (l *logger) Infoln(v ...interface{}) {
+func (l *logger) Infoln(v ...any) {
 	l.INFO.Println(v...)
 }
 
@@ -135,14 +135,14 @@ func (l *logger) Info() *log.Logger {
 
 const panicOnWarningMessage = "Warning trapped. Remove the --panicOnWarning flag to continue."
 
-func (l *logger) Warnf(format string, v ...interface{}) {
+func (l *logger) Warnf(format string, v ...any) {
 	l.WARN.Printf(format, v...)
 	if PanicOnWarning {
 		panic(panicOnWarningMessage)
 	}
 }
 
-func (l *logger) Warnln(v ...interface{}) {
+func (l *logger) Warnln(v ...any) {
 	l.WARN.Println(v...)
 	if PanicOnWarning {
 		panic(panicOnWarningMessage)
@@ -153,11 +153,11 @@ func (l *logger) Warn() *log.Logger {
 	return l.WARN
 }
 
-func (l *logger) Errorf(format string, v ...interface{}) {
+func (l *logger) Errorf(format string, v ...any) {
 	l.ERROR.Printf(format, v...)
 }
 
-func (l *logger) Errorln(v ...interface{}) {
+func (l *logger) Errorln(v ...any) {
 	l.ERROR.Println(v...)
 }
 

common/maps/maps.go

@@ -24,12 +24,12 @@ import (
 )
 
 // ToStringMapE converts in to map[string]interface{}.
-func ToStringMapE(in interface{}) (map[string]interface{}, error) {
+func ToStringMapE(in any) (map[string]any, error) {
 	switch vv := in.(type) {
 	case Params:
 		return vv, nil
 	case map[string]string:
-		var m = map[string]interface{}{}
+		var m = map[string]any{}
 		for k, v := range vv {
 			m[k] = v
 		}
@@ -43,7 +43,7 @@ func ToStringMapE(in interface{}) (map[string]interface{}, error) {
 // ToParamsAndPrepare converts in to Params and prepares it for use.
 // If in is nil, an empty map is returned.
 // See PrepareParams.
-func ToParamsAndPrepare(in interface{}) (Params, bool) {
+func ToParamsAndPrepare(in any) (Params, bool) {
 	if types.IsNil(in) {
 		return Params{}, true
 	}
@@ -56,7 +56,7 @@ func ToParamsAndPrepare(in interface{}) (Params, bool) {
 }
 
 // MustToParamsAndPrepare calls ToParamsAndPrepare and panics if it fails.
-func MustToParamsAndPrepare(in interface{}) Params {
+func MustToParamsAndPrepare(in any) Params {
 	if p, ok := ToParamsAndPrepare(in); ok {
 		return p
 	} else {
@@ -65,13 +65,13 @@ func MustToParamsAndPrepare(in interface{}) Params {
 }
 
 // ToStringMap converts in to map[string]interface{}.
-func ToStringMap(in interface{}) map[string]interface{} {
+func ToStringMap(in any) map[string]any {
 	m, _ := ToStringMapE(in)
 	return m
 }
 
 // ToStringMapStringE converts in to map[string]string.
-func ToStringMapStringE(in interface{}) (map[string]string, error) {
+func ToStringMapStringE(in any) (map[string]string, error) {
 	m, err := ToStringMapE(in)
 	if err != nil {
 		return nil, err
@@ -80,26 +80,26 @@ func ToStringMapStringE(in interface{}) (map[string]string, error) {
 }
 
 // ToStringMapString converts in to map[string]string.
-func ToStringMapString(in interface{}) map[string]string {
+func ToStringMapString(in any) map[string]string {
 	m, _ := ToStringMapStringE(in)
 	return m
 }
 
 // ToStringMapBool converts in to bool.
-func ToStringMapBool(in interface{}) map[string]bool {
+func ToStringMapBool(in any) map[string]bool {
 	m, _ := ToStringMapE(in)
 	return cast.ToStringMapBool(m)
 }
 
 // ToSliceStringMap converts in to []map[string]interface{}.
-func ToSliceStringMap(in interface{}) ([]map[string]interface{}, error) {
+func ToSliceStringMap(in any) ([]map[string]any, error) {
 	switch v := in.(type) {
-	case []map[string]interface{}:
+	case []map[string]any:
 		return v, nil
-	case []interface{}:
+	case []any:
-		var s []map[string]interface{}
+		var s []map[string]any
 		for _, entry := range v {
-			if vv, ok := entry.(map[string]interface{}); ok {
+			if vv, ok := entry.(map[string]any); ok {
 				s = append(s, vv)
 			}
 		}
@@ -146,7 +146,7 @@ func (r KeyRenamer) getNewKey(keyPath string) string {
 
 // Rename renames the keys in the given map according
 // to the patterns in the current KeyRenamer.
-func (r KeyRenamer) Rename(m map[string]interface{}) {
+func (r KeyRenamer) Rename(m map[string]any) {
 	r.renamePath("", m)
 }
 
@@ -158,15 +158,15 @@ func (KeyRenamer) keyPath(k1, k2 string) string {
 	return k1 + "/" + k2
 }
 
-func (r KeyRenamer) renamePath(parentKeyPath string, m map[string]interface{}) {
+func (r KeyRenamer) renamePath(parentKeyPath string, m map[string]any) {
 	for key, val := range m {
 		keyPath := r.keyPath(parentKeyPath, key)
 		switch val.(type) {
-		case map[interface{}]interface{}:
+		case map[any]any:
 			val = cast.ToStringMap(val)
-			r.renamePath(keyPath, val.(map[string]interface{}))
+			r.renamePath(keyPath, val.(map[string]any))
-		case map[string]interface{}:
+		case map[string]any:
-			r.renamePath(keyPath, val.(map[string]interface{}))
+			r.renamePath(keyPath, val.(map[string]any))
 		}
 
 		newKey := r.getNewKey(keyPath)

common/maps/maps_test.go

@@ -27,7 +27,7 @@ func TestPrepareParams(t *testing.T) {
 		expected Params
 	}{
 		{
-			map[string]interface{}{
+			map[string]any{
 				"abC": 32,
 			},
 			Params{
@@ -35,16 +35,16 @@ func TestPrepareParams(t *testing.T) {
 			},
 		},
 		{
-			map[string]interface{}{
+			map[string]any{
 				"abC": 32,
-				"deF": map[interface{}]interface{}{
+				"deF": map[any]any{
 					23: "A value",
-					24: map[string]interface{}{
+					24: map[string]any{
 						"AbCDe": "A value",
 						"eFgHi": "Another value",
 					},
 				},
-				"gHi": map[string]interface{}{
+				"gHi": map[string]any{
 					"J": 25,
 				},
 				"jKl": map[string]string{
@@ -85,23 +85,23 @@ func TestToSliceStringMap(t *testing.T) {
 	c := qt.New(t)
 
 	tests := []struct {
-		input    interface{}
+		input    any
-		expected []map[string]interface{}
+		expected []map[string]any
 	}{
 		{
-			input: []map[string]interface{}{
+			input: []map[string]any{
 				{"abc": 123},
 			},
-			expected: []map[string]interface{}{
+			expected: []map[string]any{
 				{"abc": 123},
 			},
 		}, {
-			input: []interface{}{
+			input: []any{
-				map[string]interface{}{
+				map[string]any{
 					"def": 456,
 				},
 			},
-			expected: []map[string]interface{}{
+			expected: []map[string]any{
 				{"def": 456},
 			},
 		},
@@ -116,7 +116,7 @@ func TestToSliceStringMap(t *testing.T) {
 
 func TestToParamsAndPrepare(t *testing.T) {
 	c := qt.New(t)
-	_, ok := ToParamsAndPrepare(map[string]interface{}{"A": "av"})
+	_, ok := ToParamsAndPrepare(map[string]any{"A": "av"})
 	c.Assert(ok, qt.IsTrue)
 
 	params, ok := ToParamsAndPrepare(nil)
@@ -127,33 +127,33 @@ func TestToParamsAndPrepare(t *testing.T) {
 func TestRenameKeys(t *testing.T) {
 	c := qt.New(t)
 
-	m := map[string]interface{}{
+	m := map[string]any{
 		"a":    32,
 		"ren1": "m1",
 		"ren2": "m1_2",
-		"sub": map[string]interface{}{
+		"sub": map[string]any{
-			"subsub": map[string]interface{}{
+			"subsub": map[string]any{
 				"REN1": "m2",
 				"ren2": "m2_2",
 			},
 		},
-		"no": map[string]interface{}{
+		"no": map[string]any{
 			"ren1": "m2",
 			"ren2": "m2_2",
 		},
 	}
 
-	expected := map[string]interface{}{
+	expected := map[string]any{
 		"a":    32,
 		"new1": "m1",
 		"new2": "m1_2",
-		"sub": map[string]interface{}{
+		"sub": map[string]any{
-			"subsub": map[string]interface{}{
+			"subsub": map[string]any{
 				"new1": "m2",
 				"ren2": "m2_2",
 			},
 		},
-		"no": map[string]interface{}{
+		"no": map[string]any{
 			"ren1": "m2",
 			"ren2": "m2_2",
 		},

common/maps/params.go

@@ -21,11 +21,11 @@ import (
 )
 
 // Params is a map where all keys are lower case.
-type Params map[string]interface{}
+type Params map[string]any
 
 // Get does a lower case and nested search in this map.
 // It will return nil if none found.
-func (p Params) Get(indices ...string) interface{} {
+func (p Params) Get(indices ...string) any {
 	v, _, _ := getNested(p, indices)
 	return v
 }
@@ -142,7 +142,7 @@ func (p Params) SetDefaultMergeStrategy(s ParamsMergeStrategy) {
 	p[mergeStrategyKey] = s
 }
 
-func getNested(m map[string]interface{}, indices []string) (interface{}, string, map[string]interface{}) {
+func getNested(m map[string]any, indices []string) (any, string, map[string]any) {
 	if len(indices) == 0 {
 		return nil, "", nil
 	}
@@ -164,7 +164,7 @@ func getNested(m map[string]interface{}, indices []string) (interface{}, string,
 	switch m2 := v.(type) {
 	case Params:
 		return getNested(m2, indices[1:])
-	case map[string]interface{}:
+	case map[string]any:
 		return getNested(m2, indices[1:])
 	default:
 		return nil, "", nil
@@ -175,7 +175,7 @@ func getNested(m map[string]interface{}, indices []string) (interface{}, string,
 // It will first try the exact match and then try to find it as a nested map value,
 // using the given separator, e.g. "mymap.name".
 // It assumes that all the maps given have lower cased keys.
-func GetNestedParam(keyStr, separator string, candidates ...Params) (interface{}, error) {
+func GetNestedParam(keyStr, separator string, candidates ...Params) (any, error) {
 	keyStr = strings.ToLower(keyStr)
 
 	// Try exact match first
@@ -195,7 +195,7 @@ func GetNestedParam(keyStr, separator string, candidates ...Params) (interface{}
 	return nil, nil
 }
 
-func GetNestedParamFn(keyStr, separator string, lookupFn func(key string) interface{}) (interface{}, string, map[string]interface{}, error) {
+func GetNestedParamFn(keyStr, separator string, lookupFn func(key string) any) (any, string, map[string]any, error) {
 	keySegments := strings.Split(keyStr, separator)
 	if len(keySegments) == 0 {
 		return nil, "", nil, nil
@@ -211,7 +211,7 @@ func GetNestedParamFn(keyStr, separator string, lookupFn func(key string) interf
 	}
 
 	switch m := first.(type) {
-	case map[string]interface{}:
+	case map[string]any:
 		v, key, owner := getNested(m, keySegments[1:])
 		return v, key, owner, nil
 	case Params:
@@ -236,7 +236,7 @@ const (
 	mergeStrategyKey = "_merge"
 )
 
-func toMergeStrategy(v interface{}) ParamsMergeStrategy {
+func toMergeStrategy(v any) ParamsMergeStrategy {
 	s := ParamsMergeStrategy(cast.ToString(v))
 	switch s {
 	case ParamsMergeStrategyDeep, ParamsMergeStrategyNone, ParamsMergeStrategyShallow:
@@ -260,13 +260,13 @@ func PrepareParams(m Params) {
 			retyped = true
 		} else {
 			switch vv := v.(type) {
-			case map[interface{}]interface{}:
+			case map[any]any:
 				var p Params = cast.ToStringMap(v)
 				v = p
 				PrepareParams(p)
 				retyped = true
-			case map[string]interface{}:
+			case map[string]any:
-				var p Params = v.(map[string]interface{})
+				var p Params = v.(map[string]any)
 				v = p
 				PrepareParams(p)
 				retyped = true

common/maps/params_test.go

@@ -20,13 +20,13 @@ import (
 )
 
 func TestGetNestedParam(t *testing.T) {
-	m := map[string]interface{}{
+	m := map[string]any{
 		"string":          "value",
 		"first":           1,
 		"with_underscore": 2,
-		"nested": map[string]interface{}{
+		"nested": map[string]any{
 			"color": "blue",
-			"nestednested": map[string]interface{}{
+			"nestednested": map[string]any{
 				"color": "green",
 			},
 		},
@@ -34,7 +34,7 @@ func TestGetNestedParam(t *testing.T) {
 
 	c := qt.New(t)
 
-	must := func(keyStr, separator string, candidates ...Params) interface{} {
+	must := func(keyStr, separator string, candidates ...Params) any {
 		v, err := GetNestedParam(keyStr, separator, candidates...)
 		c.Assert(err, qt.IsNil)
 		return v
@@ -53,14 +53,14 @@ func TestGetNestedParam(t *testing.T) {
 func TestGetNestedParamFnNestedNewKey(t *testing.T) {
 	c := qt.New(t)
 
-	nested := map[string]interface{}{
+	nested := map[string]any{
 		"color": "blue",
 	}
-	m := map[string]interface{}{
+	m := map[string]any{
 		"nested": nested,
 	}
 
-	existing, nestedKey, owner, err := GetNestedParamFn("nested.new", ".", func(key string) interface{} {
+	existing, nestedKey, owner, err := GetNestedParamFn("nested.new", ".", func(key string) any {
 		return m[key]
 	})
 

common/maps/scratch.go

@@ -24,7 +24,7 @@ import (
 
 // Scratch is a writable context used for stateful operations in Page/Node rendering.
 type Scratch struct {
-	values map[string]interface{}
+	values map[string]any
 	mu     sync.RWMutex
 }
 
@@ -50,8 +50,8 @@ func NewScratcher() Scratcher {
 // Supports numeric values and strings.
 //
 // If the first add for a key is an array or slice, then the next value(s) will be appended.
-func (c *Scratch) Add(key string, newAddend interface{}) (string, error) {
+func (c *Scratch) Add(key string, newAddend any) (string, error) {
-	var newVal interface{}
+	var newVal any
 	c.mu.RLock()
 	existingAddend, found := c.values[key]
 	c.mu.RUnlock()
@@ -82,7 +82,7 @@ func (c *Scratch) Add(key string, newAddend interface{}) (string, error) {
 
 // Set stores a value with the given key in the Node context.
 // This value can later be retrieved with Get.
-func (c *Scratch) Set(key string, value interface{}) string {
+func (c *Scratch) Set(key string, value any) string {
 	c.mu.Lock()
 	c.values[key] = value
 	c.mu.Unlock()
@@ -98,7 +98,7 @@ func (c *Scratch) Delete(key string) string {
 }
 
 // Get returns a value previously set by Add or Set.
-func (c *Scratch) Get(key string) interface{} {
+func (c *Scratch) Get(key string) any {
 	c.mu.RLock()
 	val := c.values[key]
 	c.mu.RUnlock()
@@ -109,7 +109,7 @@ func (c *Scratch) Get(key string) interface{} {
 // Values returns the raw backing map. Note that you should just use
 // this method on the locally scoped Scratch instances you obtain via newScratch, not
 // .Page.Scratch etc., as that will lead to concurrency issues.
-func (c *Scratch) Values() map[string]interface{} {
+func (c *Scratch) Values() map[string]any {
 	c.mu.RLock()
 	defer c.mu.RUnlock()
 	return c.values
@@ -117,14 +117,14 @@ func (c *Scratch) Values() map[string]interface{} {
 
 // SetInMap stores a value to a map with the given key in the Node context.
 // This map can later be retrieved with GetSortedMapValues.
-func (c *Scratch) SetInMap(key string, mapKey string, value interface{}) string {
+func (c *Scratch) SetInMap(key string, mapKey string, value any) string {
 	c.mu.Lock()
 	_, found := c.values[key]
 	if !found {
-		c.values[key] = make(map[string]interface{})
+		c.values[key] = make(map[string]any)
 	}
 
-	c.values[key].(map[string]interface{})[mapKey] = value
+	c.values[key].(map[string]any)[mapKey] = value
 	c.mu.Unlock()
 	return ""
 }
@@ -134,14 +134,14 @@ func (c *Scratch) DeleteInMap(key string, mapKey string) string {
 	c.mu.Lock()
 	_, found := c.values[key]
 	if found {
-		delete(c.values[key].(map[string]interface{}), mapKey)
+		delete(c.values[key].(map[string]any), mapKey)
 	}
 	c.mu.Unlock()
 	return ""
 }
 
 // GetSortedMapValues returns a sorted map previously filled with SetInMap.
-func (c *Scratch) GetSortedMapValues(key string) interface{} {
+func (c *Scratch) GetSortedMapValues(key string) any {
 	c.mu.RLock()
 
 	if c.values[key] == nil {
@@ -149,7 +149,7 @@ func (c *Scratch) GetSortedMapValues(key string) interface{} {
 		return nil
 	}
 
-	unsortedMap := c.values[key].(map[string]interface{})
+	unsortedMap := c.values[key].(map[string]any)
 	c.mu.RUnlock()
 	var keys []string
 	for mapKey := range unsortedMap {
@@ -158,7 +158,7 @@ func (c *Scratch) GetSortedMapValues(key string) interface{} {
 
 	sort.Strings(keys)
 
-	sortedArray := make([]interface{}, len(unsortedMap))
+	sortedArray := make([]any, len(unsortedMap))
 	for i, mapKey := range keys {
 		sortedArray[i] = unsortedMap[mapKey]
 	}
@@ -168,5 +168,5 @@ func (c *Scratch) GetSortedMapValues(key string) interface{} {
 
 // NewScratch returns a new instance of Scratch.
 func NewScratch() *Scratch {
-	return &Scratch{values: make(map[string]interface{})}
+	return &Scratch{values: make(map[string]any)}
 }

common/maps/scratch_test.go

@@ -90,7 +90,7 @@ func TestScratchAddTypedSliceToInterfaceSlice(t *testing.T) {
 	c := qt.New(t)
 
 	scratch := NewScratch()
-	scratch.Set("slice", []interface{}{})
+	scratch.Set("slice", []any{})
 
 	_, err := scratch.Add("slice", []int{1, 2})
 	c.Assert(err, qt.IsNil)
@@ -107,7 +107,7 @@ func TestScratchAddDifferentTypedSliceToInterfaceSlice(t *testing.T) {
 
 	_, err := scratch.Add("slice", []int{1, 2})
 	c.Assert(err, qt.IsNil)
-	c.Assert(scratch.Get("slice"), qt.DeepEquals, []interface{}{"foo", 1, 2})
+	c.Assert(scratch.Get("slice"), qt.DeepEquals, []any{"foo", 1, 2})
 }
 
 func TestScratchSet(t *testing.T) {
@@ -185,7 +185,7 @@ func TestScratchSetInMap(t *testing.T) {
 	scratch.SetInMap("key", "zyx", "Zyx")
 	scratch.SetInMap("key", "abc", "Abc (updated)")
 	scratch.SetInMap("key", "def", "Def")
-	c.Assert(scratch.GetSortedMapValues("key"), qt.DeepEquals, []interface{}{0: "Abc (updated)", 1: "Def", 2: "Lux", 3: "Zyx"})
+	c.Assert(scratch.GetSortedMapValues("key"), qt.DeepEquals, []any{0: "Abc (updated)", 1: "Def", 2: "Lux", 3: "Zyx"})
 }
 
 func TestScratchDeleteInMap(t *testing.T) {
@@ -199,7 +199,7 @@ func TestScratchDeleteInMap(t *testing.T) {
 	scratch.DeleteInMap("key", "abc")
 	scratch.SetInMap("key", "def", "Def")
 	scratch.DeleteInMap("key", "lmn") // Do nothing
-	c.Assert(scratch.GetSortedMapValues("key"), qt.DeepEquals, []interface{}{0: "Def", 1: "Lux", 2: "Zyx"})
+	c.Assert(scratch.GetSortedMapValues("key"), qt.DeepEquals, []any{0: "Def", 1: "Lux", 2: "Zyx"})
 }
 
 func TestScratchGetSortedMapValues(t *testing.T) {

common/math/math.go

@@ -20,7 +20,7 @@ import (
 
 // DoArithmetic performs arithmetic operations (+,-,*,/) using reflection to
 // determine the type of the two terms.
-func DoArithmetic(a, b interface{}, op rune) (interface{}, error) {
+func DoArithmetic(a, b any, op rune) (any, error) {
 	av := reflect.ValueOf(a)
 	bv := reflect.ValueOf(b)
 	var ai, bi int64

common/math/math_test.go

@@ -24,10 +24,10 @@ func TestDoArithmetic(t *testing.T) {
 	c := qt.New(t)
 
 	for _, test := range []struct {
-		a      interface{}
+		a      any
-		b      interface{}
+		b      any
 		op     rune
-		expect interface{}
+		expect any
 	}{
 		{3, 2, '+', int64(5)},
 		{3, 2, '-', int64(1)},

common/paths/path_test.go

@@ -24,7 +24,7 @@ func TestGetRelativePath(t *testing.T) {
 	tests := []struct {
 		path   string
 		base   string
-		expect interface{}
+		expect any
 	}{
 		{filepath.FromSlash("/a/b"), filepath.FromSlash("/a"), filepath.FromSlash("b")},
 		{filepath.FromSlash("/a/b/c/"), filepath.FromSlash("/a"), filepath.FromSlash("b/c/")},

common/text/position.go

@@ -69,7 +69,7 @@ func createPositionStringFormatter(formatStr string) func(p Position) string {
 	format := replacer.Replace(formatStr)
 
 	f := func(pos Position) string {
-		args := make([]interface{}, len(identifiersFound))
+		args := make([]any, len(identifiersFound))
 		for i, id := range identifiersFound {
 			switch id {
 			case ":file":

common/text/transform.go

@@ -24,7 +24,7 @@ import (
 )
 
 var accentTransformerPool = &sync.Pool{
-	New: func() interface{} {
+	New: func() any {
 		return transform.Chain(norm.NFD, runes.Remove(runes.In(unicode.Mn)), norm.NFC)
 	},
 }

common/types/convert.go

@@ -25,13 +25,13 @@ import (
 
 // ToDuration converts v to time.Duration.
 // See ToDurationE if you need to handle errors.
-func ToDuration(v interface{}) time.Duration {
+func ToDuration(v any) time.Duration {
 	d, _ := ToDurationE(v)
 	return d
 }
 
 // ToDurationE converts v to time.Duration.
-func ToDurationE(v interface{}) (time.Duration, error) {
+func ToDurationE(v any) (time.Duration, error) {
 	if n := cast.ToInt(v); n > 0 {
 		return time.Duration(n) * time.Millisecond, nil
 	}
@@ -44,14 +44,14 @@ func ToDurationE(v interface{}) (time.Duration, error) {
 
 // ToStringSlicePreserveString is the same as ToStringSlicePreserveStringE,
 // but it never fails.
-func ToStringSlicePreserveString(v interface{}) []string {
+func ToStringSlicePreserveString(v any) []string {
 	vv, _ := ToStringSlicePreserveStringE(v)
 	return vv
 }
 
 // ToStringSlicePreserveStringE converts v to a string slice.
 // If v is a string, it will be wrapped in a string slice.
-func ToStringSlicePreserveStringE(v interface{}) ([]string, error) {
+func ToStringSlicePreserveStringE(v any) ([]string, error) {
 	if v == nil {
 		return nil, nil
 	}
@@ -86,7 +86,7 @@ func ToStringSlicePreserveStringE(v interface{}) ([]string, error) {
 // TypeToString converts v to a string if it's a valid string type.
 // Note that this will not try to convert numeric values etc.,
 // use ToString for that.
-func TypeToString(v interface{}) (string, bool) {
+func TypeToString(v any) (string, bool) {
 	switch s := v.(type) {
 	case string:
 		return s, true
@@ -110,13 +110,13 @@ func TypeToString(v interface{}) (string, bool) {
 }
 
 // ToString converts v to a string.
-func ToString(v interface{}) string {
+func ToString(v any) string {
 	s, _ := ToStringE(v)
 	return s
 }
 
 // ToStringE converts v to a string.
-func ToStringE(v interface{}) (string, error) {
+func ToStringE(v any) (string, error) {
 	if s, ok := TypeToString(v); ok {
 		return s, nil
 	}

common/types/convert_test.go

@@ -26,7 +26,7 @@ func TestToStringSlicePreserveString(t *testing.T) {
 
 	c.Assert(ToStringSlicePreserveString("Hugo"), qt.DeepEquals, []string{"Hugo"})
 	c.Assert(ToStringSlicePreserveString(qt.Commentf("Hugo")), qt.DeepEquals, []string{"Hugo"})
-	c.Assert(ToStringSlicePreserveString([]interface{}{"A", "B"}), qt.DeepEquals, []string{"A", "B"})
+	c.Assert(ToStringSlicePreserveString([]any{"A", "B"}), qt.DeepEquals, []string{"A", "B"})
 	c.Assert(ToStringSlicePreserveString([]int{1, 3}), qt.DeepEquals, []string{"1", "3"})
 	c.Assert(ToStringSlicePreserveString(nil), qt.IsNil)
 }

common/types/types.go

@@ -29,8 +29,8 @@ type RLocker interface {
 
 // KeyValue is a interface{} tuple.
 type KeyValue struct {
-	Key   interface{}
+	Key   any
-	Value interface{}
+	Value any
 }
 
 // KeyValueStr is a string tuple.
@@ -41,8 +41,8 @@ type KeyValueStr struct {
 
 // KeyValues holds an key and a slice of values.
 type KeyValues struct {
-	Key    interface{}
+	Key    any
-	Values []interface{}
+	Values []any
 }
 
 // KeyString returns the key as a string, an empty string if conversion fails.
@@ -57,7 +57,7 @@ func (k KeyValues) String() string {
 // NewKeyValuesStrings takes a given key and slice of values and returns a new
 // KeyValues struct.
 func NewKeyValuesStrings(key string, values ...string) KeyValues {
-	iv := make([]interface{}, len(values))
+	iv := make([]any, len(values))
 	for i := 0; i < len(values); i++ {
 		iv[i] = values[i]
 	}
@@ -71,7 +71,7 @@ type Zeroer interface {
 }
 
 // IsNil reports whether v is nil.
-func IsNil(v interface{}) bool {
+func IsNil(v any) bool {
 	if v == nil {
 		return true
 	}

common/types/types_test.go

@@ -25,5 +25,5 @@ func TestKeyValues(t *testing.T) {
 	kv := NewKeyValuesStrings("key", "a1", "a2")
 
 	c.Assert(kv.KeyString(), qt.Equals, "key")
-	c.Assert(kv.Values, qt.DeepEquals, []interface{}{"a1", "a2"})
+	c.Assert(kv.Values, qt.DeepEquals, []any{"a1", "a2"})
 }

common/urls/ref.go

@@ -17,6 +17,6 @@ package urls
 // args must contain a path, but can also point to the target
 // language or output format.
 type RefLinker interface {
-	Ref(args map[string]interface{}) (string, error)
+	Ref(args map[string]any) (string, error)
-	RelRef(args map[string]interface{}) (string, error)
+	RelRef(args map[string]any) (string, error)
 }

compare/compare.go

@@ -17,13 +17,13 @@ package compare
 // The semantics of equals is that the two value are interchangeable
 // in the Hugo templates.
 type Eqer interface {
-	Eq(other interface{}) bool
+	Eq(other any) bool
 }
 
 // ProbablyEqer is an equal check that may return false positives, but never
 // a false negative.
 type ProbablyEqer interface {
-	ProbablyEq(other interface{}) bool
+	ProbablyEq(other any) bool
 }
 
 // Comparer can be used to compare two values.
@@ -31,5 +31,5 @@ type ProbablyEqer interface {
 // Compare returns -1 if the given version is less than, 0 if equal and 1 if greater than
 // the running version.
 type Comparer interface {
-	Compare(other interface{}) int
+	Compare(other any) int
 }

config/commonConfig.go

@@ -87,7 +87,7 @@ type Sitemap struct {
 	Filename   string
 }
 
-func DecodeSitemap(prototype Sitemap, input map[string]interface{}) Sitemap {
+func DecodeSitemap(prototype Sitemap, input map[string]any) Sitemap {
 	for key, value := range input {
 		switch key {
 		case "changefreq":
@@ -177,7 +177,7 @@ func (s *Server) MatchRedirect(pattern string) Redirect {
 
 type Headers struct {
 	For    string
-	Values map[string]interface{}
+	Values map[string]any
 }
 
 type Redirect struct {

config/commonConfig_test.go

@@ -27,7 +27,7 @@ func TestBuild(t *testing.T) {
 	c := qt.New(t)
 
 	v := New()
-	v.Set("build", map[string]interface{}{
+	v.Set("build", map[string]any{
 		"useResourceCacheWhen": "always",
 	})
 
@@ -35,7 +35,7 @@ func TestBuild(t *testing.T) {
 
 	c.Assert(b.UseResourceCacheWhen, qt.Equals, "always")
 
-	v.Set("build", map[string]interface{}{
+	v.Set("build", map[string]any{
 		"useResourceCacheWhen": "foo",
 	})
 

config/compositeConfig.go

@@ -47,7 +47,7 @@ func (c *compositeConfig) GetInt(key string) int {
 	return c.base.GetInt(key)
 }
 
-func (c *compositeConfig) Merge(key string, value interface{}) {
+func (c *compositeConfig) Merge(key string, value any) {
 	c.layer.Merge(key, value)
 }
 
@@ -58,7 +58,7 @@ func (c *compositeConfig) GetParams(key string) maps.Params {
 	return c.base.GetParams(key)
 }
 
-func (c *compositeConfig) GetStringMap(key string) map[string]interface{} {
+func (c *compositeConfig) GetStringMap(key string) map[string]any {
 	if c.layer.IsSet(key) {
 		return c.layer.GetStringMap(key)
 	}
@@ -79,7 +79,7 @@ func (c *compositeConfig) GetStringSlice(key string) []string {
 	return c.base.GetStringSlice(key)
 }
 
-func (c *compositeConfig) Get(key string) interface{} {
+func (c *compositeConfig) Get(key string) any {
 	if c.layer.IsSet(key) {
 		return c.layer.Get(key)
 	}
@@ -100,7 +100,7 @@ func (c *compositeConfig) GetString(key string) string {
 	return c.base.GetString(key)
 }
 
-func (c *compositeConfig) Set(key string, value interface{}) {
+func (c *compositeConfig) Set(key string, value any) {
 	c.layer.Set(key, value)
 }
 

config/configLoader.go

@@ -67,11 +67,11 @@ func FromFile(fs afero.Fs, filename string) (Provider, error) {
 
 // FromFileToMap is the same as FromFile, but it returns the config values
 // as a simple map.
-func FromFileToMap(fs afero.Fs, filename string) (map[string]interface{}, error) {
+func FromFileToMap(fs afero.Fs, filename string) (map[string]any, error) {
 	return loadConfigFromFile(fs, filename)
 }
 
-func readConfig(format metadecoders.Format, data []byte) (map[string]interface{}, error) {
+func readConfig(format metadecoders.Format, data []byte) (map[string]any, error) {
 	m, err := metadecoders.Default.UnmarshalToMap(data, format)
 	if err != nil {
 		return nil, err
@@ -82,7 +82,7 @@ func readConfig(format metadecoders.Format, data []byte) (map[string]interface{}
 	return m, nil
 }
 
-func loadConfigFromFile(fs afero.Fs, filename string) (map[string]interface{}, error) {
+func loadConfigFromFile(fs afero.Fs, filename string) (map[string]any, error) {
 	m, err := metadecoders.Default.UnmarshalFileToMap(fs, filename)
 	if err != nil {
 		return nil, err
@@ -156,13 +156,13 @@ func LoadConfigFromDir(sourceFs afero.Fs, configDir, environment string) (Provid
 
 			root := item
 			if len(keyPath) > 0 {
-				root = make(map[string]interface{})
+				root = make(map[string]any)
 				m := root
 				for i, key := range keyPath {
 					if i >= len(keyPath)-1 {
 						m[key] = item
 					} else {
-						nm := make(map[string]interface{})
+						nm := make(map[string]any)
 						m[key] = nm
 						m = nm
 					}
@@ -203,6 +203,6 @@ func init() {
 
 // RenameKeys renames config keys in m recursively according to a global Hugo
 // alias definition.
-func RenameKeys(m map[string]interface{}) {
+func RenameKeys(m map[string]any) {
 	keyAliases.Rename(m)
 }

config/configProvider.go

@@ -24,12 +24,12 @@ type Provider interface {
 	GetInt(key string) int
 	GetBool(key string) bool
 	GetParams(key string) maps.Params
-	GetStringMap(key string) map[string]interface{}
+	GetStringMap(key string) map[string]any
 	GetStringMapString(key string) map[string]string
 	GetStringSlice(key string) []string
-	Get(key string) interface{}
+	Get(key string) any
-	Set(key string, value interface{})
+	Set(key string, value any)
-	Merge(key string, value interface{})
+	Merge(key string, value any)
 	SetDefaults(params maps.Params)
 	SetDefaultMergeStrategy()
 	WalkParams(walkFn func(params ...KeyParams) bool)

config/defaultConfigProvider.go

@@ -84,7 +84,7 @@ type defaultConfigProvider struct {
 	keyCache sync.Map
 }
 
-func (c *defaultConfigProvider) Get(k string) interface{} {
+func (c *defaultConfigProvider) Get(k string) any {
 	if k == "" {
 		return c.root
 	}
@@ -133,7 +133,7 @@ func (c *defaultConfigProvider) GetParams(k string) maps.Params {
 	return v.(maps.Params)
 }
 
-func (c *defaultConfigProvider) GetStringMap(k string) map[string]interface{} {
+func (c *defaultConfigProvider) GetStringMap(k string) map[string]any {
 	v := c.Get(k)
 	return maps.ToStringMap(v)
 }
@@ -148,7 +148,7 @@ func (c *defaultConfigProvider) GetStringSlice(k string) []string {
 	return cast.ToStringSlice(v)
 }
 
-func (c *defaultConfigProvider) Set(k string, v interface{}) {
+func (c *defaultConfigProvider) Set(k string, v any) {
 	c.mu.Lock()
 	defer c.mu.Unlock()
 
@@ -166,7 +166,7 @@ func (c *defaultConfigProvider) Set(k string, v interface{}) {
 	}
 
 	switch vv := v.(type) {
-	case map[string]interface{}, map[interface{}]interface{}, map[string]string:
+	case map[string]any, map[any]any, map[string]string:
 		p := maps.MustToParamsAndPrepare(vv)
 		v = p
 	}
@@ -198,7 +198,7 @@ func (c *defaultConfigProvider) SetDefaults(params maps.Params) {
 	}
 }
 
-func (c *defaultConfigProvider) Merge(k string, v interface{}) {
+func (c *defaultConfigProvider) Merge(k string, v any) {
 	c.mu.Lock()
 	defer c.mu.Unlock()
 	k = strings.ToLower(k)
@@ -289,7 +289,7 @@ func (c *defaultConfigProvider) Merge(k string, v interface{}) {
 	}
 
 	switch vv := v.(type) {
-	case map[string]interface{}, map[interface{}]interface{}, map[string]string:
+	case map[string]any, map[any]any, map[string]string:
 		p := maps.MustToParamsAndPrepare(vv)
 		v = p
 	}

config/defaultConfigProvider_test.go

@@ -34,7 +34,7 @@ func TestDefaultConfigProvider(t *testing.T) {
 	c.Run("Set and get", func(c *qt.C) {
 		cfg := New()
 		var k string
-		var v interface{}
+		var v any
 
 		k, v = "foo", "bar"
 		cfg.Set(k, v)
@@ -55,7 +55,7 @@ func TestDefaultConfigProvider(t *testing.T) {
 	c.Run("Set and get map", func(c *qt.C) {
 		cfg := New()
 
-		cfg.Set("foo", map[string]interface{}{
+		cfg.Set("foo", map[string]any{
 			"bar": "baz",
 		})
 
@@ -63,14 +63,14 @@ func TestDefaultConfigProvider(t *testing.T) {
 			"bar": "baz",
 		})
 
-		c.Assert(cfg.GetStringMap("foo"), qt.DeepEquals, map[string]interface{}{"bar": string("baz")})
+		c.Assert(cfg.GetStringMap("foo"), qt.DeepEquals, map[string]any{"bar": string("baz")})
 		c.Assert(cfg.GetStringMapString("foo"), qt.DeepEquals, map[string]string{"bar": string("baz")})
 	})
 
 	c.Run("Set and get nested", func(c *qt.C) {
 		cfg := New()
 
-		cfg.Set("a", map[string]interface{}{
+		cfg.Set("a", map[string]any{
 			"B": "bv",
 		})
 		cfg.Set("a.c", "cv")
@@ -86,7 +86,7 @@ func TestDefaultConfigProvider(t *testing.T) {
 			"a": "av",
 		})
 
-		cfg.Set("b", map[string]interface{}{
+		cfg.Set("b", map[string]any{
 			"b": "bv",
 		})
 
@@ -99,7 +99,7 @@ func TestDefaultConfigProvider(t *testing.T) {
 
 		cfg.Set("a", "av")
 
-		cfg.Set("", map[string]interface{}{
+		cfg.Set("", map[string]any{
 			"a": "av2",
 			"b": "bv2",
 		})
@@ -113,7 +113,7 @@ func TestDefaultConfigProvider(t *testing.T) {
 
 		cfg.Set("a", "av")
 
-		cfg.Set("", map[string]interface{}{
+		cfg.Set("", map[string]any{
 			"b": "bv2",
 		})
 
@@ -124,14 +124,14 @@ func TestDefaultConfigProvider(t *testing.T) {
 
 		cfg = New()
 
-		cfg.Set("", map[string]interface{}{
+		cfg.Set("", map[string]any{
-			"foo": map[string]interface{}{
+			"foo": map[string]any{
 				"a": "av",
 			},
 		})
 
-		cfg.Set("", map[string]interface{}{
+		cfg.Set("", map[string]any{
-			"foo": map[string]interface{}{
+			"foo": map[string]any{
 				"b": "bv2",
 			},
 		})
@@ -145,11 +145,11 @@ func TestDefaultConfigProvider(t *testing.T) {
 	c.Run("Merge default strategy", func(c *qt.C) {
 		cfg := New()
 
-		cfg.Set("a", map[string]interface{}{
+		cfg.Set("a", map[string]any{
 			"B": "bv",
 		})
 
-		cfg.Merge("a", map[string]interface{}{
+		cfg.Merge("a", map[string]any{
 			"B": "bv2",
 			"c": "cv2",
 		})
@@ -163,7 +163,7 @@ func TestDefaultConfigProvider(t *testing.T) {
 
 		cfg.Set("a", "av")
 
-		cfg.Merge("", map[string]interface{}{
+		cfg.Merge("", map[string]any{
 			"a": "av2",
 			"b": "bv2",
 		})
@@ -176,16 +176,16 @@ func TestDefaultConfigProvider(t *testing.T) {
 	c.Run("Merge shallow", func(c *qt.C) {
 		cfg := New()
 
-		cfg.Set("a", map[string]interface{}{
+		cfg.Set("a", map[string]any{
 			"_merge": "shallow",
 			"B":      "bv",
-			"c": map[string]interface{}{
+			"c": map[string]any{
 				"b": "bv",
 			},
 		})
 
-		cfg.Merge("a", map[string]interface{}{
+		cfg.Merge("a", map[string]any{
-			"c": map[string]interface{}{
+			"c": map[string]any{
 				"d": "dv2",
 			},
 			"e": "ev2",
@@ -203,20 +203,20 @@ func TestDefaultConfigProvider(t *testing.T) {
 
 	// Issue #8679
 	c.Run("Merge typed maps", func(c *qt.C) {
-		for _, left := range []interface{}{
+		for _, left := range []any{
 			map[string]string{
 				"c": "cv1",
 			},
-			map[string]interface{}{
+			map[string]any{
 				"c": "cv1",
 			},
-			map[interface{}]interface{}{
+			map[any]any{
 				"c": "cv1",
 			},
 		} {
 			cfg := New()
 
-			cfg.Set("", map[string]interface{}{
+			cfg.Set("", map[string]any{
 				"b": left,
 			})
 
@@ -235,27 +235,27 @@ func TestDefaultConfigProvider(t *testing.T) {
 			})
 		}
 
-		for _, left := range []interface{}{
+		for _, left := range []any{
 			map[string]string{
 				"b": "bv1",
 			},
-			map[string]interface{}{
+			map[string]any{
 				"b": "bv1",
 			},
-			map[interface{}]interface{}{
+			map[any]any{
 				"b": "bv1",
 			},
 		} {
-			for _, right := range []interface{}{
+			for _, right := range []any{
 				map[string]string{
 					"b": "bv2",
 					"c": "cv2",
 				},
-				map[string]interface{}{
+				map[string]any{
 					"b": "bv2",
 					"c": "cv2",
 				},
-				map[interface{}]interface{}{
+				map[any]any{
 					"b": "bv2",
 					"c": "cv2",
 				},
@@ -280,12 +280,12 @@ func TestDefaultConfigProvider(t *testing.T) {
 	c.Run("Prevent _merge only maps", func(c *qt.C) {
 		cfg := New()
 
-		cfg.Set("", map[string]interface{}{
+		cfg.Set("", map[string]any{
 			"B": "bv",
 		})
 
-		cfg.Merge("", map[string]interface{}{
+		cfg.Merge("", map[string]any{
-			"c": map[string]interface{}{
+			"c": map[string]any{
 				"_merge": "shallow",
 				"d":      "dv2",
 			},
@@ -299,7 +299,7 @@ func TestDefaultConfigProvider(t *testing.T) {
 	c.Run("IsSet", func(c *qt.C) {
 		cfg := New()
 
-		cfg.Set("a", map[string]interface{}{
+		cfg.Set("a", map[string]any{
 			"B": "bv",
 		})
 
@@ -357,15 +357,15 @@ func TestDefaultConfigProvider(t *testing.T) {
 
 func BenchmarkDefaultConfigProvider(b *testing.B) {
 	type cfger interface {
-		Get(key string) interface{}
+		Get(key string) any
-		Set(key string, value interface{})
+		Set(key string, value any)
 		IsSet(key string) bool
 	}
 
-	newMap := func() map[string]interface{} {
+	newMap := func() map[string]any {
-		return map[string]interface{}{
+		return map[string]any{
-			"a": map[string]interface{}{
+			"a": map[string]any{
-				"b": map[string]interface{}{
+				"b": map[string]any{
 					"c": 32,
 					"d": 43,
 				},

config/docshelper.go

@@ -35,7 +35,7 @@ func init() {
 		cfg.Set("languages", lang)
 		cfg.SetDefaultMergeStrategy()
 
-		configHelpers := map[string]interface{}{
+		configHelpers := map[string]any{
 			"mergeStrategy": cfg.Get(""),
 		}
 		return docshelper.DocProvider{"config": configHelpers}

config/security/securityConfig.go

@@ -147,15 +147,15 @@ func (c Config) CheckAllowedHTTPMethod(method string) error {
 }
 
 // ToSecurityMap converts c to a map with 'security' as the root key.
-func (c Config) ToSecurityMap() map[string]interface{} {
+func (c Config) ToSecurityMap() map[string]any {
 	// Take it to JSON and back to get proper casing etc.
 	asJson, err := json.Marshal(c)
 	herrors.Must(err)
-	m := make(map[string]interface{})
+	m := make(map[string]any)
 	herrors.Must(json.Unmarshal(asJson, &m))
 
 	// Add the root
-	sec := map[string]interface{}{
+	sec := map[string]any{
 		"security": m,
 	}
 	return sec
@@ -196,7 +196,7 @@ func stringSliceToWhitelistHook() mapstructure.DecodeHookFuncType {
 	return func(
 		f reflect.Type,
 		t reflect.Type,
-		data interface{}) (interface{}, error) {
+		data any) (any, error) {
 
 		if t != reflect.TypeOf(Whitelist{}) {
 			return data, nil

config/services/servicesConfig_test.go

@@ -18,7 +18,6 @@ import (
 
 	qt "github.com/frankban/quicktest"
 	"github.com/gohugoio/hugo/config"
-	
 )
 
 func TestDecodeConfigFromTOML(t *testing.T) {

create/content.go

@@ -346,7 +346,7 @@ func (b *contentBuilder) openInEditorIfConfigured(filename string) error {
 	editorExec := strings.Fields(editor)[0]
 	editorFlags := strings.Fields(editor)[1:]
 
-	var args []interface{}
+	var args []any
 	for _, editorFlag := range editorFlags {
 		args = append(args, editorFlag)
 	}

create/content_test.go

@@ -40,7 +40,7 @@ func TestNewContentFromFile(t *testing.T) {
 		name     string
 		kind     string
 		path     string
-		expected interface{}
+		expected any
 	}{
 		{"Post", "post", "post/sample-1.md", []string{`title = "Post Arch title"`, `test = "test1"`, "date = \"2015-01-12T19:20:04-07:00\""}},
 		{"Post org-mode", "post", "post/org-1.org", []string{`#+title: ORG-1`}},
@@ -368,7 +368,7 @@ Some text.
 	return nil
 }
 
-func cContains(c *qt.C, v interface{}, matches ...string) {
+func cContains(c *qt.C, v any, matches ...string) {
 	for _, m := range matches {
 		c.Assert(v, qt.Contains, m)
 	}

deploy/cloudfront.go

@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+//go:build !nodeploy
 // +build !nodeploy
 
 package deploy

deploy/deploy.go

@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+//go:build !nodeploy
 // +build !nodeploy
 
 package deploy

deploy/deployConfig.go

@@ -115,7 +115,7 @@ func (m *matcher) Matches(path string) bool {
 // decode creates a config from a given Hugo configuration.
 func decodeConfig(cfg config.Provider) (deployConfig, error) {
 	var (
-		mediaTypesConfig []map[string]interface{}
+		mediaTypesConfig []map[string]any
 		dcfg             deployConfig
 	)
 

deploy/deploy_azure.go

@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+//go:build !solaris && !nodeploy
 // +build !solaris,!nodeploy
 
 package deploy

deploy/deploy_test.go

@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+//go:build !nodeploy
 // +build !nodeploy
 
 package deploy
@@ -252,7 +253,7 @@ func TestWalkLocal(t *testing.T) {
 			if got, err := walkLocal(fs, nil, nil, nil, media.DefaultTypes); err != nil {
 				t.Fatal(err)
 			} else {
-				expect := map[string]interface{}{}
+				expect := map[string]any{}
 				for _, path := range tc.Expect {
 					if _, ok := got[path]; !ok {
 						t.Errorf("expected %q in results, but was not found", path)
@@ -290,7 +291,7 @@ func TestLocalFile(t *testing.T) {
 		Description         string
 		Path                string
 		Matcher             *matcher
-		MediaTypesConfig    []map[string]interface{}
+		MediaTypesConfig    []map[string]any
 		WantContent         []byte
 		WantSize            int64
 		WantMD5             []byte
@@ -351,9 +352,9 @@ func TestLocalFile(t *testing.T) {
 		{
 			Description: "Custom MediaType",
 			Path:        "foo.hugo",
-			MediaTypesConfig: []map[string]interface{}{
+			MediaTypesConfig: []map[string]any{
 				{
-					"hugo/custom": map[string]interface{}{
+					"hugo/custom": map[string]any{
 						"suffixes": []string{"hugo"},
 					},
 				},

deploy/google.go

@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+//go:build !nodeploy
 // +build !nodeploy
 
 package deploy

deps/deps.go

@@ -68,7 +68,7 @@ type Deps struct {
 	FileCaches filecache.Caches
 
 	// The translation func to use
-	Translate func(translationID string, templateData interface{}) string `json:"-"`
+	Translate func(translationID string, templateData any) string `json:"-"`
 
 	// The language in use. TODO(bep) consolidate with site
 	Language *langs.Language
@@ -83,7 +83,7 @@ type Deps struct {
 	WithTemplate     func(templ tpl.TemplateManager) error `json:"-"`
 
 	// Used in tests
-	OverloadedTemplateFuncs map[string]interface{}
+	OverloadedTemplateFuncs map[string]any
 
 	translationProvider ResourceProvider
 
@@ -392,7 +392,7 @@ type DepsCfg struct {
 	TemplateProvider ResourceProvider
 	WithTemplate     func(templ tpl.TemplateManager) error
 	// Used in tests
-	OverloadedTemplateFuncs map[string]interface{}
+	OverloadedTemplateFuncs map[string]any
 
 	// i18n handling.
 	TranslationProvider ResourceProvider

docshelper/docs.go

@@ -17,7 +17,7 @@ package docshelper
 
 type (
 	DocProviderFunc = func() DocProvider
-	DocProvider     map[string]map[string]interface{}
+	DocProvider     map[string]map[string]any
 )
 
 var docProviderFuncs []DocProviderFunc
@@ -44,7 +44,7 @@ func GetDocProvider() DocProvider {
 }
 
 // Shallow merge
-func merge(dst, src map[string]interface{}) {
+func merge(dst, src map[string]any) {
 	for k, v := range src {
 		dst[k] = v
 	}

helpers/content.go

@@ -49,7 +49,7 @@ var (
 type ContentSpec struct {
 	Converters          markup.ConverterProvider
 	anchorNameSanitizer converter.AnchorNameSanitizer
-	getRenderer         func(t hooks.RendererType, id interface{}) interface{}
+	getRenderer         func(t hooks.RendererType, id any) any
 
 	// SummaryLength is the length of the summary that Hugo extracts from a content.
 	summaryLength int

helpers/docshelper.go

@@ -12,7 +12,7 @@ import (
 // This is is just some helpers used to create some JSON used in the Hugo docs.
 func init() {
 	docsProvider := func() docshelper.DocProvider {
-		var chromaLexers []interface{}
+		var chromaLexers []any
 
 		sort.Sort(lexers.Registry.Lexers)
 
@@ -47,7 +47,7 @@ func init() {
 
 		}
 
-		return docshelper.DocProvider{"chroma": map[string]interface{}{"lexers": chromaLexers}}
+		return docshelper.DocProvider{"chroma": map[string]any{"lexers": chromaLexers}}
 	}
 
 	docshelper.AddDocProviderFunc(docsProvider)

helpers/general.go

@@ -274,7 +274,7 @@ func (l *DistinctLogger) Reset() {
 
 // Println will log the string returned from fmt.Sprintln given the arguments,
 // but not if it has been logged before.
-func (l *DistinctLogger) Println(v ...interface{}) {
+func (l *DistinctLogger) Println(v ...any) {
 	// fmt.Sprint doesn't add space between string arguments
 	logStatement := strings.TrimSpace(fmt.Sprintln(v...))
 	l.printIfNotPrinted("println", logStatement, func() {
@@ -284,63 +284,63 @@ func (l *DistinctLogger) Println(v ...interface{}) {
 
 // Printf will log the string returned from fmt.Sprintf given the arguments,
 // but not if it has been logged before.
-func (l *DistinctLogger) Printf(format string, v ...interface{}) {
+func (l *DistinctLogger) Printf(format string, v ...any) {
 	logStatement := fmt.Sprintf(format, v...)
 	l.printIfNotPrinted("printf", logStatement, func() {
 		l.Logger.Printf(format, v...)
 	})
 }
 
-func (l *DistinctLogger) Debugf(format string, v ...interface{}) {
+func (l *DistinctLogger) Debugf(format string, v ...any) {
 	logStatement := fmt.Sprintf(format, v...)
 	l.printIfNotPrinted("debugf", logStatement, func() {
 		l.Logger.Debugf(format, v...)
 	})
 }
 
-func (l *DistinctLogger) Debugln(v ...interface{}) {
+func (l *DistinctLogger) Debugln(v ...any) {
 	logStatement := fmt.Sprint(v...)
 	l.printIfNotPrinted("debugln", logStatement, func() {
 		l.Logger.Debugln(v...)
 	})
 }
 
-func (l *DistinctLogger) Infof(format string, v ...interface{}) {
+func (l *DistinctLogger) Infof(format string, v ...any) {
 	logStatement := fmt.Sprintf(format, v...)
 	l.printIfNotPrinted("info", logStatement, func() {
 		l.Logger.Infof(format, v...)
 	})
 }
 
-func (l *DistinctLogger) Infoln(v ...interface{}) {
+func (l *DistinctLogger) Infoln(v ...any) {
 	logStatement := fmt.Sprint(v...)
 	l.printIfNotPrinted("infoln", logStatement, func() {
 		l.Logger.Infoln(v...)
 	})
 }
 
-func (l *DistinctLogger) Warnf(format string, v ...interface{}) {
+func (l *DistinctLogger) Warnf(format string, v ...any) {
 	logStatement := fmt.Sprintf(format, v...)
 	l.printIfNotPrinted("warnf", logStatement, func() {
 		l.Logger.Warnf(format, v...)
 	})
 }
 
-func (l *DistinctLogger) Warnln(v ...interface{}) {
+func (l *DistinctLogger) Warnln(v ...any) {
 	logStatement := fmt.Sprint(v...)
 	l.printIfNotPrinted("warnln", logStatement, func() {
 		l.Logger.Warnln(v...)
 	})
 }
 
-func (l *DistinctLogger) Errorf(format string, v ...interface{}) {
+func (l *DistinctLogger) Errorf(format string, v ...any) {
 	logStatement := fmt.Sprint(v...)
 	l.printIfNotPrinted("errorf", logStatement, func() {
 		l.Logger.Errorf(format, v...)
 	})
 }
 
-func (l *DistinctLogger) Errorln(v ...interface{}) {
+func (l *DistinctLogger) Errorln(v ...any) {
 	logStatement := fmt.Sprint(v...)
 	l.printIfNotPrinted("errorln", logStatement, func() {
 		l.Logger.Errorln(v...)
@@ -507,7 +507,7 @@ func PrintFs(fs afero.Fs, path string, w io.Writer) {
 
 	afero.Walk(fs, path, func(path string, info os.FileInfo, err error) error {
 		var filename string
-		var meta interface{}
+		var meta any
 		if fim, ok := info.(hugofs.FileMetaInfo); ok {
 			filename = fim.Meta().Filename
 			meta = fim.Meta()
@@ -519,8 +519,8 @@ func PrintFs(fs afero.Fs, path string, w io.Writer) {
 
 // HashString returns a hash from the given elements.
 // It will panic if the hash cannot be calculated.
-func HashString(elements ...interface{}) string {
+func HashString(elements ...any) string {
-	var o interface{}
+	var o any
 	if len(elements) == 1 {
 		o = elements[0]
 	} else {

helpers/testhelpers_test.go

@@ -16,7 +16,7 @@ func newTestPathSpec(fs *hugofs.Fs, v config.Provider) *PathSpec {
 	return ps
 }
 
-func newTestDefaultPathSpec(configKeyValues ...interface{}) *PathSpec {
+func newTestDefaultPathSpec(configKeyValues ...any) *PathSpec {
 	v := config.New()
 	fs := hugofs.NewMem(v)
 	cfg := newTestCfg()

htesting/hqt/checkers.go

@@ -49,7 +49,7 @@ type typeChecker struct {
 }
 
 // Check implements Checker.Check by checking that got and args[0] is of the same type.
-func (c *typeChecker) Check(got interface{}, args []interface{}, note func(key string, value interface{})) (err error) {
+func (c *typeChecker) Check(got any, args []any, note func(key string, value any)) (err error) {
 	if want := args[0]; reflect.TypeOf(got) != reflect.TypeOf(want) {
 		if _, ok := got.(error); ok && want == nil {
 			return errors.New("got non-nil error")
@@ -64,7 +64,7 @@ type stringChecker struct {
 }
 
 // Check implements Checker.Check by checking that got and args[0] represents the same normalized text (whitespace etc. removed).
-func (c *stringChecker) Check(got interface{}, args []interface{}, note func(key string, value interface{})) (err error) {
+func (c *stringChecker) Check(got any, args []any, note func(key string, value any)) (err error) {
 	s1, s2 := cast.ToString(got), cast.ToString(args[0])
 
 	if s1 == s2 {
@@ -93,12 +93,12 @@ func normalizeString(s string) string {
 // DeepAllowUnexported creates an option to allow compare of unexported types
 // in the given list of types.
 // see https://github.com/google/go-cmp/issues/40#issuecomment-328615283
-func DeepAllowUnexported(vs ...interface{}) cmp.Option {
+func DeepAllowUnexported(vs ...any) cmp.Option {
 	m := make(map[reflect.Type]struct{})
 	for _, v := range vs {
 		structTypes(reflect.ValueOf(v), m)
 	}
-	var typs []interface{}
+	var typs []any
 	for t := range m {
 		typs = append(typs, reflect.New(t).Elem().Interface())
 	}

hugofs/fileinfo.go

@@ -188,7 +188,7 @@ func (fi *dirNameOnlyFileInfo) IsDir() bool {
 	return true
 }
 
-func (fi *dirNameOnlyFileInfo) Sys() interface{} {
+func (fi *dirNameOnlyFileInfo) Sys() any {
 	return nil
 }
 

hugofs/rootmapping_fs.go

@@ -203,7 +203,7 @@ func (fs *RootMappingFs) Dirs(base string) ([]FileMetaInfo, error) {
 // Filter creates a copy of this filesystem with only mappings matching a filter.
 func (fs RootMappingFs) Filter(f func(m RootMapping) bool) *RootMappingFs {
 	rootMapToReal := radix.New()
-	fs.rootMapToReal.Walk(func(b string, v interface{}) bool {
+	fs.rootMapToReal.Walk(func(b string, v any) bool {
 		rms := v.([]RootMapping)
 		var nrms []RootMapping
 		for _, rm := range rms {
@@ -250,7 +250,7 @@ func (fs *RootMappingFs) Stat(name string) (os.FileInfo, error) {
 
 func (fs *RootMappingFs) hasPrefix(prefix string) bool {
 	hasPrefix := false
-	fs.rootMapToReal.WalkPrefix(prefix, func(b string, v interface{}) bool {
+	fs.rootMapToReal.WalkPrefix(prefix, func(b string, v any) bool {
 		hasPrefix = true
 		return true
 	})
@@ -277,7 +277,7 @@ func (fs *RootMappingFs) getRoots(key string) (string, []RootMapping) {
 
 func (fs *RootMappingFs) debug() {
 	fmt.Println("debug():")
-	fs.rootMapToReal.Walk(func(s string, v interface{}) bool {
+	fs.rootMapToReal.Walk(func(s string, v any) bool {
 		fmt.Println("Key", s)
 		return false
 	})
@@ -285,7 +285,7 @@ func (fs *RootMappingFs) debug() {
 
 func (fs *RootMappingFs) getRootsWithPrefix(prefix string) []RootMapping {
 	var roots []RootMapping
-	fs.rootMapToReal.WalkPrefix(prefix, func(b string, v interface{}) bool {
+	fs.rootMapToReal.WalkPrefix(prefix, func(b string, v any) bool {
 		roots = append(roots, v.([]RootMapping)...)
 		return false
 	})
@@ -295,7 +295,7 @@ func (fs *RootMappingFs) getRootsWithPrefix(prefix string) []RootMapping {
 
 func (fs *RootMappingFs) getAncestors(prefix string) []keyRootMappings {
 	var roots []keyRootMappings
-	fs.rootMapToReal.WalkPath(prefix, func(s string, v interface{}) bool {
+	fs.rootMapToReal.WalkPath(prefix, func(s string, v any) bool {
 		if strings.HasPrefix(prefix, s+filepathSeparator) {
 			roots = append(roots, keyRootMappings{
 				key:   s,
@@ -416,7 +416,7 @@ func (fs *RootMappingFs) collectDirEntries(prefix string) ([]os.FileInfo, error)
 
 	// Next add any file mounts inside the given directory.
 	prefixInside := prefix + filepathSeparator
-	fs.rootMapToReal.WalkPrefix(prefixInside, func(s string, v interface{}) bool {
+	fs.rootMapToReal.WalkPrefix(prefixInside, func(s string, v any) bool {
 		if (strings.Count(s, filepathSeparator) - level) != 1 {
 			// This directory is not part of the current, but we
 			// need to include the first name part to make it

hugolib/alias_test.go

@@ -51,13 +51,13 @@ func TestAlias(t *testing.T) {
 		fileSuffix string
 		urlPrefix  string
 		urlSuffix  string
-		settings   map[string]interface{}
+		settings   map[string]any
 	}{
-		{"/index.html", "http://example.com", "/", map[string]interface{}{"baseURL": "http://example.com"}},
+		{"/index.html", "http://example.com", "/", map[string]any{"baseURL": "http://example.com"}},
-		{"/index.html", "http://example.com/some/path", "/", map[string]interface{}{"baseURL": "http://example.com/some/path"}},
+		{"/index.html", "http://example.com/some/path", "/", map[string]any{"baseURL": "http://example.com/some/path"}},
-		{"/index.html", "http://example.com", "/", map[string]interface{}{"baseURL": "http://example.com", "canonifyURLs": true}},
+		{"/index.html", "http://example.com", "/", map[string]any{"baseURL": "http://example.com", "canonifyURLs": true}},
-		{"/index.html", "../..", "/", map[string]interface{}{"relativeURLs": true}},
+		{"/index.html", "../..", "/", map[string]any{"relativeURLs": true}},
-		{".html", "", ".html", map[string]interface{}{"uglyURLs": true}},
+		{".html", "", ".html", map[string]any{"uglyURLs": true}},
 	}
 
 	for _, test := range tests {

hugolib/cascade_test.go

@@ -335,7 +335,7 @@ Banner: post.jpg`,
 }
 
 func newCascadeTestBuilder(t testing.TB, langs []string) *sitesBuilder {
-	p := func(m map[string]interface{}) string {
+	p := func(m map[string]any) string {
 		var yamlStr string
 
 		if len(m) > 0 {
@@ -392,76 +392,76 @@ defaultContentLanguageInSubDir = false
 		}
 
 		withContent(
-			"_index.md", p(map[string]interface{}{
+			"_index.md", p(map[string]any{
 				"title": "Home",
-				"cascade": map[string]interface{}{
+				"cascade": map[string]any{
 					"title":   "Cascade Home",
 					"ICoN":    "home.png",
 					"outputs": []string{"HTML"},
 					"weight":  42,
 				},
 			}),
-			"p1.md", p(map[string]interface{}{
+			"p1.md", p(map[string]any{
 				"title": "p1",
 			}),
-			"p2.md", p(map[string]interface{}{}),
+			"p2.md", p(map[string]any{}),
-			"sect1/_index.md", p(map[string]interface{}{
+			"sect1/_index.md", p(map[string]any{
 				"title": "Sect1",
 				"type":  "stype",
-				"cascade": map[string]interface{}{
+				"cascade": map[string]any{
 					"title":      "Cascade Sect1",
 					"icon":       "sect1.png",
 					"type":       "stype",
 					"categories": []string{"catsect1"},
 				},
 			}),
-			"sect1/s1_2/_index.md", p(map[string]interface{}{
+			"sect1/s1_2/_index.md", p(map[string]any{
 				"title": "Sect1_2",
 			}),
-			"sect1/s1_2/p1.md", p(map[string]interface{}{
+			"sect1/s1_2/p1.md", p(map[string]any{
 				"title": "Sect1_2_p1",
 			}),
-			"sect1/s1_2/p2.md", p(map[string]interface{}{
+			"sect1/s1_2/p2.md", p(map[string]any{
 				"title": "Sect1_2_p2",
 			}),
-			"sect2/_index.md", p(map[string]interface{}{
+			"sect2/_index.md", p(map[string]any{
 				"title": "Sect2",
 			}),
-			"sect2/p1.md", p(map[string]interface{}{
+			"sect2/p1.md", p(map[string]any{
 				"title":      "Sect2_p1",
 				"categories": []string{"cool", "funny", "sad"},
 				"tags":       []string{"blue", "green"},
 			}),
-			"sect2/p2.md", p(map[string]interface{}{}),
+			"sect2/p2.md", p(map[string]any{}),
-			"sect3/p1.md", p(map[string]interface{}{}),
+			"sect3/p1.md", p(map[string]any{}),
 
 			// No front matter, see #6855
 			"sect3/nofrontmatter.md", `**Hello**`,
 			"sectnocontent/p1.md", `**Hello**`,
 			"sectnofrontmatter/_index.md", `**Hello**`,
 
-			"sect4/_index.md", p(map[string]interface{}{
+			"sect4/_index.md", p(map[string]any{
 				"title": "Sect4",
-				"cascade": map[string]interface{}{
+				"cascade": map[string]any{
 					"weight":  52,
 					"outputs": []string{"RSS"},
 				},
 			}),
-			"sect4/p1.md", p(map[string]interface{}{}),
+			"sect4/p1.md", p(map[string]any{}),
-			"p2.md", p(map[string]interface{}{}),
+			"p2.md", p(map[string]any{}),
-			"bundle1/index.md", p(map[string]interface{}{}),
+			"bundle1/index.md", p(map[string]any{}),
-			"bundle1/bp1.md", p(map[string]interface{}{}),
+			"bundle1/bp1.md", p(map[string]any{}),
-			"categories/_index.md", p(map[string]interface{}{
+			"categories/_index.md", p(map[string]any{
 				"title": "My Categories",
-				"cascade": map[string]interface{}{
+				"cascade": map[string]any{
 					"title":  "Cascade Category",
 					"icoN":   "cat.png",
 					"weight": 12,
 				},
 			}),
-			"categories/cool/_index.md", p(map[string]interface{}{}),
+			"categories/cool/_index.md", p(map[string]any{}),
-			"categories/sad/_index.md", p(map[string]interface{}{
+			"categories/sad/_index.md", p(map[string]any{
-				"cascade": map[string]interface{}{
+				"cascade": map[string]any{
 					"icon":   "sad.png",
 					"weight": 32,
 				},

hugolib/collections.go

@@ -28,7 +28,7 @@ var (
 // implementations have no value on their own.
 
 // Slice is not meant to be used externally. It's a bridge function
-func (p *pageState) Slice(items interface{}) (interface{}, error) {
+func (p *pageState) Slice(items any) (any, error) {
 	return page.ToPages(items)
 }
 
@@ -37,7 +37,7 @@ func (p *pageState) Slice(items interface{}) (interface{}, error) {
 // Group creates a PageGroup from a key and a Pages object
 // This method is not meant for external use. It got its non-typed arguments to satisfy
 // a very generic interface in the tpl package.
-func (p *pageState) Group(key interface{}, in interface{}) (interface{}, error) {
+func (p *pageState) Group(key any, in any) (any, error) {
 	pages, err := page.ToPages(in)
 	if err != nil {
 		return nil, err

hugolib/config_test.go

@@ -250,12 +250,12 @@ name = "menu-theme"
 
 		b.Assert(got["mediatypes"], qt.DeepEquals, maps.Params{
 			"text/m2": maps.Params{
-				"suffixes": []interface{}{
+				"suffixes": []any{
 					"m2theme",
 				},
 			},
 			"text/m1": maps.Params{
-				"suffixes": []interface{}{
+				"suffixes": []any{
 					"m1main",
 				},
 			},
@@ -293,13 +293,13 @@ name = "menu-theme"
 					"pl1": "p1-en-main",
 				},
 				"menus": maps.Params{
-					"main": []interface{}{
+					"main": []any{
-						map[string]interface{}{
+						map[string]any{
 							"name": "menu-lang-en-main",
 						},
 					},
-					"theme": []interface{}{
+					"theme": []any{
-						map[string]interface{}{
+						map[string]any{
 							"name": "menu-lang-en-theme",
 						},
 					},
@@ -313,18 +313,18 @@ name = "menu-theme"
 					"pl2": "p2-nb-theme",
 				},
 				"menus": maps.Params{
-					"main": []interface{}{
+					"main": []any{
-						map[string]interface{}{
+						map[string]any{
 							"name": "menu-lang-nb-main",
 						},
 					},
-					"theme": []interface{}{
+					"theme": []any{
-						map[string]interface{}{
+						map[string]any{
 							"name": "menu-lang-nb-theme",
 						},
 					},
-					"top": []interface{}{
+					"top": []any{
-						map[string]interface{}{
+						map[string]any{
 							"name": "menu-lang-nb-top",
 						},
 					},
@@ -399,8 +399,8 @@ name   = "menu-theme"
 				"en": maps.Params{
 					"languagename": "English",
 					"menus": maps.Params{
-						"main": []interface{}{
+						"main": []any{
-							map[string]interface{}{
+							map[string]any{
 								"name": "menu-theme",
 							},
 						},
@@ -710,9 +710,9 @@ theme_param="themevalue2"
 		c.Assert(cfg.Get("imaging.anchor"), qt.Equals, "top")
 		c.Assert(cfg.Get("imaging.quality"), qt.Equals, int64(75))
 		c.Assert(cfg.Get("imaging.resamplefilter"), qt.Equals, "CatmullRom")
-		c.Assert(cfg.Get("stringSlice"), qt.DeepEquals, []interface{}{"c", "d"})
+		c.Assert(cfg.Get("stringSlice"), qt.DeepEquals, []any{"c", "d"})
-		c.Assert(cfg.Get("floatSlice"), qt.DeepEquals, []interface{}{5.32})
+		c.Assert(cfg.Get("floatSlice"), qt.DeepEquals, []any{5.32})
-		c.Assert(cfg.Get("intSlice"), qt.DeepEquals, []interface{}{5, 8, 9})
+		c.Assert(cfg.Get("intSlice"), qt.DeepEquals, []any{5, 8, 9})
 		c.Assert(cfg.Get("params.api_config.api_key"), qt.Equals, "new_key")
 		c.Assert(cfg.Get("params.api_config.another_key"), qt.Equals, "default another_key")
 		c.Assert(cfg.Get("params.mytheme_section.theme_param"), qt.Equals, "themevalue_changed")

hugolib/configdir_test.go

@@ -119,10 +119,10 @@ p3 = "p3params_no_production"
 	c.Assert(cfg.GetString("params.p3"), qt.Equals, "p3params_development")
 	c.Assert(cfg.GetString("languages.no.params.p3"), qt.Equals, "p3params_no_development")
 
-	c.Assert(len(cfg.Get("menus.docs").([]interface{})), qt.Equals, 2)
+	c.Assert(len(cfg.Get("menus.docs").([]any)), qt.Equals, 2)
 	noMenus := cfg.Get("languages.no.menus.docs")
 	c.Assert(noMenus, qt.Not(qt.IsNil))
-	c.Assert(len(noMenus.([]interface{})), qt.Equals, 1)
+	c.Assert(len(noMenus.([]any)), qt.Equals, 1)
 }
 
 func TestLoadConfigDirError(t *testing.T) {

hugolib/content_map.go

@@ -83,7 +83,7 @@ func newContentMap(cfg contentMapConfig) *contentMap {
 		m.sections, m.taxonomies,
 	}
 
-	addToReverseMap := func(k string, n *contentNode, m map[interface{}]*contentNode) {
+	addToReverseMap := func(k string, n *contentNode, m map[any]*contentNode) {
 		k = strings.ToLower(k)
 		existing, found := m[k]
 		if found && existing != ambiguousContentNode {
@@ -96,8 +96,8 @@ func newContentMap(cfg contentMapConfig) *contentMap {
 	m.pageReverseIndex = &contentTreeReverseIndex{
 		t: []*contentTree{m.pages, m.sections, m.taxonomies},
 		contentTreeReverseIndexMap: &contentTreeReverseIndexMap{
-			initFn: func(t *contentTree, m map[interface{}]*contentNode) {
+			initFn: func(t *contentTree, m map[any]*contentNode) {
-				t.Walk(func(s string, v interface{}) bool {
+				t.Walk(func(s string, v any) bool {
 					n := v.(*contentNode)
 					if n.p != nil && !n.p.File().IsZero() {
 						meta := n.p.File().FileInfo().Meta()
@@ -396,7 +396,7 @@ func (m *contentMap) AddFilesBundle(header hugofs.FileMetaInfo, resources ...hug
 
 func (m *contentMap) CreateMissingNodes() error {
 	// Create missing home and root sections
-	rootSections := make(map[string]interface{})
+	rootSections := make(map[string]any)
 	trackRootSection := func(s string, b *contentNode) {
 		parts := strings.Split(s, "/")
 		if len(parts) > 2 {
@@ -409,7 +409,7 @@ func (m *contentMap) CreateMissingNodes() error {
 		}
 	}
 
-	m.sections.Walk(func(s string, v interface{}) bool {
+	m.sections.Walk(func(s string, v any) bool {
 		n := v.(*contentNode)
 
 		if s == "/" {
@@ -420,7 +420,7 @@ func (m *contentMap) CreateMissingNodes() error {
 		return false
 	})
 
-	m.pages.Walk(func(s string, v interface{}) bool {
+	m.pages.Walk(func(s string, v any) bool {
 		trackRootSection(s, v.(*contentNode))
 		return false
 	})
@@ -614,7 +614,7 @@ func (m *contentMap) deleteBundleMatching(matches func(b *contentNode) bool) {
 func (m *contentMap) deleteOrphanSections() {
 	var sectionsToDelete []string
 
-	m.sections.Walk(func(s string, v interface{}) bool {
+	m.sections.Walk(func(s string, v any) bool {
 		n := v.(*contentNode)
 
 		if n.fi != nil {
@@ -658,7 +658,7 @@ func (m *contentMap) deleteSectionByPath(s string) {
 }
 
 func (m *contentMap) deletePageByPath(s string) {
-	m.pages.Walk(func(s string, v interface{}) bool {
+	m.pages.Walk(func(s string, v any) bool {
 		fmt.Println("S", s)
 
 		return false
@@ -689,14 +689,14 @@ func (m *contentMap) testDump() string {
 
 	for i, r := range []*contentTree{m.pages, m.sections, m.resources} {
 		sb.WriteString(fmt.Sprintf("Tree %d:\n", i))
-		r.Walk(func(s string, v interface{}) bool {
+		r.Walk(func(s string, v any) bool {
 			sb.WriteString("\t" + s + "\n")
 			return false
 		})
 	}
 
 	for i, r := range []*contentTree{m.pages, m.sections} {
-		r.Walk(func(s string, v interface{}) bool {
+		r.Walk(func(s string, v any) bool {
 			c := v.(*contentNode)
 			cpToString := func(c *contentNode) string {
 				var sb strings.Builder
@@ -715,13 +715,13 @@ func (m *contentMap) testDump() string {
 			if i == 1 {
 				resourcesPrefix += cmLeafSeparator
 
-				m.pages.WalkPrefix(s+cmBranchSeparator, func(s string, v interface{}) bool {
+				m.pages.WalkPrefix(s+cmBranchSeparator, func(s string, v any) bool {
 					sb.WriteString("\t - P: " + filepath.ToSlash((v.(*contentNode).fi.(hugofs.FileMetaInfo)).Meta().Filename) + "\n")
 					return false
 				})
 			}
 
-			m.resources.WalkPrefix(resourcesPrefix, func(s string, v interface{}) bool {
+			m.resources.WalkPrefix(resourcesPrefix, func(s string, v any) bool {
 				sb.WriteString("\t - R: " + filepath.ToSlash((v.(*contentNode).fi.(hugofs.FileMetaInfo)).Meta().Filename) + "\n")
 				return false
 			})
@@ -791,7 +791,7 @@ type contentTrees []*contentTree
 func (t contentTrees) DeletePrefix(prefix string) int {
 	var count int
 	for _, tree := range t {
-		tree.Walk(func(s string, v interface{}) bool {
+		tree.Walk(func(s string, v any) bool {
 			return false
 		})
 		count += tree.DeletePrefix(prefix)
@@ -836,7 +836,7 @@ func (c *contentTree) WalkQuery(query pageMapQuery, walkFn contentTreeNodeCallba
 		filter = contentTreeNoListAlwaysFilter
 	}
 	if query.Prefix != "" {
-		c.WalkBelow(query.Prefix, func(s string, v interface{}) bool {
+		c.WalkBelow(query.Prefix, func(s string, v any) bool {
 			n := v.(*contentNode)
 			if filter != nil && filter(s, n) {
 				return false
@@ -847,7 +847,7 @@ func (c *contentTree) WalkQuery(query pageMapQuery, walkFn contentTreeNodeCallba
 		return
 	}
 
-	c.Walk(func(s string, v interface{}) bool {
+	c.Walk(func(s string, v any) bool {
 		n := v.(*contentNode)
 		if filter != nil && filter(s, n) {
 			return false
@@ -872,7 +872,7 @@ func (c contentTrees) WalkLinkable(fn contentTreeNodeCallback) {
 
 func (c contentTrees) Walk(fn contentTreeNodeCallback) {
 	for _, tree := range c {
-		tree.Walk(func(s string, v interface{}) bool {
+		tree.Walk(func(s string, v any) bool {
 			n := v.(*contentNode)
 			return fn(s, n)
 		})
@@ -881,7 +881,7 @@ func (c contentTrees) Walk(fn contentTreeNodeCallback) {
 
 func (c contentTrees) WalkPrefix(prefix string, fn contentTreeNodeCallback) {
 	for _, tree := range c {
-		tree.WalkPrefix(prefix, func(s string, v interface{}) bool {
+		tree.WalkPrefix(prefix, func(s string, v any) bool {
 			n := v.(*contentNode)
 			return fn(s, n)
 		})
@@ -891,7 +891,7 @@ func (c contentTrees) WalkPrefix(prefix string, fn contentTreeNodeCallback) {
 // WalkBelow walks the tree below the given prefix, i.e. it skips the
 // node with the given prefix as key.
 func (c *contentTree) WalkBelow(prefix string, fn radix.WalkFn) {
-	c.Tree.WalkPrefix(prefix, func(s string, v interface{}) bool {
+	c.Tree.WalkPrefix(prefix, func(s string, v any) bool {
 		if s == prefix {
 			return false
 		}
@@ -901,7 +901,7 @@ func (c *contentTree) WalkBelow(prefix string, fn radix.WalkFn) {
 
 func (c *contentTree) getMatch(matches func(b *contentNode) bool) string {
 	var match string
-	c.Walk(func(s string, v interface{}) bool {
+	c.Walk(func(s string, v any) bool {
 		n, ok := v.(*contentNode)
 		if !ok {
 			return false
@@ -920,7 +920,7 @@ func (c *contentTree) getMatch(matches func(b *contentNode) bool) string {
 
 func (c *contentTree) hasBelow(s1 string) bool {
 	var t bool
-	c.WalkBelow(s1, func(s2 string, v interface{}) bool {
+	c.WalkBelow(s1, func(s2 string, v any) bool {
 		t = true
 		return true
 	})
@@ -928,14 +928,14 @@ func (c *contentTree) hasBelow(s1 string) bool {
 }
 
 func (c *contentTree) printKeys() {
-	c.Walk(func(s string, v interface{}) bool {
+	c.Walk(func(s string, v any) bool {
 		fmt.Println(s)
 		return false
 	})
 }
 
 func (c *contentTree) printKeysPrefix(prefix string) {
-	c.WalkPrefix(prefix, func(s string, v interface{}) bool {
+	c.WalkPrefix(prefix, func(s string, v any) bool {
 		fmt.Println(s)
 		return false
 	})
@@ -1040,9 +1040,9 @@ type contentTreeReverseIndex struct {
 }
 
 type contentTreeReverseIndexMap struct {
-	m      map[interface{}]*contentNode
+	m      map[any]*contentNode
 	init   sync.Once
-	initFn func(*contentTree, map[interface{}]*contentNode)
+	initFn func(*contentTree, map[any]*contentNode)
 }
 
 func (c *contentTreeReverseIndex) Reset() {
@@ -1051,9 +1051,9 @@ func (c *contentTreeReverseIndex) Reset() {
 	}
 }
 
-func (c *contentTreeReverseIndex) Get(key interface{}) *contentNode {
+func (c *contentTreeReverseIndex) Get(key any) *contentNode {
 	c.init.Do(func() {
-		c.m = make(map[interface{}]*contentNode)
+		c.m = make(map[any]*contentNode)
 		for _, tree := range c.t {
 			c.initFn(tree, c.m)
 		}

hugolib/content_map_page.go

@@ -66,7 +66,7 @@ func (m *pageMap) createMissingTaxonomyNodes() error {
 	if m.cfg.taxonomyDisabled {
 		return nil
 	}
-	m.taxonomyEntries.Walk(func(s string, v interface{}) bool {
+	m.taxonomyEntries.Walk(func(s string, v any) bool {
 		n := v.(*contentNode)
 		vi := n.viewInfo
 		k := cleanSectionTreeKey(vi.name.plural + "/" + vi.termKey)
@@ -174,7 +174,7 @@ func (m *pageMap) newPageFromContentNode(n *contentNode, parentBucket *pagesMapB
 		return nil, err
 	}
 
-	ps.init.Add(func() (interface{}, error) {
+	ps.init.Add(func() (any, error) {
 		pp, err := newPagePaths(s, ps, metaProvider)
 		if err != nil {
 			return nil, err
@@ -271,7 +271,7 @@ func (m *pageMap) newResource(fim hugofs.FileMetaInfo, owner *pageState) (resour
 func (m *pageMap) createSiteTaxonomies() error {
 	m.s.taxonomies = make(TaxonomyList)
 	var walkErr error
-	m.taxonomies.Walk(func(s string, v interface{}) bool {
+	m.taxonomies.Walk(func(s string, v any) bool {
 		n := v.(*contentNode)
 		t := n.viewInfo
 
@@ -285,7 +285,7 @@ func (m *pageMap) createSiteTaxonomies() error {
 				walkErr = errors.Errorf("missing taxonomy: %s", viewName.plural)
 				return true
 			}
-			m.taxonomyEntries.WalkPrefix(s, func(ss string, v interface{}) bool {
+			m.taxonomyEntries.WalkPrefix(s, func(ss string, v any) bool {
 				b2 := v.(*contentNode)
 				info := b2.viewInfo
 				taxonomy.add(info.termKey, page.NewWeightedPage(info.weight, info.ref.p, n.p))
@@ -337,7 +337,7 @@ func (m *pageMap) assemblePages() error {
 		return err
 	}
 
-	m.pages.Walk(func(s string, v interface{}) bool {
+	m.pages.Walk(func(s string, v any) bool {
 		n := v.(*contentNode)
 
 		var shouldBuild bool
@@ -397,7 +397,7 @@ func (m *pageMap) assemblePages() error {
 func (m *pageMap) assembleResources(s string, p *pageState, parentBucket *pagesMapBucket) error {
 	var err error
 
-	m.resources.WalkPrefix(s, func(s string, v interface{}) bool {
+	m.resources.WalkPrefix(s, func(s string, v any) bool {
 		n := v.(*contentNode)
 		meta := n.fi.Meta()
 		classifier := meta.Classifier
@@ -432,7 +432,7 @@ func (m *pageMap) assembleSections() error {
 	var sectionsToDelete []string
 	var err error
 
-	m.sections.Walk(func(s string, v interface{}) bool {
+	m.sections.Walk(func(s string, v any) bool {
 		n := v.(*contentNode)
 		var shouldBuild bool
 
@@ -517,7 +517,7 @@ func (m *pageMap) assembleTaxonomies() error {
 	var taxonomiesToDelete []string
 	var err error
 
-	m.taxonomies.Walk(func(s string, v interface{}) bool {
+	m.taxonomies.Walk(func(s string, v any) bool {
 		n := v.(*contentNode)
 
 		if n.p != nil {
@@ -861,7 +861,7 @@ func (b *pagesMapBucket) getTaxonomyEntries() page.Pages {
 	ref := b.owner.treeRef
 	viewInfo := ref.n.viewInfo
 	prefix := strings.ToLower("/" + viewInfo.name.plural + "/" + viewInfo.termKey + "/")
-	ref.m.taxonomyEntries.WalkPrefix(prefix, func(s string, v interface{}) bool {
+	ref.m.taxonomyEntries.WalkPrefix(prefix, func(s string, v any) bool {
 		n := v.(*contentNode)
 		pas = append(pas, n.viewInfo.ref.p)
 		return false
@@ -967,7 +967,7 @@ func (w *sectionWalker) walkLevel(prefix string, createVisitor func() sectionWal
 
 	visitor := createVisitor()
 
-	w.m.taxonomies.WalkBelow(prefix, func(s string, v interface{}) bool {
+	w.m.taxonomies.WalkBelow(prefix, func(s string, v any) bool {
 		currentLevel := strings.Count(s, "/")
 
 		if currentLevel > level+1 {
@@ -986,7 +986,7 @@ func (w *sectionWalker) walkLevel(prefix string, createVisitor func() sectionWal
 				return true
 			}
 		} else {
-			w.m.taxonomyEntries.WalkPrefix(s, func(ss string, v interface{}) bool {
+			w.m.taxonomyEntries.WalkPrefix(s, func(ss string, v any) bool {
 				n := v.(*contentNode)
 				w.err = visitor.handlePage(ss, n)
 				return w.err != nil
@@ -998,7 +998,7 @@ func (w *sectionWalker) walkLevel(prefix string, createVisitor func() sectionWal
 		return w.err != nil
 	})
 
-	w.m.sections.WalkBelow(prefix, func(s string, v interface{}) bool {
+	w.m.sections.WalkBelow(prefix, func(s string, v any) bool {
 		currentLevel := strings.Count(s, "/")
 		if currentLevel > level+1 {
 			return false
@@ -1010,7 +1010,7 @@ func (w *sectionWalker) walkLevel(prefix string, createVisitor func() sectionWal
 			return true
 		}
 
-		w.m.pages.WalkPrefix(s+cmBranchSeparator, func(s string, v interface{}) bool {
+		w.m.pages.WalkPrefix(s+cmBranchSeparator, func(s string, v any) bool {
 			w.err = visitor.handlePage(s, v.(*contentNode))
 			return w.err != nil
 		})

hugolib/datafiles_test.go

@@ -33,10 +33,10 @@ func TestDataDir(t *testing.T) {
 	equivDataDirs[0].addSource("data/test/a.json", `{ "b" : { "c1": "red" , "c2": "blue" } }`)
 	equivDataDirs[1].addSource("data/test/a.yaml", "b:\n  c1: red\n  c2: blue")
 	equivDataDirs[2].addSource("data/test/a.toml", "[b]\nc1 = \"red\"\nc2 = \"blue\"\n")
-	expected := map[string]interface{}{
+	expected := map[string]any{
-		"test": map[string]interface{}{
+		"test": map[string]any{
-			"a": map[string]interface{}{
+			"a": map[string]any{
-				"b": map[string]interface{}{
+				"b": map[string]any{
 					"c1": "red",
 					"c2": "blue",
 				},
@@ -56,10 +56,10 @@ func TestDataDirNumeric(t *testing.T) {
 	equivDataDirs[0].addSource("data/test/a.json", `{ "b" : { "c1": 1.7 , "c2": 2.9 } }`)
 	equivDataDirs[1].addSource("data/test/a.yaml", "b:\n  c1: 1.7\n  c2: 2.9")
 	equivDataDirs[2].addSource("data/test/a.toml", "[b]\nc1 = 1.7\nc2 = 2.9\n")
-	expected := map[string]interface{}{
+	expected := map[string]any{
-		"test": map[string]interface{}{
+		"test": map[string]any{
-			"a": map[string]interface{}{
+			"a": map[string]any{
-				"b": map[string]interface{}{
+				"b": map[string]any{
 					"c1": 1.7,
 					"c2": 2.9,
 				},
@@ -75,10 +75,10 @@ func TestDataDirBoolean(t *testing.T) {
 	equivDataDirs[0].addSource("data/test/a.json", `{ "b" : { "c1": true , "c2": false } }`)
 	equivDataDirs[1].addSource("data/test/a.yaml", "b:\n  c1: true\n  c2: false")
 	equivDataDirs[2].addSource("data/test/a.toml", "[b]\nc1 = true\nc2 = false\n")
-	expected := map[string]interface{}{
+	expected := map[string]any{
-		"test": map[string]interface{}{
+		"test": map[string]any{
-			"a": map[string]interface{}{
+			"a": map[string]any{
-				"b": map[string]interface{}{
+				"b": map[string]any{
 					"c1": true,
 					"c2": false,
 				},
@@ -102,13 +102,13 @@ func TestDataDirTwoFiles(t *testing.T) {
 	equivDataDirs[2].addSource("data/test.toml", "hello = [\"world\", \"foo\"]")
 
 	expected :=
-		map[string]interface{}{
+		map[string]any{
-			"test": map[string]interface{}{
+			"test": map[string]any{
-				"hello": []interface{}{
+				"hello": []any{
 					"world",
 					"foo",
 				},
-				"foo": map[string]interface{}{
+				"foo": map[string]any{
 					"bar": "foofoo",
 				},
 			},
@@ -138,11 +138,11 @@ func TestDataDirOverriddenValue(t *testing.T) {
 	equivDataDirs[2].addSource("data/test.toml", "v1 = \"1\"")
 
 	expected :=
-		map[string]interface{}{
+		map[string]any{
-			"a": map[string]interface{}{"a": "1"},
+			"a": map[string]any{"a": "1"},
-			"test": map[string]interface{}{
+			"test": map[string]any{
-				"v1": map[string]interface{}{"v1-2": "2"},
+				"v1": map[string]any{"v1-2": "2"},
-				"v2": map[string]interface{}{"v2": []interface{}{"2", "3"}},
+				"v2": map[string]any{"v2": []any{"2", "3"}},
 			},
 		}
 
@@ -162,11 +162,11 @@ func TestDataDirArrayAtTopLevelOfFile(t *testing.T) {
 `)
 
 	expected :=
-		map[string]interface{}{
+		map[string]any{
-			"test": []interface{}{
+			"test": []any{
-				map[string]interface{}{"hello": "world"},
+				map[string]any{"hello": "world"},
-				map[string]interface{}{"what": "time"},
+				map[string]any{"what": "time"},
-				map[string]interface{}{"is": "lunch?"},
+				map[string]any{"is": "lunch?"},
 			},
 		}
 
@@ -183,12 +183,12 @@ func TestDataDirMultipleSources(t *testing.T) {
 	dd.addSource("data/test/second.yaml", "tender: 2")
 
 	expected :=
-		map[string]interface{}{
+		map[string]any{
-			"test": map[string]interface{}{
+			"test": map[string]any{
-				"first": map[string]interface{}{
+				"first": map[string]any{
 					"bar": 1,
 				},
-				"second": map[string]interface{}{
+				"second": map[string]any{
 					"tender": 2,
 				},
 			},
@@ -213,14 +213,14 @@ func TestDataDirMultipleSourcesCommingled(t *testing.T) {
 	// 1. A theme uses the same key; the main data folder wins
 	// 2. A sub folder uses the same key: the sub folder wins
 	expected :=
-		map[string]interface{}{
+		map[string]any{
-			"a": map[string]interface{}{
+			"a": map[string]any{
-				"b1": map[string]interface{}{
+				"b1": map[string]any{
 					"c1": "data/a/b1",
 					"c2": "mytheme/data/a/b1",
 				},
 				"b2": "data/a",
-				"b3": []interface{}{"x", "y", "z"},
+				"b3": []any{"x", "y", "z"},
 			},
 		}
 
@@ -239,10 +239,10 @@ func TestDataDirCollidingChildArrays(t *testing.T) {
 	// 1. A theme uses the same key; the main data folder wins
 	// 2. A sub folder uses the same key: the sub folder wins
 	expected :=
-		map[string]interface{}{
+		map[string]any{
-			"a": map[string]interface{}{
+			"a": map[string]any{
 				"b1": "data/a",
-				"b2": []interface{}{"1", "2", "3"},
+				"b2": []any{"1", "2", "3"},
 			},
 		}
 
@@ -257,9 +257,9 @@ func TestDataDirCollidingTopLevelArrays(t *testing.T) {
 	dd.addSource("data/a/b1.json", `["1", "2", "3"]`)
 
 	expected :=
-		map[string]interface{}{
+		map[string]any{
-			"a": map[string]interface{}{
+			"a": map[string]any{
-				"b1": []interface{}{"1", "2", "3"},
+				"b1": []any{"1", "2", "3"},
 			},
 		}
 
@@ -277,11 +277,11 @@ func TestDataDirCollidingMapsAndArrays(t *testing.T) {
 	dd.addSource("data/b.json", `["x", "y", "z"]`)
 
 	expected :=
-		map[string]interface{}{
+		map[string]any{
-			"a": map[string]interface{}{
+			"a": map[string]any{
 				"music": "Queen's Rebuke",
 			},
-			"b": []interface{}{"x", "y", "z"},
+			"b": []any{"x", "y", "z"},
 		}
 
 	doTestDataDir(t, dd, expected, "theme", "mytheme")
@@ -297,9 +297,9 @@ func TestDataDirNestedDirectories(t *testing.T) {
 	dd.addSource("data/test1/20/05/b.json", `{ "artist" : "Charlie Parker" }`)
 
 	expected :=
-		map[string]interface{}{
+		map[string]any{
-			"a":     []interface{}{"1", "2", "3"},
+			"a":     []any{"1", "2", "3"},
-			"test1": map[string]interface{}{"20": map[string]interface{}{"05": map[string]interface{}{"b": map[string]interface{}{"artist": "Charlie Parker"}}, "06": map[string]interface{}{"a": map[string]interface{}{"artist": "Michael Brecker"}}}},
+			"test1": map[string]any{"20": map[string]any{"05": map[string]any{"b": map[string]any{"artist": "Charlie Parker"}}, "06": map[string]any{"a": map[string]any{"artist": "Michael Brecker"}}}},
 		}
 
 	doTestDataDir(t, dd, expected, "theme", "mytheme")
@@ -313,7 +313,7 @@ func (d *dataDir) addSource(path, content string) {
 	d.sources = append(d.sources, [2]string{path, content})
 }
 
-func doTestEquivalentDataDirs(t *testing.T, equivDataDirs []dataDir, expected interface{}, configKeyValues ...interface{}) {
+func doTestEquivalentDataDirs(t *testing.T, equivDataDirs []dataDir, expected any, configKeyValues ...any) {
 	for i, dd := range equivDataDirs {
 		err := doTestDataDirImpl(t, dd, expected, configKeyValues...)
 		if err != "" {
@@ -322,14 +322,14 @@ func doTestEquivalentDataDirs(t *testing.T, equivDataDirs []dataDir, expected in
 	}
 }
 
-func doTestDataDir(t *testing.T, dd dataDir, expected interface{}, configKeyValues ...interface{}) {
+func doTestDataDir(t *testing.T, dd dataDir, expected any, configKeyValues ...any) {
 	err := doTestDataDirImpl(t, dd, expected, configKeyValues...)
 	if err != "" {
 		t.Error(err)
 	}
 }
 
-func doTestDataDirImpl(t *testing.T, dd dataDir, expected interface{}, configKeyValues ...interface{}) (err string) {
+func doTestDataDirImpl(t *testing.T, dd dataDir, expected any, configKeyValues ...any) (err string) {
 	cfg, fs := newTestCfg()
 
 	for i := 0; i < len(configKeyValues); i += 2 {

hugolib/embedded_shortcodes_test.go

@@ -294,12 +294,12 @@ func TestShortcodeTweet(t *testing.T) {
 	t.Parallel()
 
 	for i, this := range []struct {
-		privacy            map[string]interface{}
+		privacy            map[string]any
 		in, resp, expected string
 	}{
 		{
-			map[string]interface{}{
+			map[string]any{
-				"twitter": map[string]interface{}{
+				"twitter": map[string]any{
 					"simple": true,
 				},
 			},
@@ -308,8 +308,8 @@ func TestShortcodeTweet(t *testing.T) {
 			`.twitter-tweet a`,
 		},
 		{
-			map[string]interface{}{
+			map[string]any{
-				"twitter": map[string]interface{}{
+				"twitter": map[string]any{
 					"simple": false,
 				},
 			},
@@ -318,8 +318,8 @@ func TestShortcodeTweet(t *testing.T) {
 			`(?s)<blockquote class="twitter-tweet"><p lang="en" dir="ltr">Hugo 0.15 will have 30%\+ faster render times thanks to this commit <a href="https://t.co/FfzhM8bNhT">https://t.co/FfzhM8bNhT</a>  <a href="https://twitter.com/hashtag/gohugo\?src=hash&amp;ref_src=twsrc%5Etfw">#gohugo</a> <a href="https://twitter.com/hashtag/golang\?src=hash&amp;ref_src=twsrc%5Etfw">#golang</a> <a href="https://t.co/ITbMNU2BUf">https://t.co/ITbMNU2BUf</a></p>&mdash; Steve Francia \(@spf13\) <a href="https://twitter.com/spf13/status/666616452582129664\?ref_src=twsrc%5Etfw">November 17, 2015</a></blockquote>\s*<script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script>`,
 		},
 		{
-			map[string]interface{}{
+			map[string]any{
-				"twitter": map[string]interface{}{
+				"twitter": map[string]any{
 					"simple": false,
 				},
 			},
@@ -330,8 +330,8 @@ func TestShortcodeTweet(t *testing.T) {
 	} {
 		// overload getJSON to return mock API response from Twitter
 		tweetFuncMap := template.FuncMap{
-			"getJSON": func(urlParts ...interface{}) interface{} {
+			"getJSON": func(urlParts ...any) any {
-				var v interface{}
+				var v any
 				err := json.Unmarshal([]byte(this.resp), &v)
 				if err != nil {
 					t.Fatalf("[%d] unexpected error in json.Unmarshal: %s", i, err)
@@ -382,13 +382,13 @@ func TestShortcodeInstagram(t *testing.T) {
 	} {
 		// overload getJSON to return mock API response from Instagram
 		instagramFuncMap := template.FuncMap{
-			"getJSON": func(args ...interface{}) interface{} {
+			"getJSON": func(args ...any) any {
-				headers := args[len(args)-1].(map[string]interface{})
+				headers := args[len(args)-1].(map[string]any)
 				auth := headers["Authorization"]
 				if auth != "Bearer dummytoken" {
 					return fmt.Errorf("invalid access token: %q", auth)
 				}
-				var v interface{}
+				var v any
 				err := json.Unmarshal([]byte(this.resp), &v)
 				if err != nil {
 					return fmt.Errorf("[%d] unexpected error in json.Unmarshal: %s", i, err)

hugolib/filesystems/basefs_test.go

@@ -314,12 +314,12 @@ func TestStaticFsMultiHost(t *testing.T) {
 	v.Set("theme", "t1")
 	v.Set("defaultContentLanguage", "en")
 
-	langConfig := map[string]interface{}{
+	langConfig := map[string]any{
-		"no": map[string]interface{}{
+		"no": map[string]any{
 			"staticDir": "static_no",
 			"baseURL":   "https://example.org/no/",
 		},
-		"en": map[string]interface{}{
+		"en": map[string]any{
 			"baseURL": "https://example.org/en/",
 		},
 	}
@@ -362,17 +362,17 @@ func TestMakePathRelative(t *testing.T) {
 	c.Assert(fs.Source.MkdirAll(filepath.Join(workDir, "static", "d2"), 0777), qt.IsNil)
 	c.Assert(fs.Source.MkdirAll(filepath.Join(workDir, "dust", "d2"), 0777), qt.IsNil)
 
-	moduleCfg := map[string]interface{}{
+	moduleCfg := map[string]any{
-		"mounts": []interface{}{
+		"mounts": []any{
-			map[string]interface{}{
+			map[string]any{
 				"source": "dist",
 				"target": "static/mydist",
 			},
-			map[string]interface{}{
+			map[string]any{
 				"source": "dust",
 				"target": "static/foo/bar",
 			},
-			map[string]interface{}{
+			map[string]any{
 				"source": "static",
 				"target": "static",
 			},

hugolib/hugo_sites.go

@@ -79,7 +79,7 @@ type HugoSites struct {
 	codeownerInfo *codeownerInfo
 
 	// As loaded from the /data dirs
-	data map[string]interface{}
+	data map[string]any
 
 	contentInit sync.Once
 	content     *pageMaps
@@ -189,7 +189,7 @@ func (h *hugoSitesInit) Reset() {
 	h.translations.Reset()
 }
 
-func (h *HugoSites) Data() map[string]interface{} {
+func (h *HugoSites) Data() map[string]any {
 	if _, err := h.init.data.Do(); err != nil {
 		h.SendError(errors.Wrap(err, "failed to load data"))
 		return nil
@@ -359,7 +359,7 @@ func newHugoSites(cfg deps.DepsCfg, sites ...*Site) (*HugoSites, error) {
 		donec: make(chan bool),
 	}
 
-	h.init.data.Add(func() (interface{}, error) {
+	h.init.data.Add(func() (any, error) {
 		err := h.loadData(h.PathSpec.BaseFs.Data.Dirs)
 		if err != nil {
 			return nil, errors.Wrap(err, "failed to load data")
@@ -367,7 +367,7 @@ func newHugoSites(cfg deps.DepsCfg, sites ...*Site) (*HugoSites, error) {
 		return nil, nil
 	})
 
-	h.init.layouts.Add(func() (interface{}, error) {
+	h.init.layouts.Add(func() (any, error) {
 		for _, s := range h.Sites {
 			if err := s.Tmpl().(tpl.TemplateManager).MarkReady(); err != nil {
 				return nil, err
@@ -376,7 +376,7 @@ func newHugoSites(cfg deps.DepsCfg, sites ...*Site) (*HugoSites, error) {
 		return nil, nil
 	})
 
-	h.init.translations.Add(func() (interface{}, error) {
+	h.init.translations.Add(func() (any, error) {
 		if len(h.Sites) > 1 {
 			allTranslations := pagesToTranslationsMap(h.Sites)
 			assignTranslationsToPages(allTranslations, h.Sites)
@@ -385,7 +385,7 @@ func newHugoSites(cfg deps.DepsCfg, sites ...*Site) (*HugoSites, error) {
 		return nil, nil
 	})
 
-	h.init.gitInfo.Add(func() (interface{}, error) {
+	h.init.gitInfo.Add(func() (any, error) {
 		err := h.loadGitInfo()
 		if err != nil {
 			return nil, errors.Wrap(err, "failed to load Git info")
@@ -857,7 +857,7 @@ func (h *HugoSites) Pages() page.Pages {
 func (h *HugoSites) loadData(fis []hugofs.FileMetaInfo) (err error) {
 	spec := source.NewSourceSpec(h.PathSpec, nil, nil)
 
-	h.data = make(map[string]interface{})
+	h.data = make(map[string]any)
 	for _, fi := range fis {
 		fileSystem := spec.NewFilesystemFromFileMetaInfo(fi)
 		files, err := fileSystem.Files()
@@ -875,7 +875,7 @@ func (h *HugoSites) loadData(fis []hugofs.FileMetaInfo) (err error) {
 }
 
 func (h *HugoSites) handleDataFile(r source.File) error {
-	var current map[string]interface{}
+	var current map[string]any
 
 	f, err := r.FileInfo().Meta().Open()
 	if err != nil {
@@ -890,9 +890,9 @@ func (h *HugoSites) handleDataFile(r source.File) error {
 	for _, key := range keyParts {
 		if key != "" {
 			if _, ok := current[key]; !ok {
-				current[key] = make(map[string]interface{})
+				current[key] = make(map[string]any)
 			}
-			current = current[key].(map[string]interface{})
+			current = current[key].(map[string]any)
 		}
 	}
 
@@ -910,16 +910,16 @@ func (h *HugoSites) handleDataFile(r source.File) error {
 
 	switch data.(type) {
 	case nil:
-	case map[string]interface{}:
+	case map[string]any:
 
 		switch higherPrecedentData.(type) {
 		case nil:
 			current[r.BaseFileName()] = data
-		case map[string]interface{}:
+		case map[string]any:
 			// merge maps: insert entries from data for keys that
 			// don't already exist in higherPrecedentData
-			higherPrecedentMap := higherPrecedentData.(map[string]interface{})
+			higherPrecedentMap := higherPrecedentData.(map[string]any)
-			for key, value := range data.(map[string]interface{}) {
+			for key, value := range data.(map[string]any) {
 				if _, exists := higherPrecedentMap[key]; exists {
 					// this warning could happen if
 					// 1. A theme uses the same key; the main data folder wins
@@ -936,7 +936,7 @@ func (h *HugoSites) handleDataFile(r source.File) error {
 				"higher precedence %T data already in the data tree", data, r.Path(), higherPrecedentData)
 		}
 
-	case []interface{}:
+	case []any:
 		if higherPrecedentData == nil {
 			current[r.BaseFileName()] = data
 		} else {
@@ -970,7 +970,7 @@ func (h *HugoSites) errWithFileContext(err error, f source.File) error {
 	return err
 }
 
-func (h *HugoSites) readData(f source.File) (interface{}, error) {
+func (h *HugoSites) readData(f source.File) (any, error) {
 	file, err := f.FileInfo().Meta().Open()
 	if err != nil {
 		return nil, errors.Wrap(err, "readData: failed to open data file")

hugolib/hugo_sites_build_test.go

@@ -28,7 +28,7 @@ func TestMultiSitesMainLangInRoot(t *testing.T) {
 func doTestMultiSitesMainLangInRoot(t *testing.T, defaultInSubDir bool) {
 	c := qt.New(t)
 
-	siteConfig := map[string]interface{}{
+	siteConfig := map[string]any{
 		"DefaultContentLanguage":         "fr",
 		"DefaultContentLanguageInSubdir": defaultInSubDir,
 	}
@@ -1235,7 +1235,7 @@ func writeNewContentFile(t *testing.T, fs afero.Fs, title, date, filename string
 }
 
 type multiSiteTestBuilder struct {
-	configData   interface{}
+	configData   any
 	config       string
 	configFormat string
 
@@ -1251,14 +1251,14 @@ func (b *multiSiteTestBuilder) WithNewConfig(config string) *multiSiteTestBuilde
 	return b
 }
 
-func (b *multiSiteTestBuilder) WithNewConfigData(data interface{}) *multiSiteTestBuilder {
+func (b *multiSiteTestBuilder) WithNewConfigData(data any) *multiSiteTestBuilder {
 	b.WithConfigTemplate(data, b.configFormat, b.config)
 	return b
 }
 
-func newMultiSiteTestBuilder(t testing.TB, configFormat, config string, configData interface{}) *multiSiteTestBuilder {
+func newMultiSiteTestBuilder(t testing.TB, configFormat, config string, configData any) *multiSiteTestBuilder {
 	if configData == nil {
-		configData = map[string]interface{}{
+		configData = map[string]any{
 			"DefaultContentLanguage":         "fr",
 			"DefaultContentLanguageInSubdir": true,
 		}

hugolib/image_test.go

@@ -37,7 +37,7 @@ func TestImageOps(t *testing.T) {
 	c.Assert(err, qt.IsNil)
 	defer clean()
 
-	newBuilder := func(timeout interface{}) *sitesBuilder {
+	newBuilder := func(timeout any) *sitesBuilder {
 		v := config.New()
 		v.Set("workingDir", workDir)
 		v.Set("baseURL", "https://example.org")

hugolib/language_content_dir_test.go

@@ -251,7 +251,7 @@ Content.
 	c.Assert(contentStr, qt.Contains, "SVP3-RELREF: /sv/sect/p-sv-3/")
 
 	// Test RelRef with and without language indicator.
-	nn3RefArgs := map[string]interface{}{
+	nn3RefArgs := map[string]any{
 		"path": "/sect/page3.md",
 		"lang": "nn",
 	}

hugolib/page.go

@@ -79,7 +79,7 @@ type pageContext interface {
 }
 
 // wrapErr adds some context to the given error if possible.
-func wrapErr(err error, ctx interface{}) error {
+func wrapErr(err error, ctx any) error {
 	if pc, ok := ctx.(pageContext); ok {
 		return pc.wrapError(err)
 	}
@@ -139,7 +139,7 @@ func (p *pageState) Err() error {
 
 // Eq returns whether the current page equals the given page.
 // This is what's invoked when doing `{{ if eq $page $otherPage }}`
-func (p *pageState) Eq(other interface{}) bool {
+func (p *pageState) Eq(other any) bool {
 	pp, err := unwrapPage(other)
 	if err != nil {
 		return false
@@ -600,7 +600,7 @@ func (p *pageState) mapContent(bucket *pagesMapBucket, meta *pageMeta) error {
 	s := p.shortcodeState
 
 	rn := &pageContentMap{
-		items: make([]interface{}, 0, 20),
+		items: make([]any, 0, 20),
 	}
 
 	iter := p.source.parsed.Iterator()
@@ -737,12 +737,12 @@ Loop:
 	return nil
 }
 
-func (p *pageState) errorf(err error, format string, a ...interface{}) error {
+func (p *pageState) errorf(err error, format string, a ...any) error {
 	if herrors.UnwrapErrorWithFileContext(err) != nil {
 		// More isn't always better.
 		return err
 	}
-	args := append([]interface{}{p.Language().Lang, p.pathOrTitle()}, a...)
+	args := append([]any{p.Language().Lang, p.pathOrTitle()}, a...)
 	format = "[%s] page %q: " + format
 	if err == nil {
 		errors.Errorf(format, args...)

hugolib/page__content.go

@@ -111,7 +111,7 @@ type pageContentMap struct {
 	hasNonMarkdownShortcode bool
 
 	//  *shortcode, pageContentReplacement or pageparser.Item
-	items []interface{}
+	items []any
 }
 
 func (p *pageContentMap) AddBytes(item pageparser.Item) {

hugolib/page__data.go

@@ -26,7 +26,7 @@ type pageData struct {
 	data     page.Data
 }
 
-func (p *pageData) Data() interface{} {
+func (p *pageData) Data() any {
 	p.dataInit.Do(func() {
 		p.data = make(page.Data)
 

hugolib/page__meta.go

@@ -70,7 +70,7 @@ type pageMeta struct {
 	bundleType files.ContentClass
 
 	// Params contains configuration defined in the params section of page frontmatter.
-	params map[string]interface{}
+	params map[string]any
 
 	title     string
 	linkTitle string
@@ -110,7 +110,7 @@ type pageMeta struct {
 
 	// This is the raw front matter metadata that is going to be assigned to
 	// the Resources above.
-	resourcesMetadata []map[string]interface{}
+	resourcesMetadata []map[string]any
 
 	f source.File
 
@@ -121,7 +121,7 @@ type pageMeta struct {
 
 	s *Site
 
-	renderingConfigOverrides map[string]interface{}
+	renderingConfigOverrides map[string]any
 	contentConverterInit     sync.Once
 	contentConverter         converter.Converter
 }
@@ -223,7 +223,7 @@ func (p *pageMeta) IsPage() bool {
 //
 // This method is also implemented on SiteInfo.
 // TODO(bep) interface
-func (p *pageMeta) Param(key interface{}) (interface{}, error) {
+func (p *pageMeta) Param(key any) (any, error) {
 	return resource.Param(p, p.s.Info.Params(), key)
 }
 
@@ -347,7 +347,7 @@ func (pm *pageMeta) mergeBucketCascades(b1, b2 *pagesMapBucket) {
 	}
 }
 
-func (pm *pageMeta) setMetadata(parentBucket *pagesMapBucket, p *pageState, frontmatter map[string]interface{}) error {
+func (pm *pageMeta) setMetadata(parentBucket *pagesMapBucket, p *pageState, frontmatter map[string]any) error {
 	pm.params = make(maps.Params)
 
 	if frontmatter == nil && (parentBucket == nil || parentBucket.cascade == nil) {
@@ -368,7 +368,7 @@ func (pm *pageMeta) setMetadata(parentBucket *pagesMapBucket, p *pageState, fron
 			}
 		}
 	} else {
-		frontmatter = make(map[string]interface{})
+		frontmatter = make(map[string]any)
 	}
 
 	var cascade map[page.PageMatcher]maps.Params
@@ -546,22 +546,22 @@ func (pm *pageMeta) setMetadata(parentBucket *pagesMapBucket, p *pageState, fron
 			pm.translationKey = cast.ToString(v)
 			pm.params[loki] = pm.translationKey
 		case "resources":
-			var resources []map[string]interface{}
+			var resources []map[string]any
 			handled := true
 
 			switch vv := v.(type) {
-			case []map[interface{}]interface{}:
+			case []map[any]any:
 				for _, vvv := range vv {
 					resources = append(resources, maps.ToStringMap(vvv))
 				}
-			case []map[string]interface{}:
+			case []map[string]any:
 				resources = append(resources, vv...)
-			case []interface{}:
+			case []any:
 				for _, vvv := range vv {
 					switch vvvv := vvv.(type) {
-					case map[interface{}]interface{}:
+					case map[any]any:
 						resources = append(resources, maps.ToStringMap(vvvv))
-					case map[string]interface{}:
+					case map[string]any:
 						resources = append(resources, vvvv)
 					}
 				}
@@ -591,14 +591,14 @@ func (pm *pageMeta) setMetadata(parentBucket *pagesMapBucket, p *pageState, fron
 				pm.params[loki] = vv
 			default: // handle array of strings as well
 				switch vvv := vv.(type) {
-				case []interface{}:
+				case []any:
 					if len(vvv) > 0 {
 						switch vvv[0].(type) {
-						case map[interface{}]interface{}: // Proper parsing structured array from YAML based FrontMatter
+						case map[any]any:
 							pm.params[loki] = vvv
-						case map[string]interface{}: // Proper parsing structured array from JSON based FrontMatter
+						case map[string]any:
 							pm.params[loki] = vvv
-						case []interface{}:
+						case []any:
 							pm.params[loki] = vvv
 						default:
 							a := make([]string, len(vvv))
@@ -744,7 +744,7 @@ func (p *pageMeta) applyDefaultValues(n *contentNode) error {
 	}
 
 	if !p.f.IsZero() {
-		var renderingConfigOverrides map[string]interface{}
+		var renderingConfigOverrides map[string]any
 		bfParam := getParamToLower(p, "blackfriday")
 		if bfParam != nil {
 			renderingConfigOverrides = maps.ToStringMap(bfParam)
@@ -757,7 +757,7 @@ func (p *pageMeta) applyDefaultValues(n *contentNode) error {
 	return nil
 }
 
-func (p *pageMeta) newContentConverter(ps *pageState, markup string, renderingConfigOverrides map[string]interface{}) (converter.Converter, error) {
+func (p *pageMeta) newContentConverter(ps *pageState, markup string, renderingConfigOverrides map[string]any) (converter.Converter, error) {
 	if ps == nil {
 		panic("no Page provided")
 	}
@@ -806,7 +806,7 @@ func (p *pageMeta) Slug() string {
 	return p.urlPaths.Slug
 }
 
-func getParam(m resource.ResourceParamsProvider, key string, stringToLower bool) interface{} {
+func getParam(m resource.ResourceParamsProvider, key string, stringToLower bool) any {
 	v := m.Params()[strings.ToLower(key)]
 
 	if v == nil {
@@ -837,6 +837,6 @@ func getParam(m resource.ResourceParamsProvider, key string, stringToLower bool)
 	}
 }
 
-func getParamToLower(m resource.ResourceParamsProvider, key string) interface{} {
+func getParamToLower(m resource.ResourceParamsProvider, key string) any {
 	return getParam(m, key, true)
 }

hugolib/page__new.go

@@ -92,7 +92,7 @@ func newPageBucket(p *pageState) *pagesMapBucket {
 func newPageFromMeta(
 	n *contentNode,
 	parentBucket *pagesMapBucket,
-	meta map[string]interface{},
+	meta map[string]any,
 	metaProvider *pageMeta) (*pageState, error) {
 	if metaProvider.f == nil {
 		metaProvider.f = page.NewZeroFile(metaProvider.s.LogDistinct)
@@ -119,7 +119,7 @@ func newPageFromMeta(
 		return nil, err
 	}
 
-	ps.init.Add(func() (interface{}, error) {
+	ps.init.Add(func() (any, error) {
 		pp, err := newPagePaths(metaProvider.s, ps, metaProvider)
 		if err != nil {
 			return nil, err
@@ -189,7 +189,7 @@ type pageDeprecatedWarning struct {
 func (p *pageDeprecatedWarning) IsDraft() bool          { return p.p.m.draft }
 func (p *pageDeprecatedWarning) Hugo() hugo.Info        { return p.p.s.Info.Hugo() }
 func (p *pageDeprecatedWarning) LanguagePrefix() string { return p.p.s.Info.LanguagePrefix }
-func (p *pageDeprecatedWarning) GetParam(key string) interface{} {
+func (p *pageDeprecatedWarning) GetParam(key string) any {
 	return p.p.m.params[strings.ToLower(key)]
 }
 

hugolib/page__paginator.go

@@ -41,7 +41,7 @@ func (p *pagePaginator) reset() {
 	p.pagePaginatorInit = &pagePaginatorInit{}
 }
 
-func (p *pagePaginator) Paginate(seq interface{}, options ...interface{}) (*page.Pager, error) {
+func (p *pagePaginator) Paginate(seq any, options ...any) (*page.Pager, error) {
 	var initErr error
 	p.init.Do(func() {
 		pagerSize, err := page.ResolvePagerSize(p.source.s.Cfg, options...)
@@ -68,7 +68,7 @@ func (p *pagePaginator) Paginate(seq interface{}, options ...interface{}) (*page
 	return p.current, nil
 }
 
-func (p *pagePaginator) Paginator(options ...interface{}) (*page.Pager, error) {
+func (p *pagePaginator) Paginator(options ...any) (*page.Pager, error) {
 	var initErr error
 	p.init.Do(func() {
 		pagerSize, err := page.ResolvePagerSize(p.source.s.Cfg, options...)

hugolib/page__per_output.go

@@ -195,11 +195,11 @@ func newPageContentOutput(p *pageState, po *pageOutput) (*pageContentOutput, err
 	}
 
 	// There may be recursive loops in shortcodes and render hooks.
-	cp.initMain = parent.BranchWithTimeout(p.s.siteCfg.timeout, func(ctx context.Context) (interface{}, error) {
+	cp.initMain = parent.BranchWithTimeout(p.s.siteCfg.timeout, func(ctx context.Context) (any, error) {
 		return nil, initContent()
 	})
 
-	cp.initPlain = cp.initMain.Branch(func() (interface{}, error) {
+	cp.initPlain = cp.initMain.Branch(func() (any, error) {
 		cp.plain = helpers.StripHTML(string(cp.content))
 		cp.plainWords = strings.Fields(cp.plain)
 		cp.setWordCounts(p.m.isCJKLanguage)
@@ -272,7 +272,7 @@ func (p *pageContentOutput) Reset() {
 	p.renderHooks = &renderHooks{}
 }
 
-func (p *pageContentOutput) Content() (interface{}, error) {
+func (p *pageContentOutput) Content() (any, error) {
 	if p.p.s.initInit(p.initMain, p.p) {
 		return p.content, nil
 	}
@@ -330,7 +330,7 @@ func (p *pageContentOutput) WordCount() int {
 	return p.wordCount
 }
 
-func (p *pageContentOutput) RenderString(args ...interface{}) (template.HTML, error) {
+func (p *pageContentOutput) RenderString(args ...any) (template.HTML, error) {
 	if len(args) < 1 || len(args) > 2 {
 		return "", errors.New("want 1 or 2 arguments")
 	}
@@ -342,7 +342,7 @@ func (p *pageContentOutput) RenderString(args ...interface{}) (template.HTML, er
 	if len(args) == 1 {
 		sidx = 0
 	} else {
-		m, ok := args[0].(map[string]interface{})
+		m, ok := args[0].(map[string]any)
 		if !ok {
 			return "", errors.New("first argument must be a map")
 		}
@@ -433,14 +433,14 @@ func (p *pageContentOutput) initRenderHooks() error {
 
 		type cacheKey struct {
 			tp hooks.RendererType
-			id interface{}
+			id any
 			f  output.Format
 		}
 
-		renderCache := make(map[cacheKey]interface{})
+		renderCache := make(map[cacheKey]any)
 		var renderCacheMu sync.Mutex
 
-		resolvePosition := func(ctx interface{}) text.Position {
+		resolvePosition := func(ctx any) text.Position {
 			var offset int
 
 			switch v := ctx.(type) {
@@ -459,7 +459,7 @@ func (p *pageContentOutput) initRenderHooks() error {
 			return pos
 		}
 
-		p.renderHooks.getRenderer = func(tp hooks.RendererType, id interface{}) interface{} {
+		p.renderHooks.getRenderer = func(tp hooks.RendererType, id any) any {
 			renderCacheMu.Lock()
 			defer renderCacheMu.Unlock()
 
@@ -650,7 +650,7 @@ func (t targetPathsHolder) targetPaths() page.TargetPaths {
 	return t.paths
 }
 
-func executeToString(h tpl.TemplateHandler, templ tpl.Template, data interface{}) (string, error) {
+func executeToString(h tpl.TemplateHandler, templ tpl.Template, data any) (string, error) {
 	b := bp.GetBuffer()
 	defer bp.PutBuffer(b)
 	if err := h.Execute(templ, b, data); err != nil {

hugolib/page__ref.go

@@ -30,23 +30,23 @@ type pageRef struct {
 	p *pageState
 }
 
-func (p pageRef) Ref(argsm map[string]interface{}) (string, error) {
+func (p pageRef) Ref(argsm map[string]any) (string, error) {
 	return p.ref(argsm, p.p)
 }
 
-func (p pageRef) RefFrom(argsm map[string]interface{}, source interface{}) (string, error) {
+func (p pageRef) RefFrom(argsm map[string]any, source any) (string, error) {
 	return p.ref(argsm, source)
 }
 
-func (p pageRef) RelRef(argsm map[string]interface{}) (string, error) {
+func (p pageRef) RelRef(argsm map[string]any) (string, error) {
 	return p.relRef(argsm, p.p)
 }
 
-func (p pageRef) RelRefFrom(argsm map[string]interface{}, source interface{}) (string, error) {
+func (p pageRef) RelRefFrom(argsm map[string]any, source any) (string, error) {
 	return p.relRef(argsm, source)
 }
 
-func (p pageRef) decodeRefArgs(args map[string]interface{}) (refArgs, *Site, error) {
+func (p pageRef) decodeRefArgs(args map[string]any) (refArgs, *Site, error) {
 	var ra refArgs
 	err := mapstructure.WeakDecode(args, &ra)
 	if err != nil {
@@ -74,7 +74,7 @@ func (p pageRef) decodeRefArgs(args map[string]interface{}) (refArgs, *Site, err
 	return ra, s, nil
 }
 
-func (p pageRef) ref(argsm map[string]interface{}, source interface{}) (string, error) {
+func (p pageRef) ref(argsm map[string]any, source any) (string, error) {
 	args, s, err := p.decodeRefArgs(argsm)
 	if err != nil {
 		return "", errors.Wrap(err, "invalid arguments to Ref")
@@ -91,7 +91,7 @@ func (p pageRef) ref(argsm map[string]interface{}, source interface{}) (string,
 	return s.refLink(args.Path, source, false, args.OutputFormat)
 }
 
-func (p pageRef) relRef(argsm map[string]interface{}, source interface{}) (string, error) {
+func (p pageRef) relRef(argsm map[string]any, source any) (string, error) {
 	args, s, err := p.decodeRefArgs(argsm)
 	if err != nil {
 		return "", errors.Wrap(err, "invalid arguments to Ref")

hugolib/page__tree.go

@@ -25,7 +25,7 @@ type pageTree struct {
 	p *pageState
 }
 
-func (pt pageTree) IsAncestor(other interface{}) (bool, error) {
+func (pt pageTree) IsAncestor(other any) (bool, error) {
 	if pt.p == nil {
 		return false, nil
 	}
@@ -71,7 +71,7 @@ func (pt pageTree) CurrentSection() page.Page {
 	return p.Parent()
 }
 
-func (pt pageTree) IsDescendant(other interface{}) (bool, error) {
+func (pt pageTree) IsDescendant(other any) (bool, error) {
 	if pt.p == nil {
 		return false, nil
 	}
@@ -125,7 +125,7 @@ func (pt pageTree) FirstSection() page.Page {
 	return b.p
 }
 
-func (pt pageTree) InSection(other interface{}) (bool, error) {
+func (pt pageTree) InSection(other any) (bool, error) {
 	if pt.p == nil || types.IsNil(other) {
 		return false, nil
 	}

hugolib/page_test.go

@@ -298,7 +298,7 @@ func checkPageTitle(t *testing.T, page page.Page, title string) {
 	}
 }
 
-func checkPageContent(t *testing.T, page page.Page, expected string, msg ...interface{}) {
+func checkPageContent(t *testing.T, page page.Page, expected string, msg ...any) {
 	t.Helper()
 	a := normalizeContent(expected)
 	b := normalizeContent(content(page))
@@ -325,7 +325,7 @@ func checkPageTOC(t *testing.T, page page.Page, toc string) {
 	}
 }
 
-func checkPageSummary(t *testing.T, page page.Page, summary string, msg ...interface{}) {
+func checkPageSummary(t *testing.T, page page.Page, summary string, msg ...any) {
 	a := normalizeContent(string(page.Summary()))
 	b := normalizeContent(summary)
 	if a != b {
@@ -369,7 +369,7 @@ func normalizeExpected(ext, str string) string {
 }
 
 func testAllMarkdownEnginesForPages(t *testing.T,
-	assertFunc func(t *testing.T, ext string, pages page.Pages), settings map[string]interface{}, pageSources ...string) {
+	assertFunc func(t *testing.T, ext string, pages page.Pages), settings map[string]any, pageSources ...string) {
 
 	engines := []struct {
 		ext           string
@@ -399,8 +399,8 @@ func testAllMarkdownEnginesForPages(t *testing.T,
 				contentDir = s
 			}
 
-			cfg.Set("security", map[string]interface{}{
+			cfg.Set("security", map[string]any{
-				"exec": map[string]interface{}{
+				"exec": map[string]any{
 					"allow": []string{"^python$", "^rst2html.*", "^asciidoctor$"},
 				},
 			})
@@ -572,7 +572,7 @@ func TestCreateNewPage(t *testing.T) {
 		checkPageType(t, p, "page")
 	}
 
-	settings := map[string]interface{}{
+	settings := map[string]any{
 		"contentDir": "mycontent",
 	}
 
@@ -697,7 +697,7 @@ func TestPageWithShortCodeInSummary(t *testing.T) {
 func TestPageWithAdditionalExtension(t *testing.T) {
 	t.Parallel()
 	cfg, fs := newTestCfg()
-	cfg.Set("markup", map[string]interface{}{
+	cfg.Set("markup", map[string]any{
 		"defaultMarkdownHandler": "blackfriday", // TODO(bep)
 	})
 
@@ -1039,18 +1039,18 @@ func TestPageWithLastmodFromGitInfo(t *testing.T) {
 	wd, err := os.Getwd()
 	c.Assert(err, qt.IsNil)
 
-	cfg.Set("frontmatter", map[string]interface{}{
+	cfg.Set("frontmatter", map[string]any{
 		"lastmod": []string{":git", "lastmod"},
 	})
 	cfg.Set("defaultContentLanguage", "en")
 
-	langConfig := map[string]interface{}{
+	langConfig := map[string]any{
-		"en": map[string]interface{}{
+		"en": map[string]any{
 			"weight":       1,
 			"languageName": "English",
 			"contentDir":   "content",
 		},
-		"nn": map[string]interface{}{
+		"nn": map[string]any{
 			"weight":       2,
 			"languageName": "Nynorsk",
 			"contentDir":   "content_nn",
@@ -1102,7 +1102,7 @@ lastMod: 2018-02-28
 Content
 `
 
-			cfg.Set("frontmatter", map[string]interface{}{
+			cfg.Set("frontmatter", map[string]any{
 				"date": []string{dateHandler, "date"},
 			})
 
@@ -1163,7 +1163,7 @@ func TestWordCountWithAllCJKRunesWithoutHasCJKLanguage(t *testing.T) {
 
 func TestWordCountWithAllCJKRunesHasCJKLanguage(t *testing.T) {
 	t.Parallel()
-	settings := map[string]interface{}{"hasCJKLanguage": true}
+	settings := map[string]any{"hasCJKLanguage": true}
 
 	assertFunc := func(t *testing.T, ext string, pages page.Pages) {
 		p := pages[0]
@@ -1176,7 +1176,7 @@ func TestWordCountWithAllCJKRunesHasCJKLanguage(t *testing.T) {
 
 func TestWordCountWithMainEnglishWithCJKRunes(t *testing.T) {
 	t.Parallel()
-	settings := map[string]interface{}{"hasCJKLanguage": true}
+	settings := map[string]any{"hasCJKLanguage": true}
 
 	assertFunc := func(t *testing.T, ext string, pages page.Pages) {
 		p := pages[0]
@@ -1195,7 +1195,7 @@ func TestWordCountWithMainEnglishWithCJKRunes(t *testing.T) {
 
 func TestWordCountWithIsCJKLanguageFalse(t *testing.T) {
 	t.Parallel()
-	settings := map[string]interface{}{
+	settings := map[string]any{
 		"hasCJKLanguage": true,
 	}