// Code generated by protoc-gen-go-lite. DO NOT EDIT.
// protoc-gen-go-lite version: v0.19.1-0.20261028131920-f644656fc4a7
// source: github.com/s4wave/spacewave/bldr/web/bundler/bundler.proto

package bldr_web_bundler

import (
	fmt "fmt"
	io "io"
	slices "slices"

	protobuf_go_lite "github.com/aperturerobotics/protobuf-go-lite"
	json "github.com/aperturerobotics/protobuf-go-lite/json"
)

// WebEntrypoint is an entrypoint passed to a web bundler.
type WebEntrypoint struct {
	unknownFields []byte
	// InputPath is the input file path.
	InputPath string `protobuf:"bytes,1,opt,name=input_path,json=inputPath,proto3" json:"inputPath,omitempty"`
	// OutputPath is the output file path, if any.
	OutputPath string `protobuf:"bytes,2,opt,name=output_path,json=outputPath,proto3" json:"outputPath,omitempty"`
}

func (x *WebEntrypoint) Reset() {
	*x = WebEntrypoint{}
}

func (*WebEntrypoint) ProtoMessage() {}

func (x *WebEntrypoint) GetInputPath() string {
	if x != nil {
		return x.InputPath
	}
	return ""
}

func (x *WebEntrypoint) GetOutputPath() string {
	if x != nil {
		return x.OutputPath
	}
	return ""
}

// WebBundlerOutput contains a single web bundler output.
//
// EsbuildVarType_WEB_BUNDLER_OUTPUT
// ViteVarType_WEB_BUNDLER_OUTPUT
type WebBundlerOutput struct {
	unknownFields []byte
	// EntrypointHref is the url path to the script entrypoint.
	//
	// e.x: /p/plugin-id/script.js
	EntrypointHref string `protobuf:"bytes,1,opt,name=entrypoint_href,json=entrypointHref,proto3" json:"entrypointHref,omitempty"`
	// CssHref is the url path to the css bundle (if applicable).
	//
	// May be empty.
	// e.x: /p/plugin-id/script.css
	CssHref string `protobuf:"bytes,2,opt,name=css_href,json=cssHref,proto3" json:"cssHref,omitempty"`
}

func (x *WebBundlerOutput) Reset() {
	*x = WebBundlerOutput{}
}

func (*WebBundlerOutput) ProtoMessage() {}

func (x *WebBundlerOutput) GetEntrypointHref() string {
	if x != nil {
		return x.EntrypointHref
	}
	return ""
}

func (x *WebBundlerOutput) GetCssHref() string {
	if x != nil {
		return x.CssHref
	}
	return ""
}

// WebPkgRefConfig configures a web pkg reference.
type WebPkgRefConfig struct {
	unknownFields []byte
	// Id is the identifier of the web pkg.
	// example: @aptre/flex-layout
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Exclude indicates we should reference this web pkg but exclude it from this bundle.
	// This is useful if another plugin already provides this web pkg.
	Exclude bool `protobuf:"varint,2,opt,name=exclude,proto3" json:"exclude,omitempty"`
	// Imports is the list of imports to include in the web pkg bundle.
	// NOTE: this will be merged with any imports the code accesses.
	// NOTE: this is therefore optional.
	Imports []string `protobuf:"bytes,3,rep,name=imports,proto3" json:"imports,omitempty"`
	// Entrypoints defines the subpath entry points to build for this web package.
	//
	// For project-local packages (resolved via tsconfig paths, not node_modules):
	//   - If set, each entry declares a subpath export (e.g. ".", "./object").
	//     "." maps to the package root index file.
	//   - If empty, defaults to a single "." entrypoint (package root index).
	//
	// For node_modules packages:
	//   - If set, overrides the auto-detected exports from package.json.
	//   - If empty, entry points are read from the package.json "exports" field.
	//     Falls back to "main" or "." if no exports field is present.
	Entrypoints []*WebPkgEntrypoint `protobuf:"bytes,4,rep,name=entrypoints,proto3" json:"entrypoints,omitempty"`
}

func (x *WebPkgRefConfig) Reset() {
	*x = WebPkgRefConfig{}
}

func (*WebPkgRefConfig) ProtoMessage() {}

