Update dependencies

2025-04-09 01:00:12 +01:00
parent f0641ffd6e
commit 5a9cfc022c
882 changed files with 68930 additions and 24201 deletions
--- a/vendor/github.com/go-json-experiment/json/jsontext/value.go
+++ b/vendor/github.com/go-json-experiment/json/jsontext/value.go
@@ -9,7 +9,6 @@ import (
 	"errors"
 	"io"
 	"slices"
-	"strings"
 	"sync"

 	"github.com/go-json-experiment/json/internal/jsonflags"
@@ -18,6 +17,22 @@ import (

 // NOTE: Value is analogous to v1 json.RawMessage.

+// AppendFormat formats the JSON value in src and appends it to dst
+// according to the specified options.
+// See [Value.Format] for more details about the formatting behavior.
+//
+// The dst and src may overlap.
+// If an error is reported, then the entirety of src is appended to dst.
+func AppendFormat(dst, src []byte, opts ...Options) ([]byte, error) {
+	e := getBufferedEncoder(opts...)
+	defer putBufferedEncoder(e)
+	e.s.Flags.Set(jsonflags.OmitTopLevelNewline | 1)
+	if err := e.s.WriteValue(src); err != nil {
+		return append(dst, src...), err
+	}
+	return append(dst, e.s.Buf...), nil
+}
+
 // Value represents a single raw JSON value, which may be one of the following:
 //   - a JSON literal (i.e., null, true, or false)
 //   - a JSON string (e.g., "hello, world!")
@@ -43,70 +58,159 @@ func (v Value) String() string {
 }

 // IsValid reports whether the raw JSON value is syntactically valid
-// according to RFC 7493.
+// according to the specified options.
 //
+// By default (if no options are specified), it validates according to RFC 7493.
 // It verifies whether the input is properly encoded as UTF-8,
 // that escape sequences within strings decode to valid Unicode codepoints, and
 // that all names in each object are unique.
 // It does not verify whether numbers are representable within the limits
 // of any common numeric type (e.g., float64, int64, or uint64).
-func (v Value) IsValid() bool {
-	d := getBufferedDecoder(v)
+//
+// Relevant options include:
+//   - [AllowDuplicateNames]
+//   - [AllowInvalidUTF8]
+//
+// All other options are ignored.
+func (v Value) IsValid(opts ...Options) bool {
+	// TODO: Document support for [WithByteLimit] and [WithDepthLimit].
+	d := getBufferedDecoder(v, opts...)
 	defer putBufferedDecoder(d)
 	_, errVal := d.ReadValue()
 	_, errEOF := d.ReadToken()
 	return errVal == nil && errEOF == io.EOF
 }

+// Format formats the raw JSON value in place.
+//
+// By default (if no options are specified), it validates according to RFC 7493
+// and produces the minimal JSON representation, where
+// all whitespace is elided and JSON strings use the shortest encoding.
+//
+// Relevant options include:
+//   - [AllowDuplicateNames]
+//   - [AllowInvalidUTF8]
+//   - [EscapeForHTML]
+//   - [EscapeForJS]
+//   - [PreserveRawStrings]
+//   - [CanonicalizeRawInts]
+//   - [CanonicalizeRawFloats]
+//   - [ReorderRawObjects]
+//   - [SpaceAfterColon]
+//   - [SpaceAfterComma]
+//   - [Multiline]
+//   - [WithIndent]
+//   - [WithIndentPrefix]
+//
+// All other options are ignored.
+//
+// It is guaranteed to succeed if the value is valid according to the same options.
+// If the value is already formatted, then the buffer is not mutated.
+func (v *Value) Format(opts ...Options) error {
+	// TODO: Document support for [WithByteLimit] and [WithDepthLimit].
+	return v.format(opts, nil)
+}
+
+// format accepts two []Options to avoid the allocation appending them together.
+// It is equivalent to v.Format(append(opts1, opts2...)...).
+func (v *Value) format(opts1, opts2 []Options) error {
+	e := getBufferedEncoder(opts1...)
+	defer putBufferedEncoder(e)
+	e.s.Join(opts2...)
+	e.s.Flags.Set(jsonflags.OmitTopLevelNewline | 1)
+	if err := e.s.WriteValue(*v); err != nil {
+		return err
+	}
+	if !bytes.Equal(*v, e.s.Buf) {
+		*v = append((*v)[:0], e.s.Buf...)
+	}
+	return nil
+}
+
 // Compact removes all whitespace from the raw JSON value.
 //
-// It does not reformat JSON strings to use any other representation.
-// It is guaranteed to succeed if the input is valid.
-// If the value is already compacted, then the buffer is not mutated.
-func (v *Value) Compact() error {
-	return v.reformat(false, false, "", "")
+// It does not reformat JSON strings or numbers to use any other representation.
+// To maximize the set of JSON values that can be formatted,
+// this permits values with duplicate names and invalid UTF-8.
+//
+// Compact is equivalent to calling [Value.Format] with the following options:
+//   - [AllowDuplicateNames](true)
+//   - [AllowInvalidUTF8](true)
+//   - [PreserveRawStrings](true)
+//
+// Any options specified by the caller are applied after the initial set
+// and may deliberately override prior options.
+func (v *Value) Compact(opts ...Options) error {
+	return v.format([]Options{
+		AllowDuplicateNames(true),
+		AllowInvalidUTF8(true),
+		PreserveRawStrings(true),
+	}, opts)
 }

 // Indent reformats the whitespace in the raw JSON value so that each element
-// in a JSON object or array begins on a new, indented line beginning with
-// prefix followed by one or more copies of indent according to the nesting.
-// The value does not begin with the prefix nor any indention,
-// to make it easier to embed inside other formatted JSON data.
+// in a JSON object or array begins on a indented line according to the nesting.
 //
-// It does not reformat JSON strings to use any other representation.
-// It is guaranteed to succeed if the input is valid.
-// If the value is already indented properly, then the buffer is not mutated.
+// It does not reformat JSON strings or numbers to use any other representation.
+// To maximize the set of JSON values that can be formatted,
+// this permits values with duplicate names and invalid UTF-8.
 //
-// The prefix and indent strings must be composed of only spaces and/or tabs.
-func (v *Value) Indent(prefix, indent string) error {
-	return v.reformat(false, true, prefix, indent)
+// Indent is equivalent to calling [Value.Format] with the following options:
+//   - [AllowDuplicateNames](true)
+//   - [AllowInvalidUTF8](true)
+//   - [PreserveRawStrings](true)
+//   - [Multiline](true)
+//
+// Any options specified by the caller are applied after the initial set
+// and may deliberately override prior options.
+func (v *Value) Indent(opts ...Options) error {
+	return v.format([]Options{
+		AllowDuplicateNames(true),
+		AllowInvalidUTF8(true),
+		PreserveRawStrings(true),
+		Multiline(true),
+	}, opts)
 }

 // Canonicalize canonicalizes the raw JSON value according to the
 // JSON Canonicalization Scheme (JCS) as defined by RFC 8785
 // where it produces a stable representation of a JSON value.
 //
+// JSON strings are formatted to use their minimal representation,
+// JSON numbers are formatted as double precision numbers according
+// to some stable serialization algorithm.
+// JSON object members are sorted in ascending order by name.
+// All whitespace is removed.
+//
 // The output stability is dependent on the stability of the application data
 // (see RFC 8785, Appendix E). It cannot produce stable output from
 // fundamentally unstable input. For example, if the JSON value
 // contains ephemeral data (e.g., a frequently changing timestamp),
 // then the value is still unstable regardless of whether this is called.
 //
+// Canonicalize is equivalent to calling [Value.Format] with the following options:
+//   - [CanonicalizeRawInts](true)
+//   - [CanonicalizeRawFloats](true)
+//   - [ReorderRawObjects](true)
+//
+// Any options specified by the caller are applied after the initial set
+// and may deliberately override prior options.
+//
 // Note that JCS treats all JSON numbers as IEEE 754 double precision numbers.
 // Any numbers with precision beyond what is representable by that form
 // will lose their precision when canonicalized. For example, integer values
-// beyond ±2⁵³ will lose their precision. It is recommended that
-// int64 and uint64 data types be represented as a JSON string.
+// beyond ±2⁵³ will lose their precision. To preserve the original representation
+// of JSON integers, additionally set [CanonicalizeRawInts] to false:
 //
-// It is guaranteed to succeed if the input is valid.
-// If the value is already canonicalized, then the buffer is not mutated.
-func (v *Value) Canonicalize() error {
-	return v.reformat(true, false, "", "")
+//	v.Canonicalize(jsontext.CanonicalizeRawInts(false))
+func (v *Value) Canonicalize(opts ...Options) error {
+	return v.format([]Options{
+		CanonicalizeRawInts(true),
+		CanonicalizeRawFloats(true),
+		ReorderRawObjects(true),
+	}, opts)
 }

-// TODO: Instead of implementing the v1 Marshaler/Unmarshaler,
-// consider implementing the v2 versions instead.
-
 // MarshalJSON returns v as the JSON encoding of v.
 // It returns the stored value as the raw JSON output without any validation.
 // If v is nil, then this returns a JSON null.
@@ -123,7 +227,7 @@ func (v Value) MarshalJSON() ([]byte, error) {
 func (v *Value) UnmarshalJSON(b []byte) error {
 	// NOTE: This matches the behavior of v1 json.RawMessage.UnmarshalJSON.
 	if v == nil {
-		return errors.New("json.Value: UnmarshalJSON on nil pointer")
+		return errors.New("jsontext.Value: UnmarshalJSON on nil pointer")
 	}
 	*v = append((*v)[:0], b...)
 	return nil
@@ -138,93 +242,62 @@ func (v Value) Kind() Kind {
 	return invalidKind
 }

-func (v *Value) reformat(canonical, multiline bool, prefix, indent string) error {
-	// Write the entire value to reformat all tokens and whitespace.
-	e := getBufferedEncoder()
-	defer putBufferedEncoder(e)
-	eo := &e.s.Struct
-	if canonical {
-		eo.Flags.Set(jsonflags.AllowInvalidUTF8 | 0)    // per RFC 8785, section 3.2.4
-		eo.Flags.Set(jsonflags.AllowDuplicateNames | 0) // per RFC 8785, section 3.1
-		eo.Flags.Set(jsonflags.CanonicalizeNumbers | 1) // per RFC 8785, section 3.2.2.3
-		eo.Flags.Set(jsonflags.PreserveRawStrings | 0)  // per RFC 8785, section 3.2.2.2
-		eo.Flags.Set(jsonflags.EscapeForHTML | 0)       // per RFC 8785, section 3.2.2.2
-		eo.Flags.Set(jsonflags.EscapeForJS | 0)         // per RFC 8785, section 3.2.2.2
-		eo.Flags.Set(jsonflags.Expand | 0)              // per RFC 8785, section 3.2.1
-	} else {
-		if s := strings.TrimLeft(prefix, " \t"); len(s) > 0 {
-			panic("json: invalid character " + jsonwire.QuoteRune(s) + " in indent prefix")
-		}
-		if s := strings.TrimLeft(indent, " \t"); len(s) > 0 {
-			panic("json: invalid character " + jsonwire.QuoteRune(s) + " in indent")
-		}
-		eo.Flags.Set(jsonflags.AllowInvalidUTF8 | 1)
-		eo.Flags.Set(jsonflags.AllowDuplicateNames | 1)
-		eo.Flags.Set(jsonflags.PreserveRawStrings | 1)
-		if multiline {
-			eo.Flags.Set(jsonflags.Expand | 1)
-			eo.Flags.Set(jsonflags.Indent | 1)
-			eo.Flags.Set(jsonflags.IndentPrefix | 1)
-			eo.IndentPrefix = prefix
-			eo.Indent = indent
-		} else {
-			eo.Flags.Set(jsonflags.Expand | 0)
-		}
-	}
-	eo.Flags.Set(jsonflags.OmitTopLevelNewline | 1)
-	if err := e.s.WriteValue(*v); err != nil {
-		return err
-	}
+const commaAndWhitespace = ", \n\r\t"

-	// For canonical output, we may need to reorder object members.
-	if canonical {
-		// Obtain a buffered encoder just to use its internal buffer as
-		// a scratch buffer in reorderObjects for reordering object members.
-		e2 := getBufferedEncoder()
-		defer putBufferedEncoder(e2)
-
-		// Disable redundant checks performed earlier during encoding.
-		d := getBufferedDecoder(e.s.Buf)
-		defer putBufferedDecoder(d)
-		d.s.Flags.Set(jsonflags.AllowDuplicateNames | jsonflags.AllowInvalidUTF8 | 1)
-		reorderObjects(d, &e2.s.Buf) // per RFC 8785, section 3.2.3
-	}
-
-	// Store the result back into the value if different.
-	if !bytes.Equal(*v, e.s.Buf) {
-		*v = append((*v)[:0], e.s.Buf...)
-	}
-	return nil
+type objectMember struct {
+	// name is the unquoted name.
+	name []byte // e.g., "name"
+	// buffer is the entirety of the raw JSON object member
+	// starting from right after the previous member (or opening '{')
+	// until right after the member value.
+	buffer []byte // e.g., `, \n\r\t"name": "value"`
 }

-type memberName struct {
-	// name is the unescaped name.
-	name []byte
-	// before and after are byte offsets into Decoder.buf that represents
-	// the entire name/value pair. It may contain leading commas.
-	before, after int64
+func (x objectMember) Compare(y objectMember) int {
+	if c := jsonwire.CompareUTF16(x.name, y.name); c != 0 {
+		return c
+	}
+	// With [AllowDuplicateNames] or [AllowInvalidUTF8],
+	// names could be identical, so also sort using the member value.
+	return jsonwire.CompareUTF16(
+		bytes.TrimLeft(x.buffer, commaAndWhitespace),
+		bytes.TrimLeft(y.buffer, commaAndWhitespace))
 }

-var memberNamePool = sync.Pool{New: func() any { return new([]memberName) }}
+var objectMemberPool = sync.Pool{New: func() any { return new([]objectMember) }}

-func getMemberNames() *[]memberName {
-	ns := memberNamePool.Get().(*[]memberName)
+func getObjectMembers() *[]objectMember {
+	ns := objectMemberPool.Get().(*[]objectMember)
 	*ns = (*ns)[:0]
 	return ns
 }
-func putMemberNames(ns *[]memberName) {
+func putObjectMembers(ns *[]objectMember) {
 	if cap(*ns) < 1<<10 {
-		clear(*ns) // avoid pinning name
-		memberNamePool.Put(ns)
+		clear(*ns) // avoid pinning name and buffer
+		objectMemberPool.Put(ns)
 	}
 }

-// reorderObjects recursively reorders all object members in place
+// mustReorderObjects reorders in-place all object members in a JSON value,
+// which must be valid otherwise it panics.
+func mustReorderObjects(b []byte) {
+	// Obtain a buffered encoder just to use its internal buffer as
+	// a scratch buffer for reordering object members.
+	e2 := getBufferedEncoder()
+	defer putBufferedEncoder(e2)
+
+	// Disable unnecessary checks to syntactically parse the JSON value.
+	d := getBufferedDecoder(b)
+	defer putBufferedDecoder(d)
+	d.s.Flags.Set(jsonflags.AllowDuplicateNames | jsonflags.AllowInvalidUTF8 | 1)
+	mustReorderObjectsFromDecoder(d, &e2.s.Buf) // per RFC 8785, section 3.2.3
+}
+
+// mustReorderObjectsFromDecoder recursively reorders all object members in place
 // according to the ordering specified in RFC 8785, section 3.2.3.
 //
 // Pre-conditions:
 //   - The value is valid (i.e., no decoder errors should ever occur).
-//   - The value is compact (i.e., no whitespace is present).
 //   - Initial call is provided a Decoder reading from the start of v.
 //
 // Post-conditions:
@@ -234,13 +307,13 @@ func putMemberNames(ns *[]memberName) {
 //
 // The runtime is approximately O(n·log(n)) + O(m·log(m)),
 // where n is len(v) and m is the total number of object members.
-func reorderObjects(d *Decoder, scratch *[]byte) {
-	switch tok, _ := d.ReadToken(); tok.Kind() {
+func mustReorderObjectsFromDecoder(d *Decoder, scratch *[]byte) {
+	switch tok, err := d.ReadToken(); tok.Kind() {
 	case '{':
 		// Iterate and collect the name and offsets for every object member.
-		members := getMemberNames()
-		defer putMemberNames(members)
-		var prevName []byte
+		members := getObjectMembers()
+		defer putObjectMembers(members)
+		var prevMember objectMember
 		isSorted := true

 		beforeBody := d.InputOffset() // offset after '{'
@@ -249,14 +322,15 @@ func reorderObjects(d *Decoder, scratch *[]byte) {
 			var flags jsonwire.ValueFlags
 			name, _ := d.s.ReadValue(&flags)
 			name = jsonwire.UnquoteMayCopy(name, flags.IsVerbatim())
-			reorderObjects(d, scratch)
+			mustReorderObjectsFromDecoder(d, scratch)
 			afterValue := d.InputOffset()

+			currMember := objectMember{name, d.s.buf[beforeName:afterValue]}
 			if isSorted && len(*members) > 0 {
-				isSorted = jsonwire.CompareUTF16(prevName, []byte(name)) < 0
+				isSorted = objectMember.Compare(prevMember, currMember) < 0
 			}
-			*members = append(*members, memberName{name, beforeName, afterValue})
-			prevName = name
+			*members = append(*members, currMember)
+			prevMember = currMember
 		}
 		afterBody := d.InputOffset() // offset before '}'
 		d.ReadToken()
@@ -265,9 +339,9 @@ func reorderObjects(d *Decoder, scratch *[]byte) {
 		if isSorted {
 			return
 		}
-		slices.SortFunc(*members, func(x, y memberName) int {
-			return jsonwire.CompareUTF16(x.name, y.name)
-		})
+		firstBufferBeforeSorting := (*members)[0].buffer
+		slices.SortFunc(*members, objectMember.Compare)
+		firstBufferAfterSorting := (*members)[0].buffer

 		// Append the reordered members to a new buffer,
 		// then copy the reordered members back over the original members.
@@ -277,14 +351,24 @@ func reorderObjects(d *Decoder, scratch *[]byte) {
 		//
 		// The following invariant must hold:
 		//	sum([m.after-m.before for m in members]) == afterBody-beforeBody
+		commaAndWhitespacePrefix := func(b []byte) []byte {
+			return b[:len(b)-len(bytes.TrimLeft(b, commaAndWhitespace))]
+		}
 		sorted := (*scratch)[:0]
 		for i, member := range *members {
-			if d.s.buf[member.before] == ',' {
-				member.before++ // trim leading comma
-			}
-			sorted = append(sorted, d.s.buf[member.before:member.after]...)
-			if i < len(*members)-1 {
-				sorted = append(sorted, ',') // append trailing comma
+			switch {
+			case i == 0 && &member.buffer[0] != &firstBufferBeforeSorting[0]:
+				// First member after sorting is not the first member before sorting,
+				// so use the prefix of the first member before sorting.
+				sorted = append(sorted, commaAndWhitespacePrefix(firstBufferBeforeSorting)...)
+				sorted = append(sorted, bytes.TrimLeft(member.buffer, commaAndWhitespace)...)
+			case i != 0 && &member.buffer[0] == &firstBufferBeforeSorting[0]:
+				// Later member after sorting is the first member before sorting,
+				// so use the prefix of the first member after sorting.
+				sorted = append(sorted, commaAndWhitespacePrefix(firstBufferAfterSorting)...)
+				sorted = append(sorted, bytes.TrimLeft(member.buffer, commaAndWhitespace)...)
+			default:
+				sorted = append(sorted, member.buffer...)
 			}
 		}
 		if int(afterBody-beforeBody) != len(sorted) {
@@ -298,8 +382,12 @@ func reorderObjects(d *Decoder, scratch *[]byte) {
 		}
 	case '[':
 		for d.PeekKind() != ']' {
-			reorderObjects(d, scratch)
+			mustReorderObjectsFromDecoder(d, scratch)
 		}
 		d.ReadToken()
+	default:
+		if err != nil {
+			panic("BUG: " + err.Error())
+		}
 	}
 }