planetscale 0.2.0 → 0.3.3

data/vendor/google.golang.org/protobuf/internal/encoding/text/doc.go

@@ -1,29 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package text implements the text format for protocol buffers.
-// This package has no semantic understanding for protocol buffers and is only
-// a parser and composer for the format.
-//
-// There is no formal specification for the protobuf text format, as such the
-// C++ implementation (see google::protobuf::TextFormat) is the reference
-// implementation of the text format.
-//
-// This package is neither a superset nor a subset of the C++ implementation.
-// This implementation permits a more liberal grammar in some cases to be
-// backwards compatible with the historical Go implementation.
-// Future parsings unique to Go should not be added.
-// Some grammars allowed by the C++ implementation are deliberately
-// not implemented here because they are considered a bug by the protobuf team
-// and should not be replicated.
-//
-// The Go implementation should implement a sufficient amount of the C++
-// grammar such that the default text serialization by C++ can be parsed by Go.
-// However, just because the C++ parser accepts some input does not mean that
-// the Go implementation should as well.
-//
-// The text format is almost a superset of JSON except:
-//	* message keys are not quoted strings, but identifiers
-//	* the top-level value must be a message without the delimiters
-package text

data/vendor/google.golang.org/protobuf/internal/encoding/text/encode.go

@@ -1,265 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package text
-
-import (
-	"math"
-	"math/bits"
-	"strconv"
-	"strings"
-	"unicode/utf8"
-
-	"google.golang.org/protobuf/internal/detrand"
-	"google.golang.org/protobuf/internal/errors"
-)
-
-// encType represents an encoding type.
-type encType uint8
-
-const (
-	_ encType = (1 << iota) / 2
-	name
-	scalar
-	messageOpen
-	messageClose
-)
-
-// Encoder provides methods to write out textproto constructs and values. The user is
-// responsible for producing valid sequences of constructs and values.
-type Encoder struct {
-	encoderState
-
-	indent      string
-	delims      [2]byte
-	outputASCII bool
-}
-
-type encoderState struct {
-	lastType encType
-	indents  []byte
-	out      []byte
-}
-
-// NewEncoder returns an Encoder.
-//
-// If indent is a non-empty string, it causes every entry in a List or Message
-// to be preceded by the indent and trailed by a newline.
-//
-// If delims is not the zero value, it controls the delimiter characters used
-// for messages (e.g., "{}" vs "<>").
-//
-// If outputASCII is true, strings will be serialized in such a way that
-// multi-byte UTF-8 sequences are escaped. This property ensures that the
-// overall output is ASCII (as opposed to UTF-8).
-func NewEncoder(indent string, delims [2]byte, outputASCII bool) (*Encoder, error) {
-	e := &Encoder{}
-	if len(indent) > 0 {
-		if strings.Trim(indent, " \t") != "" {
-			return nil, errors.New("indent may only be composed of space and tab characters")
-		}
-		e.indent = indent
-	}
-	switch delims {
-	case [2]byte{0, 0}:
-		e.delims = [2]byte{'{', '}'}
-	case [2]byte{'{', '}'}, [2]byte{'<', '>'}:
-		e.delims = delims
-	default:
-		return nil, errors.New("delimiters may only be \"{}\" or \"<>\"")
-	}
-	e.outputASCII = outputASCII
-
-	return e, nil
-}
-
-// Bytes returns the content of the written bytes.
-func (e *Encoder) Bytes() []byte {
-	return e.out
-}
-
-// StartMessage writes out the '{' or '<' symbol.
-func (e *Encoder) StartMessage() {
-	e.prepareNext(messageOpen)
-	e.out = append(e.out, e.delims[0])
-}
-
-// EndMessage writes out the '}' or '>' symbol.
-func (e *Encoder) EndMessage() {
-	e.prepareNext(messageClose)
-	e.out = append(e.out, e.delims[1])
-}
-
-// WriteName writes out the field name and the separator ':'.
-func (e *Encoder) WriteName(s string) {
-	e.prepareNext(name)
-	e.out = append(e.out, s...)
-	e.out = append(e.out, ':')
-}
-
-// WriteBool writes out the given boolean value.
-func (e *Encoder) WriteBool(b bool) {
-	if b {
-		e.WriteLiteral("true")
-	} else {
-		e.WriteLiteral("false")
-	}
-}
-
-// WriteString writes out the given string value.
-func (e *Encoder) WriteString(s string) {
-	e.prepareNext(scalar)
-	e.out = appendString(e.out, s, e.outputASCII)
-}
-
-func appendString(out []byte, in string, outputASCII bool) []byte {
-	out = append(out, '"')
-	i := indexNeedEscapeInString(in)
-	in, out = in[i:], append(out, in[:i]...)
-	for len(in) > 0 {
-		switch r, n := utf8.DecodeRuneInString(in); {
-		case r == utf8.RuneError && n == 1:
-			// We do not report invalid UTF-8 because strings in the text format
-			// are used to represent both the proto string and bytes type.
-			r = rune(in[0])
-			fallthrough
-		case r < ' ' || r == '"' || r == '\\' || r == 0x7f:
-			out = append(out, '\\')
-			switch r {
-			case '"', '\\':
-				out = append(out, byte(r))
-			case '\n':
-				out = append(out, 'n')
-			case '\r':
-				out = append(out, 'r')
-			case '\t':
-				out = append(out, 't')
-			default:
-				out = append(out, 'x')
-				out = append(out, "00"[1+(bits.Len32(uint32(r))-1)/4:]...)
-				out = strconv.AppendUint(out, uint64(r), 16)
-			}
-			in = in[n:]
-		case r >= utf8.RuneSelf && (outputASCII || r <= 0x009f):
-			out = append(out, '\\')
-			if r <= math.MaxUint16 {
-				out = append(out, 'u')
-				out = append(out, "0000"[1+(bits.Len32(uint32(r))-1)/4:]...)
-				out = strconv.AppendUint(out, uint64(r), 16)
-			} else {
-				out = append(out, 'U')
-				out = append(out, "00000000"[1+(bits.Len32(uint32(r))-1)/4:]...)
-				out = strconv.AppendUint(out, uint64(r), 16)
-			}
-			in = in[n:]
-		default:
-			i := indexNeedEscapeInString(in[n:])
-			in, out = in[n+i:], append(out, in[:n+i]...)
-		}
-	}
-	out = append(out, '"')
-	return out
-}
-
-// indexNeedEscapeInString returns the index of the character that needs
-// escaping. If no characters need escaping, this returns the input length.
-func indexNeedEscapeInString(s string) int {
-	for i := 0; i < len(s); i++ {
-		if c := s[i]; c < ' ' || c == '"' || c == '\'' || c == '\\' || c >= 0x7f {
-			return i
-		}
-	}
-	return len(s)
-}
-
-// WriteFloat writes out the given float value for given bitSize.
-func (e *Encoder) WriteFloat(n float64, bitSize int) {
-	e.prepareNext(scalar)
-	e.out = appendFloat(e.out, n, bitSize)
-}
-
-func appendFloat(out []byte, n float64, bitSize int) []byte {
-	switch {
-	case math.IsNaN(n):
-		return append(out, "nan"...)
-	case math.IsInf(n, +1):
-		return append(out, "inf"...)
-	case math.IsInf(n, -1):
-		return append(out, "-inf"...)
-	default:
-		return strconv.AppendFloat(out, n, 'g', -1, bitSize)
-	}
-}
-
-// WriteInt writes out the given signed integer value.
-func (e *Encoder) WriteInt(n int64) {
-	e.prepareNext(scalar)
-	e.out = append(e.out, strconv.FormatInt(n, 10)...)
-}
-
-// WriteUint writes out the given unsigned integer value.
-func (e *Encoder) WriteUint(n uint64) {
-	e.prepareNext(scalar)
-	e.out = append(e.out, strconv.FormatUint(n, 10)...)
-}
-
-// WriteLiteral writes out the given string as a literal value without quotes.
-// This is used for writing enum literal strings.
-func (e *Encoder) WriteLiteral(s string) {
-	e.prepareNext(scalar)
-	e.out = append(e.out, s...)
-}
-
-// prepareNext adds possible space and indentation for the next value based
-// on last encType and indent option. It also updates e.lastType to next.
-func (e *Encoder) prepareNext(next encType) {
-	defer func() {
-		e.lastType = next
-	}()
-
-	// Single line.
-	if len(e.indent) == 0 {
-		// Add space after each field before the next one.
-		if e.lastType&(scalar|messageClose) != 0 && next == name {
-			e.out = append(e.out, ' ')
-			// Add a random extra space to make output unstable.
-			if detrand.Bool() {
-				e.out = append(e.out, ' ')
-			}
-		}
-		return
-	}
-
-	// Multi-line.
-	switch {
-	case e.lastType == name:
-		e.out = append(e.out, ' ')
-		// Add a random extra space after name: to make output unstable.
-		if detrand.Bool() {
-			e.out = append(e.out, ' ')
-		}
-
-	case e.lastType == messageOpen && next != messageClose:
-		e.indents = append(e.indents, e.indent...)
-		e.out = append(e.out, '\n')
-		e.out = append(e.out, e.indents...)
-
-	case e.lastType&(scalar|messageClose) != 0:
-		if next == messageClose {
-			e.indents = e.indents[:len(e.indents)-len(e.indent)]
-		}
-		e.out = append(e.out, '\n')
-		e.out = append(e.out, e.indents...)
-	}
-}
-
-// Snapshot returns the current snapshot for use in Reset.
-func (e *Encoder) Snapshot() encoderState {
-	return e.encoderState
-}
-
-// Reset resets the Encoder to the given encoderState from a Snapshot.
-func (e *Encoder) Reset(es encoderState) {
-	e.encoderState = es
-}