func (x *WebPkgRefConfig) GetId() string {
	if x != nil {
		return x.Id
	}
	return ""
}

func (x *WebPkgRefConfig) GetExclude() bool {
	if x != nil {
		return x.Exclude
	}
	return false
}

func (x *WebPkgRefConfig) GetImports() []string {
	if x != nil {
		return x.Imports
	}
	return nil
}

func (x *WebPkgRefConfig) GetEntrypoints() []*WebPkgEntrypoint {
	if x != nil {
		return x.Entrypoints
	}
	return nil
}

// WebPkgEntrypoint configures a single entry point for a web package build.
type WebPkgEntrypoint struct {
	unknownFields []byte
	// Path is the subpath export specifier relative to the package root.
	//
	// Examples:
	//   "."           - the package root (index.ts / index.js)
	//   "./object"    - a subpath directory or file (object/index.ts or object.ts)
	//   "./hooks"     - another subpath
	//
	// Follows Node.js subpath exports conventions.
	Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
}

func (x *WebPkgEntrypoint) Reset() {
	*x = WebPkgEntrypoint{}
}

func (*WebPkgEntrypoint) ProtoMessage() {}

func (x *WebPkgEntrypoint) GetPath() string {
	if x != nil {
		return x.Path
	}
	return ""
}

func (m *WebEntrypoint) CloneVT() *WebEntrypoint {
	if m == nil {
		return (*WebEntrypoint)(nil)
	}
	r := new(WebEntrypoint)
	r.InputPath = m.InputPath
	r.OutputPath = m.OutputPath
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *WebEntrypoint) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *WebBundlerOutput) CloneVT() *WebBundlerOutput {
	if m == nil {
		return (*WebBundlerOutput)(nil)
	}
	r := new(WebBundlerOutput)
	r.EntrypointHref = m.EntrypointHref
	r.CssHref = m.CssHref
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *WebBundlerOutput) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *WebPkgRefConfig) CloneVT() *WebPkgRefConfig {
	if m == nil {
		return (*WebPkgRefConfig)(nil)
	}
	r := new(WebPkgRefConfig)
	r.Id = m.Id
	r.Exclude = m.Exclude
	r.Imports = protobuf_go_lite.CloneSlice(m.Imports)
	r.Entrypoints = protobuf_go_lite.CloneVTSlice(m.Entrypoints)
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *WebPkgRefConfig) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *WebPkgEntrypoint) CloneVT() *WebPkgEntrypoint {
	if m == nil {
		return (*WebPkgEntrypoint)(nil)
	}
	r := new(WebPkgEntrypoint)
	r.Path = m.Path
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *WebPkgEntrypoint) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (this *WebEntrypoint) EqualVT(that *WebEntrypoint) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.InputPath != that.InputPath {
		return false
	}
	if this.OutputPath != that.OutputPath {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *WebEntrypoint) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*WebEntrypoint)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}

func (this *WebBundlerOutput) EqualVT(that *WebBundlerOutput) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.EntrypointHref != that.EntrypointHref {
		return false
	}
	if this.CssHref != that.CssHref {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *WebBundlerOutput) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*WebBundlerOutput)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}

func (this *WebPkgRefConfig) EqualVT(that *WebPkgRefConfig) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.Id != that.Id {
		return false
	}
	if this.Exclude != that.Exclude {
		return false
	}
	if !protobuf_go_lite.EqualSlice(this.Imports, that.Imports) {
		return false
	}
	if !protobuf_go_lite.EqualVTSliceImplicit(this.Entrypoints, that.Entrypoints, func() *WebPkgEntrypoint { return &WebPkgEntrypoint{} }) {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *WebPkgRefConfig) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*WebPkgRefConfig)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}

func (this *WebPkgEntrypoint) EqualVT(that *WebPkgEntrypoint) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.Path != that.Path {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *WebPkgEntrypoint) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*WebPkgEntrypoint)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}

// MarshalProtoJSON marshals the WebEntrypoint message to JSON.
func (x *WebEntrypoint) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.InputPath != "" || s.HasField("inputPath") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("inputPath")
		s.WriteString(x.InputPath)
	}
	if x.OutputPath != "" || s.HasField("outputPath") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("outputPath")
		s.WriteString(x.OutputPath)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the WebEntrypoint to JSON.
