From 6351af8927c3f1b4dde7e8a3418530eda1d94f2e Mon Sep 17 00:00:00 2001 From: fulldump Date: Sun, 19 Oct 2025 23:15:38 +0200 Subject: [PATCH 1/2] upgrade toolchain to go 1.25.2 --- go.mod | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/go.mod b/go.mod index a349f8a..a517664 100644 --- a/go.mod +++ b/go.mod @@ -1,6 +1,6 @@ module github.com/fulldump/inceptiondb -go 1.25 +go 1.25.2 require ( github.com/SierraSoftworks/connor v1.0.2 From 2183206d83ee4cbfea2ec5169d177f707717256a Mon Sep 17 00:00:00 2001 From: fulldump Date: Sun, 19 Oct 2025 23:59:11 +0200 Subject: [PATCH 2/2] fix: temporary workaround: use repo github.com/go-json-experiment/json instead of builtin jsonv2 GOEXPERIMENT because of a bug in FIPS140 that panics on codex --- Makefile | 2 - cmd/bench/README.md | 6 +- collection/collection.go | 5 +- go.mod | 1 + go.sum | 2 + .../go-json-experiment/json/AUTHORS | 3 + .../go-json-experiment/json/CONTRIBUTORS | 3 + .../go-json-experiment/json/LICENSE | 27 + .../go-json-experiment/json/README.md | 175 ++ .../go-json-experiment/json/alias.go | 1008 +++++++++ .../go-json-experiment/json/api.png | Bin 0 -> 154576 bytes .../go-json-experiment/json/arshal.go | 580 +++++ .../go-json-experiment/json/arshal_any.go | 287 +++ .../go-json-experiment/json/arshal_default.go | 1910 +++++++++++++++++ .../go-json-experiment/json/arshal_funcs.go | 436 ++++ .../go-json-experiment/json/arshal_inlined.go | 229 ++ .../go-json-experiment/json/arshal_methods.go | 357 +++ .../go-json-experiment/json/arshal_time.go | 775 +++++++ .../github.com/go-json-experiment/json/doc.go | 264 +++ .../go-json-experiment/json/errors.go | 435 ++++ .../go-json-experiment/json/fields.go | 654 ++++++ .../go-json-experiment/json/fold.go | 58 + .../go-json-experiment/json/intern.go | 88 + .../json/internal/internal.go | 42 + .../json/internal/jsonflags/flags.go | 215 ++ .../json/internal/jsonopts/options.go | 202 ++ .../json/internal/jsonwire/decode.go | 629 ++++++ .../json/internal/jsonwire/encode.go | 290 +++ .../json/internal/jsonwire/wire.go | 217 ++ .../go-json-experiment/json/jsontext/alias.go | 536 +++++ .../json/jsontext/decode.go | 1179 ++++++++++ .../go-json-experiment/json/jsontext/doc.go | 111 + .../json/jsontext/encode.go | 977 +++++++++ .../json/jsontext/errors.go | 182 ++ .../json/jsontext/export.go | 77 + .../json/jsontext/options.go | 304 +++ .../go-json-experiment/json/jsontext/pools.go | 152 ++ .../go-json-experiment/json/jsontext/quote.go | 41 + .../go-json-experiment/json/jsontext/state.go | 828 +++++++ .../go-json-experiment/json/jsontext/token.go | 527 +++++ .../go-json-experiment/json/jsontext/value.go | 395 ++++ .../go-json-experiment/json/migrate.sh | 48 + .../go-json-experiment/json/options.go | 289 +++ vendor/modules.txt | 8 + 44 files changed, 14547 insertions(+), 7 deletions(-) create mode 100644 vendor/github.com/go-json-experiment/json/AUTHORS create mode 100644 vendor/github.com/go-json-experiment/json/CONTRIBUTORS create mode 100644 vendor/github.com/go-json-experiment/json/LICENSE create mode 100644 vendor/github.com/go-json-experiment/json/README.md create mode 100644 vendor/github.com/go-json-experiment/json/alias.go create mode 100644 vendor/github.com/go-json-experiment/json/api.png create mode 100644 vendor/github.com/go-json-experiment/json/arshal.go create mode 100644 vendor/github.com/go-json-experiment/json/arshal_any.go create mode 100644 vendor/github.com/go-json-experiment/json/arshal_default.go create mode 100644 vendor/github.com/go-json-experiment/json/arshal_funcs.go create mode 100644 vendor/github.com/go-json-experiment/json/arshal_inlined.go create mode 100644 vendor/github.com/go-json-experiment/json/arshal_methods.go create mode 100644 vendor/github.com/go-json-experiment/json/arshal_time.go create mode 100644 vendor/github.com/go-json-experiment/json/doc.go create mode 100644 vendor/github.com/go-json-experiment/json/errors.go create mode 100644 vendor/github.com/go-json-experiment/json/fields.go create mode 100644 vendor/github.com/go-json-experiment/json/fold.go create mode 100644 vendor/github.com/go-json-experiment/json/intern.go create mode 100644 vendor/github.com/go-json-experiment/json/internal/internal.go create mode 100644 vendor/github.com/go-json-experiment/json/internal/jsonflags/flags.go create mode 100644 vendor/github.com/go-json-experiment/json/internal/jsonopts/options.go create mode 100644 vendor/github.com/go-json-experiment/json/internal/jsonwire/decode.go create mode 100644 vendor/github.com/go-json-experiment/json/internal/jsonwire/encode.go create mode 100644 vendor/github.com/go-json-experiment/json/internal/jsonwire/wire.go create mode 100644 vendor/github.com/go-json-experiment/json/jsontext/alias.go create mode 100644 vendor/github.com/go-json-experiment/json/jsontext/decode.go create mode 100644 vendor/github.com/go-json-experiment/json/jsontext/doc.go create mode 100644 vendor/github.com/go-json-experiment/json/jsontext/encode.go create mode 100644 vendor/github.com/go-json-experiment/json/jsontext/errors.go create mode 100644 vendor/github.com/go-json-experiment/json/jsontext/export.go create mode 100644 vendor/github.com/go-json-experiment/json/jsontext/options.go create mode 100644 vendor/github.com/go-json-experiment/json/jsontext/pools.go create mode 100644 vendor/github.com/go-json-experiment/json/jsontext/quote.go create mode 100644 vendor/github.com/go-json-experiment/json/jsontext/state.go create mode 100644 vendor/github.com/go-json-experiment/json/jsontext/token.go create mode 100644 vendor/github.com/go-json-experiment/json/jsontext/value.go create mode 100644 vendor/github.com/go-json-experiment/json/migrate.sh create mode 100644 vendor/github.com/go-json-experiment/json/options.go diff --git a/Makefile b/Makefile index dbcf795..c478ccc 100644 --- a/Makefile +++ b/Makefile @@ -4,8 +4,6 @@ FLAGS = -ldflags "\ -X github.com/fulldump/inceptiondb/bootstrap.VERSION=$(VERSION) \ " -export GOEXPERIMENT=jsonv2 - test: go test -cover ./... diff --git a/cmd/bench/README.md b/cmd/bench/README.md index 2c174a6..69e70bb 100644 --- a/cmd/bench/README.md +++ b/cmd/bench/README.md @@ -7,11 +7,11 @@ Compile and run the command. ## Test inserts ```sh -GOEXPERIMENT=jsonv2 go run . --test insert --n 2_000_000 --workers 16 +go run . --test insert --n 2_000_000 --workers 16 ``` ## Test patch ```sh -GOEXPERIMENT=jsonv2 go run . --test patch --n 100_000 --workers 16 -``` \ No newline at end of file +go run . --test patch --n 100_000 --workers 16 +``` diff --git a/collection/collection.go b/collection/collection.go index c9fe682..aa64340 100644 --- a/collection/collection.go +++ b/collection/collection.go @@ -4,8 +4,6 @@ import ( "bufio" "bytes" "encoding/json" - "encoding/json/jsontext" - json2 "encoding/json/v2" "fmt" "io" "os" @@ -14,6 +12,9 @@ import ( "sync/atomic" "time" + json2 "github.com/go-json-experiment/json" + "github.com/go-json-experiment/json/jsontext" + "github.com/google/uuid" "github.com/fulldump/inceptiondb/utils" diff --git a/go.mod b/go.mod index a517664..10bac91 100644 --- a/go.mod +++ b/go.mod @@ -8,6 +8,7 @@ require ( github.com/fulldump/biff v1.3.0 github.com/fulldump/box v0.7.0 github.com/fulldump/goconfig v1.7.1 + github.com/go-json-experiment/json v0.0.0-20250910080747-cc2cfa0554c3 github.com/google/btree v1.1.3 github.com/google/uuid v1.6.0 ) diff --git a/go.sum b/go.sum index 6d18100..f3dc3ba 100644 --- a/go.sum +++ b/go.sum @@ -9,6 +9,8 @@ github.com/fulldump/box v0.7.0 h1:aaGVNDmEOzizQ+U9bLtL8ST7RA5mjpT9i9q9h84GgoE= github.com/fulldump/box v0.7.0/go.mod h1:k1dcwIeNOar6zLlP9D8oF/4FjQeK8kAt7BtRUh/SrMg= github.com/fulldump/goconfig v1.7.1 h1:KTaig5QRf7ysL/0Om1q+J4OyMXbtsg+nonPY5SB+DUg= github.com/fulldump/goconfig v1.7.1/go.mod h1:qsSyOhlzhYkL2dJ3KWKxs1hX3Qv58Jzj8pRsIEkHmUY= +github.com/go-json-experiment/json v0.0.0-20250910080747-cc2cfa0554c3 h1:02WINGfSX5w0Mn+F28UyRoSt9uvMhKguwWMlOAh6U/0= +github.com/go-json-experiment/json v0.0.0-20250910080747-cc2cfa0554c3/go.mod h1:uNVvRXArCGbZ508SxYYTC5v1JWoz2voff5pm25jU1Ok= github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/google/btree v1.1.3 h1:CVpQJjYgC4VbzxeGVHfvZrv1ctoYCAI8vbl07Fcxlyg= github.com/google/btree v1.1.3/go.mod h1:qOPhT0dTNdNzV6Z/lhRX0YXUafgPLFUh+gZMl761Gm4= diff --git a/vendor/github.com/go-json-experiment/json/AUTHORS b/vendor/github.com/go-json-experiment/json/AUTHORS new file mode 100644 index 0000000..2b00ddb --- /dev/null +++ b/vendor/github.com/go-json-experiment/json/AUTHORS @@ -0,0 +1,3 @@ +# This source code refers to The Go Authors for copyright purposes. +# The master list of authors is in the main Go distribution, +# visible at https://tip.golang.org/AUTHORS. diff --git a/vendor/github.com/go-json-experiment/json/CONTRIBUTORS b/vendor/github.com/go-json-experiment/json/CONTRIBUTORS new file mode 100644 index 0000000..1fbd3e9 --- /dev/null +++ b/vendor/github.com/go-json-experiment/json/CONTRIBUTORS @@ -0,0 +1,3 @@ +# This source code was written by the Go contributors. +# The master list of contributors is in the main Go distribution, +# visible at https://tip.golang.org/CONTRIBUTORS. diff --git a/vendor/github.com/go-json-experiment/json/LICENSE b/vendor/github.com/go-json-experiment/json/LICENSE new file mode 100644 index 0000000..2441273 --- /dev/null +++ b/vendor/github.com/go-json-experiment/json/LICENSE @@ -0,0 +1,27 @@ +Copyright (c) 2020 The Go Authors. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/vendor/github.com/go-json-experiment/json/README.md b/vendor/github.com/go-json-experiment/json/README.md new file mode 100644 index 0000000..937c398 --- /dev/null +++ b/vendor/github.com/go-json-experiment/json/README.md @@ -0,0 +1,175 @@ +# JSON Serialization (v2) + +[![GoDev](https://img.shields.io/static/v1?label=godev&message=reference&color=00add8)](https://pkg.go.dev/github.com/go-json-experiment/json) +[![Build Status](https://github.com/go-json-experiment/json/actions/workflows/test.yml/badge.svg?branch=master)](https://github.com/go-json-experiment/json/actions) + +This module hosts an experimental implementation of v2 `encoding/json`. +The API is unstable and breaking changes will regularly be made. +Do not depend on this in publicly available modules. + +Any commits that make breaking API or behavior changes will be marked +with the string "WARNING: " near the top of the commit message. +It is your responsibility to inspect the list of commit changes +when upgrading the module. Not all breaking changes will lead to build failures. + +A [proposal to include this module in Go as `encoding/json/v2` and `encoding/json/jsontext`](https://github.com/golang/go/issues/71497) has been started on the Go Github project on 2025-01-30. Please provide your feedback there. + +## Goals and objectives + +* **Mostly backwards compatible:** If possible, v2 should aim to be _mostly_ +compatible with v1 in terms of both API and default behavior to ease migration. +For example, the `Marshal` and `Unmarshal` functions are the most widely used +declarations in the v1 package. It seems sensible for equivalent functionality +in v2 to be named the same and have a mostly compatible signature. +Behaviorally, we should aim for 95% to 99% backwards compatibility. +We do not aim for 100% compatibility since we want the freedom to break +certain behaviors that are now considered to have been a mistake. +Options exist that can bring the v2 implementation to 100% compatibility, +but it will not be the default. + +* **More flexible:** There is a +[long list of feature requests](https://github.com/golang/go/issues?q=is%3Aissue+is%3Aopen+encoding%2Fjson+in%3Atitle). +We should aim to provide the most flexible features that addresses most usages. +We do not want to over fit the v2 API to handle every possible use case. +Ideally, the features provided should be orthogonal in nature such that +any combination of features results in as few surprising edge cases as possible. + +* **More performant:** JSON serialization is widely used and any bit of extra +performance gains will be greatly appreciated. Some rarely used behaviors of v1 +may be dropped in favor of better performance. For example, +despite `Encoder` and `Decoder` operating on an `io.Writer` and `io.Reader`, +they do not operate in a truly streaming manner, +leading to a loss in performance. The v2 implementation should aim to be truly +streaming by default (see [#33714](https://golang.org/issue/33714)). + +* **Easy to use (hard to misuse):** The v2 API should aim to make +the common case easy and the less common case at least possible. +The API should avoid behavior that goes contrary to user expectation, +which may result in subtle bugs (see [#36225](https://golang.org/issue/36225)). + +* **v1 and v2 maintainability:** Since the v1 implementation must stay forever, +it would be beneficial if v1 could be implemented under the hood with v2, +allowing for less maintenance burden in the future. This probably implies that +behavioral changes in v2 relative to v1 need to be exposed as options. + +* **Avoid unsafe:** Standard library packages generally avoid the use of +package `unsafe` even if it could provide a performance boost. +We aim to preserve this property. + +## Expectations + +While this module aims to possibly be the v2 implementation of `encoding/json`, +there is no guarantee that this outcome will occur. As with any major change +to the Go standard library, this will eventually go through the +[Go proposal process](https://github.com/golang/proposal#readme). +At the present moment, this is still in the design and experimentation phase +and is not ready for a formal proposal. + +There are several possible outcomes from this experiment: +1. We determine that a v2 `encoding/json` would not provide sufficient benefit +over the existing v1 `encoding/json` package. Thus, we abandon this effort. +2. We propose a v2 `encoding/json` design, but it is rejected in favor of some +other design that is considered superior. +3. We propose a v2 `encoding/json` design, but rather than adding an entirely +new v2 `encoding/json` package, we decide to merge its functionality into +the existing v1 `encoding/json` package. +4. We propose a v2 `encoding/json` design and it is accepted, resulting in +its addition to the standard library. +5. Some other unforeseen outcome (among the infinite number of possibilities). + +## Development + +This module is primarily developed by +[@dsnet](https://github.com/dsnet), +[@mvdan](https://github.com/mvdan), and +[@johanbrandhorst](https://github.com/johanbrandhorst) +with feedback provided by +[@rogpeppe](https://github.com/rogpeppe), +[@ChrisHines](https://github.com/ChrisHines), and +[@rsc](https://github.com/rsc). + +Discussion about semantics occur semi-regularly, where a +[record of past meetings can be found here](https://docs.google.com/document/d/1rovrOTd-wTawGMPPlPuKhwXaYBg9VszTXR9AQQL5LfI/edit?usp=sharing). + +## Design overview + +This package aims to provide a clean separation between syntax and semantics. +Syntax deals with the structural representation of JSON (as specified in +[RFC 4627](https://tools.ietf.org/html/rfc4627), +[RFC 7159](https://tools.ietf.org/html/rfc7159), +[RFC 7493](https://tools.ietf.org/html/rfc7493), +[RFC 8259](https://tools.ietf.org/html/rfc8259), and +[RFC 8785](https://tools.ietf.org/html/rfc8785)). +Semantics deals with the meaning of syntactic data as usable application data. + +The `Encoder` and `Decoder` types are streaming tokenizers concerned with the +packing or parsing of JSON data. They operate on `Token` and `Value` types +which represent the common data structures that are representable in JSON. +`Encoder` and `Decoder` do not aim to provide any interpretation of the data. + +Functions like `Marshal`, `MarshalWrite`, `MarshalEncode`, `Unmarshal`, +`UnmarshalRead`, and `UnmarshalDecode` provide semantic meaning by correlating +any arbitrary Go type with some JSON representation of that type (as stored in +data types like `[]byte`, `io.Writer`, `io.Reader`, `Encoder`, or `Decoder`). + +![API overview](api.png) + +This diagram provides a high-level overview of the v2 `json` and `jsontext` packages. +Purple blocks represent types, while blue blocks represent functions or methods. +The arrows and their direction represent the approximate flow of data. +The bottom half of the diagram contains functionality that is only concerned +with syntax (implemented by the `jsontext` package), +while the upper half contains functionality that assigns +semantic meaning to syntactic data handled by the bottom half +(as implemented by the v2 `json` package). + +In contrast to v1 `encoding/json`, options are represented as separate types +rather than being setter methods on the `Encoder` or `Decoder` types. +Some options affects JSON serialization at the syntactic layer, +while others affect it at the semantic layer. +Some options only affect JSON when decoding, +while others affect JSON while encoding. + +## Behavior changes + +The v2 `json` package changes the default behavior of `Marshal` and `Unmarshal` +relative to the v1 `json` package to be more sensible. +Some of these behavior changes have options and workarounds to opt into +behavior similar to what v1 provided. + +This table shows an overview of the changes: + +| v1 | v2 | Details | +| -- | -- | ------- | +| JSON object members are unmarshaled into a Go struct using a **case-insensitive name match**. | JSON object members are unmarshaled into a Go struct using a **case-sensitive name match**. | [CaseSensitivity](/v1/diff_test.go#:~:text=TestCaseSensitivity) | +| When marshaling a Go struct, a struct field marked as `omitempty` is omitted if **the field value is an empty Go value**, which is defined as false, 0, a nil pointer, a nil interface value, and any empty array, slice, map, or string. | When marshaling a Go struct, a struct field marked as `omitempty` is omitted if **the field value would encode as an empty JSON value**, which is defined as a JSON null, or an empty JSON string, object, or array. | [OmitEmptyOption](/v1/diff_test.go#:~:text=TestOmitEmptyOption) | +| The `string` option **does affect** Go strings and bools. | The `string` option **does not affect** Go strings or bools. | [StringOption](/v1/diff_test.go#:~:text=TestStringOption) | +| The `string` option **does not recursively affect** sub-values of the Go field value. | The `string` option **does recursively affect** sub-values of the Go field value. | [StringOption](/v1/diff_test.go#:~:text=TestStringOption) | +| The `string` option **sometimes accepts** a JSON null escaped within a JSON string. | The `string` option **never accepts** a JSON null escaped within a JSON string. | [StringOption](/v1/diff_test.go#:~:text=TestStringOption) | +| A nil Go slice is marshaled as a **JSON null**. | A nil Go slice is marshaled as an **empty JSON array**. | [NilSlicesAndMaps](/v1/diff_test.go#:~:text=TestNilSlicesAndMaps) | +| A nil Go map is marshaled as a **JSON null**. | A nil Go map is marshaled as an **empty JSON object**. | [NilSlicesAndMaps](/v1/diff_test.go#:~:text=TestNilSlicesAndMaps) | +| A Go array may be unmarshaled from a **JSON array of any length**. | A Go array must be unmarshaled from a **JSON array of the same length**. | [Arrays](/v1/diff_test.go#:~:text=Arrays) | +| A Go byte array is represented as a **JSON array of JSON numbers**. | A Go byte array is represented as a **Base64-encoded JSON string**. | [ByteArrays](/v1/diff_test.go#:~:text=TestByteArrays) | +| `MarshalJSON` and `UnmarshalJSON` methods declared on a pointer receiver are **inconsistently called**. | `MarshalJSON` and `UnmarshalJSON` methods declared on a pointer receiver are **consistently called**. | [PointerReceiver](/v1/diff_test.go#:~:text=TestPointerReceiver) | +| A Go map is marshaled in a **deterministic order**. | A Go map is marshaled in a **non-deterministic order**. | [MapDeterminism](/v1/diff_test.go#:~:text=TestMapDeterminism) | +| JSON strings are encoded **with HTML-specific characters being escaped**. | JSON strings are encoded **without any characters being escaped** (unless necessary). | [EscapeHTML](/v1/diff_test.go#:~:text=TestEscapeHTML) | +| When marshaling, invalid UTF-8 within a Go string **are silently replaced**. | When marshaling, invalid UTF-8 within a Go string **results in an error**. | [InvalidUTF8](/v1/diff_test.go#:~:text=TestInvalidUTF8) | +| When unmarshaling, invalid UTF-8 within a JSON string **are silently replaced**. | When unmarshaling, invalid UTF-8 within a JSON string **results in an error**. | [InvalidUTF8](/v1/diff_test.go#:~:text=TestInvalidUTF8) | +| When marshaling, **an error does not occur** if the output JSON value contains objects with duplicate names. | When marshaling, **an error does occur** if the output JSON value contains objects with duplicate names. | [DuplicateNames](/v1/diff_test.go#:~:text=TestDuplicateNames) | +| When unmarshaling, **an error does not occur** if the input JSON value contains objects with duplicate names. | When unmarshaling, **an error does occur** if the input JSON value contains objects with duplicate names. | [DuplicateNames](/v1/diff_test.go#:~:text=TestDuplicateNames) | +| Unmarshaling a JSON null into a non-empty Go value **inconsistently clears the value or does nothing**. | Unmarshaling a JSON null into a non-empty Go value **always clears the value**. | [MergeNull](/v1/diff_test.go#:~:text=TestMergeNull) | +| Unmarshaling a JSON value into a non-empty Go value **follows inconsistent and bizarre behavior**. | Unmarshaling a JSON value into a non-empty Go value **always merges if the input is an object, and otherwise replaces**. | [MergeComposite](/v1/diff_test.go#:~:text=TestMergeComposite) | +| A `time.Duration` is represented as a **JSON number containing the decimal number of nanoseconds**. | A `time.Duration` has no default representation in v2 (see [#71631](https://golang.org/issue/71631)) and results in an error. | | +| A Go struct with only unexported fields **can be serialized**. | A Go struct with only unexported fields **cannot be serialized**. | [EmptyStructs](/v1/diff_test.go#:~:text=TestEmptyStructs) | + +See [diff_test.go](/v1/diff_test.go) for details about every change. + +## Performance + +One of the goals of the v2 module is to be more performant than v1, +but not at the expense of correctness. +In general, v2 is at performance parity with v1 for marshaling, +but dramatically faster for unmarshaling. + +See https://github.com/go-json-experiment/jsonbench for benchmarks +comparing v2 with v1 and a number of other popular JSON implementations. diff --git a/vendor/github.com/go-json-experiment/json/alias.go b/vendor/github.com/go-json-experiment/json/alias.go new file mode 100644 index 0000000..e239118 --- /dev/null +++ b/vendor/github.com/go-json-experiment/json/alias.go @@ -0,0 +1,1008 @@ +// Copyright 2025 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. + +// Code generated by alias_gen.go; DO NOT EDIT. + +//go:build goexperiment.jsonv2 && go1.25 + +// Package json implements semantic processing of JSON as specified in RFC 8259. +// JSON is a simple data interchange format that can represent +// primitive data types such as booleans, strings, and numbers, +// in addition to structured data types such as objects and arrays. +// +// [Marshal] and [Unmarshal] encode and decode Go values +// to/from JSON text contained within a []byte. +// [MarshalWrite] and [UnmarshalRead] operate on JSON text +// by writing to or reading from an [io.Writer] or [io.Reader]. +// [MarshalEncode] and [UnmarshalDecode] operate on JSON text +// by encoding to or decoding from a [jsontext.Encoder] or [jsontext.Decoder]. +// [Options] may be passed to each of the marshal or unmarshal functions +// to configure the semantic behavior of marshaling and unmarshaling +// (i.e., alter how JSON data is understood as Go data and vice versa). +// [jsontext.Options] may also be passed to the marshal or unmarshal functions +// to configure the syntactic behavior of encoding or decoding. +// +// The data types of JSON are mapped to/from the data types of Go based on +// the closest logical equivalent between the two type systems. For example, +// a JSON boolean corresponds with a Go bool, +// a JSON string corresponds with a Go string, +// a JSON number corresponds with a Go int, uint or float, +// a JSON array corresponds with a Go slice or array, and +// a JSON object corresponds with a Go struct or map. +// See the documentation on [Marshal] and [Unmarshal] for a comprehensive list +// of how the JSON and Go type systems correspond. +// +// Arbitrary Go types can customize their JSON representation by implementing +// [Marshaler], [MarshalerTo], [Unmarshaler], or [UnmarshalerFrom]. +// This provides authors of Go types with control over how their types are +// serialized as JSON. Alternatively, users can implement functions that match +// [MarshalFunc], [MarshalToFunc], [UnmarshalFunc], or [UnmarshalFromFunc] +// to specify the JSON representation for arbitrary types. +// This provides callers of JSON functionality with control over +// how any arbitrary type is serialized as JSON. +// +// # JSON Representation of Go structs +// +// A Go struct is naturally represented as a JSON object, +// where each Go struct field corresponds with a JSON object member. +// When marshaling, all Go struct fields are recursively encoded in depth-first +// order as JSON object members except those that are ignored or omitted. +// When unmarshaling, JSON object members are recursively decoded +// into the corresponding Go struct fields. +// Object members that do not match any struct fields, +// also known as “unknown members”, are ignored by default or rejected +// if [RejectUnknownMembers] is specified. +// +// The representation of each struct field can be customized in the +// "json" struct field tag, where the tag is a comma separated list of options. +// As a special case, if the entire tag is `json:"-"`, +// then the field is ignored with regard to its JSON representation. +// Some options also have equivalent behavior controlled by a caller-specified [Options]. +// Field-specified options take precedence over caller-specified options. +// +// The first option is the JSON object name override for the Go struct field. +// If the name is not specified, then the Go struct field name +// is used as the JSON object name. JSON names containing commas or quotes, +// or names identical to "" or "-", can be specified using +// a single-quoted string literal, where the syntax is identical to +// the Go grammar for a double-quoted string literal, +// but instead uses single quotes as the delimiters. +// By default, unmarshaling uses case-sensitive matching to identify +// the Go struct field associated with a JSON object name. +// +// After the name, the following tag options are supported: +// +// - omitzero: When marshaling, the "omitzero" option specifies that +// the struct field should be omitted if the field value is zero +// as determined by the "IsZero() bool" method if present, +// otherwise based on whether the field is the zero Go value. +// This option has no effect when unmarshaling. +// +// - omitempty: When marshaling, the "omitempty" option specifies that +// the struct field should be omitted if the field value would have been +// encoded as a JSON null, empty string, empty object, or empty array. +// This option has no effect when unmarshaling. +// +// - string: The "string" option specifies that [StringifyNumbers] +// be set when marshaling or unmarshaling a struct field value. +// This causes numeric types to be encoded as a JSON number +// within a JSON string, and to be decoded from a JSON string +// containing the JSON number without any surrounding whitespace. +// This extra level of encoding is often necessary since +// many JSON parsers cannot precisely represent 64-bit integers. +// +// - case: When unmarshaling, the "case" option specifies how +// JSON object names are matched with the JSON name for Go struct fields. +// The option is a key-value pair specified as "case:value" where +// the value must either be 'ignore' or 'strict'. +// The 'ignore' value specifies that matching is case-insensitive +// where dashes and underscores are also ignored. If multiple fields match, +// the first declared field in breadth-first order takes precedence. +// The 'strict' value specifies that matching is case-sensitive. +// This takes precedence over the [MatchCaseInsensitiveNames] option. +// +// - inline: The "inline" option specifies that +// the JSON representable content of this field type is to be promoted +// as if they were specified in the parent struct. +// It is the JSON equivalent of Go struct embedding. +// A Go embedded field is implicitly inlined unless an explicit JSON name +// is specified. The inlined field must be a Go struct +// (that does not implement any JSON methods), [jsontext.Value], +// map[~string]T, or an unnamed pointer to such types. When marshaling, +// inlined fields from a pointer type are omitted if it is nil. +// Inlined fields of type [jsontext.Value] and map[~string]T are called +// “inlined fallbacks” as they can represent all possible +// JSON object members not directly handled by the parent struct. +// Only one inlined fallback field may be specified in a struct, +// while many non-fallback fields may be specified. This option +// must not be specified with any other option (including the JSON name). +// +// - unknown: The "unknown" option is a specialized variant +// of the inlined fallback to indicate that this Go struct field +// contains any number of unknown JSON object members. The field type must +// be a [jsontext.Value], map[~string]T, or an unnamed pointer to such types. +// If [DiscardUnknownMembers] is specified when marshaling, +// the contents of this field are ignored. +// If [RejectUnknownMembers] is specified when unmarshaling, +// any unknown object members are rejected regardless of whether +// an inlined fallback with the "unknown" option exists. This option +// must not be specified with any other option (including the JSON name). +// +// - format: The "format" option 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. +// +// The "omitzero" and "omitempty" options are mostly semantically identical. +// The former is defined in terms of the Go type system, +// while the latter in terms of the JSON type system. +// Consequently they behave differently in some circumstances. +// For example, only a nil slice or map is omitted under "omitzero", while +// an empty slice or map is omitted under "omitempty" regardless of nilness. +// The "omitzero" option is useful for types with a well-defined zero value +// (e.g., [net/netip.Addr]) or have an IsZero method (e.g., [time.Time.IsZero]). +// +// Every Go struct corresponds to a list of JSON representable fields +// which is constructed by performing a breadth-first search over +// all struct fields (excluding unexported or ignored fields), +// where the search recursively descends into inlined structs. +// The set of non-inlined fields in a struct must have unique JSON names. +// If multiple fields all have the same JSON name, then the one +// at shallowest depth takes precedence and the other fields at deeper depths +// are excluded from the list of JSON representable fields. +// If multiple fields at the shallowest depth have the same JSON name, +// but exactly one is explicitly tagged with a JSON name, +// then that field takes precedence and all others are excluded from the list. +// This is analogous to Go visibility rules for struct field selection +// with embedded struct types. +// +// Marshaling or unmarshaling a non-empty struct +// without any JSON representable fields results in a [SemanticError]. +// Unexported fields must not have any `json` tags except for `json:"-"`. +// +// # Security Considerations +// +// JSON is frequently used as a data interchange format to communicate +// between different systems, possibly implemented in different languages. +// For interoperability and security reasons, it is important that +// all implementations agree upon the semantic meaning of the data. +// +// [For example, suppose we have two micro-services.] +// The first service is responsible for authenticating a JSON request, +// while the second service is responsible for executing the request +// (having assumed that the prior service authenticated the request). +// If an attacker were able to maliciously craft a JSON request such that +// both services believe that the same request is from different users, +// it could bypass the authenticator with valid credentials for one user, +// but maliciously perform an action on behalf of a different user. +// +// According to RFC 8259, there unfortunately exist many JSON texts +// that are syntactically valid but semantically ambiguous. +// For example, the standard does not define how to interpret duplicate +// names within an object. +// +// The v1 [encoding/json] and [encoding/json/v2] packages +// interpret some inputs in different ways. In particular: +// +// - The standard specifies that JSON must be encoded using UTF-8. +// By default, v1 replaces invalid bytes of UTF-8 in JSON strings +// with the Unicode replacement character, +// while v2 rejects inputs with invalid UTF-8. +// To change the default, specify the [jsontext.AllowInvalidUTF8] option. +// The replacement of invalid UTF-8 is a form of data corruption +// that alters the precise meaning of strings. +// +// - The standard does not specify a particular behavior when +// duplicate names are encountered within a JSON object, +// which means that different implementations may behave differently. +// By default, v1 allows for the presence of duplicate names, +// while v2 rejects duplicate names. +// To change the default, specify the [jsontext.AllowDuplicateNames] option. +// If allowed, object members are processed in the order they are observed, +// meaning that later values will replace or be merged into prior values, +// depending on the Go value type. +// +// - The standard defines a JSON object as an unordered collection of name/value pairs. +// While ordering can be observed through the underlying [jsontext] API, +// both v1 and v2 generally avoid exposing the ordering. +// No application should semantically depend on the order of object members. +// Allowing duplicate names is a vector through which ordering of members +// can accidentally be observed and depended upon. +// +// - The standard suggests that JSON object names are typically compared +// based on equality of the sequence of Unicode code points, +// which implies that comparing names is often case-sensitive. +// When unmarshaling a JSON object into a Go struct, +// by default, v1 uses a (loose) case-insensitive match on the name, +// while v2 uses a (strict) case-sensitive match on the name. +// To change the default, specify the [MatchCaseInsensitiveNames] option. +// The use of case-insensitive matching provides another vector through +// which duplicate names can occur. Allowing case-insensitive matching +// means that v1 or v2 might interpret JSON objects differently from most +// other JSON implementations (which typically use a case-sensitive match). +// +// - The standard does not specify a particular behavior when +// an unknown name in a JSON object is encountered. +// When unmarshaling a JSON object into a Go struct, by default +// both v1 and v2 ignore unknown names and their corresponding values. +// To change the default, specify the [RejectUnknownMembers] option. +// +// - The standard suggests that implementations may use a float64 +// to represent a JSON number. Consequently, large JSON integers +// may lose precision when stored as a floating-point type. +// Both v1 and v2 correctly preserve precision when marshaling and +// unmarshaling a concrete integer type. However, even if v1 and v2 +// preserve precision for concrete types, other JSON implementations +// may not be able to preserve precision for outputs produced by v1 or v2. +// The `string` tag option can be used to specify that an integer type +// is to be quoted within a JSON string to avoid loss of precision. +// Furthermore, v1 and v2 may still lose precision when unmarshaling +// into an any interface value, where unmarshal uses a float64 +// by default to represent a JSON number. +// To change the default, specify the [WithUnmarshalers] option +// with a custom unmarshaler that pre-populates the interface value +// with a concrete Go type that can preserve precision. +// +// RFC 8785 specifies a canonical form for any JSON text, +// which explicitly defines specific behaviors that RFC 8259 leaves undefined. +// In theory, if a text can successfully [jsontext.Value.Canonicalize] +// without changing the semantic meaning of the data, then it provides a +// greater degree of confidence that the data is more secure and interoperable. +// +// The v2 API generally chooses more secure defaults than v1, +// but care should still be taken with large integers or unknown members. +// +// [For example, suppose we have two micro-services.]: https://www.youtube.com/watch?v=avilmOcHKHE&t=1057s +package json + +import ( + "encoding/json/jsontext" + "encoding/json/v2" + "io" +) + +// Marshal serializes a Go value as a []byte according to the provided +// marshal and encode options (while ignoring unmarshal or decode options). +// It does not terminate the output with a newline. +// +// Type-specific marshal functions and methods take precedence +// over the default representation of a value. +// Functions or methods that operate on *T are only called when encoding +// a value of type T (by taking its address) or a non-nil value of *T. +// Marshal ensures that a value is always addressable +// (by boxing it on the heap if necessary) so that +// these functions and methods can be consistently called. For performance, +// it is recommended that Marshal be passed a non-nil pointer to the value. +// +// The input value is encoded as JSON according the following rules: +// +// - If any type-specific functions in a [WithMarshalers] option match +// the value type, then those functions are called to encode the value. +// If all applicable functions return [SkipFunc], +// then the value is encoded according to subsequent rules. +// +// - If the value type implements [MarshalerTo], +// then the MarshalJSONTo method is called to encode the value. +// +// - If the value type implements [Marshaler], +// then the MarshalJSON method is called to encode the value. +// +// - If the value type implements [encoding.TextAppender], +// then the AppendText method is called to encode the value and +// subsequently encode its result as a JSON string. +// +// - If the value type implements [encoding.TextMarshaler], +// then the MarshalText method is called to encode the value and +// subsequently encode its result as a JSON string. +// +// - Otherwise, the value is encoded according to the value's type +// as described in detail below. +// +// Most Go types have a default JSON representation. +// Certain types support specialized formatting according to +// a format flag optionally specified in the Go struct tag +// for the struct field that contains the current value +// (see the “JSON Representation of Go structs” section for more details). +// +// The representation of each type is as follows: +// +// - A Go boolean is encoded as a JSON boolean (e.g., true or false). +// It does not support any custom format flags. +// +// - A Go string is encoded as a JSON string. +// It does not support any custom format flags. +// +// - A Go []byte or [N]byte is encoded 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 encoded as a JSON array +// where each byte is recursively JSON-encoded as each JSON array element. +// +// - A Go integer is encoded as a JSON number without fractions or exponents. +// If [StringifyNumbers] is specified or encoding a JSON object name, +// then the JSON number is encoded within a JSON string. +// It does not support any custom format flags. +// +// - A Go float is encoded as a JSON number. +// If [StringifyNumbers] is specified or encoding a JSON object name, +// then the JSON number is encoded within a JSON string. +// If the format is "nonfinite", then NaN, +Inf, and -Inf are encoded as +// the JSON strings "NaN", "Infinity", and "-Infinity", respectively. +// Otherwise, the presence of non-finite numbers results in a [SemanticError]. +// +// - A Go map is encoded as a JSON object, where each Go map key and value +// is recursively encoded as a name and value pair in the JSON object. +// The Go map key must encode as a JSON string, otherwise this results +// in a [SemanticError]. The Go map is traversed in a non-deterministic order. +// For deterministic encoding, consider using the [Deterministic] option. +// 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. +// Otherwise by default, a nil map is encoded as an empty JSON object. +// +// - A Go struct is encoded as a JSON object. +// See the “JSON Representation of Go structs” section +// in the package-level documentation for more details. +// +// - A Go slice is encoded as a JSON array, where each Go slice element +// is recursively JSON-encoded as the elements of the 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. +// Otherwise by default, a nil slice is encoded as an empty JSON array. +// +// - A Go array is encoded as a JSON array, where each Go array element +// is recursively JSON-encoded as the elements of the JSON array. +// The JSON array length is always identical to the Go array length. +// It does not support any custom format flags. +// +// - A Go pointer is encoded as a JSON null if nil, otherwise it is +// the recursively JSON-encoded representation of the underlying value. +// Format flags are forwarded to the encoding of the underlying value. +// +// - A Go interface is encoded as a JSON null if nil, otherwise it is +// the recursively JSON-encoded representation of the underlying value. +// It does not support any custom format flags. +// +// - A Go [time.Time] is encoded 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 encoded 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, round the timestamp to the relevant unit. +// Otherwise, the format is used as-is with [time.Time.Format] if non-empty. +// +// - A Go [time.Duration] currently has no default representation and +// requires an explicit format to be specified. +// If the format is "sec", "milli", "micro", or "nano", +// then the duration is encoded as a possibly fractional JSON number +// of the number of seconds (or milliseconds, microseconds, or nanoseconds). +// To avoid a fractional component, round the duration to the relevant unit. +// If the format is "units", it is encoded as a JSON string formatted using +// [time.Duration.String] (e.g., "1h30m" for 1 hour 30 minutes). +// If the format is "iso8601", it is encoded 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. +// +// - All other Go types (e.g., complex numbers, channels, and functions) +// have no default representation and result in a [SemanticError]. +// +// JSON cannot represent cyclic data structures and Marshal does not handle them. +// Passing cyclic structures will result in an error. +func Marshal(in any, opts ...Options) (out []byte, err error) { + return json.Marshal(in, opts...) +} + +// MarshalWrite serializes a Go value into an [io.Writer] according to the provided +// marshal and encode options (while ignoring unmarshal or decode options). +// It does not terminate the output with a newline. +// See [Marshal] for details about the conversion of a Go value into JSON. +func MarshalWrite(out io.Writer, in any, opts ...Options) (err error) { + return json.MarshalWrite(out, in, opts...) +} + +// MarshalEncode serializes a Go value into an [jsontext.Encoder] according to +// the provided marshal options (while ignoring unmarshal, encode, or decode options). +// Any marshal-relevant options already specified on the [jsontext.Encoder] +// take lower precedence than the set of options provided by the caller. +// Unlike [Marshal] and [MarshalWrite], encode options are ignored because +// they must have already been specified on the provided [jsontext.Encoder]. +// +// See [Marshal] for details about the conversion of a Go value into JSON. +func MarshalEncode(out *jsontext.Encoder, in any, opts ...Options) (err error) { + return json.MarshalEncode(out, in, opts...) +} + +// Unmarshal decodes a []byte input into a Go value according to the provided +// unmarshal and decode options (while ignoring marshal or encode options). +// The input must be a single JSON value with optional whitespace interspersed. +// The output must be a non-nil pointer. +// +// Type-specific unmarshal functions and methods take precedence +// over the default representation of a value. +// Functions or methods that operate on *T are only called when decoding +// a value of type T (by taking its address) or a non-nil value of *T. +// Unmarshal ensures that a value is always addressable +// (by boxing it on the heap if necessary) so that +// these functions and methods can be consistently called. +// +// The input is decoded into the output according the following rules: +// +// - If any type-specific functions in a [WithUnmarshalers] option match +// the value type, then those functions are called to decode the JSON +// value. If all applicable functions return [SkipFunc], +// then the input is decoded according to subsequent rules. +// +// - If the value type implements [UnmarshalerFrom], +// then the UnmarshalJSONFrom method is called to decode the JSON value. +// +// - If the value type implements [Unmarshaler], +// then the UnmarshalJSON method is called to decode the JSON value. +// +// - If the value type implements [encoding.TextUnmarshaler], +// then the input is decoded as a JSON string and +// the UnmarshalText method is called with the decoded string value. +// This fails with a [SemanticError] if the input is not a JSON string. +// +// - Otherwise, the JSON value is decoded according to the value's type +// as described in detail below. +// +// Most Go types have a default JSON representation. +// Certain types support specialized formatting according to +// a format flag optionally specified in the Go struct tag +// for the struct field that contains the current value +// (see the “JSON Representation of Go structs” section for more details). +// A JSON null may be decoded into every supported Go value where +// it is equivalent to storing the zero value of the Go value. +// If the input JSON kind is not handled by the current Go value type, +// then this fails with a [SemanticError]. Unless otherwise specified, +// the decoded value replaces any pre-existing value. +// +// The representation of each type is as follows: +// +// - A Go boolean is decoded from a JSON boolean (e.g., true or false). +// It does not support any custom format flags. +// +// - A Go string is decoded from a JSON string. +// It does not support any custom format flags. +// +// - A Go []byte or [N]byte is decoded from 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 Go slice or array is decoded from a +// JSON array where each JSON element is recursively decoded for each byte. +// When decoding into a non-nil []byte, the slice length is reset to zero +// and the decoded input is appended to it. +// When decoding into a [N]byte, the input must decode to exactly N bytes, +// otherwise it fails with a [SemanticError]. +// +// - A Go integer is decoded from a JSON number. +// It must be decoded from a JSON string containing a JSON number +// if [StringifyNumbers] is specified or decoding a JSON object name. +// It fails with a [SemanticError] if the JSON number +// has a fractional or exponent component. +// It also fails if it overflows the representation of the Go integer type. +// It does not support any custom format flags. +// +// - A Go float is decoded from a JSON number. +// It must be decoded from a JSON string containing a JSON number +// if [StringifyNumbers] is specified or decoding a JSON object name. +// It fails if it overflows the representation of the Go float type. +// If the format is "nonfinite", then the JSON strings +// "NaN", "Infinity", and "-Infinity" are decoded as NaN, +Inf, and -Inf. +// Otherwise, the presence of such strings results in a [SemanticError]. +// +// - A Go map is decoded from a JSON object, +// where each JSON object name and value pair is recursively decoded +// as the Go map key and value. Maps are not cleared. +// If the Go map is nil, then a new map is allocated to decode into. +// If the decoded key matches an existing Go map entry, the entry value +// is reused by decoding the JSON object value into it. +// The formats "emitnull" and "emitempty" have no effect when decoding. +// +// - A Go struct is decoded from a JSON object. +// See the “JSON Representation of Go structs” section +// in the package-level documentation for more details. +// +// - A Go slice is decoded from a JSON array, where each JSON element +// is recursively decoded and appended to the Go slice. +// Before appending into a Go slice, a new slice is allocated if it is nil, +// otherwise the slice length is reset to zero. +// The formats "emitnull" and "emitempty" have no effect when decoding. +// +// - A Go array is decoded from a JSON array, where each JSON array element +// is recursively decoded as each corresponding Go array element. +// Each Go array element is zeroed before decoding into it. +// It fails with a [SemanticError] if the JSON array does not contain +// the exact same number of elements as the Go array. +// It does not support any custom format flags. +// +// - A Go pointer is decoded based on the JSON kind and underlying Go type. +// If the input is a JSON null, then this stores a nil pointer. +// Otherwise, it allocates a new underlying value if the pointer is nil, +// and recursively JSON decodes into the underlying value. +// Format flags are forwarded to the decoding of the underlying type. +// +// - A Go interface is decoded based on the JSON kind and underlying Go type. +// If the input is a JSON null, then this stores a nil interface value. +// Otherwise, a nil interface value of an empty interface type is initialized +// with a zero Go bool, string, float64, map[string]any, or []any if the +// input is a JSON boolean, string, number, object, or array, respectively. +// If the interface value is still nil, then this fails with a [SemanticError] +// since decoding could not determine an appropriate Go type to decode into. +// For example, unmarshaling into a nil io.Reader fails since +// there is no concrete type to populate the interface value with. +// Otherwise an underlying value exists and it recursively decodes +// the JSON input into it. It does not support any custom format flags. +// +// - A Go [time.Time] is decoded from a JSON string containing the time +// 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 for parsing. +// If the format is "unix", "unixmilli", "unixmicro", or "unixnano", +// then the timestamp is decoded from an optionally 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. +// Otherwise, the format is used as-is with [time.Time.Parse] if non-empty. +// +// - A Go [time.Duration] currently has no default representation and +// requires an explicit format to be specified. +// If the format is "sec", "milli", "micro", or "nano", +// then the duration is decoded from an optionally fractional JSON number +// of the number of seconds (or milliseconds, microseconds, or nanoseconds). +// If the format is "units", it is decoded from a JSON string parsed using +// [time.ParseDuration] (e.g., "1h30m" for 1 hour 30 minutes). +// If the format is "iso8601", it is decoded from a JSON string using the +// ISO 8601 standard for durations (e.g., "PT1H30M" for 1 hour 30 minutes) +// accepting only accurate units of hours, minutes, or seconds. +// +// - All other Go types (e.g., complex numbers, channels, and functions) +// have no default representation and result in a [SemanticError]. +// +// In general, unmarshaling follows merge semantics (similar to RFC 7396) +// where the decoded Go value replaces the destination value +// for any JSON kind other than an object. +// For JSON objects, the input object is merged into the destination value +// where matching object members recursively apply merge semantics. +func Unmarshal(in []byte, out any, opts ...Options) (err error) { + return json.Unmarshal(in, out, opts...) +} + +// UnmarshalRead deserializes a Go value from an [io.Reader] according to the +// provided unmarshal and decode options (while ignoring marshal or encode options). +// The input must be a single JSON value with optional whitespace interspersed. +// It consumes the entirety of [io.Reader] until [io.EOF] is encountered, +// without reporting an error for EOF. The output must be a non-nil pointer. +// See [Unmarshal] for details about the conversion of JSON into a Go value. +func UnmarshalRead(in io.Reader, out any, opts ...Options) (err error) { + return json.UnmarshalRead(in, out, opts...) +} + +// UnmarshalDecode deserializes a Go value from a [jsontext.Decoder] according to +// the provided unmarshal options (while ignoring marshal, encode, or decode options). +// Any unmarshal options already specified on the [jsontext.Decoder] +// take lower precedence than the set of options provided by the caller. +// Unlike [Unmarshal] and [UnmarshalRead], decode options are ignored because +// they must have already been specified on the provided [jsontext.Decoder]. +// +// The input may be a stream of one or more JSON values, +// where this only unmarshals the next JSON value in the stream. +// The output must be a non-nil pointer. +// See [Unmarshal] for details about the conversion of JSON into a Go value. +func UnmarshalDecode(in *jsontext.Decoder, out any, opts ...Options) (err error) { + return json.UnmarshalDecode(in, out, opts...) +} + +// SkipFunc may be returned by [MarshalToFunc] and [UnmarshalFromFunc] functions. +// +// Any function that returns SkipFunc must not cause observable side effects +// on the provided [jsontext.Encoder] or [jsontext.Decoder]. +// For example, it is permissible to call [jsontext.Decoder.PeekKind], +// but not permissible to call [jsontext.Decoder.ReadToken] or +// [jsontext.Encoder.WriteToken] since such methods mutate the state. +var SkipFunc = json.SkipFunc + +// Marshalers is a list of functions that may override the marshal behavior +// of specific types. Populate [WithMarshalers] to use it with +// [Marshal], [MarshalWrite], or [MarshalEncode]. +// A nil *Marshalers is equivalent to an empty list. +// There are no exported fields or methods on Marshalers. +type Marshalers = json.Marshalers + +// JoinMarshalers constructs a flattened list of marshal functions. +// If multiple functions in the list are applicable for a value of a given type, +// then those earlier in the list take precedence over those that come later. +// If a function returns [SkipFunc], then the next applicable function is called, +// otherwise the default marshaling behavior is used. +// +// For example: +// +// m1 := JoinMarshalers(f1, f2) +// m2 := JoinMarshalers(f0, m1, f3) // equivalent to m3 +// m3 := JoinMarshalers(f0, f1, f2, f3) // equivalent to m2 +func JoinMarshalers(ms ...*Marshalers) *Marshalers { + return json.JoinMarshalers(ms...) +} + +// Unmarshalers is a list of functions that may override the unmarshal behavior +// of specific types. Populate [WithUnmarshalers] to use it with +// [Unmarshal], [UnmarshalRead], or [UnmarshalDecode]. +// A nil *Unmarshalers is equivalent to an empty list. +// There are no exported fields or methods on Unmarshalers. +type Unmarshalers = json.Unmarshalers + +// JoinUnmarshalers constructs a flattened list of unmarshal functions. +// If multiple functions in the list are applicable for a value of a given type, +// then those earlier in the list take precedence over those that come later. +// If a function returns [SkipFunc], then the next applicable function is called, +// otherwise the default unmarshaling behavior is used. +// +// For example: +// +// u1 := JoinUnmarshalers(f1, f2) +// u2 := JoinUnmarshalers(f0, u1, f3) // equivalent to u3 +// u3 := JoinUnmarshalers(f0, f1, f2, f3) // equivalent to u2 +func JoinUnmarshalers(us ...*Unmarshalers) *Unmarshalers { + return json.JoinUnmarshalers(us...) +} + +// MarshalFunc constructs a type-specific marshaler that +// specifies how to marshal values of type T. +// T can be any type except a named pointer. +// The function is always provided with a non-nil pointer value +// if T is an interface or pointer type. +// +// The function must marshal exactly one JSON value. +// The value of T must not be retained outside the function call. +// It may not return [SkipFunc]. +func MarshalFunc[T any](fn func(T) ([]byte, error)) *Marshalers { + return json.MarshalFunc[T](fn) +} + +// MarshalToFunc constructs a type-specific marshaler that +// specifies how to marshal values of type T. +// T can be any type except a named pointer. +// The function is always provided with a non-nil pointer value +// if T is an interface or pointer type. +// +// The function must marshal exactly one JSON value by calling write methods +// on the provided encoder. It may return [SkipFunc] such that marshaling can +// move on to the next marshal function. However, no mutable method calls may +// be called on the encoder if [SkipFunc] is returned. +// The pointer to [jsontext.Encoder] and the value of T +// must not be retained outside the function call. +func MarshalToFunc[T any](fn func(*jsontext.Encoder, T) error) *Marshalers { + return json.MarshalToFunc[T](fn) +} + +// UnmarshalFunc constructs a type-specific unmarshaler that +// specifies how to unmarshal values of type T. +// T must be an unnamed pointer or an interface type. +// The function is always provided with a non-nil pointer value. +// +// The function must unmarshal exactly one JSON value. +// The input []byte must not be mutated. +// The input []byte and value T must not be retained outside the function call. +// It may not return [SkipFunc]. +func UnmarshalFunc[T any](fn func([]byte, T) error) *Unmarshalers { + return json.UnmarshalFunc[T](fn) +} + +// UnmarshalFromFunc constructs a type-specific unmarshaler that +// specifies how to unmarshal values of type T. +// T must be an unnamed pointer or an interface type. +// The function is always provided with a non-nil pointer value. +// +// The function must unmarshal exactly one JSON value by calling read methods +// on the provided decoder. It may return [SkipFunc] such that unmarshaling can +// move on to the next unmarshal function. However, no mutable method calls may +// be called on the decoder if [SkipFunc] is returned. +// The pointer to [jsontext.Decoder] and the value of T +// must not be retained outside the function call. +func UnmarshalFromFunc[T any](fn func(*jsontext.Decoder, T) error) *Unmarshalers { + return json.UnmarshalFromFunc[T](fn) +} + +// Marshaler is implemented by types that can marshal themselves. +// It is recommended that types implement [MarshalerTo] unless the implementation +// is trying to avoid a hard dependency on the "jsontext" package. +// +// It is recommended that implementations return a buffer that is safe +// for the caller to retain and potentially mutate. +// +// If the returned error is a [SemanticError], then unpopulated fields +// of the error may be populated by [json] with additional context. +// Errors of other types are wrapped within a [SemanticError]. +type Marshaler = json.Marshaler + +// MarshalerTo is implemented by types that can marshal themselves. +// It is recommended that types implement MarshalerTo instead of [Marshaler] +// since this is both more performant and flexible. +// If a type implements both Marshaler and MarshalerTo, +// then MarshalerTo takes precedence. In such a case, both implementations +// should aim to have equivalent behavior for the default marshal options. +// +// The implementation must write only one JSON value to the Encoder and +// must not retain the pointer to [jsontext.Encoder]. +// +// If the returned error is a [SemanticError], then unpopulated fields +// of the error may be populated by [json] with additional context. +// Errors of other types are wrapped within a [SemanticError], +// unless it is an IO error. +type MarshalerTo = json.MarshalerTo + +// Unmarshaler is implemented by types that can unmarshal themselves. +// It is recommended that types implement [UnmarshalerFrom] unless the implementation +// is trying to avoid a hard dependency on the "jsontext" package. +// +// The input can be assumed to be a valid encoding of a JSON value +// if called from unmarshal functionality in this package. +// UnmarshalJSON must copy the JSON data if it is retained after returning. +// It is recommended that UnmarshalJSON implement merge semantics when +// unmarshaling into a pre-populated value. +// +// Implementations must not retain or mutate the input []byte. +// +// If the returned error is a [SemanticError], then unpopulated fields +// of the error may be populated by [json] with additional context. +// Errors of other types are wrapped within a [SemanticError]. +type Unmarshaler = json.Unmarshaler + +// UnmarshalerFrom is implemented by types that can unmarshal themselves. +// It is recommended that types implement UnmarshalerFrom instead of [Unmarshaler] +// since this is both more performant and flexible. +// If a type implements both Unmarshaler and UnmarshalerFrom, +// then UnmarshalerFrom takes precedence. In such a case, both implementations +// should aim to have equivalent behavior for the default unmarshal options. +// +// The implementation must read only one JSON value from the Decoder. +// It is recommended that UnmarshalJSONFrom implement merge semantics when +// unmarshaling into a pre-populated value. +// +// Implementations must not retain the pointer to [jsontext.Decoder]. +// +// If the returned error is a [SemanticError], then unpopulated fields +// of the error may be populated by [json] with additional context. +// Errors of other types are wrapped within a [SemanticError], +// unless it is a [jsontext.SyntacticError] or an IO error. +type UnmarshalerFrom = json.UnmarshalerFrom + +// ErrUnknownName indicates that a JSON object member could not be +// unmarshaled because the name is not known to the target Go struct. +// This error is directly wrapped within a [SemanticError] when produced. +// +// The name of an unknown JSON object member can be extracted as: +// +// err := ... +// var serr json.SemanticError +// if errors.As(err, &serr) && serr.Err == json.ErrUnknownName { +// ptr := serr.JSONPointer // JSON pointer to unknown name +// name := ptr.LastToken() // unknown name itself +// ... +// } +// +// This error is only returned if [RejectUnknownMembers] is true. +var ErrUnknownName = json.ErrUnknownName + +// SemanticError describes an error determining the meaning +// of JSON data as Go data or vice-versa. +// +// If a [Marshaler], [MarshalerTo], [Unmarshaler], or [UnmarshalerFrom] method +// returns a SemanticError when called by the [json] package, +// then the ByteOffset, JSONPointer, and GoType fields are automatically +// populated by the calling context if they are the zero value. +// +// The contents of this error as produced by this package may change over time. +type SemanticError = json.SemanticError + +// Options configure [Marshal], [MarshalWrite], [MarshalEncode], +// [Unmarshal], [UnmarshalRead], and [UnmarshalDecode] with specific features. +// Each function takes in a variadic list of options, where properties +// set in later options override the value of previously set properties. +// +// The Options type is identical to [encoding/json.Options] and +// [encoding/json/jsontext.Options]. Options from the other packages can +// be used interchangeably with functionality in this package. +// +// Options represent either a singular option or a set of options. +// It can be functionally thought of as a Go map of option properties +// (even though the underlying implementation avoids Go maps for performance). +// +// The constructors (e.g., [Deterministic]) return a singular option value: +// +// opt := Deterministic(true) +// +// which is analogous to creating a single entry map: +// +// opt := Options{"Deterministic": true} +// +// [JoinOptions] composes multiple options values to together: +// +// out := JoinOptions(opts...) +// +// which is analogous to making a new map and copying the options over: +// +// out := make(Options) +// for _, m := range opts { +// for k, v := range m { +// out[k] = v +// } +// } +// +// [GetOption] looks up the value of options parameter: +// +// v, ok := GetOption(opts, Deterministic) +// +// which is analogous to a Go map lookup: +// +// v, ok := Options["Deterministic"] +// +// There is a single Options type, which is used with both marshal and unmarshal. +// Some options affect both operations, while others only affect one operation: +// +// - [StringifyNumbers] affects marshaling and unmarshaling +// - [Deterministic] affects marshaling only +// - [FormatNilSliceAsNull] affects marshaling only +// - [FormatNilMapAsNull] affects marshaling only +// - [OmitZeroStructFields] affects marshaling only +// - [MatchCaseInsensitiveNames] affects marshaling and unmarshaling +// - [DiscardUnknownMembers] affects marshaling only +// - [RejectUnknownMembers] affects unmarshaling only +// - [WithMarshalers] affects marshaling only +// - [WithUnmarshalers] affects unmarshaling only +// +// Options that do not affect a particular operation are ignored. +type Options = json.Options + +// JoinOptions coalesces the provided list of options into a single Options. +// Properties set in later options override the value of previously set properties. +func JoinOptions(srcs ...Options) Options { + return json.JoinOptions(srcs...) +} + +// GetOption returns the value stored in opts with the provided setter, +// reporting whether the value is present. +// +// Example usage: +// +// v, ok := json.GetOption(opts, json.Deterministic) +// +// Options are most commonly introspected to alter the JSON representation of +// [MarshalerTo.MarshalJSONTo] and [UnmarshalerFrom.UnmarshalJSONFrom] methods, and +// [MarshalToFunc] and [UnmarshalFromFunc] functions. +// In such cases, the presence bit should generally be ignored. +func GetOption[T any](opts Options, setter func(T) Options) (T, bool) { + return json.GetOption[T](opts, setter) +} + +// DefaultOptionsV2 is the full set of all options that define v2 semantics. +// It is equivalent to all options under [Options], [encoding/json.Options], +// and [encoding/json/jsontext.Options] being set to false or the zero value, +// except for the options related to whitespace formatting. +func DefaultOptionsV2() Options { + return json.DefaultOptionsV2() +} + +// StringifyNumbers specifies that numeric Go types should be marshaled +// as a JSON string containing the equivalent JSON number value. +// When unmarshaling, numeric Go types are parsed from a JSON string +// containing the JSON number without any surrounding whitespace. +// +// According to RFC 8259, section 6, a JSON implementation may choose to +// limit the representation of a JSON number to an IEEE 754 binary64 value. +// This may cause decoders to lose precision for int64 and uint64 types. +// Quoting JSON numbers as a JSON string preserves the exact precision. +// +// This affects either marshaling or unmarshaling. +func StringifyNumbers(v bool) Options { + return json.StringifyNumbers(v) +} + +// Deterministic specifies that the same input value will be serialized +// as the exact same output bytes. Different processes of +// the same program will serialize equal values to the same bytes, +// but different versions of the same program are not guaranteed +// to produce the exact same sequence of bytes. +// +// This only affects marshaling and is ignored when unmarshaling. +func Deterministic(v bool) Options { + return json.Deterministic(v) +} + +// FormatNilSliceAsNull specifies that a nil Go slice should marshal as a +// JSON null instead of the default representation as an empty JSON array +// (or an empty JSON string in the case of ~[]byte). +// Slice fields explicitly marked with `format:emitempty` still marshal +// as an empty JSON array. +// +// This only affects marshaling and is ignored when unmarshaling. +func FormatNilSliceAsNull(v bool) Options { + return json.FormatNilSliceAsNull(v) +} + +// FormatNilMapAsNull specifies that a nil Go map should marshal as a +// JSON null instead of the default representation as an empty JSON object. +// Map fields explicitly marked with `format:emitempty` still marshal +// as an empty JSON object. +// +// This only affects marshaling and is ignored when unmarshaling. +func FormatNilMapAsNull(v bool) Options { + return json.FormatNilMapAsNull(v) +} + +// OmitZeroStructFields specifies that a Go struct should marshal in such a way +// that all struct fields that are zero are omitted from the marshaled output +// if the value is zero as determined by the "IsZero() bool" method if present, +// otherwise based on whether the field is the zero Go value. +// This is semantically equivalent to specifying the `omitzero` tag option +// on every field in a Go struct. +// +// This only affects marshaling and is ignored when unmarshaling. +func OmitZeroStructFields(v bool) Options { + return json.OmitZeroStructFields(v) +} + +// MatchCaseInsensitiveNames specifies that JSON object members are matched +// against Go struct fields using a case-insensitive match of the name. +// Go struct fields explicitly marked with `case:strict` or `case:ignore` +// always use case-sensitive (or case-insensitive) name matching, +// regardless of the value of this option. +// +// This affects either marshaling or unmarshaling. +// For marshaling, this option may alter the detection of duplicate names +// (assuming [jsontext.AllowDuplicateNames] is false) from inlined fields +// if it matches one of the declared fields in the Go struct. +func MatchCaseInsensitiveNames(v bool) Options { + return json.MatchCaseInsensitiveNames(v) +} + +// DiscardUnknownMembers specifies that marshaling should ignore any +// JSON object members stored in Go struct fields dedicated to storing +// unknown JSON object members. +// +// This only affects marshaling and is ignored when unmarshaling. +func DiscardUnknownMembers(v bool) Options { + return json.DiscardUnknownMembers(v) +} + +// RejectUnknownMembers specifies that unknown members should be rejected +// when unmarshaling a JSON object, regardless of whether there is a field +// to store unknown members. +// +// This only affects unmarshaling and is ignored when marshaling. +func RejectUnknownMembers(v bool) Options { + return json.RejectUnknownMembers(v) +} + +// WithMarshalers specifies a list of type-specific marshalers to use, +// which can be used to override the default marshal behavior for values +// of particular types. +// +// This only affects marshaling and is ignored when unmarshaling. +func WithMarshalers(v *Marshalers) Options { + return json.WithMarshalers(v) +} + +// WithUnmarshalers specifies a list of type-specific unmarshalers to use, +// which can be used to override the default unmarshal behavior for values +// of particular types. +// +// This only affects unmarshaling and is ignored when marshaling. +func WithUnmarshalers(v *Unmarshalers) Options { + return json.WithUnmarshalers(v) +} diff --git a/vendor/github.com/go-json-experiment/json/api.png b/vendor/github.com/go-json-experiment/json/api.png new file mode 100644 index 0000000000000000000000000000000000000000..778b4dbf2fece2c5bce273b7524c920b13d8e73c GIT binary patch literal 154576 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%0Ax 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�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