data/vendor/google.golang.org/protobuf/internal/errors/errors.go

@@ -1,89 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package errors implements functions to manipulate errors.
-package errors
-
-import (
-	"errors"
-	"fmt"
-
-	"google.golang.org/protobuf/internal/detrand"
-)
-
-// Error is a sentinel matching all errors produced by this package.
-var Error = errors.New("protobuf error")
-
-// New formats a string according to the format specifier and arguments and
-// returns an error that has a "proto" prefix.
-func New(f string, x ...interface{}) error {
-	return &prefixError{s: format(f, x...)}
-}
-
-type prefixError struct{ s string }
-
-var prefix = func() string {
-	// Deliberately introduce instability into the error message string to
-	// discourage users from performing error string comparisons.
-	if detrand.Bool() {
-		return "proto: " // use non-breaking spaces (U+00a0)
-	} else {
-		return "proto: " // use regular spaces (U+0020)
-	}
-}()
-
-func (e *prefixError) Error() string {
-	return prefix + e.s
-}
-
-func (e *prefixError) Unwrap() error {
-	return Error
-}
-
-// Wrap returns an error that has a "proto" prefix, the formatted string described
-// by the format specifier and arguments, and a suffix of err. The error wraps err.
-func Wrap(err error, f string, x ...interface{}) error {
-	return &wrapError{
-		s:   format(f, x...),
-		err: err,
-	}
-}
-
-type wrapError struct {
-	s   string
-	err error
-}
-
-func (e *wrapError) Error() string {
-	return format("%v%v: %v", prefix, e.s, e.err)
-}
-
-func (e *wrapError) Unwrap() error {
-	return e.err
-}
-
-func (e *wrapError) Is(target error) bool {
-	return target == Error
-}
-
-func format(f string, x ...interface{}) string {
-	// avoid "proto: " prefix when chaining
-	for i := 0; i < len(x); i++ {
-		switch e := x[i].(type) {
-		case *prefixError:
-			x[i] = e.s
-		case *wrapError:
-			x[i] = format("%v: %v", e.s, e.err)
-		}
-	}
-	return fmt.Sprintf(f, x...)
-}
-
-func InvalidUTF8(name string) error {
-	return New("field %v contains invalid UTF-8", name)
-}
-
-func RequiredNotSet(name string) error {
-	return New("required field %v not set", name)
-}

