// call of panic. If recover is called outside the deferred function it will
// not stop a panicking sequence. In this case, or when the goroutine is not
// panicking, recover returns nil.
//
// Prior to Go 1.21, recover would also return nil if panic is called with
// a nil argument. See [panic] for details.
func recover() any

// The print built-in function formats its arguments in an

making it difficult to use `Reset` and `Stop` correctly.
A visible effect of this change is that `len` and `cap` of timer channels
now returns 0 instead of 1, which may affect programs that
poll the length to decide whether a receive on the timer channel
will succeed.
Such code should use a non-blocking receive instead.

These new behaviors are only enabled when the main Go program

</p>

<p>
The return value of <code>recover</code> is <code>nil</code> when the
goroutine is not panicking or <code>recover</code> was not called directly by a deferred function.
Conversely, if a goroutine is panicking and <code>recover</code> was called directly by a deferred function,
the return value of <code>recover</code> is guaranteed not to be <code>nil</code>.

pkg encoding/binary, const MaxVarintLen32 = 5
pkg encoding/binary, const MaxVarintLen64 = 10
pkg encoding/csv, method (*Writer) Error() error
pkg encoding/json, method (*Decoder) Buffered() io.Reader
pkg encoding/json, method (*Decoder) UseNumber()
pkg encoding/json, method (Number) Float64() (float64, error)
pkg encoding/json, method (Number) Int64() (int64, error)
pkg encoding/json, method (Number) String() string

	}
	var info struct {
		Dict struct {
			Data []byte `xml:",innerxml"`
		} `xml:"dict"`
	}
	if err := xml.Unmarshal(out, &info); err != nil {
		return fmt.Errorf("mountDevImage: failed to decode mount information: %v", err)
	}
	dict, err := parsePlistDict(info.Dict.Data)
	if err != nil {
		return fmt.Errorf("mountDevImage: failed to parse mount information: %v", err)
	}

		dec := json.NewDecoder(bytes.NewReader(out))
		for {
			var pkg struct {
				ImportPath, Dir string
				ImportMap       map[string]string
				Standard        bool
			}
			err := dec.Decode(&pkg)
			if err == io.EOF {
				break
			}
			if err != nil {
				log.Fatalf("go list: invalid output: %v", err)
			}

			// - Package "unsafe" contains special signatures requiring

		}
	}
}

// firstError returns the first error value triggered by the input.
func firstError(input *Input) (err error) {
	panicOnError = true
	defer func() {
		panicOnError = false
		switch e := recover(); e := e.(type) {
		case nil:
		case error:
			err = e
		default:
			panic(e)
		}
	}()

	for {
		tok := input.Next()
		if tok == scanner.EOF {
			return
		}
	}