You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: tag.go
    path of file: ./repos/streamdal/apps/server/vendor/github.com/alecthomas/kong
    
    the code of the file until where you have to start completion: package kong

import (
	"errors"
	"fmt"
	"reflect"
	"strconv"
	"strings"
	"unicode/utf8"
)

// Tag represents the parsed state of Kong tags in a struct field tag.
type Tag struct {
	Ignored     bool // Field is ignored by Kong. ie. kong:"-"
	Cmd         bool
	Arg         bool
	Required    bool
	Optional    bool
	Name        string
	Help        string
	Type        string
	TypeName    string
	HasDefault  bool
	Default     string
	Format      string
	PlaceHolder string
	Envs        []string
	Short    
    
func parseTagItems(tagString string, chr tagChars) (map[string][]string, error) {
	d := map[string][]string{}
	key := []rune{}
	value := []rune{}
	quotes := false
	inKey := true

	add := func() error {
		// Bare tags are quoted, therefore we need to unquote them in the same fashion reflect.Lookup() (implicitly)
		// unquotes "kong tags".
		s := string(value)

		if chr.needsUnquote && s != "" {
			if unquoted, err := strconv.Unquote(fmt.Sprintf(`"%s"`, s)); err == nil {
				s = unquoted
			} else {
				return fmt.Errorf("unquoting tag value `%s`: %w", s, err)
			}
		}

		d[string(key)] = append(d[string(key)], s)
		key = []rune{}
		value = []rune{}
		inKey = true

		return nil
	}

	runes := []rune(tagString)
	for idx := 0; idx < len(runes); idx++ {
		r := runes[idx]
		next := rune(0)
		eof := false
		if idx < len(runes)-1 {
			next = runes[idx+1]
		} else {
			eof = true
		}
		if !quotes && r == chr.sep {
			if err := add(); err != nil {
				return nil, err
			}

			continue
		}
		if r == chr.assign && inKey {
			inKey = false
			continue
		}
		if r == '\\' {
			if next == chr.quote {
				idx++

				// We need to keep the backslashes, otherwise subsequent unquoting cannot work
				if chr.needsUnquote {
					value = append(value, r)
				}

				r = chr.quote
			}
		} else if r == chr.quote {
			if quotes {
				quotes = false
				if next == chr.sep || eof {
					continue
				}
				return nil, fmt.Errorf("%v has an unexpected char at pos %v", tagString, idx)
			}
			quotes = true
			continue
		}
		if inKey {
			key = append(key, r)
		} else {
			value = append(value, r)
		}
	}
	if quotes {
		return nil, fmt.Errorf("%v is not quoted properly", tagString)
	}

	if err := add(); err != nil {
		return nil, err
	}

	return d, nil
}