data/vendor/google.golang.org/protobuf/internal/errors/is_go112.go

@@ -1,39 +0,0 @@
-// Copyright 2020 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build !go1.13
-
-package errors
-
-import "reflect"
-
-// Is is a copy of Go 1.13's errors.Is for use with older Go versions.
-func Is(err, target error) bool {
-	if target == nil {
-		return err == target
-	}
-
-	isComparable := reflect.TypeOf(target).Comparable()
-	for {
-		if isComparable && err == target {
-			return true
-		}
-		if x, ok := err.(interface{ Is(error) bool }); ok && x.Is(target) {
-			return true
-		}
-		if err = unwrap(err); err == nil {
-			return false
-		}
-	}
-}
-
-func unwrap(err error) error {
-	u, ok := err.(interface {
-		Unwrap() error
-	})
-	if !ok {
-		return nil
-	}
-	return u.Unwrap()
-}

data/vendor/google.golang.org/protobuf/internal/errors/is_go113.go

@@ -1,12 +0,0 @@
-// Copyright 2020 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build go1.13
-
-package errors
-
-import "errors"
-
-// Is is errors.Is.
-func Is(err, target error) bool { return errors.Is(err, target) }

data/vendor/google.golang.org/protobuf/internal/filedesc/build.go

@@ -1,158 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package filedesc provides functionality for constructing descriptors.
-//
-// The types in this package implement interfaces in the protoreflect package
-// related to protobuf descripriptors.
-package filedesc
-
-import (
-	"google.golang.org/protobuf/encoding/protowire"
-	"google.golang.org/protobuf/internal/genid"
-	"google.golang.org/protobuf/reflect/protoreflect"
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-	preg "google.golang.org/protobuf/reflect/protoregistry"
-)
-
-// Builder construct a protoreflect.FileDescriptor from the raw descriptor.
-type Builder struct {
-	// GoPackagePath is the Go package path that is invoking this builder.
-	GoPackagePath string
-
-	// RawDescriptor is the wire-encoded bytes of FileDescriptorProto
-	// and must be populated.
-	RawDescriptor []byte
-
-	// NumEnums is the total number of enums declared in the file.
-	NumEnums int32
-	// NumMessages is the total number of messages declared in the file.
-	// It includes the implicit message declarations for map entries.
-	NumMessages int32
-	// NumExtensions is the total number of extensions declared in the file.
-	NumExtensions int32
-	// NumServices is the total number of services declared in the file.
-	NumServices int32
-
-	// TypeResolver resolves extension field types for descriptor options.
-	// If nil, it uses protoregistry.GlobalTypes.
-	TypeResolver interface {
-		preg.ExtensionTypeResolver
-	}
-
-	// FileRegistry is use to lookup file, enum, and message dependencies.
-	// Once constructed, the file descriptor is registered here.
-	// If nil, it uses protoregistry.GlobalFiles.
-	FileRegistry interface {
-		FindFileByPath(string) (protoreflect.FileDescriptor, error)
-		FindDescriptorByName(pref.FullName) (pref.Descriptor, error)
-		RegisterFile(pref.FileDescriptor) error
-	}
-}
-
-// resolverByIndex is an interface Builder.FileRegistry may implement.
-// If so, it permits looking up an enum or message dependency based on the
-// sub-list and element index into filetype.Builder.DependencyIndexes.
-type resolverByIndex interface {
-	FindEnumByIndex(int32, int32, []Enum, []Message) pref.EnumDescriptor
-	FindMessageByIndex(int32, int32, []Enum, []Message) pref.MessageDescriptor
-}
-
-// Indexes of each sub-list in filetype.Builder.DependencyIndexes.
-const (
-	listFieldDeps int32 = iota
-	listExtTargets
-	listExtDeps
-	listMethInDeps
-	listMethOutDeps
-)
-
-// Out is the output of the Builder.
-type Out struct {
-	File pref.FileDescriptor
-
-	// Enums is all enum descriptors in "flattened ordering".
-	Enums []Enum
-	// Messages is all message descriptors in "flattened ordering".
-	// It includes the implicit message declarations for map entries.
-	Messages []Message
-	// Extensions is all extension descriptors in "flattened ordering".
-	Extensions []Extension
-	// Service is all service descriptors in "flattened ordering".
-	Services []Service
-}
-
-// Build constructs a FileDescriptor given the parameters set in Builder.
-// It assumes that the inputs are well-formed and panics if any inconsistencies
-// are encountered.
-//
-// If NumEnums+NumMessages+NumExtensions+NumServices is zero,
-// then Build automatically derives them from the raw descriptor.
-func (db Builder) Build() (out Out) {
-	// Populate the counts if uninitialized.
-	if db.NumEnums+db.NumMessages+db.NumExtensions+db.NumServices == 0 {
-		db.unmarshalCounts(db.RawDescriptor, true)
-	}
-
-	// Initialize resolvers and registries if unpopulated.
-	if db.TypeResolver == nil {
-		db.TypeResolver = preg.GlobalTypes
-	}
-	if db.FileRegistry == nil {
-		db.FileRegistry = preg.GlobalFiles
-	}
-
-	fd := newRawFile(db)
-	out.File = fd
-	out.Enums = fd.allEnums
-	out.Messages = fd.allMessages
-	out.Extensions = fd.allExtensions
-	out.Services = fd.allServices
-
-	if err := db.FileRegistry.RegisterFile(fd); err != nil {
-		panic(err)
-	}
-	return out
-}
-
-// unmarshalCounts counts the number of enum, message, extension, and service
-// declarations in the raw message, which is either a FileDescriptorProto
-// or a MessageDescriptorProto depending on whether isFile is set.
-func (db *Builder) unmarshalCounts(b []byte, isFile bool) {
-	for len(b) > 0 {
-		num, typ, n := protowire.ConsumeTag(b)
-		b = b[n:]
-		switch typ {
-		case protowire.BytesType:
-			v, m := protowire.ConsumeBytes(b)
-			b = b[m:]
-			if isFile {
-				switch num {
-				case genid.FileDescriptorProto_EnumType_field_number:
-					db.NumEnums++
-				case genid.FileDescriptorProto_MessageType_field_number:
-					db.unmarshalCounts(v, false)
-					db.NumMessages++
-				case genid.FileDescriptorProto_Extension_field_number:
-					db.NumExtensions++
-				case genid.FileDescriptorProto_Service_field_number:
-					db.NumServices++
-				}
-			} else {
-				switch num {
-				case genid.DescriptorProto_EnumType_field_number:
-					db.NumEnums++
-				case genid.DescriptorProto_NestedType_field_number:
-					db.unmarshalCounts(v, false)
-					db.NumMessages++
-				case genid.DescriptorProto_Extension_field_number:
-					db.NumExtensions++
-				}
-			}
-		default:
-			m := protowire.ConsumeFieldValue(num, typ, b)
-			b = b[m:]
-		}
-	}
-}