diff --git a/cases/gen_trieval.go b/cases/gen_trieval.go
index 6c7222a..14dd33b 100644
--- a/cases/gen_trieval.go
+++ b/cases/gen_trieval.go
@@ -19,19 +19,19 @@
 //
 // The per-rune values have the following format:
 //
-//   if (exception) {
-//     15..4  unsigned exception index
-//   } else {
-//     15..8  XOR pattern or index to XOR pattern for case mapping
-//            Only 13..8 are used for XOR patterns.
-//         7  inverseFold (fold to upper, not to lower)
-//         6  index: interpret the XOR pattern as an index
-//            or isMid if case mode is cIgnorableUncased.
-//      5..4  CCC: zero (normal or break), above or other
-//   }
-//      3  exception: interpret this value as an exception index
-//         (TODO: is this bit necessary? Probably implied from case mode.)
-//   2..0  case mode
+//	if (exception) {
+//	  15..4  unsigned exception index
+//	} else {
+//	  15..8  XOR pattern or index to XOR pattern for case mapping
+//	         Only 13..8 are used for XOR patterns.
+//	      7  inverseFold (fold to upper, not to lower)
+//	      6  index: interpret the XOR pattern as an index
+//	         or isMid if case mode is cIgnorableUncased.
+//	   5..4  CCC: zero (normal or break), above or other
+//	}
+//	   3  exception: interpret this value as an exception index
+//	      (TODO: is this bit necessary? Probably implied from case mode.)
+//	2..0  case mode
 //
 // For the non-exceptional cases, a rune must be either uncased, lowercase or
 // uppercase. If the rune is cased, the XOR pattern maps either a lowercase
@@ -133,37 +133,40 @@
 // The entry is pointed to by the exception index in an entry. It has the
 // following format:
 //
-// Header
-// byte 0:
-//  7..6  unused
-//  5..4  CCC type (same bits as entry)
-//     3  unused
-//  2..0  length of fold
+// Header:
 //
-// byte 1:
-//   7..6  unused
-//   5..3  length of 1st mapping of case type
-//   2..0  length of 2nd mapping of case type
+//	byte 0:
+//	 7..6  unused
+//	 5..4  CCC type (same bits as entry)
+//	    3  unused
+//	 2..0  length of fold
 //
-//   case     1st    2nd
-//   lower -> upper, title
-//   upper -> lower, title
-//   title -> lower, upper
+//	byte 1:
+//	  7..6  unused
+//	  5..3  length of 1st mapping of case type
+//	  2..0  length of 2nd mapping of case type
+//
+//	  case     1st    2nd
+//	  lower -> upper, title
+//	  upper -> lower, title
+//	  title -> lower, upper
 //
 // Lengths with the value 0x7 indicate no value and implies no change.
 // A length of 0 indicates a mapping to zero-length string.
 //
 // Body bytes:
-//   case folding bytes
-//   lowercase mapping bytes
-//   uppercase mapping bytes
-//   titlecase mapping bytes
-//   closure mapping bytes (for NFKC_Casefold). (TODO)
+//
+//	case folding bytes
+//	lowercase mapping bytes
+//	uppercase mapping bytes
+//	titlecase mapping bytes
+//	closure mapping bytes (for NFKC_Casefold). (TODO)
 //
 // Fallbacks:
-//   missing fold  -> lower
-//   missing title -> upper
-//   all missing   -> original rune
+//
+//	missing fold  -> lower
+//	missing title -> upper
+//	all missing   -> original rune
 //
 // exceptions starts with a dummy byte to enforce that there is no zero index
 // value.
diff --git a/cases/trieval.go b/cases/trieval.go
index 99e0396..4e4d13f 100644
--- a/cases/trieval.go
+++ b/cases/trieval.go
@@ -14,19 +14,19 @@
 //
 // The per-rune values have the following format:
 //
-//   if (exception) {
-//     15..4  unsigned exception index
-//   } else {
-//     15..8  XOR pattern or index to XOR pattern for case mapping
-//            Only 13..8 are used for XOR patterns.
-//         7  inverseFold (fold to upper, not to lower)
-//         6  index: interpret the XOR pattern as an index
-//            or isMid if case mode is cIgnorableUncased.
-//      5..4  CCC: zero (normal or break), above or other
-//   }
-//      3  exception: interpret this value as an exception index
-//         (TODO: is this bit necessary? Probably implied from case mode.)
-//   2..0  case mode
+//	if (exception) {
+//	  15..4  unsigned exception index
+//	} else {
+//	  15..8  XOR pattern or index to XOR pattern for case mapping
+//	         Only 13..8 are used for XOR patterns.
+//	      7  inverseFold (fold to upper, not to lower)
+//	      6  index: interpret the XOR pattern as an index
+//	         or isMid if case mode is cIgnorableUncased.
+//	   5..4  CCC: zero (normal or break), above or other
+//	}
+//	   3  exception: interpret this value as an exception index
+//	      (TODO: is this bit necessary? Probably implied from case mode.)
+//	2..0  case mode
 //
 // For the non-exceptional cases, a rune must be either uncased, lowercase or
 // uppercase. If the rune is cased, the XOR pattern maps either a lowercase
@@ -128,37 +128,40 @@
 // The entry is pointed to by the exception index in an entry. It has the
 // following format:
 //
-// Header
-// byte 0:
-//  7..6  unused
-//  5..4  CCC type (same bits as entry)
-//     3  unused
-//  2..0  length of fold
+// Header:
 //
-// byte 1:
-//   7..6  unused
-//   5..3  length of 1st mapping of case type
-//   2..0  length of 2nd mapping of case type
+//	byte 0:
+//	 7..6  unused
+//	 5..4  CCC type (same bits as entry)
+//	    3  unused
+//	 2..0  length of fold
 //
-//   case     1st    2nd
-//   lower -> upper, title
-//   upper -> lower, title
-//   title -> lower, upper
+//	byte 1:
+//	  7..6  unused
+//	  5..3  length of 1st mapping of case type
+//	  2..0  length of 2nd mapping of case type
+//
+//	  case     1st    2nd
+//	  lower -> upper, title
+//	  upper -> lower, title
+//	  title -> lower, upper
 //
 // Lengths with the value 0x7 indicate no value and implies no change.
 // A length of 0 indicates a mapping to zero-length string.
 //
 // Body bytes:
-//   case folding bytes
-//   lowercase mapping bytes
-//   uppercase mapping bytes
-//   titlecase mapping bytes
-//   closure mapping bytes (for NFKC_Casefold). (TODO)
+//
+//	case folding bytes
+//	lowercase mapping bytes
+//	uppercase mapping bytes
+//	titlecase mapping bytes
+//	closure mapping bytes (for NFKC_Casefold). (TODO)
 //
 // Fallbacks:
-//   missing fold  -> lower
-//   missing title -> upper
-//   all missing   -> original rune
+//
+//	missing fold  -> lower
+//	missing title -> upper
+//	all missing   -> original rune
 //
 // exceptions starts with a dummy byte to enforce that there is no zero index
 // value.
diff --git a/cmd/gotext/doc.go b/cmd/gotext/doc.go
index fa247c6..d363ae2 100644
--- a/cmd/gotext/doc.go
+++ b/cmd/gotext/doc.go
@@ -4,60 +4,47 @@
 //
 // Usage:
 //
-// 	gotext command [arguments]
+//	gotext command [arguments]
 //
 // The commands are:
 //
-// 	update      merge translations and generate catalog
-// 	extract     extracts strings to be translated from code
-// 	rewrite     rewrites fmt functions to use a message Printer
-// 	generate    generates code to insert translated messages
+//	update      merge translations and generate catalog
+//	extract     extracts strings to be translated from code
+//	rewrite     rewrites fmt functions to use a message Printer
+//	generate    generates code to insert translated messages
 //
 // Use "gotext help [command]" for more information about a command.
 //
 // Additional help topics:
 //
-//
 // Use "gotext help [topic]" for more information about that topic.
 //
-//
-// Merge translations and generate catalog
+// # Merge translations and generate catalog
 //
 // Usage:
 //
-// 	gotext update <package>* [-out <gofile>]
+//	gotext update <package>* [-out <gofile>]
 //
-//
-//
-//
-// Extracts strings to be translated from code
+// # Extracts strings to be translated from code
 //
 // Usage:
 //
-// 	gotext extract <package>*
+//	gotext extract <package>*
 //
-//
-//
-//
-// Rewrites fmt functions to use a message Printer
+// # Rewrites fmt functions to use a message Printer
 //
 // Usage:
 //
-// 	gotext rewrite <package>
+//	gotext rewrite <package>
 //
 // rewrite is typically done once for a project. It rewrites all usages of
 // fmt to use x/text's message package whenever a message.Printer is in scope.
 // It rewrites Print and Println calls with constant strings to the equivalent
 // using Printf to allow translators to reorder arguments.
 //
-//
-// Generates code to insert translated messages
+// # Generates code to insert translated messages
 //
 // Usage:
 //
-// 	gotext generate <package>
-//
-//
-//
-//
+//	gotext generate <package>
 package main