func (x *WebEntrypoint) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the WebEntrypoint message from JSON.
func (x *WebEntrypoint) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "input_path", "inputPath":
			s.AddField("input_path")
			x.InputPath = s.ReadString()
		case "output_path", "outputPath":
			s.AddField("output_path")
			x.OutputPath = s.ReadString()
		}
	})
}

// UnmarshalJSON unmarshals the WebEntrypoint from JSON.
func (x *WebEntrypoint) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the WebBundlerOutput message to JSON.
func (x *WebBundlerOutput) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.EntrypointHref != "" || s.HasField("entrypointHref") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("entrypointHref")
		s.WriteString(x.EntrypointHref)
	}
	if x.CssHref != "" || s.HasField("cssHref") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("cssHref")
		s.WriteString(x.CssHref)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the WebBundlerOutput to JSON.
func (x *WebBundlerOutput) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the WebBundlerOutput message from JSON.
func (x *WebBundlerOutput) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "entrypoint_href", "entrypointHref":
			s.AddField("entrypoint_href")
			x.EntrypointHref = s.ReadString()
		case "css_href", "cssHref":
			s.AddField("css_href")
			x.CssHref = s.ReadString()
		}
	})
}

// UnmarshalJSON unmarshals the WebBundlerOutput from JSON.
func (x *WebBundlerOutput) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the WebPkgRefConfig message to JSON.
func (x *WebPkgRefConfig) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.Id != "" || s.HasField("id") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("id")
		s.WriteString(x.Id)
	}
	if x.Exclude || s.HasField("exclude") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("exclude")
		s.WriteBool(x.Exclude)
	}
	if len(x.Imports) > 0 || s.HasField("imports") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("imports")
		s.WriteStringArray(x.Imports)
	}
	if len(x.Entrypoints) > 0 || s.HasField("entrypoints") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("entrypoints")
		s.WriteArrayStart()
		var wroteElement bool
		for _, element := range x.Entrypoints {
			s.WriteMoreIf(&wroteElement)
			element.MarshalProtoJSON(s.WithField("entrypoints"))
		}
		s.WriteArrayEnd()
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the WebPkgRefConfig to JSON.
func (x *WebPkgRefConfig) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the WebPkgRefConfig message from JSON.
func (x *WebPkgRefConfig) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "id":
			s.AddField("id")
			x.Id = s.ReadString()
		case "exclude":
			s.AddField("exclude")
			x.Exclude = s.ReadBool()
		case "imports":
			s.AddField("imports")
			if s.ReadNil() {
				x.Imports = nil
				return
			}
			x.Imports = s.ReadStringArray()
		case "entrypoints":
			s.AddField("entrypoints")
			if s.ReadNil() {
				x.Entrypoints = nil
				return
			}
			s.ReadArray(func() {
				if s.ReadNil() {
					x.Entrypoints = append(x.Entrypoints, nil)
					return
				}
				v := &WebPkgEntrypoint{}
				v.UnmarshalProtoJSON(s.WithField("entrypoints", false))
				if s.Err() != nil {
					return
				}
				x.Entrypoints = append(x.Entrypoints, v)
			})
		}
	})
}

// UnmarshalJSON unmarshals the WebPkgRefConfig from JSON.
func (x *WebPkgRefConfig) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the WebPkgEntrypoint message to JSON.
func (x *WebPkgEntrypoint) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.Path != "" || s.HasField("path") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("path")
		s.WriteString(x.Path)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the WebPkgEntrypoint to JSON.
func (x *WebPkgEntrypoint) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the WebPkgEntrypoint message from JSON.
func (x *WebPkgEntrypoint) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "path":
			s.AddField("path")
			x.Path = s.ReadString()
		}
	})
}

// UnmarshalJSON unmarshals the WebPkgEntrypoint from JSON.
func (x *WebPkgEntrypoint) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

