Update

vendor/github.com/go-json-experiment/json/jsontext/value.go

@@ -17,7 +17,24 @@ import (
 	"github.com/go-json-experiment/json/internal/jsonwire"
 )
 
-// NOTE: Value is analogous to v1 json.RawMessage.
+// AppendFloat appends src to dst as a JSON number per RFC 8259, section 6.
+//
+// Except for -0, which is formatted as -0 instead of 0,
+// the output is identical to ECMA-262, 10th edition, section 7.1.12.1
+// and (for 64-bit precision) identical to RFC 8785, section 3.2.2.3.
+// The values NaN, +Inf, and -Inf will be represented as a JSON string
+// with the values "NaN", "Infinity", and "-Infinity".
+//
+// Note that most JSON libraries and standards assume that JSON numbers
+// are 64-bit floating-point numbers. As such, prefer using 64 bits
+// of precision unless the recipient can know from other context
+// that the encoded number uses 32 bits of precision.
+func AppendFloat(dst []byte, src float64, bits int) []byte {
+	if bits != 32 && bits != 64 {
+		panic("illegal AppendFloat bit size")
+	}
+	return jsonwire.AppendFloat(dst, src, bits)
+}
 
 // AppendFormat formats the JSON value in src and appends it to dst
 // according to the specified options.
@@ -25,16 +42,18 @@ import (
 //
 // 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) {
+func AppendFormat[Bytes ~[]byte | ~string](dst []byte, src Bytes, 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 {
+	if err := e.s.WriteValue(Value(src)); err != nil {
 		return append(dst, src...), err
 	}
 	return append(dst, e.s.Buf...), nil
 }
 
+// NOTE: Value is analogous to v1 json.RawMessage.
+
 // 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!")
@@ -113,7 +132,7 @@ func (v *Value) Format(opts ...Options) error {
 	return v.format(opts, nil)
 }
 
-// format accepts two []Options to avoid the allocation appending them together.
+// format accepts two []Options to avoid the allocation of appending them together.
 // It is equivalent to v.Format(append(opts1, opts2...)...).
 func (v *Value) format(opts1, opts2 []Options) error {
 	e := getBufferedEncoder(opts1...)
@@ -133,7 +152,7 @@ func (v *Value) format(opts1, opts2 []Options) error {
 //
 // 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.
+// it permits values with duplicate names and invalid UTF-8.
 //
 // Compact is equivalent to calling [Value.Format] with the following options:
 //   - [AllowDuplicateNames](true)
@@ -151,11 +170,11 @@ func (v *Value) Compact(opts ...Options) error {
 }
 
 // Indent reformats the whitespace in the raw JSON value so that each element
-// in a JSON object or array begins on a indented line according to the nesting.
+// in a JSON object or array begins on an indented line according to the nesting.
 //
 // 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.
+// it permits values with duplicate names and invalid UTF-8.
 //
 // Indent is equivalent to calling [Value.Format] with the following options:
 //   - [AllowDuplicateNames](true)
@@ -175,8 +194,10 @@ func (v *Value) Indent(opts ...Options) error {
 }
 
 // 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 Canonicalization Scheme (JCS) as defined by RFC 8785.
+// Canonicalization produces a JSON value with the same meaning as the original,
+// but is stable in the sense that calling Canonicalize on a canonicalized
+// value does nothing.
 //
 // JSON strings are formatted to use their minimal representation,
 // JSON numbers are formatted as double precision numbers according
@@ -184,12 +205,6 @@ func (v *Value) Indent(opts ...Options) error {
 // 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)
@@ -214,7 +229,7 @@ func (v *Value) Canonicalize(opts ...Options) error {
 }
 
 // MarshalJSON returns v as the JSON encoding of v.
-// It returns the stored value as the raw JSON output without any validation.
+// It performs no validation.
 // If v is nil, then this returns a JSON null.
 func (v Value) MarshalJSON() ([]byte, error) {
 	// NOTE: This matches the behavior of v1 json.RawMessage.MarshalJSON.
@@ -236,7 +251,7 @@ func (v *Value) UnmarshalJSON(b []byte) error {
 }
 
 // Kind returns the starting token kind.
-// For a valid value, this will never include '}' or ']'.
+// For a valid value, this will never include [KindEndObject] or [KindEndArray].
 func (v Value) Kind() Kind {
 	if v := v[jsonwire.ConsumeWhitespace(v):]; len(v) > 0 {
 		return Kind(v[0]).normalize()