media: Make Type comparable

So we can use it and output.Format as map key etc.

This commit also fixes the media.Type implementation so it does not need to mutate itself to handle different suffixes for the same MIME type, e.g. jpg vs. jpeg.

This means that there are no Suffix or FullSuffix on media.Type anymore.

Fixes #8317
Fixes #8324

19 files changed, 255 insertions, 196 deletions

diff --git a/deploy/deploy.go b/deploy/deploy.go
index 1aaae5aa7..c75461750 100644
--- a/deploy/deploy.go
+++ b/deploy/deploy.go
@@ -432,7 +432,7 @@ func (lf *localFile) ContentType() string {
 	}
 
 	ext := filepath.Ext(lf.NativePath)
-	if mimeType, found := lf.mediaTypes.GetFirstBySuffix(strings.TrimPrefix(ext, ".")); found {
+	if mimeType, _, found := lf.mediaTypes.GetFirstBySuffix(strings.TrimPrefix(ext, ".")); found {
 		return mimeType.Type()
 	}
 
diff --git a/hugolib/config_test.go b/hugolib/config_test.go
index aeeee5fa5..ecb450067 100644
--- a/hugolib/config_test.go
+++ b/hugolib/config_test.go
@@ -220,8 +220,9 @@ map[string]interface {}{
       MainType: "text",
       SubType: "m1",
       Delimiter: ".",
-      Suffixes: []string{
-        "m1main",
+      FirstSuffix: SuffixInfo{
+        Suffix: "m1main",
+        FullSuffix: ".m1main",
       },
     },
   },
@@ -231,8 +232,9 @@ map[string]interface {}{
       MainType: "text",
       SubType: "m2",
       Delimiter: ".",
-      Suffixes: []string{
-        "m2theme",
+      FirstSuffix: SuffixInfo{
+        Suffix: "m2theme",
+        FullSuffix: ".m2theme",
       },
     },
   },
diff --git a/hugolib/pagebundler_test.go b/hugolib/pagebundler_test.go
index fc02d5857..7d775871a 100644
--- a/hugolib/pagebundler_test.go
+++ b/hugolib/pagebundler_test.go
@@ -34,8 +34,6 @@ import (
 
 	"github.com/gohugoio/hugo/htesting"
 
-	"github.com/gohugoio/hugo/media"
-
 	"github.com/gohugoio/hugo/deps"
 	"github.com/spf13/viper"
 
@@ -76,7 +74,7 @@ func TestPageBundlerSiteRegular(t *testing.T) {
 
 						cfg.Set("outputFormats", map[string]interface{}{
 							"CUSTOMO": map[string]interface{}{
-								"mediaType":     media.HTMLType,
+								"mediaType":     "text/html",
 								"baseName":      "cindex",
 								"path":          "cpath",
 								"permalinkable": true,
diff --git a/hugolib/site.go b/hugolib/site.go
index d2a5e68ae..3c7c03bd1 100644
--- a/hugolib/site.go
+++ b/hugolib/site.go
@@ -913,7 +913,7 @@ type whatChanged struct {
 // package, so it will behave correctly with Hugo's built-in server.
 func (s *Site) RegisterMediaTypes() {
 	for _, mt := range s.mediaTypesConfig {
-		for _, suffix := range mt.Suffixes {
+		for _, suffix := range mt.Suffixes() {
 			_ = mime.AddExtensionType(mt.Delimiter+suffix, mt.Type()+"; charset=utf-8")
 		}
 	}
diff --git a/hugolib/site_output_test.go b/hugolib/site_output_test.go
index 5a329942c..1961dd06f 100644
--- a/hugolib/site_output_test.go
+++ b/hugolib/site_output_test.go
@@ -305,13 +305,14 @@ baseName = "customdelimbase"
 
 	c.Assert(err, qt.IsNil)
 
+	s := h.Sites[0]
+
 	th.assertFileContent("public/_redirects", "a dotless")
 	th.assertFileContent("public/defaultdelimbase.defd", "default delimim")
 	// This looks weird, but the user has chosen this definition.
 	th.assertFileContent("public/nosuffixbase", "no suffix")
 	th.assertFileContent("public/customdelimbase_del", "custom delim")
 
-	s := h.Sites[0]
 	home := s.getPage(page.KindHome)
 	c.Assert(home, qt.Not(qt.IsNil))
 
diff --git a/media/mediaType.go b/media/mediaType.go
index 9e35212b2..a35d80e3e 100644
--- a/media/mediaType.go
+++ b/media/mediaType.go
@@ -20,6 +20,8 @@ import (
 	"sort"
 	"strings"
 
+	"github.com/spf13/cast"
+
 	"github.com/gohugoio/hugo/common/maps"
 
 	"github.com/mitchellh/mapstructure"
@@ -36,28 +38,37 @@ const (
 // If suffix is not provided, the sub type will be used.
 // See // https://en.wikipedia.org/wiki/Media_type
 type Type struct {
-	MainType string `json:"mainType"` // i.e. text
-	SubType  string `json:"subType"`  // i.e. html
+	MainType  string `json:"mainType"`  // i.e. text
+	SubType   string `json:"subType"`   // i.e. html
+	Delimiter string `json:"delimiter"` // e.g. "."
+
+	// FirstSuffix holds the first suffix defined for this Type.
+	FirstSuffix SuffixInfo `json:"firstSuffix"`
 
 	// This is the optional suffix after the "+" in the MIME type,
 	//  e.g. "xml" in "application/rss+xml".
 	mimeSuffix string
 
-	Delimiter string `json:"delimiter"` // e.g. "."
-
-	Suffixes []string `json:"suffixes"`
+	// E.g. "jpg,jpeg"
+	// Stored as a string to make Type comparable.
+	suffixesCSV string
+}
 
-	// Set when doing lookup by suffix.
-	fileSuffix string
+// SuffixInfo holds information about a Type's suffix.
+type SuffixInfo struct {
+	Suffix     string `json:"suffix"`
+	FullSuffix string `json:"fullSuffix"`
 }
 
-// FromStringAndExt is same as FromString, but adds the file extension to the type.
+// FromStringAndExt creates a Type from a MIME string and a given extension.
 func FromStringAndExt(t, ext string) (Type, error) {
 	tp, err := fromString(t)
 	if err != nil {
 		return tp, err
 	}
-	tp.Suffixes = []string{strings.TrimPrefix(ext, ".")}
+	tp.suffixesCSV = strings.TrimPrefix(ext, ".")
+	tp.Delimiter = defaultDelimiter
+	tp.init()
 	return tp, nil
 }
 
@@ -102,61 +113,83 @@ func (m Type) String() string {
 	return m.Type()
 }
 
-// FullSuffix returns the file suffix with any delimiter prepended.
-func (m Type) FullSuffix() string {
-	return m.Delimiter + m.Suffix()
+// Suffixes returns all valid file suffixes for this type.
+func (m Type) Suffixes() []string {
+	if m.suffixesCSV == "" {
+		return nil
+	}
+
+	return strings.Split(m.suffixesCSV, ",")
 }
 
-// Suffix returns the file suffix without any delimiter prepended.
-func (m Type) Suffix() string {
-	if m.fileSuffix != "" {
-		return m.fileSuffix
-	}
-	if len(m.Suffixes) > 0 {
-		return m.Suffixes[0]
+func (m *Type) init() {
+	m.FirstSuffix.FullSuffix = ""
+	m.FirstSuffix.Suffix = ""
+	if suffixes := m.Suffixes(); suffixes != nil {
+		m.FirstSuffix.Suffix = suffixes[0]
+		m.FirstSuffix.FullSuffix = m.Delimiter + m.FirstSuffix.Suffix
 	}
-	// There are MIME types without file suffixes.
-	return ""
+}
+
+// WithDelimiterAndSuffixes is used in tests.
+func WithDelimiterAndSuffixes(t Type, delimiter, suffixesCSV string) Type {
+	t.Delimiter = delimiter
+	t.suffixesCSV = suffixesCSV
+	t.init()
+	return t
+}
+
+func newMediaType(main, sub string, suffixes []string) Type {
+	t := Type{MainType: main, SubType: sub, suffixesCSV: strings.Join(suffixes, ","), Delimiter: defaultDelimiter}
+	t.init()
+	return t
+}
+
+func newMediaTypeWithMimeSuffix(main, sub, mimeSuffix string, suffixes []string) Type {
+	mt := newMediaType(main, sub, suffixes)
+	mt.mimeSuffix = mimeSuffix
+	mt.init()
+	return mt
 }
 
 // Definitions from https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types etc.
 // Note that from Hugo 0.44 we only set Suffix if it is part of the MIME type.
 var (
-	CalendarType   = Type{MainType: "text", SubType: "calendar", Suffixes: []string{"ics"}, Delimiter: defaultDelimiter}
-	CSSType        = Type{MainType: "text", SubType: "css", Suffixes: []string{"css"}, Delimiter: defaultDelimiter}
-	SCSSType       = Type{MainType: "text", SubType: "x-scss", Suffixes: []string{"scss"}, Delimiter: defaultDelimiter}
-	SASSType       = Type{MainType: "text", SubType: "x-sass", Suffixes: []string{"sass"}, Delimiter: defaultDelimiter}
-	CSVType        = Type{MainType: "text", SubType: "csv", Suffixes: []string{"csv"}, Delimiter: defaultDelimiter}
-	HTMLType       = Type{MainType: "text", SubType: "html", Suffixes: []string{"html"}, Delimiter: defaultDelimiter}
-	JavascriptType = Type{MainType: "application", SubType: "javascript", Suffixes: []string{"js"}, Delimiter: defaultDelimiter}
-	TypeScriptType = Type{MainType: "application", SubType: "typescript", Suffixes: []string{"ts"}, Delimiter: defaultDelimiter}
-	TSXType        = Type{MainType: "text", SubType: "tsx", Suffixes: []string{"tsx"}, Delimiter: defaultDelimiter}
-	JSXType        = Type{MainType: "text", SubType: "jsx", Suffixes: []string{"jsx"}, Delimiter: defaultDelimiter}
-
-	JSONType = Type{MainType: "application", SubType: "json", Suffixes: []string{"json"}, Delimiter: defaultDelimiter}
-	RSSType  = Type{MainType: "application", SubType: "rss", mimeSuffix: "xml", Suffixes: []string{"xml"}, Delimiter: defaultDelimiter}
-	XMLType  = Type{MainType: "application", SubType: "xml", Suffixes: []string{"xml"}, Delimiter: defaultDelimiter}
-	SVGType  = Type{MainType: "image", SubType: "svg", mimeSuffix: "xml", Suffixes: []string{"svg"}, Delimiter: defaultDelimiter}
-	TextType = Type{MainType: "text", SubType: "plain", Suffixes: []string{"txt"}, Delimiter: defaultDelimiter}
-	TOMLType = Type{MainType: "application", SubType: "toml", Suffixes: []string{"toml"}, Delimiter: defaultDelimiter}
-	YAMLType = Type{MainType: "application", SubType: "yaml", Suffixes: []string{"yaml", "yml"}, Delimiter: defaultDelimiter}
+	CalendarType   = newMediaType("text", "calendar", []string{"ics"})
+	CSSType        = newMediaType("text", "css", []string{"css"})
+	SCSSType       = newMediaType("text", "x-scss", []string{"scss"})
+	SASSType       = newMediaType("text", "x-sass", []string{"sass"})
+	CSVType        = newMediaType("text", "csv", []string{"csv"})
+	HTMLType       = newMediaType("text", "html", []string{"html"})
+	JavascriptType = newMediaType("application", "javascript", []string{"js"})
+	TypeScriptType = newMediaType("application", "typescript", []string{"ts"})
+	TSXType        = newMediaType("text", "tsx", []string{"tsx"})
+	JSXType        = newMediaType("text", "jsx", []string{"jsx"})
+
+	JSONType = newMediaType("application", "json", []string{"json"})
+	RSSType  = newMediaTypeWithMimeSuffix("application", "rss", "xml", []string{"xml"})
+	XMLType  = newMediaType("application", "xml", []string{"xml"})
+	SVGType  = newMediaTypeWithMimeSuffix("image", "svg", "xml", []string{"svg"})
+	TextType = newMediaType("text", "plain", []string{"txt"})
+	TOMLType = newMediaType("application", "toml", []string{"toml"})
+	YAMLType = newMediaType("application", "yaml", []string{"yaml", "yml"})
 
 	// Common image types
-	PNGType  = Type{MainType: "image", SubType: "png", Suffixes: []string{"png"}, Delimiter: defaultDelimiter}
-	JPEGType = Type{MainType: "image", SubType: "jpeg", Suffixes: []string{"jpg", "jpeg"}, Delimiter: defaultDelimiter}
-	GIFType  = Type{MainType: "image", SubType: "gif", Suffixes: []string{"gif"}, Delimiter: defaultDelimiter}
-	TIFFType = Type{MainType: "image", SubType: "tiff", Suffixes: []string{"tif", "tiff"}, Delimiter: defaultDelimiter}
-	BMPType  = Type{MainType: "image", SubType: "bmp", Suffixes: []string{"bmp"}, Delimiter: defaultDelimiter}
+	PNGType  = newMediaType("image", "png", []string{"png"})
+	JPEGType = newMediaType("image", "jpeg", []string{"jpg", "jpeg"})
+	GIFType  = newMediaType("image", "gif", []string{"gif"})
+	TIFFType = newMediaType("image", "tiff", []string{"tif", "tiff"})
+	BMPType  = newMediaType("image", "bmp", []string{"bmp"})
 
 	// Common video types
-	AVIType  = Type{MainType: "video", SubType: "x-msvideo", Suffixes: []string{"avi"}, Delimiter: defaultDelimiter}
-	MPEGType = Type{MainType: "video", SubType: "mpeg", Suffixes: []string{"mpg", "mpeg"}, Delimiter: defaultDelimiter}
-	MP4Type  = Type{MainType: "video", SubType: "mp4", Suffixes: []string{"mp4"}, Delimiter: defaultDelimiter}
-	OGGType  = Type{MainType: "video", SubType: "ogg", Suffixes: []string{"ogv"}, Delimiter: defaultDelimiter}
-	WEBMType = Type{MainType: "video", SubType: "webm", Suffixes: []string{"webm"}, Delimiter: defaultDelimiter}
-	GPPType  = Type{MainType: "video", SubType: "3gpp", Suffixes: []string{"3gpp", "3gp"}, Delimiter: defaultDelimiter}
-
-	OctetType = Type{MainType: "application", SubType: "octet-stream"}
+	AVIType  = newMediaType("video", "x-msvideo", []string{"avi"})
+	MPEGType = newMediaType("video", "mpeg", []string{"mpg", "mpeg"})
+	MP4Type  = newMediaType("video", "mp4", []string{"mp4"})
+	OGGType  = newMediaType("video", "ogg", []string{"ogv"})
+	WEBMType = newMediaType("video", "webm", []string{"webm"})
+	GPPType  = newMediaType("video", "3gpp", []string{"3gpp", "3gp"})
+
+	OctetType = newMediaType("application", "octet-stream", nil)
 )
 
 // DefaultTypes is the default media types supported by Hugo.
@@ -221,54 +254,56 @@ func (t Types) GetByType(tp string) (Type, bool) {
 
 // BySuffix will return all media types matching a suffix.
 func (t Types) BySuffix(suffix string) []Type {
+	suffix = strings.ToLower(suffix)
 	var types []Type
 	for _, tt := range t {
-		if match := tt.matchSuffix(suffix); match != "" {
+		if tt.hasSuffix(suffix) {
 			types = append(types, tt)
 		}
 	}
 	return types
 }
 
-// GetFirstBySuffix will return the first media type matching the given suffix.
-func (t Types) GetFirstBySuffix(suffix string) (Type, bool) {
+// GetFirstBySuffix will return the first type matching the given suffix.
+func (t Types) GetFirstBySuffix(suffix string) (Type, SuffixInfo, bool) {
+	suffix = strings.ToLower(suffix)
 	for _, tt := range t {
-		if match := tt.matchSuffix(suffix); match != "" {
-			tt.fileSuffix = match
-			return tt, true
+		if tt.hasSuffix(suffix) {
+			return tt, SuffixInfo{
+				FullSuffix: tt.Delimiter + suffix,
+				Suffix:     suffix,
+			}, true
 		}
 	}
-	return Type{}, false
+	return Type{}, SuffixInfo{}, false
 }
 
 // GetBySuffix gets a media type given as suffix, e.g. "html".
 // It will return false if no format could be found, or if the suffix given
 // is ambiguous.
 // The lookup is case insensitive.
-func (t Types) GetBySuffix(suffix string) (tp Type, found bool) {
+func (t Types) GetBySuffix(suffix string) (tp Type, si SuffixInfo, found bool) {
+	suffix = strings.ToLower(suffix)
 	for _, tt := range t {
-		if match := tt.matchSuffix(suffix); match != "" {
+		if tt.hasSuffix(suffix) {
 			if found {
 				// ambiguous
 				found = false
 				return
 			}
 			tp = tt
-			tp.fileSuffix = match
+			si = SuffixInfo{
+				FullSuffix: tt.Delimiter + suffix,
+				Suffix:     suffix,
+			}
 			found = true
 		}
 	}
 	return
 }
 
-func (m Type) matchSuffix(suffix string) string {
-	for _, s := range m.Suffixes {
-		if strings.EqualFold(suffix, s) {
-			return s
-		}
-	}
-
-	return ""
+func (m Type) hasSuffix(suffix string) bool {
+	return strings.Contains(m.suffixesCSV, suffix)
 }
 
 // GetByMainSubType gets a media type given a main and a sub type e.g. "text" and "plain".
@@ -328,9 +363,6 @@ func DecodeTypes(mms ...map[string]interface{}) (Types, error) {
 	// Maps type string to Type. Type string is the full application/svg+xml.
 	mmm := make(map[string]Type)
 	for _, dt := range DefaultTypes {
-		suffixes := make([]string, len(dt.Suffixes))
-		copy(suffixes, dt.Suffixes)
-		dt.Suffixes = suffixes
 		mmm[dt.Type()] = dt
 	}
 
@@ -360,11 +392,17 @@ func DecodeTypes(mms ...map[string]interface{}) (Types, error) {
 				return Types{}, suffixIsRemoved()
 			}
 
+			if suffixes, found := vm["suffixes"]; found {
+				mediaType.suffixesCSV = strings.TrimSpace(strings.ToLower(strings.Join(cast.ToStringSlice(suffixes), ",")))
+			}
+
 			// The user may set the delimiter as an empty string.
-			if !delimiterSet && len(mediaType.Suffixes) != 0 {
+			if !delimiterSet && mediaType.suffixesCSV != "" {
 				mediaType.Delimiter = defaultDelimiter
 			}
 
+			mediaType.init()
+
 			mmm[k] = mediaType
 
 		}
@@ -387,12 +425,14 @@ func (m Type) IsZero() bool {
 func (m Type) MarshalJSON() ([]byte, error) {
 	type Alias Type
 	return json.Marshal(&struct {
-		Type   string `json:"type"`
-		String string `json:"string"`
 		Alias
+		Type     string   `json:"type"`
+		String   string   `json:"string"`
+		Suffixes []string `json:"suffixes"`
 	}{
-		Type:   m.Type(),
-		String: m.String(),
-		Alias:  (Alias)(m),
+		Alias:    (Alias)(m),
+		Type:     m.Type(),
+		String:   m.String(),
+		Suffixes: strings.Split(m.suffixesCSV, ","),
 	})
 }
diff --git a/media/mediaType_test.go b/media/mediaType_test.go
index a846ac6ad..e44ab27ec 100644
--- a/media/mediaType_test.go
+++ b/media/mediaType_test.go
@@ -14,16 +14,12 @@
 package media
 
 import (
+	"encoding/json"
 	"testing"
 
 	qt "github.com/frankban/quicktest"
-	"github.com/google/go-cmp/cmp"
 )
 
-var eq = qt.CmpEquals(cmp.Comparer(func(m1, m2 Type) bool {
-	return m1.Type() == m2.Type()
-}))
-
 func TestDefaultTypes(t *testing.T) {
 	c := qt.New(t)
 	for _, test := range []struct {
@@ -53,8 +49,6 @@ func TestDefaultTypes(t *testing.T) {
 	} {
 		c.Assert(test.tp.MainType, qt.Equals, test.expectedMainType)
 		c.Assert(test.tp.SubType, qt.Equals, test.expectedSubType)
-		c.Assert(test.tp.Suffix(), qt.Equals, test.expectedSuffix)
-		c.Assert(test.tp.Delimiter, qt.Equals, defaultDelimiter)
 
 		c.Assert(test.tp.Type(), qt.Equals, test.expectedType)
 		c.Assert(test.tp.String(), qt.Equals, test.expectedString)
@@ -71,25 +65,25 @@ func TestGetByType(t *testing.T) {
 
 	mt, found := types.GetByType("text/HTML")
 	c.Assert(found, qt.Equals, true)
-	c.Assert(HTMLType, eq, mt)
+	c.Assert(HTMLType, qt.Equals, mt)
 
 	_, found = types.GetByType("text/nono")
 	c.Assert(found, qt.Equals, false)
 
 	mt, found = types.GetByType("application/rss+xml")
 	c.Assert(found, qt.Equals, true)
-	c.Assert(RSSType, eq, mt)
+	c.Assert(RSSType, qt.Equals, mt)
 
 	mt, found = types.GetByType("application/rss")
 	c.Assert(found, qt.Equals, true)
-	c.Assert(RSSType, eq, mt)
+	c.Assert(RSSType, qt.Equals, mt)
 }
 
 func TestGetByMainSubType(t *testing.T) {
 	c := qt.New(t)
 	f, found := DefaultTypes.GetByMainSubType("text", "plain")
 	c.Assert(found, qt.Equals, true)
-	c.Assert(TextType, eq, f)
+	c.Assert(f, qt.Equals, TextType)
 	_, found = DefaultTypes.GetByMainSubType("foo", "plain")
 	c.Assert(found, qt.Equals, false)
 }
@@ -104,48 +98,63 @@ func TestBySuffix(t *testing.T) {
 
 func TestGetFirstBySuffix(t *testing.T) {
 	c := qt.New(t)
-	f, found := DefaultTypes.GetFirstBySuffix("xml")
+	_, f, found := DefaultTypes.GetFirstBySuffix("xml")
 	c.Assert(found, qt.Equals, true)
-	c.Assert(f, eq, Type{MainType: "application", SubType: "rss", mimeSuffix: "xml", Delimiter: ".", Suffixes: []string{"xml"}, fileSuffix: "xml"})
+	c.Assert(f, qt.Equals, SuffixInfo{
+		Suffix:     "xml",
+		FullSuffix: ".xml"})
 }
 
 func TestFromTypeString(t *testing.T) {
 	c := qt.New(t)
 	f, err := fromString("text/html")
 	c.Assert(err, qt.IsNil)
-	c.Assert(f.Type(), eq, HTMLType.Type())
+	c.Assert(f.Type(), qt.Equals, HTMLType.Type())
 
 	f, err = fromString("application/custom")
 	c.Assert(err, qt.IsNil)
-	c.Assert(f, eq, Type{MainType: "application", SubType: "custom", mimeSuffix: "", fileSuffix: ""})
+	c.Assert(f, qt.Equals, Type{MainType: "application", SubType: "custom", mimeSuffix: ""})
 
 	f, err = fromString("application/custom+sfx")
 	c.Assert(err, qt.IsNil)
-	c.Assert(f, eq, Type{MainType: "application", SubType: "custom", mimeSuffix: "sfx"})
+	c.Assert(f, qt.Equals, Type{MainType: "application", SubType: "custom", mimeSuffix: "sfx"})
 
 	_, err = fromString("noslash")
 	c.Assert(err, qt.Not(qt.IsNil))
 
 	f, err = fromString("text/xml; charset=utf-8")
 	c.Assert(err, qt.IsNil)
-	c.Assert(f, eq, Type{MainType: "text", SubType: "xml", mimeSuffix: ""})
-	c.Assert(f.Suffix(), qt.Equals, "")
+
+	c.Assert(f, qt.Equals, Type{MainType: "text", SubType: "xml", mimeSuffix: ""})
+
+}
+
+func TestFromStringAndExt(t *testing.T) {
+	c := qt.New(t)
+	f, err := FromStringAndExt("text/html", "html")
+	c.Assert(err, qt.IsNil)
+	c.Assert(f, qt.Equals, HTMLType)
+	f, err = FromStringAndExt("text/html", ".html")
+	c.Assert(err, qt.IsNil)
+	c.Assert(f, qt.Equals, HTMLType)
 }
 
 // Add a test for the SVG case
 // https://github.com/gohugoio/hugo/issues/4920
 func TestFromExtensionMultipleSuffixes(t *testing.T) {
 	c := qt.New(t)
-	tp, found := DefaultTypes.GetBySuffix("svg")
+	tp, si, found := DefaultTypes.GetBySuffix("svg")
 	c.Assert(found, qt.Equals, true)
 	c.Assert(tp.String(), qt.Equals, "image/svg+xml")
-	c.Assert(tp.fileSuffix, qt.Equals, "svg")
-	c.Assert(tp.FullSuffix(), qt.Equals, ".svg")
-	tp, found = DefaultTypes.GetByType("image/svg+xml")
+	c.Assert(si.Suffix, qt.Equals, "svg")
+	c.Assert(si.FullSuffix, qt.Equals, ".svg")
+	c.Assert(tp.FirstSuffix.Suffix, qt.Equals, si.Suffix)
+	c.Assert(tp.FirstSuffix.FullSuffix, qt.Equals, si.FullSuffix)
+	ftp, found := DefaultTypes.GetByType("image/svg+xml")
 	c.Assert(found, qt.Equals, true)
-	c.Assert(tp.String(), qt.Equals, "image/svg+xml")
+	c.Assert(ftp.String(), qt.Equals, "image/svg+xml")
 	c.Assert(found, qt.Equals, true)
-	c.Assert(tp.FullSuffix(), qt.Equals, ".svg")
+
 }
 
 func TestDecodeTypes(t *testing.T) {
@@ -169,10 +178,10 @@ func TestDecodeTypes(t *testing.T) {
 			false,
 			func(t *testing.T, name string, tt Types) {
 				c.Assert(len(tt), qt.Equals, len(DefaultTypes))
-				json, found := tt.GetBySuffix("jasn")
+				json, si, found := tt.GetBySuffix("jasn")
 				c.Assert(found, qt.Equals, true)
 				c.Assert(json.String(), qt.Equals, "application/json")
-				c.Assert(json.FullSuffix(), qt.Equals, ".jasn")
+				c.Assert(si.FullSuffix, qt.Equals, ".jasn")
 			},
 		},
 		{
@@ -180,7 +189,7 @@ func TestDecodeTypes(t *testing.T) {
 			[]map[string]interface{}{
 				{
 					"application/hugo+hg": map[string]interface{}{
-						"suffixes":  []string{"hg1", "hg2"},
+						"suffixes":  []string{"hg1", "hG2"},
 						"Delimiter": "_",
 					},
 				},
@@ -188,15 +197,18 @@ func TestDecodeTypes(t *testing.T) {
 			false,
 			func(t *testing.T, name string, tt Types) {
 				c.Assert(len(tt), qt.Equals, len(DefaultTypes)+1)
-				hg, found := tt.GetBySuffix("hg2")
+				hg, si, found := tt.GetBySuffix("hg2")
 				c.Assert(found, qt.Equals, true)
 				c.Assert(hg.mimeSuffix, qt.Equals, "hg")
-				c.Assert(hg.Suffix(), qt.Equals, "hg2")
-				c.Assert(hg.FullSuffix(), qt.Equals, "_hg2")
+				c.Assert(hg.FirstSuffix.Suffix, qt.Equals, "hg1")
+				c.Assert(hg.FirstSuffix.FullSuffix, qt.Equals, "_hg1")
+				c.Assert(si.Suffix, qt.Equals, "hg2")
+				c.Assert(si.FullSuffix, qt.Equals, "_hg2")
 				c.Assert(hg.String(), qt.Equals, "application/hugo+hg")
 
-				hg, found = tt.GetByType("application/hugo+hg")
+				_, found = tt.GetByType("application/hugo+hg")
 				c.Assert(found, qt.Equals, true)
+
 			},
 		},
 		{
@@ -209,14 +221,14 @@ func TestDecodeTypes(t *testing.T) {
 				},
 			},
 			false,
-			func(t *testing.T, name string, tt Types) {
-				c.Assert(len(tt), qt.Equals, len(DefaultTypes)+1)
+			func(t *testing.T, name string, tp Types) {
+				c.Assert(len(tp), qt.Equals, len(DefaultTypes)+1)
 				// Make sure we have not broken the default config.
 
-				_, found := tt.GetBySuffix("json")
+				_, _, found := tp.GetBySuffix("json")
 				c.Assert(found, qt.Equals, true)
 
-				hugo, found := tt.GetBySuffix("hgo2")
+				hugo, _, found := tp.GetBySuffix("hgo2")
 				c.Assert(found, qt.Equals, true)
 				c.Assert(hugo.String(), qt.Equals, "text/hugo+hgo")
 			},
@@ -234,25 +246,33 @@ func TestDecodeTypes(t *testing.T) {
 	}
 }
 
+func TestToJSON(t *testing.T) {
+	c := qt.New(t)
+	b, err := json.Marshal(MPEGType)
+	c.Assert(err, qt.IsNil)
+	c.Assert(string(b), qt.Equals, `{"mainType":"video","subType":"mpeg","delimiter":".","firstSuffix":{"suffix":"mpg","fullSuffix":".mpg"},"type":"video/mpeg","string":"video/mpeg","suffixes":["mpg","mpeg"]}`)
+}
+
 func BenchmarkTypeOps(b *testing.B) {
 	mt := MPEGType
 	mts := DefaultTypes
 	for i := 0; i < b.N; i++ {
-		_ = mt.FullSuffix()
+		ff := mt.FirstSuffix
+		_ = ff.FullSuffix
 		_ = mt.IsZero()
 		c, err := mt.MarshalJSON()
 		if c == nil || err != nil {
 			b.Fatal("failed")
 		}
 		_ = mt.String()
-		_ = mt.Suffix()
+		_ = ff.Suffix
 		_ = mt.Suffixes
 		_ = mt.Type()
 		_ = mts.BySuffix("xml")
 		_, _ = mts.GetByMainSubType("application", "xml")
-		_, _ = mts.GetBySuffix("xml")
+		_, _, _ = mts.GetBySuffix("xml")
 		_, _ = mts.GetByType("application")
-		_, _ = mts.GetFirstBySuffix("xml")
+		_, _, _ = mts.GetFirstBySuffix("xml")
 
 	}
 }
diff --git a/output/docshelper.go b/output/docshelper.go
index 42b871ab5..95e521ea3 100644
--- a/output/docshelper.go
+++ b/output/docshelper.go
@@ -76,7 +76,7 @@ func createLayoutExamples() interface{} {
 			Example:      example.name,
 			Kind:         example.d.Kind,
 			OutputFormat: example.f.Name,
-			Suffix:       example.f.MediaType.Suffix(),
+			Suffix:       example.f.MediaType.FirstSuffix.Suffix,
 			Layouts:      makeLayoutsPresentable(layouts),
 		})
 	}
diff --git a/output/layout.go b/output/layout.go
index 55e7fa305..91c7cc652 100644
--- a/output/layout.go
+++ b/output/layout.go
@@ -229,7 +229,7 @@ func (l *layoutBuilder) resolveVariations() []string {
 					continue
 				}
 
-				s := constructLayoutPath(typeVar, layoutVar, variation, l.f.MediaType.Suffix())
+				s := constructLayoutPath(typeVar, layoutVar, variation, l.f.MediaType.FirstSuffix.Suffix)
 				if s != "" {
 					layouts = append(layouts, s)
 				}
diff --git a/output/layout_test.go b/output/layout_test.go
index f98eea960..8b7a2b541 100644
--- a/output/layout_test.go
+++ b/output/layout_test.go
@@ -28,12 +28,8 @@ import (
 func TestLayout(t *testing.T) {
 	c := qt.New(t)
 
-	noExtNoDelimMediaType := media.TextType
-	noExtNoDelimMediaType.Suffixes = nil
-	noExtNoDelimMediaType.Delimiter = ""
-
-	noExtMediaType := media.TextType
-	noExtMediaType.Suffixes = nil
+	noExtNoDelimMediaType := media.WithDelimiterAndSuffixes(media.TextType, "", "")
+	noExtMediaType := media.WithDelimiterAndSuffixes(media.TextType, ".", "")
 
 	var (
 		ampType = Format{
diff --git a/output/outputFormat.go b/output/outputFormat.go
index ee5881e2a..1bd86d2ca 100644
--- a/output/outputFormat.go
+++ b/output/outputFormat.go
@@ -20,6 +20,8 @@ import (
 	"sort"
 	"strings"
 
+	"github.com/pkg/errors"
+
 	"github.com/mitchellh/mapstructure"
 
 	"github.com/gohugoio/hugo/media"
@@ -207,14 +209,16 @@ func (formats Formats) Less(i, j int) bool {
 // The lookup is case insensitive.
 func (formats Formats) GetBySuffix(suffix string) (f Format, found bool) {
 	for _, ff := range formats {
-		if strings.EqualFold(suffix, ff.MediaType.Suffix()) {
-			if found {
-				// ambiguous
-				found = false
-				return
+		for _, suffix2 := range ff.MediaType.Suffixes() {
+			if strings.EqualFold(suffix, suffix2) {
+				if found {
+					// ambiguous
+					found = false
+					return
+				}
+				f = ff
+				found = true
 			}
-			f = ff
-			found = true
 		}
 	}
 	return
@@ -310,6 +314,7 @@ func DecodeFormats(mediaTypes media.Types, maps ...map[string]interface{}) (Form
 				}
 
 				f = append(f, newOutFormat)
+
 			}
 		}
 	}
@@ -319,7 +324,7 @@ func DecodeFormats(mediaTypes media.Types, maps ...map[string]interface{}) (Form
 	return f, nil
 }
 
-func decode(mediaTypes media.Types, input, output interface{}) error {
+func decode(mediaTypes media.Types, input interface{}, output *Format) error {
 	config := &mapstructure.DecoderConfig{
 		Metadata:         nil,
 		Result:           output,
@@ -337,12 +342,19 @@ func decode(mediaTypes media.Types, input, output interface{}) error {
 						// If mediaType is a string, look it up and replace it
 						// in the map.
 						vv := dataVal.MapIndex(key)
-						if mediaTypeStr, ok := vv.Interface().(string); ok {
-							mediaType, found := mediaTypes.GetByType(mediaTypeStr)
+						vvi := vv.Interface()
+
+						switch vviv := vvi.(type) {
+						case media.Type:
+						// OK
+						case string:
+							mediaType, found := mediaTypes.GetByType(vviv)
 							if !found {
-								return c, fmt.Errorf("media type %q not found", mediaTypeStr)
+								return c, fmt.Errorf("media type %q not found", vviv)
 							}
 							dataVal.SetMapIndex(key, reflect.ValueOf(mediaType))
+						default:
+							return nil, errors.Errorf("invalid output format configuration; wrong type for media type, expected string (e.g. text/html), got %T", vvi)
 						}
 					}
 				}
@@ -357,12 +369,13 @@ func decode(mediaTypes media.Types, input, output interface{}) error {
 	}
 
 	return decoder.Decode(input)
+
 }
 
 // BaseFilename returns the base filename of f including an extension (ie.
 // "index.xml").
 func (f Format) BaseFilename() string {
-	return f.BaseName + f.MediaType.FullSuffix()
+	return f.BaseName + f.MediaType.FirstSuffix.FullSuffix
 }
 
 // MarshalJSON returns the JSON encoding of f.
diff --git a/output/outputFormat_test.go b/output/outputFormat_test.go
index d91f1e410..806998866 100644
--- a/output/outputFormat_test.go
+++ b/output/outputFormat_test.go
@@ -19,36 +19,26 @@ import (
 
 	qt "github.com/frankban/quicktest"
 	"github.com/gohugoio/hugo/media"
-	"github.com/google/go-cmp/cmp"
-)
-
-var eq = qt.CmpEquals(
-	cmp.Comparer(func(m1, m2 media.Type) bool {
-		return m1.Type() == m2.Type()
-	}),
-	cmp.Comparer(func(o1, o2 Format) bool {
-		return o1.Name == o2.Name
-	}),
 )
 
 func TestDefaultTypes(t *testing.T) {
 	c := qt.New(t)
 	c.Assert(CalendarFormat.Name, qt.Equals, "Calendar")
-	c.Assert(CalendarFormat.MediaType, eq, media.CalendarType)
+	c.Assert(CalendarFormat.MediaType, qt.Equals, media.CalendarType)
 	c.Assert(CalendarFormat.Protocol, qt.Equals, "webcal://")
 	c.Assert(CalendarFormat.Path, qt.HasLen, 0)
 	c.Assert(CalendarFormat.IsPlainText, qt.Equals, true)
 	c.Assert(CalendarFormat.IsHTML, qt.Equals, false)
 
 	c.Assert(CSSFormat.Name, qt.Equals, "CSS")
-	c.Assert(CSSFormat.MediaType, eq, media.CSSType)
+	c.Assert(CSSFormat.MediaType, qt.Equals, media.CSSType)
 	c.Assert(CSSFormat.Path, qt.HasLen, 0)
 	c.Assert(CSSFormat.Protocol, qt.HasLen, 0) // Will inherit the BaseURL protocol.
 	c.Assert(CSSFormat.IsPlainText, qt.Equals, true)
 	c.Assert(CSSFormat.IsHTML, qt.Equals, false)
 
 	c.Assert(CSVFormat.Name, qt.Equals, "CSV")
-	c.Assert(CSVFormat.MediaType, eq, media.CSVType)
+	c.Assert(CSVFormat.MediaType, qt.Equals, media.CSVType)
 	c.Assert(CSVFormat.Path, qt.HasLen, 0)
 	c.Assert(CSVFormat.Protocol, qt.HasLen, 0)
 	c.Assert(CSVFormat.IsPlainText, qt.Equals, true)
@@ -56,7 +46,7 @@ func TestDefaultTypes(t *testing.T) {
 	c.Assert(CSVFormat.Permalinkable, qt.Equals, false)
 
 	c.Assert(HTMLFormat.Name, qt.Equals, "HTML")
-	c.Assert(HTMLFormat.MediaType, eq, media.HTMLType)
+	c.Assert(HTMLFormat.MediaType, qt.Equals, media.HTMLType)
 	c.Assert(HTMLFormat.Path, qt.HasLen, 0)
 	c.Assert(HTMLFormat.Protocol, qt.HasLen, 0)
 	c.Assert(HTMLFormat.IsPlainText, qt.Equals, false)
@@ -64,7 +54,7 @@ func TestDefaultTypes(t *testing.T) {
 	c.Assert(AMPFormat.Permalinkable, qt.Equals, true)
 
 	c.Assert(AMPFormat.Name, qt.Equals, "AMP")
-	c.Assert(AMPFormat.MediaType, eq, media.HTMLType)
+	c.Assert(AMPFormat.MediaType, qt.Equals, media.HTMLType)
 	c.Assert(AMPFormat.Path, qt.Equals, "amp")
 	c.Assert(AMPFormat.Protocol, qt.HasLen, 0)
 	c.Assert(AMPFormat.IsPlainText, qt.Equals, false)
@@ -72,7 +62,7 @@ func TestDefaultTypes(t *testing.T) {
 	c.Assert(AMPFormat.Permalinkable, qt.Equals, true)
 
 	c.Assert(RSSFormat.Name, qt.Equals, "RSS")
-	c.Assert(RSSFormat.MediaType, eq, media.RSSType)
+	c.Assert(RSSFormat.MediaType, qt.Equals, media.RSSType)
 	c.Assert(RSSFormat.Path, qt.HasLen, 0)
 	c.Assert(RSSFormat.IsPlainText, qt.Equals, false)
 	c.Assert(RSSFormat.NoUgly, qt.Equals, true)
@@ -83,7 +73,7 @@ func TestGetFormatByName(t *testing.T) {
 	c := qt.New(t)
 	formats := Formats{AMPFormat, CalendarFormat}
 	tp, _ := formats.GetByName("AMp")
-	c.Assert(tp, eq, AMPFormat)
+	c.Assert(tp, qt.Equals, AMPFormat)
 	_, found := formats.GetByName("HTML")
 	c.Assert(found, qt.Equals, false)
 	_, found = formats.GetByName("FOO")
@@ -95,9 +85,9 @@ func TestGetFormatByExt(t *testing.T) {
 	formats1 := Formats{AMPFormat, CalendarFormat}
 	formats2 := Formats{AMPFormat, HTMLFormat, CalendarFormat}
 	tp, _ := formats1.GetBySuffix("html")
-	c.Assert(tp, eq, AMPFormat)
+	c.Assert(tp, qt.Equals, AMPFormat)
 	tp, _ = formats1.GetBySuffix("ics")
-	c.Assert(tp, eq, CalendarFormat)
+	c.Assert(tp, qt.Equals, CalendarFormat)
 	_, found := formats1.GetBySuffix("not")
 	c.Assert(found, qt.Equals, false)
 
@@ -129,18 +119,18 @@ func TestGetFormatByFilename(t *testing.T) {
 	formats := Formats{AMPFormat, HTMLFormat, noExtDelimFormat, noExt, CalendarFormat}
 	f, found := formats.FromFilename("my.amp.html")
 	c.Assert(found, qt.Equals, true)
-	c.Assert(f, eq, AMPFormat)
+	c.Assert(f, qt.Equals, AMPFormat)
 	_, found = formats.FromFilename("my.ics")
 	c.Assert(found, qt.Equals, true)
 	f, found = formats.FromFilename("my.html")
 	c.Assert(found, qt.Equals, true)
-	c.Assert(f, eq, HTMLFormat)
+	c.Assert(f, qt.Equals, HTMLFormat)
 	f, found = formats.FromFilename("my.nem")
 	c.Assert(found, qt.Equals, true)
-	c.Assert(f, eq, noExtDelimFormat)
+	c.Assert(f, qt.Equals, noExtDelimFormat)
 	f, found = formats.FromFilename("my.nex")
 	c.Assert(found, qt.Equals, true)
-	c.Assert(f, eq, noExt)
+	c.Assert(f, qt.Equals, noExt)
 	_, found = formats.FromFilename("my.css")
 	c.Assert(found, qt.Equals, false)
 }
@@ -172,7 +162,7 @@ func TestDecodeFormats(t *testing.T) {
 				c.Assert(len(f), qt.Equals, len(DefaultFormats), msg)
 				json, _ := f.GetByName("JSON")
 				c.Assert(json.BaseName, qt.Equals, "myindex")
-				c.Assert(json.MediaType, eq, media.JSONType)
+				c.Assert(json.MediaType, qt.Equals, media.JSONType)
 				c.Assert(json.IsPlainText, qt.Equals, false)
 			},
 		},
@@ -192,7 +182,7 @@ func TestDecodeFormats(t *testing.T) {
 				xml, found := f.GetByName("MYXMLFORMAT")
 				c.Assert(found, qt.Equals, true)
 				c.Assert(xml.BaseName, qt.Equals, "myxml")
-				c.Assert(xml.MediaType, eq, media.XMLType)
+				c.Assert(xml.MediaType, qt.Equals, media.XMLType)
 
 				// Verify that we haven't changed the DefaultFormats slice.
 				json, _ := f.GetByName("JSON")
@@ -234,7 +224,7 @@ func TestDecodeFormats(t *testing.T) {
 				xml, found := f.GetByName("MYOTHERXMLFORMAT")
 				c.Assert(found, qt.Equals, true)
 				c.Assert(xml.BaseName, qt.Equals, "myredefined")
-				c.Assert(xml.MediaType, eq, media.XMLType)
+				c.Assert(xml.MediaType, qt.Equals, media.XMLType)
 			},
 		},
 	}
diff --git a/parser/metadecoders/format.go b/parser/metadecoders/format.go
index d2b35223d..bba89dbea 100644
--- a/parser/metadecoders/format.go
+++ b/parser/metadecoders/format.go
@@ -59,7 +59,7 @@ func FormatFromString(formatStr string) Format {
 // FormatFromMediaType gets the Format given a MIME type, empty string
 // if unknown.
 func FormatFromMediaType(m media.Type) Format {
-	for _, suffix := range m.Suffixes {
+	for _, suffix := range m.Suffixes() {
 		if f := FormatFromString(suffix); f != "" {
 			return f
 		}
diff --git a/resources/images/image.go b/resources/images/image.go
index 3d28263c0..b71321244 100644
--- a/resources/images/image.go
+++ b/resources/images/image.go
@@ -265,7 +265,7 @@ func (f Format) SupportsTransparency() bool {
 // DefaultExtension returns the default file extension of this format, starting with a dot.
 // For example: .jpg for JPEG
 func (f Format) DefaultExtension() string {
-	return f.MediaType().FullSuffix()
+	return f.MediaType().FirstSuffix.FullSuffix
 }
 
 // MediaType returns the media type of this image, e.g. image/jpeg for JPEG
diff --git a/resources/page/page_paths.go b/resources/page/page_paths.go
index fc576f05a..3d34866d1 100644
--- a/resources/page/page_paths.go
+++ b/resources/page/page_paths.go
@@ -128,6 +128,7 @@ func CreateTargetPaths(d TargetPathDescriptor) (tp TargetPaths) {
 	}
 
 	pagePath := slash
+	fullSuffix := d.Type.MediaType.FirstSuffix.FullSuffix
 
 	var (
 		pagePathDir string
@@ -172,7 +173,7 @@ func CreateTargetPaths(d TargetPathDescriptor) (tp TargetPaths) {
 		hasSlash := strings.HasSuffix(d.URL, slash)
 
 		if hasSlash || !hasDot {
-			pagePath = pjoin(pagePath, d.Type.BaseName+d.Type.MediaType.FullSuffix())
+			pagePath = pjoin(pagePath, d.Type.BaseName+fullSuffix)
 		} else if hasDot {
 			pagePathDir = path.Dir(pagePathDir)
 		}
@@ -229,9 +230,9 @@ func CreateTargetPaths(d TargetPathDescriptor) (tp TargetPaths) {
 		linkDir = pagePathDir
 
 		if isUgly {
-			pagePath = addSuffix(pagePath, d.Type.MediaType.FullSuffix())
+			pagePath = addSuffix(pagePath, fullSuffix)
 		} else {
-			pagePath = pjoin(pagePath, d.Type.BaseName+d.Type.MediaType.FullSuffix())
+			pagePath = pjoin(pagePath, d.Type.BaseName+fullSuffix)
 		}
 
 		if !isHtmlIndex(pagePath) {
@@ -267,9 +268,9 @@ func CreateTargetPaths(d TargetPathDescriptor) (tp TargetPaths) {
 		linkDir = pagePathDir
 
 		if base != "" {
-			pagePath = path.Join(pagePath, addSuffix(base, d.Type.MediaType.FullSuffix()))
+			pagePath = path.Join(pagePath, addSuffix(base, fullSuffix))
 		} else {
-			pagePath = addSuffix(pagePath, d.Type.MediaType.FullSuffix())
+			pagePath = addSuffix(pagePath, fullSuffix)
 		}
 
 		if !isHtmlIndex(pagePath) {
diff --git a/resources/page/page_paths_test.go b/resources/page/page_paths_test.go
index ab7164f46..28937899f 100644
--- a/resources/page/page_paths_test.go
+++ b/resources/page/page_paths_test.go
@@ -27,8 +27,7 @@ import (
 func TestPageTargetPath(t *testing.T) {
 	pathSpec := newTestPathSpec()
 
-	noExtNoDelimMediaType := media.TextType
-	noExtNoDelimMediaType.Suffixes = []string{}
+	noExtNoDelimMediaType := media.WithDelimiterAndSuffixes(media.TextType, "", "")
 	noExtNoDelimMediaType.Delimiter = ""
 
 	// Netlify style _redirects
@@ -209,11 +208,11 @@ func TestPageTargetPath(t *testing.T) {
 							// TODO(bep) simplify
 							if test.d.Kind == KindPage && test.d.BaseName == test.d.Type.BaseName {
 							} else if test.d.Kind == KindHome && test.d.Type.Path != "" {
-							} else if test.d.Type.MediaType.Suffix() != "" && (!strings.HasPrefix(expected.TargetFilename, "/index") || test.d.Addends != "") && test.d.URL == "" && isUgly {
+							} else if test.d.Type.MediaType.FirstSuffix.Suffix != "" && (!strings.HasPrefix(expected.TargetFilename, "/index") || test.d.Addends != "") && test.d.URL == "" && isUgly {
 								expected.TargetFilename = strings.Replace(expected.TargetFilename,
-									"/"+test.d.Type.BaseName+"."+test.d.Type.MediaType.Suffix(),
-									"."+test.d.Type.MediaType.Suffix(), 1)
-								expected.Link = strings.TrimSuffix(expected.Link, "/") + "." + test.d.Type.MediaType.Suffix()
+									"/"+test.d.Type.BaseName+"."+test.d.Type.MediaType.FirstSuffix.Suffix,
+									"."+test.d.Type.MediaType.FirstSuffix.Suffix, 1)
+								expected.Link = strings.TrimSuffix(expected.Link, "/") + "." + test.d.Type.MediaType.FirstSuffix.Suffix
 
 							}
 
diff --git a/resources/postpub/fields_test.go b/resources/postpub/fields_test.go
index 10a68ac5a..19c3720f7 100644
--- a/resources/postpub/fields_test.go
+++ b/resources/postpub/fields_test.go
@@ -31,15 +31,14 @@ func TestCreatePlaceholders(t *testing.T) {
 	})
 
 	c.Assert(m, qt.DeepEquals, map[string]interface{}{
-		"FullSuffix":  "pre_foo.FullSuffix_post",
 		"IsZero":      "pre_foo.IsZero_post",
-		"Type":        "pre_foo.Type_post",
-		"MainType":    "pre_foo.MainType_post",
-		"Delimiter":   "pre_foo.Delimiter_post",
 		"MarshalJSON": "pre_foo.MarshalJSON_post",
+		"Suffixes":    "pre_foo.Suffixes_post",
+		"Delimiter":   "pre_foo.Delimiter_post",
+		"FirstSuffix": "pre_foo.FirstSuffix_post",
 		"String":      "pre_foo.String_post",
-		"Suffix":      "pre_foo.Suffix_post",
+		"Type":        "pre_foo.Type_post",
+		"MainType":    "pre_foo.MainType_post",
 		"SubType":     "pre_foo.SubType_post",
-		"Suffixes":    "pre_foo.Suffixes_post",
 	})
 }
diff --git a/resources/resource_spec.go b/resources/resource_spec.go
index dc13d16d9..156def363 100644
--- a/resources/resource_spec.go
+++ b/resources/resource_spec.go
@@ -268,10 +268,10 @@ func (r *Spec) newResource(sourceFs afero.Fs, fd ResourceSourceDescriptor) (reso
 	}
 
 	ext := strings.ToLower(filepath.Ext(fd.RelTargetFilename))
-	mimeType, found := r.MediaTypes.GetFirstBySuffix(strings.TrimPrefix(ext, "."))
+	mimeType, suffixInfo, found := r.MediaTypes.GetFirstBySuffix(strings.TrimPrefix(ext, "."))
 	// TODO(bep) we need to handle these ambiguous types better, but in this context
 	// we most likely want the application/xml type.
-	if mimeType.Suffix() == "xml" && mimeType.SubType == "rss" {
+	if suffixInfo.Suffix == "xml" && mimeType.SubType == "rss" {
 		mimeType, found = r.MediaTypes.GetByType("application/xml")
 	}
 
diff --git a/tpl/tplimpl/shortcodes.go b/tpl/tplimpl/shortcodes.go
index 789bc07d3..938fc74e2 100644
--- a/tpl/tplimpl/shortcodes.go
+++ b/tpl/tplimpl/shortcodes.go
@@ -56,7 +56,7 @@ func (s *shortcodeTemplates) fromVariants(variants tpl.TemplateVariants) (shortc
 	return s.fromVariantsSlice([]string{
 		variants.Language,
 		strings.ToLower(variants.OutputFormat.Name),
-		variants.OutputFormat.MediaType.Suffix(),
+		variants.OutputFormat.MediaType.FirstSuffix.Suffix,
 	})
 }