func (m *WebEntrypoint) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *WebEntrypoint) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *WebEntrypoint) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i = protobuf_go_lite.EncodeRawBytes(dAtA, i, m.unknownFields)
	}
	if len(m.OutputPath) > 0 {
		i = protobuf_go_lite.EncodeString(dAtA, i, m.OutputPath)
		i--
		dAtA[i] = 0x12
	}
	if len(m.InputPath) > 0 {
		i = protobuf_go_lite.EncodeString(dAtA, i, m.InputPath)
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *WebBundlerOutput) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *WebBundlerOutput) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *WebBundlerOutput) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i = protobuf_go_lite.EncodeRawBytes(dAtA, i, m.unknownFields)
	}
	if len(m.CssHref) > 0 {
		i = protobuf_go_lite.EncodeString(dAtA, i, m.CssHref)
		i--
		dAtA[i] = 0x12
	}
	if len(m.EntrypointHref) > 0 {
		i = protobuf_go_lite.EncodeString(dAtA, i, m.EntrypointHref)
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *WebPkgRefConfig) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *WebPkgRefConfig) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *WebPkgRefConfig) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i = protobuf_go_lite.EncodeRawBytes(dAtA, i, m.unknownFields)
	}
	if len(m.Entrypoints) > 0 {
		for iNdEx := len(m.Entrypoints) - 1; iNdEx >= 0; iNdEx-- {
			size, err := m.Entrypoints[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Imports) > 0 {
		for iNdEx := len(m.Imports) - 1; iNdEx >= 0; iNdEx-- {
			i = protobuf_go_lite.EncodeString(dAtA, i, m.Imports[iNdEx])
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Exclude {
		i = protobuf_go_lite.EncodeBool(dAtA, i, m.Exclude)
		i--
		dAtA[i] = 0x10
	}
	if len(m.Id) > 0 {
		i = protobuf_go_lite.EncodeString(dAtA, i, m.Id)
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *WebPkgEntrypoint) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *WebPkgEntrypoint) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *WebPkgEntrypoint) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i = protobuf_go_lite.EncodeRawBytes(dAtA, i, m.unknownFields)
	}
	if len(m.Path) > 0 {
		i = protobuf_go_lite.EncodeString(dAtA, i, m.Path)
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *WebEntrypoint) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += protobuf_go_lite.SizeStringNonEmpty(1, m.InputPath)
	n += protobuf_go_lite.SizeStringNonEmpty(1, m.OutputPath)
	n += len(m.unknownFields)
	return n
}

func (m *WebBundlerOutput) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += protobuf_go_lite.SizeStringNonEmpty(1, m.EntrypointHref)
	n += protobuf_go_lite.SizeStringNonEmpty(1, m.CssHref)
	n += len(m.unknownFields)
	return n
}

func (m *WebPkgRefConfig) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += protobuf_go_lite.SizeStringNonEmpty(1, m.Id)
	n += protobuf_go_lite.SizeBoolNonZero(1, m.Exclude)
	n += protobuf_go_lite.SizeStringSlice(1, m.Imports)
	for _, e := range m.Entrypoints {
		l = e.SizeVT()
		n += protobuf_go_lite.SizeMessage(1, l)
	}
	n += len(m.unknownFields)
	return n
}

func (m *WebPkgEntrypoint) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += protobuf_go_lite.SizeStringNonEmpty(1, m.Path)
	n += len(m.unknownFields)
	return n
}

func (x *WebEntrypoint) MarshalProtoText() string {
	var sb protobuf_go_lite.TextBuilder
	initialLen := protobuf_go_lite.TextStartMessage(&sb, "WebEntrypoint")
	if x.InputPath != "" {
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "input_path")
		protobuf_go_lite.TextWriteString(&sb, x.InputPath)
	}
	if x.OutputPath != "" {
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "output_path")
		protobuf_go_lite.TextWriteString(&sb, x.OutputPath)
	}
	return protobuf_go_lite.TextFinishMessage(&sb)
}

func (x *WebEntrypoint) String() string {
	return x.MarshalProtoText()
}

func (x *WebBundlerOutput) MarshalProtoText() string {
	var sb protobuf_go_lite.TextBuilder
	initialLen := protobuf_go_lite.TextStartMessage(&sb, "WebBundlerOutput")
	if x.EntrypointHref != "" {
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "entrypoint_href")
		protobuf_go_lite.TextWriteString(&sb, x.EntrypointHref)
	}
	if x.CssHref != "" {
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "css_href")
		protobuf_go_lite.TextWriteString(&sb, x.CssHref)
	}
	return protobuf_go_lite.TextFinishMessage(&sb)
}

