"text/x-clojure",
				"text/x-coffeescript",
				"text/x-csrc",
				"text/x-csharp",
				"text/x-cobol",
				"text/x-coldfusion",
				"text/x-common-lisp",
				"text/x-diff",
				"text/x-eiffel",
				"text/x-emacs-lisp",
				"text/x-erlang",
				"text/x-expect",
				"text/x-forth",
				"text/x-fortran",
				"text/x-go",
				"text/x-groovy",
				"text/x-haskell",

    <glob pattern="*.cfc"/>
    <sub-class-of type="text/plain"/>
  </mime-type>

  <mime-type type="text/x-common-lisp">
    <_comment>Common Lisp source code</_comment>
    <glob pattern="*.cl"/>
    <glob pattern="*.jl"/>
    <glob pattern="*.lisp"/>
    <glob pattern="*.lsp"/>
    <sub-class-of type="text/plain"/>
  </mime-type>

  <mime-type type="text/x-diff">
    <magic priority="50">

// BodyBase is shared by all of our statement pseudo-node types which can
// contain other statements.
type BodyBase struct {
	List    []Statement
	CanFail bool
}

func (w *BodyBase) add(node Statement) {
	var last Statement
	if len(w.List) > 0 {
		last = w.List[len(w.List)-1]
	}
	if node, ok := node.(*CondBreak); ok {
		w.CanFail = true
		if last, ok := last.(*CondBreak); ok {

}

// Prev returns the previous list element or nil.
func (e *Element) Prev() *Element {
	if p := e.prev; e.list != nil && p != &e.list.root {
		return p
	}
	return nil
}

// List represents a doubly linked list.
// The zero value for List is an empty list ready to use.
type List struct {
	root Element // sentinel list element, only &root, root.prev, and root.next are used

			return false
		}
		list = &listBuilder{bullet: rune(bullet), num: num}
		p.addBlock(list)
	}
	b := &itemBuilder{list: list, width: n, haveContent: !t.isBlank()}
	list.todo = func() line {
		p.addBlock(b)
		list.item = b
		return t
	}
	return true
}

// GitHub task list extension

func (p *parseState) taskList(list *List) {
	for _, item := range list.Items {
		item := item.(*Item)

import (
	"fmt"
)

type Ordered interface {
	~int | ~int8 | ~int16 | ~int32 | ~int64 |
		~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
		~float32 | ~float64 |
		~string
}

// _List is a linked list of ordered values of type T.
type _List[T Ordered] struct {
	next *_List[T]
	val  T
}

func (l *_List[T]) Largest() T {
	var max T
	for p := l; p != nil; p = p.next {
		if p.val > max {
			max = p.val

-- input --
Text.
- Not a list.
 - Here is the list.
     • Using multiple bullets.
          * Indentation does not matter.
     + Lots of bullets.
More text.

-- gofmt --
Text.
- Not a list.
  - Here is the list.
  - Using multiple bullets.
  - Indentation does not matter.
  - Lots of bullets.

More text.

-- text --
Text. - Not a list.
  - Here is the list.
  - Using multiple bullets.

apiVersion: v1
kind: List
items:
- apiVersion: v1
  kind: Service
  metadata:
    name: list-service-test
  spec:
    ports:
    - protocol: TCP
      port: 80
    selector:
      app: list-deployment-test
- apiVersion: apps/v1
  kind: Deployment
  metadata:
    name: list-deployment-test
    labels:
      app: list-deployment-test
  spec:
    replicas: 1
    selector:
      matchLabels:

apiVersion: v1
kind: List
items:
  - apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: hello-v1
    spec:
      replicas: 3
      selector:
        matchLabels:
          app: hello  
          tier: backend
          track: stable
          version: v1
      template:
        metadata:
          labels:
            app: hello
            tier: backend
            track: stable

)

var CmdList = &base.Command{
	// Note: -f -json -m are listed explicitly because they are the most common list flags.
	// Do not send CLs removing them because they're covered by [list flags].
	UsageLine: "go list [-f format] [-json] [-m] [list flags] [build flags] [packages]",
	Short:     "list packages or modules",
	Long: `
List lists the named packages, one per line.
The most commonly-used flags are -f and -json, which control the form