@ttsc/win32-arm64 0.33.1 → 0.34.0

package/bin/go/src/encoding/json/fold.go

@@ -38,7 +38,7 @@ func appendFoldedName(out, in []byte) []byte {
 	return out
 }
 
-// foldRune is returns the smallest rune for all runes in the same fold set.
+// foldRune returns the smallest rune for all runes in the same fold set.
 func foldRune(r rune) rune {
 	for {
 		r2 := unicode.SimpleFold(r)

package/bin/go/src/encoding/json/internal/internal.go

@@ -24,6 +24,16 @@ var (
 	ErrNilInterface    = errors.New("cannot derive concrete type for nil interface with finite type set")
 )
 
+// ValueError wraps the error with a Go value relevant to the error.
+// This is only used for v1 compatibility purposes.
+type ValueError struct {
+	Val any
+	Err error
+}
+
+func (ve *ValueError) Error() string { return ve.Err.Error() }
+func (ve *ValueError) Unwrap() error { return ve.Err }
+
 var (
 	// TransformMarshalError converts a v2 error into a v1 error.
 	// It is called only at the top-level of a Marshal function.
@@ -32,7 +42,7 @@ var (
 	// It is called after a user-defined Marshal method/function fails.
 	NewMarshalerError func(any, error, string) error
 	// TransformUnmarshalError converts a v2 error into a v1 error.
-	// It is called only at the top-level of a Unmarshal function.
+	// It is called only at the top-level of an Unmarshal function.
 	TransformUnmarshalError func(any, error) error
 
 	// NewRawNumber returns new(jsonv1.Number).

package/bin/go/src/encoding/json/internal/jsonflags/flags.go

@@ -43,9 +43,10 @@ const (
 		ByteLimit |
 		DepthLimit |
 		Marshalers |
-		Unmarshalers
+		Unmarshalers |
+		FormatTag
 
-	// DefaultV1Flags is the set of booleans flags that default to true under
+	// DefaultV1Flags is the set of boolean flags that default to true under
 	// v1 semantics. None of the non-boolean flags differ between v1 and v2.
 	DefaultV1Flags = 0 |
 		AllowDuplicateNames |
@@ -83,6 +84,12 @@ const (
 
 	// CanonicalizeNumbers is the set of flags related to raw number canonicalization.
 	CanonicalizeNumbers = CanonicalizeRawInts | CanonicalizeRawFloats
+
+	// TagFlags is the set of flags related to the presence of struct field tags.
+	// Tags have non-recursive effects, where the tag only applies to
+	// the top-level of the field value itself.
+	// Whenever descending into a JSON object or array, these flags are cleared.
+	TagFlags = StringTag | FormatTag
 )
 
 // Encoder and decoder flags.
@@ -120,10 +127,12 @@ const (
 	FormatNilSliceAsNull      // marshal only
 	OmitZeroStructFields      // marshal only
 	MatchCaseInsensitiveNames // marshal or unmarshal
-	DiscardUnknownMembers     // marshal only
 	RejectUnknownMembers      // unmarshal only
 	Marshalers                // marshal only; non-boolean flag
 	Unmarshalers              // unmarshal only; non-boolean flag
+	StringTag                 // marshal or unmarshal
+	FormatTag                 // marshal or unmarshal; non-boolean flag
+	FormatTagSupported        // marshal or unmarshal
 
 	maxArshalV2Flag
 )
@@ -143,7 +152,6 @@ const (
 	ParseTimeWithLooseRFC3339       // unmarshal
 	ReportErrorsWithLegacySemantics // marshal or unmarshal
 	StringifyWithLegacySemantics    // marshal or unmarshal
-	StringifyBoolsAndStrings        // marshal or unmarshal; for internal use by jsonv2.makeStructArshaler
 	UnmarshalAnyWithRawNumber       // unmarshal; for internal use by jsonv1.Decoder.UseNumber
 	UnmarshalArrayFromAnyLength     // unmarshal
 
@@ -151,7 +159,7 @@ const (
 )
 
 // bitsUsed is the number of bits used in the 64-bit boolean flags
-const bitsUsed = 42
+const bitsUsed = 43
 
 // Static compile check that bitsUsed and maxArshalV1Flag are in sync.
 const _ = uint64((1<<bitsUsed)-maxArshalV1Flag) + uint64(maxArshalV1Flag-(1<<bitsUsed))
@@ -171,9 +179,9 @@ func (dst *Flags) Join(src Flags) {
 	// then copy over source value bits over to the destination (using OR).
 	//	e.g., dst := Flags{Presence: 0b_1100_0011, Values: 0b_1000_0011}
 	//	e.g., src := Flags{Presence: 0b_0101_1010, Values: 0b_1001_0010}
-	dst.Presence |= src.Presence // e.g., 0b_1100_0011 | 0b_0101_1010 -> 0b_110_11011
-	dst.Values &= ^src.Presence  // e.g., 0b_1000_0011 & 0b_1010_0101 -> 0b_100_00001
-	dst.Values |= src.Values     // e.g., 0b_1000_0001 | 0b_1001_0010 -> 0b_100_10011
+	dst.Presence |= src.Presence // e.g., 0b_1100_0011 | 0b_0101_1010 -> 0b_1101_1011
+	dst.Values &= ^src.Presence  // e.g., 0b_1000_0011 & 0b_1010_0101 -> 0b_1000_0001
+	dst.Values |= src.Values     // e.g., 0b_1000_0001 | 0b_1001_0010 -> 0b_1001_0011
 }
 
 // Set sets both the presence and value for the provided bool (or set of bools).
@@ -185,7 +193,7 @@ func (fs *Flags) Set(f Bools) {
 	//	e.g., fs := Flags{Presence: 0b_0101_0010, Values: 0b_0001_0010}
 	//	e.g., f := 0b_1001_0001
 	id := uint64(f) &^ uint64(1)  // e.g., 0b_1001_0001 & 0b_1111_1110 -> 0b_1001_0000
-	fs.Presence |= id             // e.g., 0b_0101_0010 | 0b_1001_0000 -> 0b_1101_0011
+	fs.Presence |= id             // e.g., 0b_0101_0010 | 0b_1001_0000 -> 0b_1101_0010
 	fs.Values &= ^id              // e.g., 0b_0001_0010 & 0b_0110_1111 -> 0b_0000_0010
 	fs.Values |= uint64(f&1) * id // e.g., 0b_0000_0010 | 0b_1001_0000 -> 0b_1001_0010
 }

package/bin/go/src/encoding/json/internal/jsonopts/options.go

@@ -17,6 +17,11 @@ type Options interface {
 	JSONOptions(internal.NotForPublicUse)
 }
 
+// experimentalFormatTagSupporter is a special option method that allows
+// [github.com/go-json-experiment/json.ExperimentalSupportFormatTag]
+// to enable experimental `format` tag functionality at runtime.
+type experimentalFormatTagSupporter interface{ ExperimentalSupportFormatTag() bool }
+
 // Struct is the combination of all options in struct form.
 // This is efficient to pass down the call stack and to query.
 type Struct struct {
@@ -41,8 +46,7 @@ type ArshalValues struct {
 	Marshalers   any // jsonflags.Marshalers
 	Unmarshalers any // jsonflags.Unmarshalers
 
-	Format      string
-	FormatDepth int
+	Format string // valid if jsonflags.FormatTag is set
 }
 
 // DefaultOptionsV2 is the set of all options that define default v2 behavior.
@@ -82,6 +86,13 @@ func GetOption[T any](opts Options, setter func(T) Options) (T, bool) {
 	case jsonflags.Bools:
 		v := structOpts.Flags.Get(opt)
 		ok := structOpts.Flags.Has(opt)
+		if !ok && opt == jsonflags.StringifyNumbers && structOpts.Flags.Get(jsonflags.StringTag) {
+			return any(true).(T), true // check also whether the option is specified via a `string` tag
+		}
+		return any(v).(T), ok
+	case experimentalFormatTagSupporter:
+		v := structOpts.Flags.Get(jsonflags.FormatTagSupported)
+		ok := structOpts.Flags.Has(jsonflags.FormatTagSupported)
 		return any(v).(T), ok
 	case Indent:
 		if !structOpts.Flags.Has(jsonflags.Indent) {
@@ -114,72 +125,54 @@ func GetOption[T any](opts Options, setter func(T) Options) (T, bool) {
 var JoinUnknownOption = func(Struct, Options) Struct { panic("unknown option") }
 
 func (dst *Struct) Join(srcs ...Options) {
-	dst.join(false, srcs...)
-}
-
-func (dst *Struct) JoinWithoutCoderOptions(srcs ...Options) {
-	dst.join(true, srcs...)
-}
-
-func (dst *Struct) join(excludeCoderOptions bool, srcs ...Options) {
 	for _, src := range srcs {
 		switch src := src.(type) {
 		case nil:
 			continue
 		case jsonflags.Bools:
-			if excludeCoderOptions {
-				src &= ^jsonflags.AllCoderFlags
-			}
 			dst.Flags.Set(src)
-		case Indent:
-			if excludeCoderOptions {
-				continue
+		case experimentalFormatTagSupporter:
+			if src.ExperimentalSupportFormatTag() {
+				dst.Flags.Set(jsonflags.FormatTagSupported | 1)
+			} else {
+				dst.Flags.Set(jsonflags.FormatTagSupported | 0)
 			}
+		case Indent:
 			dst.Flags.Set(jsonflags.Multiline | jsonflags.Indent | 1)
 			dst.Indent = string(src)
 		case IndentPrefix:
-			if excludeCoderOptions {
-				continue
-			}
 			dst.Flags.Set(jsonflags.Multiline | jsonflags.IndentPrefix | 1)
 			dst.IndentPrefix = string(src)
 		case ByteLimit:
-			if excludeCoderOptions {
-				continue
-			}
 			dst.Flags.Set(jsonflags.ByteLimit | 1)
 			dst.ByteLimit = int64(src)
 		case DepthLimit:
-			if excludeCoderOptions {
-				continue
-			}
 			dst.Flags.Set(jsonflags.DepthLimit | 1)
 			dst.DepthLimit = int(src)
 		case *Struct:
-			srcFlags := src.Flags // shallow copy the flags
-			if excludeCoderOptions {
-				srcFlags.Clear(jsonflags.AllCoderFlags)
-			}
-			dst.Flags.Join(srcFlags)
-			if srcFlags.Has(jsonflags.NonBooleanFlags) {
-				if srcFlags.Has(jsonflags.Indent) {
+			dst.Flags.Join(src.Flags)
+			if src.Flags.Has(jsonflags.NonBooleanFlags) {
+				if src.Flags.Has(jsonflags.Indent) {
 					dst.Indent = src.Indent
 				}
-				if srcFlags.Has(jsonflags.IndentPrefix) {
+				if src.Flags.Has(jsonflags.IndentPrefix) {
 					dst.IndentPrefix = src.IndentPrefix
 				}
-				if srcFlags.Has(jsonflags.ByteLimit) {
+				if src.Flags.Has(jsonflags.ByteLimit) {
 					dst.ByteLimit = src.ByteLimit
 				}
-				if srcFlags.Has(jsonflags.DepthLimit) {
+				if src.Flags.Has(jsonflags.DepthLimit) {
 					dst.DepthLimit = src.DepthLimit
 				}
-				if srcFlags.Has(jsonflags.Marshalers) {
+				if src.Flags.Has(jsonflags.Marshalers) {
 					dst.Marshalers = src.Marshalers
 				}
-				if srcFlags.Has(jsonflags.Unmarshalers) {
+				if src.Flags.Has(jsonflags.Unmarshalers) {
 					dst.Unmarshalers = src.Unmarshalers
 				}
+				if src.Flags.Has(jsonflags.FormatTag) {
+					dst.Format = src.Format
+				}
 			}
 		default:
 			*dst = JoinUnknownOption(*dst, src)
@@ -187,6 +180,28 @@ func (dst *Struct) join(excludeCoderOptions bool, srcs ...Options) {
 	}
 }
 
+// InitializeMultiline sets default options implied by Multiline.
+func (s *Struct) InitializeMultiline() {
+	if !s.Flags.Has(jsonflags.SpaceAfterColon) {
+		s.Flags.Set(jsonflags.SpaceAfterColon | 1)
+	}
+	if !s.Flags.Has(jsonflags.SpaceAfterComma) {
+		s.Flags.Set(jsonflags.SpaceAfterComma | 0)
+	}
+	if !s.Flags.Has(jsonflags.Indent) {
+		s.Flags.Set(jsonflags.Indent | 1)
+		s.Indent = "\t"
+	}
+}
+
+// ChangedWhitespace reports whether whitespace values have changed.
+func ChangedWhitespace(s1, s2 Struct) bool {
+	return s1.Flags.Get(jsonflags.Multiline) != s2.Flags.Get(jsonflags.Multiline) ||
+		s1.Flags.Get(jsonflags.SpaceAfterColon) != s2.Flags.Get(jsonflags.SpaceAfterColon) ||
+		s1.Flags.Get(jsonflags.SpaceAfterComma) != s2.Flags.Get(jsonflags.SpaceAfterComma) ||
+		(s2.Flags.Get(jsonflags.Multiline) && (s1.Indent != s2.Indent || s1.IndentPrefix != s2.IndentPrefix))
+}
+
 type (
 	Indent       string // jsontext.WithIndent
 	IndentPrefix string // jsontext.WithIndentPrefix

package/bin/go/src/encoding/json/internal/jsonopts/options_format.go

@@ -0,0 +1,124 @@
+// Copyright 2026 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.
+
+//go:build goexperiment.jsonv2
+
+package jsonopts
+
+// NOTE: While [ExperimentalSupportFormatTag] is exported,
+// it is in an internal package and thus inaccessible for public use.
+//
+// The [github.com/go-json-experiment/json] module is kept in sync
+// with the Go standard standard library and will expose this option
+// in a way that public code can now directly reference.
+
+type supportFormatTag struct {
+	Options
+	v bool
+}
+
+var (
+	enableFormatTag  = supportFormatTag{v: true}
+	disableFormatTag = supportFormatTag{v: false}
+)
+
+// ExperimentalSupportFormatTag is a marker method that is specially
+// recognized by the "encoding/json/v2" runtime.
+func (o *supportFormatTag) ExperimentalSupportFormatTag() bool {
+	return o.v
+}
+
+// ExperimentalSupportFormatTag enables support for the `format` tag.
+//
+// WARNING: This is an experimental feature and will be removed in the future
+// as either a failed experiment or be formally included in "encoding/json/v2"
+// in some semantically similar form, in which case, users of this option
+// must migrate to the officially supported feature.
+//
+// The `format` tag was originally part of the "encoding/json/v2" experiment
+// but support for it was removed (see https://go.dev/issue/79071) for the
+// initial release of "encoding/json/v2" in light of the anticipation that
+// the Go language might support typed struct tags (https://go.dev/issue/74472).
+//
+// Typed struct tags are a more expressive and type-safe way to express format
+// attributes than the bespoke `format` tag option that implements a miniature
+// domain-specific language (DSL) within the "json" package itself.
+//
+// While "encoding/json/v2" was in the experimental phase,
+// some users were already depending on the `format` tag option.
+// This experimental option exists to provide a temporary workaround
+// until the (hopeful) inclusion of typed struct tags and support for
+// formatting directives in "encoding/json/v2" using that language mechanism.
+//
+// This option enables support for the `format` tag option, which specifies
+// a format flag used to specialize the formatting of the field value.
+// The option is a key-value pair specified as "format:value" where
+// the value must be either a literal consisting of letters and numbers
+// (e.g., `format:RFC3339`) or a single-quoted string literal
+// (e.g., `format:'2006-01-02'`). The interpretation of the format flag
+// is determined by the struct field type.
+//
+// Go types with alternative representations are as follows:
+//
+//   - A Go []byte or [N]byte is usually represented as a JSON string
+//     containing the binary value encoded using RFC 4648.
+//     If the format is "base64" or unspecified, then this uses RFC 4648, section 4.
+//     If the format is "base64url", then this uses RFC 4648, section 5.
+//     If the format is "base32", then this uses RFC 4648, section 6.
+//     If the format is "base32hex", then this uses RFC 4648, section 7.
+//     If the format is "base16" or "hex", then this uses RFC 4648, section 8.
+//     If the format is "array", then the bytes value is represented as a JSON array
+//     where each element recursively uses the JSON representation of each byte.
+//
+//   - A Go float is usually represented as a JSON number.
+//     If the format is "nonfinite", then NaN, +Inf, and -Inf are represented as
+//     the JSON strings "NaN", "Infinity", and "-Infinity", respectively.
+//     Without the use of this format, such string values result in a [SemanticError].
+//
+//   - A nil Go map is usually encoded using an empty JSON object.
+//     If the format is "emitnull", then a nil map is encoded as a JSON null.
+//     If the format is "emitempty", then a nil map is encoded as an empty JSON object,
+//     regardless of whether [FormatNilMapAsNull] is specified.
+//
+//   - A nil Go slice is usually encoded using an empty JSON array.
+//     If the format is "emitnull", then a nil slice is encoded as a JSON null.
+//     If the format is "emitempty", then a nil slice is encoded as an empty JSON array,
+//     regardless of whether [FormatNilSliceAsNull] is specified.
+//
+//   - A Go pointer usually uses the JSON representation of the underlying value.
+//     The format is forwarded to the marshaling and unmarshaling of the underlying type.
+//
+//   - A Go [time.Time] is usually represented as a JSON string containing
+//     the timestamp formatted in RFC 3339 with nanosecond precision.
+//     If the format matches one of the format constants declared
+//     in the time package (e.g., RFC1123), then that format is used.
+//     If the format is "unix", "unixmilli", "unixmicro", or "unixnano",
+//     then the timestamp is represented as a possibly fractional JSON number
+//     of the number of seconds (or milliseconds, microseconds, or nanoseconds)
+//     since the Unix epoch, which is January 1st, 1970 at 00:00:00 UTC.
+//     To avoid a fractional component when encoding,
+//     round the timestamp to the relevant unit.
+//     Otherwise if non-empty, the format is used as-is and
+//     encoded using [time.Time.Format] and
+//     decoded using [time.Time.Parse].
+//
+//   - A Go [time.Duration] usually has no default representation.
+//     If the format is "sec", "milli", "micro", or "nano",
+//     then the duration is represented as a possibly fractional JSON number
+//     of the number of seconds (or milliseconds, microseconds, or nanoseconds).
+//     To avoid a fractional component when encoding,
+//     round the duration to the relevant unit.
+//     If the format is "units", it is represented as a JSON string
+//     encoded using [time.Duration.String] and decoded using [time.ParseDuration]
+//     (e.g., "1h30m" for 1 hour 30 minutes).
+//     If the format is "iso8601", it is represented as a JSON string using the
+//     ISO 8601 standard for durations (e.g., "PT1H30M" for 1 hour 30 minutes)
+//     using only accurate units of hours, minutes, and seconds.
+func ExperimentalSupportFormatTag(v bool) Options {
+	if v {
+		return &enableFormatTag
+	} else {
+		return &disableFormatTag
+	}
+}

package/bin/go/src/encoding/json/internal/jsontest/testdata.go

@@ -25,7 +25,13 @@ import (
 // by other packages such that the location of testdata may change relative
 // to the working directory of the test itself.
 //
-//go:embed testdata/*.json.zst
+// Various tools assume that testdata directories are unnecessary if you don't
+// need to run tests. This includes cmd/internal/bootstrap_test, which runs go
+// install std on a GOROOT excluding testdata directories. Since this is an
+// importable package rather than a test, to avoid breaking that case we must
+// not actually name the directory testdata.
+//
+//go:embed _embed/*.json.zst
 var testdataFS embed.FS
 
 type Entry struct {
@@ -43,7 +49,7 @@ func mustGet[T any](v T, err error) T {
 
 // Data is a list of JSON testdata.
 var Data = func() (entries []Entry) {
-	fis := mustGet(fs.ReadDir(testdataFS, "testdata"))
+	fis := mustGet(fs.ReadDir(testdataFS, "_embed"))
 	slices.SortFunc(fis, func(x, y fs.DirEntry) int { return strings.Compare(x.Name(), y.Name()) })
 	for _, fi := range fis {
 		var entry Entry
@@ -57,7 +63,7 @@ var Data = func() (entries []Entry) {
 
 		// Lazily read and decompress the test data.
 		entry.Data = sync.OnceValue(func() []byte {
-			filePath := path.Join("testdata", fi.Name())
+			filePath := path.Join("_embed", fi.Name())
 			b := mustGet(fs.ReadFile(testdataFS, filePath))
 			zr := zstd.NewReader(bytes.NewReader(b))
 			return mustGet(io.ReadAll(zr))
@@ -494,7 +500,7 @@ type (
 		Coordinates          any             `json:"coordinates"`
 		Place                any             `json:"place"`
 		Contributors         any             `json:"contributors"`
-		RetweeetedStatus     *twitterStatus  `json:"retweeted_status"`
+		RetweetedStatus      *twitterStatus  `json:"retweeted_status"`
 		RetweetCount         int             `json:"retweet_count"`
 		FavoriteCount        int             `json:"favorite_count"`
 		Entities             twitterEntities `json:"entities,omitempty"`

package/bin/go/src/encoding/json/internal/jsonwire/decode.go

@@ -39,7 +39,7 @@ func ConsumeWhitespace(b []byte) (n int) {
 }
 
 // ConsumeNull consumes the next JSON null literal per RFC 7159, section 3.
-// It returns 0 if it is invalid, in which case consumeLiteral should be used.
+// It returns 0 if it is invalid, in which case ConsumeLiteral should be used.
 func ConsumeNull(b []byte) int {
 	// NOTE: The arguments and logic are kept simple to keep this inlinable.
 	const literal = "null"
@@ -50,7 +50,7 @@ func ConsumeNull(b []byte) int {
 }
 
 // ConsumeFalse consumes the next JSON false literal per RFC 7159, section 3.
-// It returns 0 if it is invalid, in which case consumeLiteral should be used.
+// It returns 0 if it is invalid, in which case ConsumeLiteral should be used.
 func ConsumeFalse(b []byte) int {
 	// NOTE: The arguments and logic are kept simple to keep this inlinable.
 	const literal = "false"
@@ -61,7 +61,7 @@ func ConsumeFalse(b []byte) int {
 }
 
 // ConsumeTrue consumes the next JSON true literal per RFC 7159, section 3.
-// It returns 0 if it is invalid, in which case consumeLiteral should be used.
+// It returns 0 if it is invalid, in which case ConsumeLiteral should be used.
 func ConsumeTrue(b []byte) int {
 	// NOTE: The arguments and logic are kept simple to keep this inlinable.
 	const literal = "true"
@@ -88,7 +88,7 @@ func ConsumeLiteral(b []byte, lit string) (n int, err error) {
 // ConsumeSimpleString consumes the next JSON string per RFC 7159, section 7
 // but is limited to the grammar for an ASCII string without escape sequences.
 // It returns 0 if it is invalid or more complicated than a simple string,
-// in which case consumeString should be called.
+// in which case [ConsumeString] should be called.
 //
 // It rejects '<', '>', and '&' for compatibility reasons since these were
 // always escaped in the v1 implementation. Thus, if this function reports
@@ -118,7 +118,7 @@ func ConsumeString(flags *ValueFlags, b []byte, validateUTF8 bool) (n int, err e
 	return ConsumeStringResumable(flags, b, 0, validateUTF8)
 }
 
-// ConsumeStringResumable is identical to consumeString but supports resuming
+// ConsumeStringResumable is identical to [ConsumeString] but supports resuming
 // from a previous call that returned io.ErrUnexpectedEOF.
 func ConsumeStringResumable(flags *ValueFlags, b []byte, resumeOffset int, validateUTF8 bool) (n int, err error) {
 	// Consume the leading double quote.
@@ -254,7 +254,7 @@ func ConsumeStringResumable(flags *ValueFlags, b []byte, resumeOffset int, valid
 // Any invalid UTF-8 within the string will be replaced with utf8.RuneError,
 // but the error will be specified as having encountered such an error.
 // The input must be an entire JSON string with no surrounding whitespace.
-func AppendUnquote[Bytes ~[]byte | ~string](dst []byte, src Bytes) (v []byte, err error) {
+func AppendUnquote(dst, src []byte) (v []byte, err error) {
 	dst = slices.Grow(dst, len(src))
 
 	// Consume the leading double quote.
@@ -292,7 +292,7 @@ func AppendUnquote[Bytes ~[]byte | ~string](dst []byte, src Bytes) (v []byte, er
 			return dst, err
 		}
 
-		switch r, rn := utf8.DecodeRuneInString(string(truncateMaxUTF8(src[n:]))); {
+		switch r, rn := utf8.DecodeRune(src[n:]); {
 		// Handle UTF-8 encoded byte sequence.
 		// Due to specialized handling of ASCII above, we know that
 		// all normal sequences at this point must be 2 bytes or larger.
@@ -364,7 +364,7 @@ func AppendUnquote[Bytes ~[]byte | ~string](dst []byte, src Bytes) (v []byte, er
 		// Handle invalid UTF-8.
 		case r == utf8.RuneError:
 			dst = append(dst, src[i:n]...)
-			if !utf8.FullRuneInString(string(truncateMaxUTF8(src[n:]))) {
+			if !utf8.FullRune(src[n:]) {
 				return dst, io.ErrUnexpectedEOF
 			}
 			// NOTE: An unescaped string may be longer than the escaped string
@@ -387,7 +387,7 @@ func AppendUnquote[Bytes ~[]byte | ~string](dst []byte, src Bytes) (v []byte, er
 
 // hasEscapedUTF16Prefix reports whether b is possibly
 // the truncated prefix of a \uFFFF escape sequence.
-func hasEscapedUTF16Prefix[Bytes ~[]byte | ~string](b Bytes, lowerSurrogateHalf bool) bool {
+func hasEscapedUTF16Prefix(b []byte, lowerSurrogateHalf bool) bool {
 	for i := range len(b) {
 		switch c := b[i]; {
 		case i == 0 && c != '\\':
@@ -420,9 +420,9 @@ func UnquoteMayCopy(b []byte, isVerbatim bool) []byte {
 }
 
 // ConsumeSimpleNumber consumes the next JSON number per RFC 7159, section 6
-// but is limited to the grammar for a positive integer.
+// but is limited to the grammar for a non-negative integer.
 // It returns 0 if it is invalid or more complicated than a simple integer,
-// in which case consumeNumber should be called.
+// in which case ConsumeNumber should be called.
 func ConsumeSimpleNumber(b []byte) (n int) {
 	// NOTE: The arguments and logic are kept simple to keep this inlinable.
 	if len(b) > 0 {
@@ -467,7 +467,7 @@ func ConsumeNumber(b []byte) (n int, err error) {
 	return n, err
 }
 
-// ConsumeNumberResumable is identical to consumeNumber but supports resuming
+// ConsumeNumberResumable is identical to ConsumeNumber but supports resuming
 // from a previous call that returned io.ErrUnexpectedEOF.
 func ConsumeNumberResumable(b []byte, resumeOffset int, state ConsumeNumberState) (n int, _ ConsumeNumberState, err error) {
 	// Jump to the right state when resuming from a partial consumption.
@@ -565,7 +565,7 @@ beforeExponent:
 // parseHexUint16 is similar to strconv.ParseUint,
 // but operates directly on []byte and is optimized for base-16.
 // See https://go.dev/issue/42429.
-func parseHexUint16[Bytes ~[]byte | ~string](b Bytes) (v uint16, ok bool) {
+func parseHexUint16(b []byte) (v uint16, ok bool) {
 	if len(b) != 4 {
 		return 0, false
 	}
@@ -604,26 +604,3 @@ func ParseUint(b []byte) (v uint64, ok bool) {
 	}
 	return v, true
 }
-
-// ParseFloat parses a floating point number according to the Go float grammar.
-// Note that the JSON number grammar is a strict subset.
-//
-// If the number overflows the finite representation of a float,
-// then we return MaxFloat since any finite value will always be infinitely
-// more accurate at representing another finite value than an infinite value.
-func ParseFloat(b []byte, bits int) (v float64, ok bool) {
-	fv, err := strconv.ParseFloat(string(b), bits)
-	if math.IsInf(fv, 0) {
-		switch {
-		case bits == 32 && math.IsInf(fv, +1):
-			fv = +math.MaxFloat32
-		case bits == 64 && math.IsInf(fv, +1):
-			fv = +math.MaxFloat64
-		case bits == 32 && math.IsInf(fv, -1):
-			fv = -math.MaxFloat32
-		case bits == 64 && math.IsInf(fv, -1):
-			fv = -math.MaxFloat64
-		}
-	}
-	return fv, err == nil
-}

package/bin/go/src/encoding/json/internal/jsonwire/encode.go

@@ -32,7 +32,7 @@ var escapeASCII = [...]uint8{
 // NeedEscape reports whether src needs escaping of any characters.
 // It conservatively assumes EscapeForHTML and EscapeForJS.
 // It reports true for inputs with invalid UTF-8.
-func NeedEscape[Bytes ~[]byte | ~string](src Bytes) bool {
+func NeedEscape(src []byte) bool {
 	var i int
 	for uint(len(src)) > uint(i) {
 		if c := src[i]; c < utf8.RuneSelf {
@@ -41,7 +41,7 @@ func NeedEscape[Bytes ~[]byte | ~string](src Bytes) bool {
 			}
 			i++
 		} else {
-			r, rn := utf8.DecodeRuneInString(string(truncateMaxUTF8(src[i:])))
+			r, rn := utf8.DecodeRune(src[i:])
 			if r == utf8.RuneError || r == '\u2028' || r == '\u2029' {
 				return true
 			}
@@ -62,7 +62,7 @@ func NeedEscape[Bytes ~[]byte | ~string](src Bytes) bool {
 // invalid bytes are replaced with the Unicode replacement character ('\ufffd').
 // If no escape flags are set, then the shortest representable form is used,
 // which is also the canonical form for strings (RFC 8785, section 3.2.2.2).
-func AppendQuote[Bytes ~[]byte | ~string](dst []byte, src Bytes, flags *jsonflags.Flags) ([]byte, error) {
+func AppendQuote(dst, src []byte, flags *jsonflags.Flags) ([]byte, error) {
 	var i, n int
 	var hasInvalidUTF8 bool
 	dst = slices.Grow(dst, len(`"`)+len(src)+len(`"`))
@@ -82,7 +82,7 @@ func AppendQuote[Bytes ~[]byte | ~string](dst []byte, src Bytes, flags *jsonflag
 			}
 		} else {
 			// Handle multi-byte Unicode.
-			r, rn := utf8.DecodeRuneInString(string(truncateMaxUTF8(src[n:])))
+			r, rn := utf8.DecodeRune(src[n:])
 			n += rn
 			if r != utf8.RuneError && r != '\u2028' && r != '\u2029' {
 				continue // no escaping possibly needed
@@ -178,7 +178,7 @@ func ReformatString(dst, src []byte, flags *jsonflags.Flags) ([]byte, int, error
 				}
 				i++
 			} else {
-				r, rn := utf8.DecodeRune(truncateMaxUTF8(src[i:]))
+				r, rn := utf8.DecodeRune(src[i:])
 				if (r == '\u2028' || r == '\u2029') && flags.Get(jsonflags.EscapeForJS) {
 					dst = append(dst, src[lastAppendIndex:i]...)
 					dst = appendEscapedUnicode(dst, r)
@@ -193,7 +193,7 @@ func ReformatString(dst, src []byte, flags *jsonflags.Flags) ([]byte, int, error
 	// The input contains characters that might need escaping,
 	// unnecessary escape sequences, or invalid UTF-8.
 	// Perform a round-trip unquote and quote to properly reformat
-	// these sequences according the current flags.
+	// these sequences according to the current flags.
 	b, _ := AppendUnquote(nil, src[:n])
 	dst, _ = AppendQuote(dst, b, flags)
 	return dst, n, nil
@@ -235,7 +235,7 @@ func AppendFloat(dst []byte, src float64, bits int) []byte {
 	return dst
 }
 
-// ReformatNumber consumes a JSON string from src and appends it to dst,
+// ReformatNumber consumes a JSON number from src and appends it to dst,
 // canonicalizing it if specified.
 // It returns the appended output and the number of consumed input bytes.
 func ReformatNumber(dst, src []byte, flags *jsonflags.Flags) ([]byte, int, error) {