func (x *WebBundlerOutput) String() string {
	return x.MarshalProtoText()
}

func (x *WebPkgRefConfig) MarshalProtoText() string {
	var sb protobuf_go_lite.TextBuilder
	initialLen := protobuf_go_lite.TextStartMessage(&sb, "WebPkgRefConfig")
	if x.Id != "" {
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "id")
		protobuf_go_lite.TextWriteString(&sb, x.Id)
	}
	if x.Exclude != false {
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "exclude")
		protobuf_go_lite.TextWriteBool(&sb, x.Exclude)
	}
	if len(x.Imports) > 0 {
		protobuf_go_lite.TextWriteListStart(&sb, initialLen, "imports")
		for i, v := range x.Imports {
			protobuf_go_lite.TextWriteListSeparator(&sb, i)
			protobuf_go_lite.TextWriteString(&sb, v)
		}
		protobuf_go_lite.TextWriteListEnd(&sb)
	}
	if len(x.Entrypoints) > 0 {
		protobuf_go_lite.TextWriteListStart(&sb, initialLen, "entrypoints")
		for i, v := range x.Entrypoints {
			protobuf_go_lite.TextWriteListSeparator(&sb, i)
			if v == nil {
				protobuf_go_lite.TextWriteTextMarshaler(&sb, &WebPkgEntrypoint{})
			} else {
				protobuf_go_lite.TextWriteTextMarshaler(&sb, v)
			}
		}
		protobuf_go_lite.TextWriteListEnd(&sb)
	}
	return protobuf_go_lite.TextFinishMessage(&sb)
}

func (x *WebPkgRefConfig) String() string {
	return x.MarshalProtoText()
}

func (x *WebPkgEntrypoint) MarshalProtoText() string {
	var sb protobuf_go_lite.TextBuilder
	initialLen := protobuf_go_lite.TextStartMessage(&sb, "WebPkgEntrypoint")
	if x.Path != "" {
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "path")
		protobuf_go_lite.TextWriteString(&sb, x.Path)
	}
	return protobuf_go_lite.TextFinishMessage(&sb)
}

func (x *WebPkgEntrypoint) String() string {
	return x.MarshalProtoText()
}

func (m *WebEntrypoint) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	var err error
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		wire, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
		if err != nil {
			return err
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: WebEntrypoint: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WebEntrypoint: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InputPath", wireType)
			}
			var v string
			v, iNdEx, err = protobuf_go_lite.DecodeString(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.InputPath = v
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OutputPath", wireType)
			}
			var v string
			v, iNdEx, err = protobuf_go_lite.DecodeString(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.OutputPath = v
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *WebBundlerOutput) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	var err error
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		wire, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
		if err != nil {
			return err
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: WebBundlerOutput: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WebBundlerOutput: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EntrypointHref", wireType)
			}
			var v string
			v, iNdEx, err = protobuf_go_lite.DecodeString(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.EntrypointHref = v
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CssHref", wireType)
			}
			var v string
			v, iNdEx, err = protobuf_go_lite.DecodeString(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.CssHref = v
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *WebPkgRefConfig) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	var err error
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		wire, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
		if err != nil {
			return err
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: WebPkgRefConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WebPkgRefConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var v string
			v, iNdEx, err = protobuf_go_lite.DecodeString(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.Id = v
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Exclude", wireType)
			}
			var v bool
			v, iNdEx, err = protobuf_go_lite.DecodeVarintBool(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.Exclude = bool(v)
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Imports", wireType)
			}
			var v string
			v, iNdEx, err = protobuf_go_lite.DecodeString(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.Imports = append(m.Imports, v)
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Entrypoints", wireType)
			}
			msgStart, postIndex, err := protobuf_go_lite.DecodeLengthDelimited(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.Entrypoints = append(m.Entrypoints, &WebPkgEntrypoint{})
			if err := m.Entrypoints[len(m.Entrypoints)-1].UnmarshalVT(dAtA[msgStart:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *WebPkgEntrypoint) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	var err error
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		wire, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
		if err != nil {
			return err
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: WebPkgEntrypoint: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WebPkgEntrypoint: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
			}
			var v string
			v, iNdEx, err = protobuf_go_lite.DecodeString(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.Path = v
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}