diff --git a/collate/build/builder.go b/collate/build/builder.go
index 092a4b5..3efb738 100644
--- a/collate/build/builder.go
+++ b/collate/build/builder.go
@@ -225,26 +225,37 @@
 //
 // Examples: create a tailoring for Swedish, where "ä" is ordered after "z"
 // at the primary sorting level:
-//      t := b.Tailoring("se")
-// 		t.SetAnchor("z")
-// 		t.Insert(colltab.Primary, "ä", "")
+//
+//	t := b.Tailoring("se")
+//	t.SetAnchor("z")
+//	t.Insert(colltab.Primary, "ä", "")
+//
 // Order "ü" after "ue" at the secondary sorting level:
-//		t.SetAnchor("ue")
-//		t.Insert(colltab.Secondary, "ü","")
+//
+//	t.SetAnchor("ue")
+//	t.Insert(colltab.Secondary, "ü","")
+//
 // or
-//		t.SetAnchor("u")
-//		t.Insert(colltab.Secondary, "ü", "e")
+//
+//	t.SetAnchor("u")
+//	t.Insert(colltab.Secondary, "ü", "e")
+//
 // Order "q" afer "ab" at the secondary level and "Q" after "q"
 // at the tertiary level:
-// 		t.SetAnchor("ab")
-// 		t.Insert(colltab.Secondary, "q", "")
-// 		t.Insert(colltab.Tertiary, "Q", "")
+//
+//	t.SetAnchor("ab")
+//	t.Insert(colltab.Secondary, "q", "")
+//	t.Insert(colltab.Tertiary, "Q", "")
+//
 // Order "b" before "a":
-//      t.SetAnchorBefore("a")
-//      t.Insert(colltab.Primary, "b", "")
+//
+//	t.SetAnchorBefore("a")
+//	t.Insert(colltab.Primary, "b", "")
+//
 // Order "0" after the last primary ignorable:
-//      t.SetAnchor("<last_primary_ignorable/>")
-//      t.Insert(colltab.Primary, "0", "")
+//
+//	t.SetAnchor("<last_primary_ignorable/>")
+//	t.Insert(colltab.Primary, "0", "")
 func (t *Tailoring) Insert(level colltab.Level, str, extend string) error {
 	if t.anchor == nil {
 		return fmt.Errorf("%s:Insert: no anchor point set for tailoring of %s", t.id, str)
diff --git a/collate/build/colelem.go b/collate/build/colelem.go
index 04fc3bf..1aaa062 100644
--- a/collate/build/colelem.go
+++ b/collate/build/colelem.go
@@ -51,6 +51,7 @@
 //   - n* is the size of the first node in the contraction trie.
 //   - i* is the index of the first node in the contraction trie.
 //   - b* is the offset into the contraction collation element table.
+//
 // See contract.go for details on the contraction trie.
 const (
 	contractID            = 0xC0000000
@@ -103,7 +104,8 @@
 // The collation element, in this case, is of the form
 // 11110000 00000000 wwwwwwww vvvvvvvv, where
 //   - v* is the replacement tertiary weight for the first rune,
-//   - w* is the replacement tertiary weight for the second rune,
+//   - w* is the replacement tertiary weight for the second rune.
+//
 // Tertiary weights of subsequent runes should be replaced with maxTertiary.
 // See https://www.unicode.org/reports/tr10/#Compatibility_Decompositions for more details.
 const (
@@ -162,7 +164,9 @@
 // primaries (either double primaries or for illegal runes)
 // to our own representation.
 // A CJK character C is represented in the DUCET as
-//   [.FBxx.0020.0002.C][.BBBB.0000.0000.C]
+//
+//	[.FBxx.0020.0002.C][.BBBB.0000.0000.C]
+//
 // We will rewrite these characters to a single CE.
 // We assume the CJK values start at 0x8000.
 // See https://unicode.org/reports/tr10/#Implicit_Weights
diff --git a/collate/build/contract.go b/collate/build/contract.go
index e2df64f..5d79eb8 100644
--- a/collate/build/contract.go
+++ b/collate/build/contract.go
@@ -56,19 +56,22 @@
 // entry might still resemble a completed suffix.
 // Examples:
 // The suffix strings "ab" and "ac" can be represented as:
-// []ctEntry{
-//     {'a', 1, 1, noIndex},  // 'a' by itself does not match, so i is 0xFF.
-//     {'b', 'c', 0, 1},   // "ab" -> 1, "ac" -> 2
-// }
+//
+//	[]ctEntry{
+//		{'a', 1, 1, noIndex},  // 'a' by itself does not match, so i is 0xFF.
+//		{'b', 'c', 0, 1},   // "ab" -> 1, "ac" -> 2
+//	}
 //
 // The suffix strings "ab", "abc", "abd", and "abcd" can be represented as:
-// []ctEntry{
-//     {'a', 1, 1, noIndex}, // 'a' must be followed by 'b'.
-//     {'b', 1, 2, 1},    // "ab" -> 1, may be followed by 'c' or 'd'.
-//     {'d', 'd', final, 3},  // "abd" -> 3
-//     {'c', 4, 1, 2},    // "abc" -> 2, may be followed by 'd'.
-//     {'d', 'd', final, 4},  // "abcd" -> 4
-// }
+//
+//	[]ctEntry{
+//		{'a', 1, 1, noIndex}, // 'a' must be followed by 'b'.
+//		{'b', 1, 2, 1},    // "ab" -> 1, may be followed by 'c' or 'd'.
+//		{'d', 'd', final, 3},  // "abd" -> 3
+//		{'c', 4, 1, 2},    // "abc" -> 2, may be followed by 'd'.
+//		{'d', 'd', final, 4},  // "abcd" -> 4
+//	}
+//
 // See genStateTests in contract_test.go for more examples.
 type ctEntry struct {
 	L uint8 // non-final: byte value to match; final: lowest match in range.
diff --git a/feature/plural/gen.go b/feature/plural/gen.go
index b9c5f24..5f8f375 100644
--- a/feature/plural/gen.go
+++ b/feature/plural/gen.go
@@ -359,15 +359,16 @@
 // the resulting or conditions to conds.
 //
 // Example rules:
-//   // Category "one" in English: only allow 1 with no visible fraction
-//   i = 1 and v = 0 @integer 1
 //
-//   // Category "few" in Czech: all numbers with visible fractions
-//   v != 0   @decimal ...
+//	// Category "one" in English: only allow 1 with no visible fraction
+//	i = 1 and v = 0 @integer 1
 //
-//   // Category "zero" in Latvian: all multiples of 10 or the numbers 11-19 or
-//   // numbers with a fraction 11..19 and no trailing zeros.
-//   n % 10 = 0 or n % 100 = 11..19 or v = 2 and f % 100 = 11..19 @integer ...
+//	// Category "few" in Czech: all numbers with visible fractions
+//	v != 0   @decimal ...
+//
+//	// Category "zero" in Latvian: all multiples of 10 or the numbers 11-19 or
+//	// numbers with a fraction 11..19 and no trailing zeros.
+//	n % 10 = 0 or n % 100 = 11..19 or v = 2 and f % 100 = 11..19 @integer ...
 //
 // @integer and @decimal are followed by examples and are not relevant for the
 // rule itself. The are used here to signal the termination of the rule.
diff --git a/feature/plural/message.go b/feature/plural/message.go
index f931f8a..6248d01 100644
--- a/feature/plural/message.go
+++ b/feature/plural/message.go
@@ -35,13 +35,13 @@
 // The cases argument are pairs of selectors and messages. Selectors are of type
 // string or Form. Messages are of type string or catalog.Message. A selector
 // matches an argument if:
-//    - it is "other" or Other
-//    - it matches the plural form of the argument: "zero", "one", "two", "few",
-//      or "many", or the equivalent Form
-//    - it is of the form "=x" where x is an integer that matches the value of
-//      the argument.
-//    - it is of the form "<x" where x is an integer that is larger than the
-//      argument.
+//   - it is "other" or Other
+//   - it matches the plural form of the argument: "zero", "one", "two", "few",
+//     or "many", or the equivalent Form
+//   - it is of the form "=x" where x is an integer that matches the value of
+//     the argument.
+//   - it is of the form "<x" where x is an integer that is larger than the
+//     argument.
 //
 // The format argument determines the formatting parameters for which to
 // determine the plural form. This is especially relevant for non-integer
diff --git a/feature/plural/plural.go b/feature/plural/plural.go
index 5b521b1..e9f2d42 100644
--- a/feature/plural/plural.go
+++ b/feature/plural/plural.go
@@ -20,7 +20,6 @@
 
 // Rules defines the plural rules for all languages for a certain plural type.
 //
-//
 // This package is UNDER CONSTRUCTION and its API may change.
 type Rules struct {
 	rules          []pluralCheck
@@ -54,19 +53,19 @@
 
 // getIntApprox converts the digits in slice digits[start:end] to an integer
 // according to the following rules:
-//	- Let i be asInt(digits[start:end]), where out-of-range digits are assumed
-//	  to be zero.
-//	- Result n is big if i / 10^nMod > 1.
-//	- Otherwise the result is i % 10^nMod.
+//   - Let i be asInt(digits[start:end]), where out-of-range digits are assumed
+//     to be zero.
+//   - Result n is big if i / 10^nMod > 1.
+//   - Otherwise the result is i % 10^nMod.
 //
 // For example, if digits is {1, 2, 3} and start:end is 0:5, then the result
 // for various values of nMod is:
-//	- when nMod == 2, n == big
-//	- when nMod == 3, n == big
-//	- when nMod == 4, n == big
-//	- when nMod == 5, n == 12300
-//	- when nMod == 6, n == 12300
-//	- when nMod == 7, n == 12300
+//   - when nMod == 2, n == big
+//   - when nMod == 3, n == big
+//   - when nMod == 4, n == big
+//   - when nMod == 5, n == 12300
+//   - when nMod == 6, n == 12300
+//   - when nMod == 7, n == 12300
 func getIntApprox(digits []byte, start, end, nMod, big int) (n int) {
 	// Leading 0 digits just result in 0.
 	p := start
@@ -107,12 +106,13 @@
 //
 // The following table contains examples of possible arguments to represent
 // the given numbers.
-//      decimal    digits              exp    scale
-//      123        []byte{1, 2, 3}     3      0
-//      123.4      []byte{1, 2, 3, 4}  3      1
-//      123.40     []byte{1, 2, 3, 4}  3      2
-//      100000     []byte{1}           6      0
-//      100000.00  []byte{1}           6      3
+//
+//	decimal    digits              exp    scale
+//	123        []byte{1, 2, 3}     3      0
+//	123.4      []byte{1, 2, 3, 4}  3      1
+//	123.40     []byte{1, 2, 3, 4}  3      2
+//	100000     []byte{1}           6      0
+//	100000.00  []byte{1}           6      3
 func (p *Rules) MatchDigits(t language.Tag, digits []byte, exp, scale int) Form {
 	index := tagToID(t)
 
@@ -152,14 +152,15 @@
 // MatchPlural returns the plural form for the given language and plural
 // operands (as defined in
 // https://unicode.org/reports/tr35/tr35-numbers.html#Language_Plural_Rules):
-//  where
-//  	n  absolute value of the source number (integer and decimals)
-//  input
-//  	i  integer digits of n.
-//  	v  number of visible fraction digits in n, with trailing zeros.
-//  	w  number of visible fraction digits in n, without trailing zeros.
-//  	f  visible fractional digits in n, with trailing zeros (f = t * 10^(v-w))
-//  	t  visible fractional digits in n, without trailing zeros.
+//
+//	where
+//		n  absolute value of the source number (integer and decimals)
+//	input
+//		i  integer digits of n.
+//		v  number of visible fraction digits in n, with trailing zeros.
+//		w  number of visible fraction digits in n, without trailing zeros.
+//		f  visible fractional digits in n, with trailing zeros (f = t * 10^(v-w))
+//		t  visible fractional digits in n, without trailing zeros.
 //
 // If any of the operand values is too large to fit in an int, it is okay to
 // pass the value modulo 10,000,000.
diff --git a/internal/catmsg/catmsg.go b/internal/catmsg/catmsg.go
index c0bf86f..1b257a7 100644
--- a/internal/catmsg/catmsg.go
+++ b/internal/catmsg/catmsg.go
@@ -9,8 +9,7 @@
 // own. For instance, the plural package provides functionality for selecting
 // translation strings based on the plural category of substitution arguments.
 //
-//
-// Encoding and Decoding
+// # Encoding and Decoding
 //
 // Catalogs store Messages encoded as a single string. Compiling a message into
 // a string both results in compacter representation and speeds up evaluation.
@@ -25,8 +24,7 @@
 // the message. This decoder takes a Decoder argument which provides the
 // counterparts for the decoding.
 //
-//
-// Renderers
+// # Renderers
 //
 // A Decoder must be initialized with a Renderer implementation. These
 // implementations must be provided by packages that use Catalogs, typically
@@ -38,22 +36,22 @@
 // as sequence of substrings passed to the Renderer. The following snippet shows
 // how to express the above example using the message package.
 //
-//   message.Set(language.English, "You are %d minute(s) late.",
-//       catalog.Var("minutes", plural.Select(1, "one", "minute")),
-//       catalog.String("You are %[1]d ${minutes} late."))
+//	message.Set(language.English, "You are %d minute(s) late.",
+//		catalog.Var("minutes", plural.Select(1, "one", "minute")),
+//		catalog.String("You are %[1]d ${minutes} late."))
 //
-//   p := message.NewPrinter(language.English)
-//   p.Printf("You are %d minute(s) late.", 5) // always 5 minutes late.
+//	p := message.NewPrinter(language.English)
+//	p.Printf("You are %d minute(s) late.", 5) // always 5 minutes late.
 //
 // To evaluate the Printf, package message wraps the arguments in a Renderer
 // that is passed to the catalog for message decoding. The call sequence that
 // results from evaluating the above message, assuming the person is rather
 // tardy, is:
 //
-//   Render("You are %[1]d ")
-//   Arg(1)
-//   Render("minutes")
-//   Render(" late.")
+//	Render("You are %[1]d ")
+//	Arg(1)
+//	Render("minutes")
+//	Render(" late.")
 //
 // The calls to Arg is caused by the plural.Select execution, which evaluates
 // the argument to determine whether the singular or plural message form should
@@ -267,10 +265,12 @@
 // Var defines a message that can be substituted for a placeholder of the same
 // name. If an expression does not result in a string after evaluation, Name is
 // used as the substitution. For example:
-//    Var{
-//      Name:    "minutes",
-//      Message: plural.Select(1, "one", "minute"),
-//    }
+//
+//	Var{
+//	  Name:    "minutes",
+//	  Message: plural.Select(1, "one", "minute"),
+//	}
+//
 // will resolve to minute for singular and minutes for plural forms.
 type Var struct {
 	Name    string
@@ -318,13 +318,15 @@
 // calls for each placeholder and interstitial string. For example, for the
 // message: "%[1]v ${invites} %[2]v to ${their} party." The sequence of calls
 // is:
-//   d.Render("%[1]v ")
-//   d.Arg(1)
-//   d.Render(resultOfInvites)
-//   d.Render(" %[2]v to ")
-//   d.Arg(2)
-//   d.Render(resultOfTheir)
-//   d.Render(" party.")
+//
+//	d.Render("%[1]v ")
+//	d.Arg(1)
+//	d.Render(resultOfInvites)
+//	d.Render(" %[2]v to ")
+//	d.Arg(2)
+//	d.Render(resultOfTheir)
+//	d.Render(" party.")
+//
 // where the messages for "invites" and "their" both use a plural.Select
 // referring to the first argument.
 //
diff --git a/internal/cldrtree/cldrtree.go b/internal/cldrtree/cldrtree.go
index 7530831..cc2714e 100644
--- a/internal/cldrtree/cldrtree.go
+++ b/internal/cldrtree/cldrtree.go
@@ -4,7 +4,6 @@
 
 // Package cldrtree builds and generates a CLDR index file, including all
 // inheritance.
-//
 package cldrtree
 
 //go:generate go test -gen
diff --git a/internal/colltab/collelem.go b/internal/colltab/collelem.go
index 396cebd..0c23c8a 100644
--- a/internal/colltab/collelem.go
+++ b/internal/colltab/collelem.go
@@ -78,24 +78,27 @@
 // For normal collation elements, we assume that a collation element either has
 // a primary or non-default secondary value, not both.
 // Collation elements with a primary value are of the form
-// 01pppppp pppppppp ppppppp0 ssssssss
-//   - p* is primary collation value
-//   - s* is the secondary collation value
-// 00pppppp pppppppp ppppppps sssttttt, where
-//   - p* is primary collation value
-//   - s* offset of secondary from default value.
-//   - t* is the tertiary collation value
-// 100ttttt cccccccc pppppppp pppppppp
-//   - t* is the tertiar collation value
-//   - c* is the canonical combining class
-//   - p* is the primary collation value
+//
+//	01pppppp pppppppp ppppppp0 ssssssss
+//	  - p* is primary collation value
+//	  - s* is the secondary collation value
+//	00pppppp pppppppp ppppppps sssttttt, where
+//	  - p* is primary collation value
+//	  - s* offset of secondary from default value.
+//	  - t* is the tertiary collation value
+//	100ttttt cccccccc pppppppp pppppppp
+//	  - t* is the tertiar collation value
+//	  - c* is the canonical combining class
+//	  - p* is the primary collation value
+//
 // Collation elements with a secondary value are of the form
-// 1010cccc ccccssss ssssssss tttttttt, where
-//   - c* is the canonical combining class
-//   - s* is the secondary collation value
-//   - t* is the tertiary collation value
-// 11qqqqqq qqqqqqqq qqqqqqq0 00000000
-//   - q* quaternary value
+//
+//	1010cccc ccccssss ssssssss tttttttt, where
+//	  - c* is the canonical combining class
+//	  - s* is the secondary collation value
+//	  - t* is the tertiary collation value
+//	11qqqqqq qqqqqqqq qqqqqqq0 00000000
+//	  - q* quaternary value
 const (
 	ceTypeMask              = 0xC0000000
 	ceTypeMaskExt           = 0xE0000000
@@ -296,6 +299,7 @@
 //   - n* is the size of the first node in the contraction trie.
 //   - i* is the index of the first node in the contraction trie.
 //   - b* is the offset into the contraction collation element table.
+//
 // See contract.go for details on the contraction trie.
 const (
 	maxNBits              = 4
@@ -326,6 +330,7 @@
 // The Elem, in this case, is of the form 11110000 00000000 wwwwwwww vvvvvvvv, where
 //   - v* is the replacement tertiary weight for the first rune,
 //   - w* is the replacement tertiary weight for the second rune,
+//
 // Tertiary weights of subsequent runes should be replaced with maxTertiary.
 // See https://www.unicode.org/reports/tr10/#Compatibility_Decompositions for more details.
 func splitDecompose(ce Elem) (t1, t2 uint8) {
diff --git a/internal/export/idna/gen_trieval.go b/internal/export/idna/gen_trieval.go
index 9d92407..501bfab 100644
--- a/internal/export/idna/gen_trieval.go
+++ b/internal/export/idna/gen_trieval.go
@@ -22,23 +22,23 @@
 //
 // The per-rune values have the following format:
 //
-//   if mapped {
-//     if inlinedXOR {
-//       15..13 inline XOR marker
-//       12..11 unused
-//       10..3  inline XOR mask
-//     } else {
-//       15..3  index into xor or mapping table
-//     }
-//   } else {
-//       15..14 unused
-//       13     mayNeedNorm
-//       12..11 attributes
-//       10..8  joining type
-//        7..3  category type
-//   }
-//      2  use xor pattern
-//   1..0  mapped category
+//	if mapped {
+//	  if inlinedXOR {
+//	    15..13 inline XOR marker
+//	    12..11 unused
+//	    10..3  inline XOR mask
+//	  } else {
+//	    15..3  index into xor or mapping table
+//	  }
+//	} else {
+//	    15..14 unused
+//	    13     mayNeedNorm
+//	    12..11 attributes
+//	    10..8  joining type
+//	     7..3  category type
+//	}
+//	   2  use xor pattern
+//	1..0  mapped category
 //
 // See the definitions below for a more detailed description of the various
 // bits.
diff --git a/internal/export/idna/trieval.go b/internal/export/idna/trieval.go
index 7a8cf88..9c070a4 100644
--- a/internal/export/idna/trieval.go
+++ b/internal/export/idna/trieval.go
@@ -17,23 +17,23 @@
 //
 // The per-rune values have the following format:
 //
-//   if mapped {
-//     if inlinedXOR {
-//       15..13 inline XOR marker
-//       12..11 unused
-//       10..3  inline XOR mask
-//     } else {
-//       15..3  index into xor or mapping table
-//     }
-//   } else {
-//       15..14 unused
-//       13     mayNeedNorm
-//       12..11 attributes
-//       10..8  joining type
-//        7..3  category type
-//   }
-//      2  use xor pattern
-//   1..0  mapped category
+//	if mapped {
+//	  if inlinedXOR {
+//	    15..13 inline XOR marker
+//	    12..11 unused
+//	    10..3  inline XOR mask
+//	  } else {
+//	    15..3  index into xor or mapping table
+//	  }
+//	} else {
+//	    15..14 unused
+//	    13     mayNeedNorm
+//	    12..11 attributes
+//	    10..8  joining type
+//	     7..3  category type
+//	}
+//	   2  use xor pattern
+//	1..0  mapped category
 //
 // See the definitions below for a more detailed description of the various
 // bits.
diff --git a/internal/language/tables.go b/internal/language/tables.go
index a19480c..3552e1a 100644
--- a/internal/language/tables.go
+++ b/internal/language/tables.go
@@ -121,9 +121,10 @@
 // lang holds an alphabetically sorted list of ISO-639 language identifiers.
 // All entries are 4 bytes. The index of the identifier (divided by 4) is the language tag.
 // For 2-byte language identifiers, the two successive bytes have the following meaning:
-//     - if the first letter of the 2- and 3-letter ISO codes are the same:
-//       the second and third letter of the 3-letter ISO code.
-//     - otherwise: a 0 and a by 2 bits right-shifted index into altLangISO3.
+//   - if the first letter of the 2- and 3-letter ISO codes are the same:
+//     the second and third letter of the 3-letter ISO code.
+//   - otherwise: a 0 and a by 2 bits right-shifted index into altLangISO3.
+//
 // For 3-byte language identifiers the 4th byte is 0.
 const lang tag.Index = "" + // Size: 5324 bytes
 	"---\x00aaaraai\x00aak\x00aau\x00abbkabi\x00abq\x00abr\x00abt\x00aby\x00a" +
@@ -1086,9 +1087,9 @@
 
 // regionISO holds a list of alphabetically sorted 2-letter ISO region codes.
 // Each 2-letter codes is followed by two bytes with the following meaning:
-//     - [A-Z}{2}: the first letter of the 2-letter code plus these two
-//                 letters form the 3-letter ISO code.
-//     - 0, n:     index into altRegionISO3.
+//   - [A-Z]{2}: the first letter of the 2-letter code plus these two
+//     letters form the 3-letter ISO code.
+//   - 0, n:     index into altRegionISO3.
 const regionISO tag.Index = "" + // Size: 1308 bytes
 	"AAAAACSCADNDAEREAFFGAGTGAIIAALLBAMRMANNTAOGOAQTAARRGASSMATUTAUUSAWBWAXLA" +
 	"AZZEBAIHBBRBBDGDBEELBFFABGGRBHHRBIDIBJENBLLMBMMUBNRNBOOLBQESBRRABSHSBTTN" +
@@ -1206,7 +1207,9 @@
 
 // m49Index gives indexes into fromM49 based on the three most significant bits
 // of a 10-bit UN.M49 code. To search an UN.M49 code in fromM49, search in
-//    fromM49[m49Index[msb39(code)]:m49Index[msb3(code)+1]]
+//
+//	fromM49[m49Index[msb39(code)]:m49Index[msb3(code)+1]]
+//
 // for an entry where the first 7 bits match the 7 lsb of the UN.M49 code.
 // The region code is stored in the 9 lsb of the indexed value.
 // Size: 18 bytes, 9 elements
diff --git a/internal/number/decimal.go b/internal/number/decimal.go
index cb656db..37e0c4b 100644
--- a/internal/number/decimal.go
+++ b/internal/number/decimal.go
@@ -33,13 +33,14 @@
 // may point outside a valid position in Digits.
 //
 // Examples:
-//      Number     Decimal
-//      12345      Digits: [1, 2, 3, 4, 5], Exp: 5
-//      12.345     Digits: [1, 2, 3, 4, 5], Exp: 2
-//      12000      Digits: [1, 2],          Exp: 5
-//      12000.00   Digits: [1, 2],          Exp: 5
-//      0.00123    Digits: [1, 2, 3],       Exp: -2
-//      0          Digits: [],              Exp: 0
+//
+//	Number     Decimal
+//	12345      Digits: [1, 2, 3, 4, 5], Exp: 5
+//	12.345     Digits: [1, 2, 3, 4, 5], Exp: 2
+//	12000      Digits: [1, 2],          Exp: 5
+//	12000.00   Digits: [1, 2],          Exp: 5
+//	0.00123    Digits: [1, 2, 3],       Exp: -2
+//	0          Digits: [],              Exp: 0
 type Decimal struct {
 	digits
 
@@ -60,22 +61,23 @@
 // engineering notation. Digits must have at least one digit.
 //
 // Examples:
-//      Number     Decimal
-//    decimal
-//      12345      Digits: [1, 2, 3, 4, 5], Exp: 5  End: 5
-//      12.345     Digits: [1, 2, 3, 4, 5], Exp: 2  End: 5
-//      12000      Digits: [1, 2],          Exp: 5  End: 5
-//      12000.00   Digits: [1, 2],          Exp: 5  End: 7
-//      0.00123    Digits: [1, 2, 3],       Exp: -2 End: 3
-//      0          Digits: [],              Exp: 0  End: 1
-//    scientific (actual exp is Exp - Comma)
-//      0e0        Digits: [0],             Exp: 1, End: 1, Comma: 1
-//      .0e0       Digits: [0],             Exp: 0, End: 1, Comma: 0
-//      0.0e0      Digits: [0],             Exp: 1, End: 2, Comma: 1
-//      1.23e4     Digits: [1, 2, 3],       Exp: 5, End: 3, Comma: 1
-//      .123e5     Digits: [1, 2, 3],       Exp: 5, End: 3, Comma: 0
-//    engineering
-//      12.3e3     Digits: [1, 2, 3],       Exp: 5, End: 3, Comma: 2
+//
+//	  Number     Decimal
+//	decimal
+//	  12345      Digits: [1, 2, 3, 4, 5], Exp: 5  End: 5
+//	  12.345     Digits: [1, 2, 3, 4, 5], Exp: 2  End: 5
+//	  12000      Digits: [1, 2],          Exp: 5  End: 5
+//	  12000.00   Digits: [1, 2],          Exp: 5  End: 7
+//	  0.00123    Digits: [1, 2, 3],       Exp: -2 End: 3
+//	  0          Digits: [],              Exp: 0  End: 1
+//	scientific (actual exp is Exp - Comma)
+//	  0e0        Digits: [0],             Exp: 1, End: 1, Comma: 1
+//	  .0e0       Digits: [0],             Exp: 0, End: 1, Comma: 0
+//	  0.0e0      Digits: [0],             Exp: 1, End: 2, Comma: 1
+//	  1.23e4     Digits: [1, 2, 3],       Exp: 5, End: 3, Comma: 1
+//	  .123e5     Digits: [1, 2, 3],       Exp: 5, End: 3, Comma: 0
+//	engineering
+//	  12.3e3     Digits: [1, 2, 3],       Exp: 5, End: 3, Comma: 2
 type Digits struct {
 	digits
 	// End indicates the end position of the number.
diff --git a/internal/testtext/codesize.go b/internal/testtext/codesize.go
index 5fc5eae..88df487 100644
--- a/internal/testtext/codesize.go
+++ b/internal/testtext/codesize.go
@@ -16,11 +16,13 @@
 
 // CodeSize builds the given code sample and returns the binary size or en error
 // if an error occurred. The code sample typically will look like this:
-//     package main
-//     import "golang.org/x/text/somepackage"
-//     func main() {
-//         somepackage.Func() // reference Func to cause it to be linked in.
-//     }
+//
+//	package main
+//	import "golang.org/x/text/somepackage"
+//	func main() {
+//	    somepackage.Func() // reference Func to cause it to be linked in.
+//	}
+//
 // See dict_test.go in the display package for an example.
 func CodeSize(s string) (int, error) {
 	// Write the file.
diff --git a/internal/triegen/triegen.go b/internal/triegen/triegen.go
index 51d218a..de54a80 100644
--- a/internal/triegen/triegen.go
+++ b/internal/triegen/triegen.go
@@ -34,23 +34,24 @@
 // triegen generates both tables and code. The code is optimized to use the
 // automatically chosen data types. The following code is generated for a Trie
 // or multiple Tries named "foo":
-//	- type fooTrie
-//		The trie type.
 //
-//	- func newFooTrie(x int) *fooTrie
-//		Trie constructor, where x is the index of the trie passed to Gen.
+//   - type fooTrie
+//     The trie type.
 //
-//	- func (t *fooTrie) lookup(s []byte) (v uintX, sz int)
-//		The lookup method, where uintX is automatically chosen.
+//   - func newFooTrie(x int) *fooTrie
+//     Trie constructor, where x is the index of the trie passed to Gen.
 //
-//	- func lookupString, lookupUnsafe and lookupStringUnsafe
-//		Variants of the above.
+//   - func (t *fooTrie) lookup(s []byte) (v uintX, sz int)
+//     The lookup method, where uintX is automatically chosen.
 //
-//	- var fooValues and fooIndex and any tables generated by Compacters.
-//		The core trie data.
+//   - func lookupString, lookupUnsafe and lookupStringUnsafe
+//     Variants of the above.
 //
-//	- var fooTrieHandles
-//		Indexes of starter blocks in case of multiple trie roots.
+//   - var fooValues and fooIndex and any tables generated by Compacters.
+//     The core trie data.
+//
+//   - var fooTrieHandles
+//     Indexes of starter blocks in case of multiple trie roots.
 //
 // It is recommended that users test the generated trie by checking the returned
 // value for every rune. Such exhaustive tests are possible as the number of
diff --git a/internal/utf8internal/utf8internal.go b/internal/utf8internal/utf8internal.go
index 575cea8..e5c53b1 100644
--- a/internal/utf8internal/utf8internal.go
+++ b/internal/utf8internal/utf8internal.go
@@ -74,7 +74,7 @@
 
 // AcceptRanges is a slice of AcceptRange values. For a given byte sequence b
 //
-//		AcceptRanges[First[b[0]]>>AcceptShift]
+//	AcceptRanges[First[b[0]]>>AcceptShift]
 //
 // will give the value of AcceptRange for the multi-byte UTF-8 sequence starting
 // at b[0].
diff --git a/language/display/lookup.go b/language/display/lookup.go
index e6dc0e0..8830775 100644
--- a/language/display/lookup.go
+++ b/language/display/lookup.go
@@ -92,10 +92,10 @@
 // offsets for a string in data. For example, consider a header that defines
 // strings for the languages de, el, en, fi, and nl:
 //
-// 		header{
-// 			data: "GermanGreekEnglishDutch",
-//  		index: []uint16{ 0, 6, 11, 18, 18, 23 },
-// 		}
+//	header{
+//		data: "GermanGreekEnglishDutch",
+//		index: []uint16{0, 6, 11, 18, 18, 23},
+//	}
 //
 // For a language with index i, the string is defined by
 // data[index[i]:index[i+1]]. So the number of elements in index is always one
@@ -204,9 +204,11 @@
 // for each length, which can be used in combination with binary search to get
 // the index associated with a tag.
 // For example, a tagIndex{
-//   "arenesfrruzh",  // 6 2-byte tags.
-//   "barwae",        // 2 3-byte tags.
-//   "",
+//
+//	"arenesfrruzh",  // 6 2-byte tags.
+//	"barwae",        // 2 3-byte tags.
+//	"",
+//
 // }
 // would mean that the 2-byte tag "fr" had an index of 3, and the 3-byte tag
 // "wae" had an index of 7.
diff --git a/language/doc.go b/language/doc.go
index 8afecd5..212b77c 100644
--- a/language/doc.go
+++ b/language/doc.go
@@ -10,18 +10,17 @@
 // and provides the user with the best experience
 // (see https://blog.golang.org/matchlang).
 //
-//
-// Matching preferred against supported languages
+// # Matching preferred against supported languages
 //
 // A Matcher for an application that supports English, Australian English,
 // Danish, and standard Mandarin can be created as follows:
 //
-//    var matcher = language.NewMatcher([]language.Tag{
-//        language.English,   // The first language is used as fallback.
-//        language.MustParse("en-AU"),
-//        language.Danish,
-//        language.Chinese,
-//    })
+//	var matcher = language.NewMatcher([]language.Tag{
+//	    language.English,   // The first language is used as fallback.
+//	    language.MustParse("en-AU"),
+//	    language.Danish,
+//	    language.Chinese,
+//	})
 //
 // This list of supported languages is typically implied by the languages for
 // which there exists translations of the user interface.
@@ -30,14 +29,14 @@
 // language tags.
 // The MatchString finds best matches for such strings:
 //
-//    handler(w http.ResponseWriter, r *http.Request) {
-//        lang, _ := r.Cookie("lang")
-//        accept := r.Header.Get("Accept-Language")
-//        tag, _ := language.MatchStrings(matcher, lang.String(), accept)
+//	handler(w http.ResponseWriter, r *http.Request) {
+//	    lang, _ := r.Cookie("lang")
+//	    accept := r.Header.Get("Accept-Language")
+//	    tag, _ := language.MatchStrings(matcher, lang.String(), accept)
 //
-//        // tag should now be used for the initialization of any
-//        // locale-specific service.
-//    }
+//	    // tag should now be used for the initialization of any
+//	    // locale-specific service.
+//	}
 //
 // The Matcher's Match method can be used to match Tags directly.
 //
@@ -48,8 +47,7 @@
 // For instance, it will know that a reader of Bokmål Danish can read Norwegian
 // and will know that Cantonese ("yue") is a good match for "zh-HK".
 //
-//
-// Using match results
+// # Using match results
 //
 // To guarantee a consistent user experience to the user it is important to
 // use the same language tag for the selection of any locale-specific services.
@@ -58,9 +56,9 @@
 // More subtly confusing is using the wrong sorting order or casing
 // algorithm for a certain language.
 //
-//    All the packages in x/text that provide locale-specific services
-//    (e.g. collate, cases) should be initialized with the tag that was
-//    obtained at the start of an interaction with the user.
+// All the packages in x/text that provide locale-specific services
+// (e.g. collate, cases) should be initialized with the tag that was
+// obtained at the start of an interaction with the user.
 //
 // Note that Tag that is returned by Match and MatchString may differ from any
 // of the supported languages, as it may contain carried over settings from
@@ -70,8 +68,7 @@
 // Match and MatchString both return the index of the matched supported tag
 // to simplify associating such data with the matched tag.
 //
-//
-// Canonicalization
+// # Canonicalization
 //
 // If one uses the Matcher to compare languages one does not need to
 // worry about canonicalization.
@@ -92,10 +89,9 @@
 // equivalence relations. The CanonType type can be used to alter the
 // canonicalization form.
 //
-// References
+// # References
 //
 // BCP 47 - Tags for Identifying Languages http://tools.ietf.org/html/bcp47
-//
 package language // import "golang.org/x/text/language"
 
 // TODO: explanation on how to match languages for your own locale-specific
diff --git a/message/catalog/catalog.go b/message/catalog/catalog.go
index de595b5..96955d0 100644
--- a/message/catalog/catalog.go
+++ b/message/catalog/catalog.go
@@ -13,8 +13,7 @@
 // language. The Loader interface defines a source of dictionaries. A
 // translation of a format string is represented by a Message.
 //
-//
-// Catalogs
+// # Catalogs
 //
 // A Catalog defines a programmatic interface for setting message translations.
 // It maintains a set of per-language dictionaries with translations for a set
@@ -24,8 +23,7 @@
 // the key. For example, a Dictionary for "en-GB" could leave out entries that
 // are identical to those in a dictionary for "en".
 //
-//
-// Messages
+// # Messages
 //
 // A Message is a format string which varies on the value of substitution
 // variables. For instance, to indicate the number of results one could want "no
@@ -39,8 +37,7 @@
 // to selected string. This separation of concerns allows Catalog to be used to
 // store any kind of formatting strings.
 //
-//
-// Selecting messages based on linguistic features of substitution arguments
+// # Selecting messages based on linguistic features of substitution arguments
 //
 // Messages may vary based on any linguistic features of the argument values.
 // The most common one is plural form, but others exist.
@@ -48,10 +45,10 @@
 // Selection messages are provided in packages that provide support for a
 // specific linguistic feature. The following snippet uses plural.Selectf:
 //
-//   catalog.Set(language.English, "You are %d minute(s) late.",
-//       plural.Selectf(1, "",
-//           plural.One, "You are 1 minute late.",
-//           plural.Other, "You are %d minutes late."))
+//	catalog.Set(language.English, "You are %d minute(s) late.",
+//		plural.Selectf(1, "",
+//			plural.One, "You are 1 minute late.",
+//			plural.Other, "You are %d minutes late."))
 //
 // In this example, a message is stored in the Catalog where one of two messages
 // is selected based on the first argument, a number. The first message is
@@ -64,47 +61,46 @@
 // Selects can be nested. This allows selecting sentences based on features of
 // multiple arguments or multiple linguistic properties of a single argument.
 //
-//
-// String interpolation
+// # String interpolation
 //
 // There is often a lot of commonality between the possible variants of a
 // message. For instance, in the example above the word "minute" varies based on
 // the plural catogory of the argument, but the rest of the sentence is
 // identical. Using interpolation the above message can be rewritten as:
 //
-//   catalog.Set(language.English, "You are %d minute(s) late.",
-//       catalog.Var("minutes",
-//           plural.Selectf(1, "", plural.One, "minute", plural.Other, "minutes")),
-//       catalog.String("You are %[1]d ${minutes} late."))
+//	catalog.Set(language.English, "You are %d minute(s) late.",
+//		catalog.Var("minutes",
+//			plural.Selectf(1, "", plural.One, "minute", plural.Other, "minutes")),
+//		catalog.String("You are %[1]d ${minutes} late."))
 //
 // Var is defined to return the variable name if the message does not yield a
 // match. This allows us to further simplify this snippet to
 //
-//   catalog.Set(language.English, "You are %d minute(s) late.",
-//       catalog.Var("minutes", plural.Selectf(1, "", plural.One, "minute")),
-//       catalog.String("You are %d ${minutes} late."))
+//	catalog.Set(language.English, "You are %d minute(s) late.",
+//		catalog.Var("minutes", plural.Selectf(1, "", plural.One, "minute")),
+//		catalog.String("You are %d ${minutes} late."))
 //
 // Overall this is still only a minor improvement, but things can get a lot more
 // unwieldy if more than one linguistic feature is used to determine a message
 // variant. Consider the following example:
 //
-//   // argument 1: list of hosts, argument 2: list of guests
-//   catalog.Set(language.English, "%[1]v invite(s) %[2]v to their party.",
-//     catalog.Var("their",
-//         plural.Selectf(1, ""
-//             plural.One, gender.Select(1, "female", "her", "other", "his"))),
-//     catalog.Var("invites", plural.Selectf(1, "", plural.One, "invite"))
-//     catalog.String("%[1]v ${invites} %[2]v to ${their} party.")),
+//	// argument 1: list of hosts, argument 2: list of guests
+//	catalog.Set(language.English, "%[1]v invite(s) %[2]v to their party.",
+//		catalog.Var("their",
+//			plural.Selectf(1, ""
+//				plural.One, gender.Select(1, "female", "her", "other", "his"))),
+//		catalog.Var("invites", plural.Selectf(1, "", plural.One, "invite"))
+//		catalog.String("%[1]v ${invites} %[2]v to ${their} party.")),
 //
 // Without variable substitution, this would have to be written as
 //
-//   // argument 1: list of hosts, argument 2: list of guests
-//   catalog.Set(language.English, "%[1]v invite(s) %[2]v to their party.",
-//     plural.Selectf(1, "",
-//         plural.One, gender.Select(1,
-//             "female", "%[1]v invites %[2]v to her party."
-//             "other", "%[1]v invites %[2]v to his party."),
-//         plural.Other, "%[1]v invites %[2]v to their party.")
+//	// argument 1: list of hosts, argument 2: list of guests
+//	catalog.Set(language.English, "%[1]v invite(s) %[2]v to their party.",
+//		plural.Selectf(1, "",
+//			plural.One, gender.Select(1,
+//				"female", "%[1]v invites %[2]v to her party."
+//				"other", "%[1]v invites %[2]v to his party."),
+//			plural.Other, "%[1]v invites %[2]v to their party."))
 //
 // Not necessarily shorter, but using variables there is less duplication and
 // the messages are more maintenance friendly. Moreover, languages may have up
@@ -113,33 +109,32 @@
 // Different messages using the same inflections can reuse variables by moving
 // them to macros. Using macros we can rewrite the message as:
 //
-//   // argument 1: list of hosts, argument 2: list of guests
-//   catalog.SetString(language.English, "%[1]v invite(s) %[2]v to their party.",
-//       "%[1]v ${invites(1)} %[2]v to ${their(1)} party.")
+//	// argument 1: list of hosts, argument 2: list of guests
+//	catalog.SetString(language.English, "%[1]v invite(s) %[2]v to their party.",
+//		"%[1]v ${invites(1)} %[2]v to ${their(1)} party.")
 //
 // Where the following macros were defined separately.
 //
-//   catalog.SetMacro(language.English, "invites", plural.Selectf(1, "",
-//      plural.One, "invite"))
-//   catalog.SetMacro(language.English, "their", plural.Selectf(1, "",
-//      plural.One, gender.Select(1, "female", "her", "other", "his"))),
+//	catalog.SetMacro(language.English, "invites", plural.Selectf(1, "",
+//		plural.One, "invite"))
+//	catalog.SetMacro(language.English, "their", plural.Selectf(1, "",
+//		plural.One, gender.Select(1, "female", "her", "other", "his"))),
 //
 // Placeholders use parentheses and the arguments to invoke a macro.
 //
-//
-// Looking up messages
+// # Looking up messages
 //
 // Message lookup using Catalogs is typically only done by specialized packages
 // and is not something the user should be concerned with. For instance, to
 // express the tardiness of a user using the related message we defined earlier,
 // the user may use the package message like so:
 //
-//   p := message.NewPrinter(language.English)
-//   p.Printf("You are %d minute(s) late.", 5)
+//	p := message.NewPrinter(language.English)
+//	p.Printf("You are %d minute(s) late.", 5)
 //
 // Which would print:
-//   You are 5 minutes late.
 //
+//	You are 5 minutes late.
 //
 // This package is UNDER CONSTRUCTION and its API may change.
 package catalog // import "golang.org/x/text/message/catalog"
diff --git a/message/doc.go b/message/doc.go
index 72e8fde..4bf7bdc 100644
--- a/message/doc.go
+++ b/message/doc.go
@@ -5,22 +5,21 @@
 // Package message implements formatted I/O for localized strings with functions
 // analogous to the fmt's print functions. It is a drop-in replacement for fmt.
 //
-//
-// Localized Formatting
+// # Localized Formatting
 //
 // A format string can be localized by replacing any of the print functions of
 // fmt with an equivalent call to a Printer.
 //
-//    p := message.NewPrinter(message.MatchLanguage("en"))
-//    p.Println(123456.78) // Prints 123,456.78
+//	p := message.NewPrinter(message.MatchLanguage("en"))
+//	p.Println(123456.78) // Prints 123,456.78
 //
-//    p.Printf("%d ducks in a row", 4331) // Prints 4,331 ducks in a row
+//	p.Printf("%d ducks in a row", 4331) // Prints 4,331 ducks in a row
 //
-//    p := message.NewPrinter(message.MatchLanguage("nl"))
-//    p.Printf("Hoogte: %.1f meter", 1244.9) // Prints Hoogte: 1,244.9 meter
+//	p := message.NewPrinter(message.MatchLanguage("nl"))
+//	p.Printf("Hoogte: %.1f meter", 1244.9) // Prints Hoogte: 1,244.9 meter
 //
-//    p := message.NewPrinter(message.MatchLanguage("bn"))
-//    p.Println(123456.78) // Prints ১,২৩,৪৫৬.৭৮
+//	p := message.NewPrinter(message.MatchLanguage("bn"))
+//	p.Println(123456.78) // Prints ১,২৩,৪৫৬.৭৮
 //
 // Printer currently supports numbers and specialized types for which packages
 // exist in x/text. Other builtin types such as time.Time and slices are
@@ -35,8 +34,7 @@
 //
 // See package fmt for more options.
 //
-//
-// Translation
+// # Translation
 //
 // The format strings that are passed to Printf, Sprintf, Fprintf, or Errorf
 // are used as keys to look up translations for the specified languages.
@@ -44,34 +42,36 @@
 //
 // One can use arbitrary keys to distinguish between otherwise ambiguous
 // strings:
-//    p := message.NewPrinter(language.English)
-//    p.Printf("archive(noun)")  // Prints "archive"
-//    p.Printf("archive(verb)")  // Prints "archive"
 //
-//    p := message.NewPrinter(language.German)
-//    p.Printf("archive(noun)")  // Prints "Archiv"
-//    p.Printf("archive(verb)")  // Prints "archivieren"
+//	p := message.NewPrinter(language.English)
+//	p.Printf("archive(noun)")  // Prints "archive"
+//	p.Printf("archive(verb)")  // Prints "archive"
+//
+//	p := message.NewPrinter(language.German)
+//	p.Printf("archive(noun)")  // Prints "Archiv"
+//	p.Printf("archive(verb)")  // Prints "archivieren"
 //
 // To retain the fallback functionality, use Key:
-//    p.Printf(message.Key("archive(noun)", "archive"))
-//    p.Printf(message.Key("archive(verb)", "archive"))
 //
+//	p.Printf(message.Key("archive(noun)", "archive"))
+//	p.Printf(message.Key("archive(verb)", "archive"))
 //
-// Translation Pipeline
+// # Translation Pipeline
 //
 // Format strings that contain text need to be translated to support different
 // locales. The first step is to extract strings that need to be translated.
 //
 // 1. Install gotext
-//    go get -u golang.org/x/text/cmd/gotext
-//    gotext -help
+//
+//	go get -u golang.org/x/text/cmd/gotext
+//	gotext -help
 //
 // 2. Mark strings in your source to be translated by using message.Printer,
 // instead of the functions of the fmt package.
 //
 // 3. Extract the strings from your source
 //
-//    gotext extract
+//	gotext extract
 //
 // The output will be written to the textdata directory.
 //
@@ -89,13 +89,11 @@
 // see also package golang.org/x/text/message/catalog can be used to implement
 // either dynamic or static loading of messages.
 //
-//
-// Plural and Gender Forms
+// # Plural and Gender Forms
 //
 // Translated messages can vary based on the plural and gender forms of
 // substitution values. In general, it is up to the translators to provide
 // alternative translations for such forms. See the packages in
 // golang.org/x/text/feature and golang.org/x/text/message/catalog for more
 // information.
-//
 package message
diff --git a/number/doc.go b/number/doc.go
index 2ad8d43..8766230 100644
--- a/number/doc.go
+++ b/number/doc.go
@@ -9,19 +9,18 @@
 // builtin Go types and anything that implements the Convert interface
 // (currently internal).
 //
-//    p := message.NewPrinter(language.English)
+//	p := message.NewPrinter(language.English)
 //
-//    p.Printf("%v bottles of beer on the wall.", number.Decimal(1234))
-//    // Prints: 1,234 bottles of beer on the wall.
+//	p.Printf("%v bottles of beer on the wall.", number.Decimal(1234))
+//	// Prints: 1,234 bottles of beer on the wall.
 //
-//    p.Printf("%v of gophers lose too much fur", number.Percent(0.12))
-//    // Prints: 12% of gophers lose too much fur.
+//	p.Printf("%v of gophers lose too much fur", number.Percent(0.12))
+//	// Prints: 12% of gophers lose too much fur.
 //
-//    p := message.NewPrinter(language.Dutch)
+//	p := message.NewPrinter(language.Dutch)
 //
-//    p.Printf("There are %v bikes per household.", number.Decimal(1.2))
-//    // Prints: Er zijn 1,2 fietsen per huishouden.
-//
+//	p.Printf("There are %v bikes per household.", number.Decimal(1.2))
+//	// Prints: Er zijn 1,2 fietsen per huishouden.
 //
 // The width and scale specified in the formatting directives override the
 // configuration of the formatter.
diff --git a/unicode/bidi/core.go b/unicode/bidi/core.go
index fde188a..9d2ae54 100644
--- a/unicode/bidi/core.go
+++ b/unicode/bidi/core.go
@@ -193,14 +193,14 @@
 //
 // At the end of this function:
 //
-//  - The member variable matchingPDI is set to point to the index of the
-//    matching PDI character for each isolate initiator character. If there is
-//    no matching PDI, it is set to the length of the input text. For other
-//    characters, it is set to -1.
-//  - The member variable matchingIsolateInitiator is set to point to the
-//    index of the matching isolate initiator character for each PDI character.
-//    If there is no matching isolate initiator, or the character is not a PDI,
-//    it is set to -1.
+//   - The member variable matchingPDI is set to point to the index of the
+//     matching PDI character for each isolate initiator character. If there is
+//     no matching PDI, it is set to the length of the input text. For other
+//     characters, it is set to -1.
+//   - The member variable matchingIsolateInitiator is set to point to the
+//     index of the matching isolate initiator character for each PDI character.
+//     If there is no matching isolate initiator, or the character is not a PDI,
+//     it is set to -1.
 func (p *paragraph) determineMatchingIsolates() {
 	p.matchingPDI = make([]int, p.Len())
 	p.matchingIsolateInitiator = make([]int, p.Len())
@@ -435,7 +435,7 @@
 }
 
 // Rule X10, second bullet: Determine the start-of-sequence (sos) and end-of-sequence (eos) types,
-// 			 either L or R, for each isolating run sequence.
+// either L or R, for each isolating run sequence.
 func (p *paragraph) isolatingRunSequence(indexes []int) *isolatingRunSequence {
 	length := len(indexes)
 	types := make([]Class, length)
@@ -905,7 +905,7 @@
 // Lines are concatenated from left to right. So for example, the fifth
 // character from the left on the third line is
 //
-// 		getReordering(linebreaks)[linebreaks[1] + 4]
+//	getReordering(linebreaks)[linebreaks[1] + 4]
 //
 // (linebreaks[1] is the position after the last character of the second
 // line, which is also the index of the first character on the third line,
diff --git a/unicode/cldr/collate.go b/unicode/cldr/collate.go
index 27c5bac..056fe7f 100644
--- a/unicode/cldr/collate.go
+++ b/unicode/cldr/collate.go
@@ -98,9 +98,13 @@
 }
 
 // parseSpecialAnchor parses the anchor syntax which is either of the form
-//    ['before' <level>] <anchor>
+//
+//	['before' <level>] <anchor>
+//
 // or
-//    [<label>]
+//
+//	[<label>]
+//
 // The starting should already be consumed.
 func parseSpecialAnchor(p RuleProcessor, s string) (tail string, err error) {
 	i := strings.IndexByte(s, ']')
diff --git a/unicode/norm/forminfo.go b/unicode/norm/forminfo.go
index 526c703..d69ccb4 100644
--- a/unicode/norm/forminfo.go
+++ b/unicode/norm/forminfo.go
@@ -110,10 +110,11 @@
 }
 
 // We pack quick check data in 4 bits:
-//   5:    Combines forward  (0 == false, 1 == true)
-//   4..3: NFC_QC Yes(00), No (10), or Maybe (11)
-//   2:    NFD_QC Yes (0) or No (1). No also means there is a decomposition.
-//   1..0: Number of trailing non-starters.
+//
+//	5:    Combines forward  (0 == false, 1 == true)
+//	4..3: NFC_QC Yes(00), No (10), or Maybe (11)
+//	2:    NFD_QC Yes (0) or No (1). No also means there is a decomposition.
+//	1..0: Number of trailing non-starters.
 //
 // When all 4 bits are zero, the character is inert, meaning it is never
 // influenced by normalization.
diff --git a/unicode/norm/maketables.go b/unicode/norm/maketables.go
index 0d24d21..dd05b6f 100644
--- a/unicode/norm/maketables.go
+++ b/unicode/norm/maketables.go
@@ -132,8 +132,10 @@
 }
 
 // In UnicodeData.txt, some ranges are marked like this:
+//
 //	3400;<CJK Ideograph Extension A, First>;Lo;0;L;;;;;N;;;;;
 //	4DB5;<CJK Ideograph Extension A, Last>;Lo;0;L;;;;;N;;;;;
+//
 // parseCharacter keeps a state variable indicating the weirdness.
 type State int
 
diff --git a/unicode/norm/normalize.go b/unicode/norm/normalize.go
index 95efcf2..4747ad0 100644
--- a/unicode/norm/normalize.go
+++ b/unicode/norm/normalize.go
@@ -18,16 +18,17 @@
 // A Form denotes a canonical representation of Unicode code points.
 // The Unicode-defined normalization and equivalence forms are:
 //
-//   NFC   Unicode Normalization Form C
-//   NFD   Unicode Normalization Form D
-//   NFKC  Unicode Normalization Form KC
-//   NFKD  Unicode Normalization Form KD
+//	NFC   Unicode Normalization Form C
+//	NFD   Unicode Normalization Form D
+//	NFKC  Unicode Normalization Form KC
+//	NFKD  Unicode Normalization Form KD
 //
 // For a Form f, this documentation uses the notation f(x) to mean
 // the bytes or string x converted to the given form.
 // A position n in x is called a boundary if conversion to the form can
 // proceed independently on both sides:
-//   f(x) == append(f(x[0:n]), f(x[n:])...)
+//
+//	f(x) == append(f(x[0:n]), f(x[n:])...)
 //
 // References: https://unicode.org/reports/tr15/ and
 // https://unicode.org/notes/tn5/.
diff --git a/width/tables10.0.0.go b/width/tables10.0.0.go
index 186b1d4..cd9d91c 100644
--- a/width/tables10.0.0.go
+++ b/width/tables10.0.0.go
@@ -1146,21 +1146,31 @@
 }
 
 // inverseData contains 4-byte entries of the following format:
-//   <length> <modified UTF-8-encoded rune> <0 padding>
+//
+//	<length> <modified UTF-8-encoded rune> <0 padding>
+//
 // The last byte of the UTF-8-encoded rune is xor-ed with the last byte of the
 // UTF-8 encoding of the original rune. Mappings often have the following
 // pattern:
-//   Ａ -> A  (U+FF21 -> U+0041)
-//   Ｂ -> B  (U+FF22 -> U+0042)
-//   ...
+//
+//	Ａ -> A  (U+FF21 -> U+0041)
+//	Ｂ -> B  (U+FF22 -> U+0042)
+//	...
+//
 // By xor-ing the last byte the same entry can be shared by many mappings. This
 // reduces the total number of distinct entries by about two thirds.
 // The resulting entry for the aforementioned mappings is
-//   { 0x01, 0xE0, 0x00, 0x00 }
+//
+//	{ 0x01, 0xE0, 0x00, 0x00 }
+//
 // Using this entry to map U+FF21 (UTF-8 [EF BC A1]), we get
-//   E0 ^ A1 = 41.
+//
+//	E0 ^ A1 = 41.
+//
 // Similarly, for U+FF22 (UTF-8 [EF BC A2]), we get
-//   E0 ^ A2 = 42.
+//
+//	E0 ^ A2 = 42.
+//
 // Note that because of the xor-ing, the byte sequence stored in the entry is
 // not valid UTF-8.
 var inverseData = [150][4]byte{
diff --git a/width/tables11.0.0.go b/width/tables11.0.0.go
index 990f762..327eaef 100644
--- a/width/tables11.0.0.go
+++ b/width/tables11.0.0.go
@@ -1158,21 +1158,31 @@
 }
 
 // inverseData contains 4-byte entries of the following format:
-//   <length> <modified UTF-8-encoded rune> <0 padding>
+//
+//	<length> <modified UTF-8-encoded rune> <0 padding>
+//
 // The last byte of the UTF-8-encoded rune is xor-ed with the last byte of the
 // UTF-8 encoding of the original rune. Mappings often have the following
 // pattern:
-//   Ａ -> A  (U+FF21 -> U+0041)
-//   Ｂ -> B  (U+FF22 -> U+0042)
-//   ...
+//
+//	Ａ -> A  (U+FF21 -> U+0041)
+//	Ｂ -> B  (U+FF22 -> U+0042)
+//	...
+//
 // By xor-ing the last byte the same entry can be shared by many mappings. This
 // reduces the total number of distinct entries by about two thirds.
 // The resulting entry for the aforementioned mappings is
-//   { 0x01, 0xE0, 0x00, 0x00 }
+//
+//	{ 0x01, 0xE0, 0x00, 0x00 }
+//
 // Using this entry to map U+FF21 (UTF-8 [EF BC A1]), we get
-//   E0 ^ A1 = 41.
+//
+//	E0 ^ A1 = 41.
+//
 // Similarly, for U+FF22 (UTF-8 [EF BC A2]), we get
-//   E0 ^ A2 = 42.
+//
+//	E0 ^ A2 = 42.
+//
 // Note that because of the xor-ing, the byte sequence stored in the entry is
 // not valid UTF-8.
 var inverseData = [150][4]byte{
diff --git a/width/tables12.0.0.go b/width/tables12.0.0.go
index 8529629..5c14ade 100644
--- a/width/tables12.0.0.go
+++ b/width/tables12.0.0.go
@@ -1178,21 +1178,31 @@
 }
 
 // inverseData contains 4-byte entries of the following format:
-//   <length> <modified UTF-8-encoded rune> <0 padding>
+//
+//	<length> <modified UTF-8-encoded rune> <0 padding>
+//
 // The last byte of the UTF-8-encoded rune is xor-ed with the last byte of the
 // UTF-8 encoding of the original rune. Mappings often have the following
 // pattern:
-//   Ａ -> A  (U+FF21 -> U+0041)
-//   Ｂ -> B  (U+FF22 -> U+0042)
-//   ...
+//
+//	Ａ -> A  (U+FF21 -> U+0041)
+//	Ｂ -> B  (U+FF22 -> U+0042)
+//	...
+//
 // By xor-ing the last byte the same entry can be shared by many mappings. This
 // reduces the total number of distinct entries by about two thirds.
 // The resulting entry for the aforementioned mappings is
-//   { 0x01, 0xE0, 0x00, 0x00 }
+//
+//	{ 0x01, 0xE0, 0x00, 0x00 }
+//
 // Using this entry to map U+FF21 (UTF-8 [EF BC A1]), we get
-//   E0 ^ A1 = 41.
+//
+//	E0 ^ A1 = 41.
+//
 // Similarly, for U+FF22 (UTF-8 [EF BC A2]), we get
-//   E0 ^ A2 = 42.
+//
+//	E0 ^ A2 = 42.
+//
 // Note that because of the xor-ing, the byte sequence stored in the entry is
 // not valid UTF-8.
 var inverseData = [150][4]byte{
diff --git a/width/tables13.0.0.go b/width/tables13.0.0.go
index bac3f1a..ab258e3 100644
--- a/width/tables13.0.0.go
+++ b/width/tables13.0.0.go
@@ -1179,21 +1179,31 @@
 }
 
 // inverseData contains 4-byte entries of the following format:
-//   <length> <modified UTF-8-encoded rune> <0 padding>
+//
+//	<length> <modified UTF-8-encoded rune> <0 padding>
+//
 // The last byte of the UTF-8-encoded rune is xor-ed with the last byte of the
 // UTF-8 encoding of the original rune. Mappings often have the following
 // pattern:
-//   Ａ -> A  (U+FF21 -> U+0041)
-//   Ｂ -> B  (U+FF22 -> U+0042)
-//   ...
+//
+//	Ａ -> A  (U+FF21 -> U+0041)
+//	Ｂ -> B  (U+FF22 -> U+0042)
+//	...
+//
 // By xor-ing the last byte the same entry can be shared by many mappings. This
 // reduces the total number of distinct entries by about two thirds.
 // The resulting entry for the aforementioned mappings is
-//   { 0x01, 0xE0, 0x00, 0x00 }
+//
+//	{ 0x01, 0xE0, 0x00, 0x00 }
+//
 // Using this entry to map U+FF21 (UTF-8 [EF BC A1]), we get
-//   E0 ^ A1 = 41.
+//
+//	E0 ^ A1 = 41.
+//
 // Similarly, for U+FF22 (UTF-8 [EF BC A2]), we get
-//   E0 ^ A2 = 42.
+//
+//	E0 ^ A2 = 42.
+//
 // Note that because of the xor-ing, the byte sequence stored in the entry is
 // not valid UTF-8.
 var inverseData = [150][4]byte{
diff --git a/width/tables9.0.0.go b/width/tables9.0.0.go
index b3db84f..6781f3d 100644
--- a/width/tables9.0.0.go
+++ b/width/tables9.0.0.go
@@ -1114,21 +1114,31 @@
 }
 
 // inverseData contains 4-byte entries of the following format:
-//   <length> <modified UTF-8-encoded rune> <0 padding>
+//
+//	<length> <modified UTF-8-encoded rune> <0 padding>
+//
 // The last byte of the UTF-8-encoded rune is xor-ed with the last byte of the
 // UTF-8 encoding of the original rune. Mappings often have the following
 // pattern:
-//   Ａ -> A  (U+FF21 -> U+0041)
-//   Ｂ -> B  (U+FF22 -> U+0042)
-//   ...
+//
+//	Ａ -> A  (U+FF21 -> U+0041)
+//	Ｂ -> B  (U+FF22 -> U+0042)
+//	...
+//
 // By xor-ing the last byte the same entry can be shared by many mappings. This
 // reduces the total number of distinct entries by about two thirds.
 // The resulting entry for the aforementioned mappings is
-//   { 0x01, 0xE0, 0x00, 0x00 }
+//
+//	{ 0x01, 0xE0, 0x00, 0x00 }
+//
 // Using this entry to map U+FF21 (UTF-8 [EF BC A1]), we get
-//   E0 ^ A1 = 41.
+//
+//	E0 ^ A1 = 41.
+//
 // Similarly, for U+FF22 (UTF-8 [EF BC A2]), we get
-//   E0 ^ A2 = 42.
+//
+//	E0 ^ A2 = 42.
+//
 // Note that because of the xor-ing, the byte sequence stored in the entry is
 // not valid UTF-8.
 var inverseData = [150][4]byte{