diff --git a/go.mod b/go.mod
index 66e1c82f4..a26be6f82 100644
--- a/go.mod
+++ b/go.mod
@@ -4,7 +4,7 @@ go 1.26.3
require (
github.com/google/go-containerregistry v0.21.5
- github.com/onsi/gomega v1.42.0
+ github.com/onsi/gomega v1.44.0
github.com/sabhiram/go-gitignore v0.0.0-20210923224102-525f6e181f06
github.com/schollz/progressbar/v3 v3.19.0
github.com/shipwright-io/build v0.20.2
@@ -116,14 +116,14 @@ require (
go.uber.org/multierr v1.11.0 // indirect
go.uber.org/zap v1.28.0 // indirect
go.yaml.in/yaml/v2 v2.4.4 // indirect
- go.yaml.in/yaml/v3 v3.0.4 // indirect
+ go.yaml.in/yaml/v3 v3.0.5 // indirect
golang.org/x/exp v0.0.0-20260410095643-746e56fc9e2f // indirect
- golang.org/x/net v0.55.0 // indirect
+ golang.org/x/net v0.56.0 // indirect
golang.org/x/oauth2 v0.36.0 // indirect
- golang.org/x/sync v0.20.0 // indirect
- golang.org/x/sys v0.45.0 // indirect
- golang.org/x/term v0.43.0 // indirect
- golang.org/x/text v0.37.0 // indirect
+ golang.org/x/sync v0.21.0 // indirect
+ golang.org/x/sys v0.46.0 // indirect
+ golang.org/x/term v0.44.0 // indirect
+ golang.org/x/text v0.38.0 // indirect
golang.org/x/time v0.14.0 // indirect
gomodules.xyz/jsonpatch/v2 v2.5.0 // indirect
google.golang.org/genproto/googleapis/api v0.0.0-20260401024825-9d38bb4040a9 // indirect
diff --git a/go.sum b/go.sum
index d2b8fafbc..96ef5f50e 100644
--- a/go.sum
+++ b/go.sum
@@ -173,8 +173,8 @@ github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq
github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
github.com/onsi/ginkgo/v2 v2.31.0 h1:GtuJos5DFUV9EerYJo8RhYxosYNGvOdDE5haKq6Grfs=
github.com/onsi/ginkgo/v2 v2.31.0/go.mod h1:+aXOY+vzZ5mu2iI2HpTZUPmM//oQfsNFX6gU9kNcA44=
-github.com/onsi/gomega v1.42.0 h1:CJby8u36xb7v34W78F8WKvqTQP7PCMIPB78IVDB73l4=
-github.com/onsi/gomega v1.42.0/go.mod h1:M/Uqpu/8qTjtzCLUA2zJHX9Iilrau25x1PdoSRbWh5A=
+github.com/onsi/gomega v1.44.0 h1:eAiGl3Pw5jz5GQdDff0BcxYpAX1JxW8xD7mFUuwNfZQ=
+github.com/onsi/gomega v1.44.0/go.mod h1:e/C2HwaZ1DhvjzXXuFhcR7hY7Sh9pl7MmoWKEjzwcdA=
github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U=
github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM=
github.com/opencontainers/image-spec v1.1.1 h1:y0fUlFfIZhPF1W537XOLg0/fcx6zcHCJwooC2xJA040=
@@ -208,8 +208,6 @@ github.com/schollz/progressbar/v3 v3.19.0 h1:Ea18xuIRQXLAUidVDox3AbwfUhD0/1Ivohy
github.com/schollz/progressbar/v3 v3.19.0/go.mod h1:IsO3lpbaGuzh8zIMzgY3+J8l4C8GjO0Y9S69eFvNsec=
github.com/sergi/go-diff v1.4.0 h1:n/SP9D5ad1fORl+llWyN+D6qoUETXNZARKjyY2/KVCw=
github.com/sergi/go-diff v1.4.0/go.mod h1:A0bzQcvG0E7Rwjx0REVgAGH58e96+X0MeOfepqsbeW4=
-github.com/shipwright-io/build v0.20.0 h1:gwn7ch4NSNiilMhjK5TosAYbQl6zXS+N77LfaDYzB6Q=
-github.com/shipwright-io/build v0.20.0/go.mod h1:4yGXARV6zi7BJCSaLGjBjFXtwCUqQvm1xfDN9g9dQPI=
github.com/shipwright-io/build v0.20.2 h1:6RS6vhUI4j5aQOin10K3UFDcTVPCEsHeCg+QZFZqK2w=
github.com/shipwright-io/build v0.20.2/go.mod h1:4yGXARV6zi7BJCSaLGjBjFXtwCUqQvm1xfDN9g9dQPI=
github.com/sirupsen/logrus v1.9.4 h1:TsZE7l11zFCLZnZ+teH4Umoq5BhEIfIzfRDZ1Uzql2w=
@@ -273,29 +271,30 @@ go.uber.org/zap v1.28.0 h1:IZzaP1Fv73/T/pBMLk4VutPl36uNC+OSUh3JLG3FIjo=
go.uber.org/zap v1.28.0/go.mod h1:rDLpOi171uODNm/mxFcuYWxDsqWSAVkFdX4XojSKg/Q=
go.yaml.in/yaml/v2 v2.4.4 h1:tuyd0P+2Ont/d6e2rl3be67goVK4R6deVxCUX5vyPaQ=
go.yaml.in/yaml/v2 v2.4.4/go.mod h1:gMZqIpDtDqOfM0uNfy0SkpRhvUryYH0Z6wdMYcacYXQ=
-go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=
go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
+go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw=
+go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg=
golang.org/x/exp v0.0.0-20260410095643-746e56fc9e2f h1:W3F4c+6OLc6H2lb//N1q4WpJkhzJCK5J6kUi1NTVXfM=
golang.org/x/exp v0.0.0-20260410095643-746e56fc9e2f/go.mod h1:J1xhfL/vlindoeF/aINzNzt2Bket5bjo9sdOYzOsU80=
-golang.org/x/mod v0.35.0 h1:Ww1D637e6Pg+Zb2KrWfHQUnH2dQRLBQyAtpr/haaJeM=
-golang.org/x/mod v0.35.0/go.mod h1:+GwiRhIInF8wPm+4AoT6L0FA1QWAad3OMdTRx4tFYlU=
-golang.org/x/net v0.55.0 h1:bcvxaJn3e1U6InsFWt1JUq1aSjnRxLzT2rtD2KfkDF8=
-golang.org/x/net v0.55.0/go.mod h1:L5U2KuzuOe1lY7Z+aWVIKK6qEeJXnXV9yzGA+WCHJww=
+golang.org/x/mod v0.36.0 h1:JJjpVx6myfUsUdAzZuOSTTmRE0PfZeNWzzvKrP7amb4=
+golang.org/x/mod v0.36.0/go.mod h1:moc6ELqsWcOw5Ef3xVprK5ul/MvtVvkIXLziUOICjUQ=
+golang.org/x/net v0.56.0 h1:Rw8j/hFzGvJUZwNBXnAtf5sVDVt+65SK2C7IxCxZt5o=
+golang.org/x/net v0.56.0/go.mod h1:D3Ku6r+V6JROoZK144D2XfMHFcMq/0zSfLelVTCFKec=
golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs=
golang.org/x/oauth2 v0.36.0/go.mod h1:YDBUJMTkDnJS+A4BP4eZBjCqtokkg1hODuPjwiGPO7Q=
-golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=
-golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
+golang.org/x/sync v0.21.0 h1:HLII4xRRTtCRkxYp4HNFF0Js/Og6q2i++KXbg0gHCwM=
+golang.org/x/sync v0.21.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.45.0 h1:dO4czNzziLiiXplLQgBCEpCvXQ3dnkn0SdaZSYdQ+FY=
-golang.org/x/sys v0.45.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
-golang.org/x/term v0.43.0 h1:S4RLU2sB31O/NCl+zFN9Aru9A/Cq2aqKpTZJ6B+DwT4=
-golang.org/x/term v0.43.0/go.mod h1:lrhlHNdQJHO+1qVYiHfFKVuVioJIheAc3fBSMFYEIsk=
-golang.org/x/text v0.37.0 h1:Cqjiwd9eSg8e0QAkyCaQTNHFIIzWtidPahFWR83rTrc=
-golang.org/x/text v0.37.0/go.mod h1:a5sjxXGs9hsn/AJVwuElvCAo9v8QYLzvavO5z2PiM38=
+golang.org/x/sys v0.46.0 h1:noSf2Fq6F8DBgS+LysIkx7rIExoNHJsxOAtPp4rthXw=
+golang.org/x/sys v0.46.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/term v0.44.0 h1:0rLvDRCtNj0gZkyIXhCyOb2OAzEhLVqc4B+hrsBhrmc=
+golang.org/x/term v0.44.0/go.mod h1:7ze4MdzUzLXpSAoFP1H0bOI9aXDqveSvatT5vKcFh2Y=
+golang.org/x/text v0.38.0 h1:sXmwo9DwP3OK9EZ7PqAdaooSGozfl/3a6/xJcbzPRhE=
+golang.org/x/text v0.38.0/go.mod h1:YXZt3QhHUKYT53r2lLKFIVi6Ao1jdzrTR/KQ09qyxF4=
golang.org/x/time v0.14.0 h1:MRx4UaLrDotUKUdCIqzPC48t1Y9hANFKIRpNx+Te8PI=
golang.org/x/time v0.14.0/go.mod h1:eL/Oa2bBBK0TkX57Fyni+NgnyQQN4LitPmob2Hjnqw4=
-golang.org/x/tools v0.44.0 h1:UP4ajHPIcuMjT1GqzDWRlalUEoY+uzoZKnhOjbIPD2c=
-golang.org/x/tools v0.44.0/go.mod h1:KA0AfVErSdxRZIsOVipbv3rQhVXTnlU6UhKxHd1seDI=
+golang.org/x/tools v0.45.0 h1:18qN3FAooORvApf5XjCXgsuayZOEtXf6JK18I3+ONa8=
+golang.org/x/tools v0.45.0/go.mod h1:LuUGqqaXcXMEFEruIVJVm5mgDD8vww/z/SR1gQ4uE/0=
gomodules.xyz/jsonpatch/v2 v2.5.0 h1:JELs8RLM12qJGXU4u/TO3V25KW8GreMKl9pdkk14RM0=
gomodules.xyz/jsonpatch/v2 v2.5.0/go.mod h1:AH3dM2RI6uoBZxn3LVrfvJ3E0/9dG4cSrbuBJT4moAY=
gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4=
diff --git a/vendor/github.com/cespare/xxhash/v2/~/Library/Application Support/go/telemetry/local/asm@go1.26.3-go1.26.3-darwin-arm64-2026-06-30.v1.count b/vendor/github.com/cespare/xxhash/v2/~/Library/Application Support/go/telemetry/local/asm@go1.26.3-go1.26.3-darwin-arm64-2026-06-30.v1.count
deleted file mode 100644
index 2bcb9c7d1..000000000
Binary files a/vendor/github.com/cespare/xxhash/v2/~/Library/Application Support/go/telemetry/local/asm@go1.26.3-go1.26.3-darwin-arm64-2026-06-30.v1.count and /dev/null differ
diff --git a/vendor/github.com/cespare/xxhash/v2/~/Library/Application Support/go/telemetry/local/weekends b/vendor/github.com/cespare/xxhash/v2/~/Library/Application Support/go/telemetry/local/weekends
deleted file mode 100644
index 0cfbf0888..000000000
--- a/vendor/github.com/cespare/xxhash/v2/~/Library/Application Support/go/telemetry/local/weekends
+++ /dev/null
@@ -1 +0,0 @@
-2
diff --git a/vendor/github.com/klauspost/compress/zstd/internal/xxhash/~/Library/Application Support/go/telemetry/local/asm@go1.26.3-go1.26.3-darwin-arm64-2026-06-30.v1.count b/vendor/github.com/klauspost/compress/zstd/internal/xxhash/~/Library/Application Support/go/telemetry/local/asm@go1.26.3-go1.26.3-darwin-arm64-2026-06-30.v1.count
deleted file mode 100644
index 07405d273..000000000
Binary files a/vendor/github.com/klauspost/compress/zstd/internal/xxhash/~/Library/Application Support/go/telemetry/local/asm@go1.26.3-go1.26.3-darwin-arm64-2026-06-30.v1.count and /dev/null differ
diff --git a/vendor/github.com/klauspost/compress/zstd/internal/xxhash/~/Library/Application Support/go/telemetry/local/weekends b/vendor/github.com/klauspost/compress/zstd/internal/xxhash/~/Library/Application Support/go/telemetry/local/weekends
deleted file mode 100644
index b8626c4cf..000000000
--- a/vendor/github.com/klauspost/compress/zstd/internal/xxhash/~/Library/Application Support/go/telemetry/local/weekends
+++ /dev/null
@@ -1 +0,0 @@
-4
diff --git a/vendor/github.com/modern-go/reflect2/~/Library/Application Support/go/telemetry/local/asm@go1.26.3-go1.26.3-darwin-arm64-2026-06-30.v1.count b/vendor/github.com/modern-go/reflect2/~/Library/Application Support/go/telemetry/local/asm@go1.26.3-go1.26.3-darwin-arm64-2026-06-30.v1.count
deleted file mode 100644
index dfd78a88d..000000000
Binary files a/vendor/github.com/modern-go/reflect2/~/Library/Application Support/go/telemetry/local/asm@go1.26.3-go1.26.3-darwin-arm64-2026-06-30.v1.count and /dev/null differ
diff --git a/vendor/github.com/modern-go/reflect2/~/Library/Application Support/go/telemetry/local/weekends b/vendor/github.com/modern-go/reflect2/~/Library/Application Support/go/telemetry/local/weekends
deleted file mode 100644
index 1e8b31496..000000000
--- a/vendor/github.com/modern-go/reflect2/~/Library/Application Support/go/telemetry/local/weekends
+++ /dev/null
@@ -1 +0,0 @@
-6
diff --git a/vendor/github.com/onsi/gomega/.gitignore b/vendor/github.com/onsi/gomega/.gitignore
index 425d0a509..b3003b4e0 100644
--- a/vendor/github.com/onsi/gomega/.gitignore
+++ b/vendor/github.com/onsi/gomega/.gitignore
@@ -4,4 +4,5 @@
.idea
gomega.iml
TODO
-.vscode
\ No newline at end of file
+.vscode
+/.release/
diff --git a/vendor/github.com/onsi/gomega/CHANGELOG.md b/vendor/github.com/onsi/gomega/CHANGELOG.md
index e7601cfde..07f33258c 100644
--- a/vendor/github.com/onsi/gomega/CHANGELOG.md
+++ b/vendor/github.com/onsi/gomega/CHANGELOG.md
@@ -1,3 +1,41 @@
+## Unreleased
+
+### Features
+
+### Fixes
+
+### Maintenance
+
+## 1.44.0
+
+### Fixes
+- `BeNumerically` compares signed and unsigned integers by value: `-1` no longer equals `uint64(math.MaxUint64)` and `uint(5)` is now greater than `-3` (#925) [26e3c6b]
+- `BeNumerically("~")` no longer overflows when computing the distance between extreme integers (#928) [1955764]
+- `BeNumerically("==", x, threshold)` now honors the threshold for floats, as it already did for integers (#927) [10e2aca]
+- `HaveKeyWithValue` succeeds if any key accepted by the key matcher has a matching value, rather than depending on map iteration order (#929) [ffc577a]
+- `HaveKey` and `HaveKeyWithValue` treat key and value matcher errors like `ContainElement` does: a match wins, and an error is only reported when nothing matches (#926) [dc91598]
+- `MatchJSON` no longer treats numbers too large for a float64 as equal to one another (#930) [9d619a5]
+- `MatchJSON` compares integers beyond ±2^53 exactly, so neighboring large integers (e.g. IDs) no longer match; all other numbers are still compared as float64s (#931) [8ef1aa7, 630fe12]
+- `HaveExactElements` reports missing or extra elements that start at index 0, and reports the first extra element's index rather than the last (#934) [af1b777]
+- `MatchYAML` compares every document in a multi-document stream rather than only the first; empty documents (e.g. a leading or trailing `---`) are ignored (#933) [2773796]
+- `MatchXML` ignores namespace prefixes: elements and attributes are compared by namespace URI, and the URIs declared on each element must match whatever prefix they are bound to (#932) [c0dbd89, 2565350]
+
+## 1.43.1
+
+### Maintenance
+- Update go.yaml.in/yaml/v3 to v3.0.5 [d547015]
+- Releases are now cut by a GitHub Actions workflow (Actions -> Release -> Run workflow) rather than by hand, with changelog entries collected under `## Unreleased` as the work happens. Releases still ship the stripped-down tree on `master-lite` - tests removed and Ginkgo dropped from `go.mod` - and the workflow now builds it and checks it on every push. See RELEASING.md. [e9dc84d]
+
+## 1.43.0
+
+### Features
+
+Add gomock adaptor extension for using Gomega matchers with gomock
+
+## 1.42.1
+
+Bump Dependencies
+
## 1.42.0
Add a set of Claude skill as a marketplace plugin
diff --git a/vendor/github.com/onsi/gomega/README.md b/vendor/github.com/onsi/gomega/README.md
index 6eb36fdf8..ac545907f 100644
--- a/vendor/github.com/onsi/gomega/README.md
+++ b/vendor/github.com/onsi/gomega/README.md
@@ -1,6 +1,9 @@
-
+
+
+
+
-[](https://github.com/onsi/gomega/actions/workflows/test.yml)
+[](https://github.com/onsi/gomega/actions/workflows/test.yml?query=branch%3Amaster) [](https://onsi.github.io/gomega/) [](https://github.com/sponsors/onsi)
Jump straight to the [docs](http://onsi.github.io/gomega/) to learn about Gomega, including a list of [all available matchers](http://onsi.github.io/gomega/#provided-matchers).
diff --git a/vendor/github.com/onsi/gomega/RELEASING.md b/vendor/github.com/onsi/gomega/RELEASING.md
index 9973fff49..fdbeb37cc 100644
--- a/vendor/github.com/onsi/gomega/RELEASING.md
+++ b/vendor/github.com/onsi/gomega/RELEASING.md
@@ -1,23 +1,143 @@
-A Gomega release is a tagged sha and a GitHub release. To cut a release:
-
-1. Ensure CHANGELOG.md is up to date.
- - Use
- ```bash
- LAST_VERSION=$(git tag --sort=version:refname | tail -n1)
- CHANGES=$(git log --pretty=format:'- %s [%h]' HEAD...$LAST_VERSION)
- echo -e "## NEXT\n\n$CHANGES\n\n### Features\n\n### Fixes\n\n### Maintenance\n\n$(cat CHANGELOG.md)" > CHANGELOG.md
- ```
- to update the changelog
- - Categorize the changes into
- - Breaking Changes (requires a major version)
- - New Features (minor version)
- - Fixes (fix version)
- - Maintenance (which in general should not be mentioned in `CHANGELOG.md` as they have no user impact)
-1. Update GOMEGA_VERSION in `gomega_dsl.go`
-1. Commit, push, and release:
- ```
- git commit -m "vM.m.p"
- git push
- gh release create "vM.m.p"
- git fetch --tags origin master
- ```
\ No newline at end of file
+# Releasing Gomega
+
+A release is one GitHub Actions run: **Actions → Release → Run workflow → bump: patch | minor**,
+from `master`. From the command line:
+
+```bash
+gh workflow run release.yml -f bump=patch # or -f bump=minor
+```
+
+The run:
+
+1. Runs the whole test workflow (`test.yml`). Nothing else happens unless it passes.
+2. Runs `scripts/release.sh`, which
+ - computes the next version from `GOMEGA_VERSION` in `gomega_dsl.go`,
+ - renames `## Unreleased` in `CHANGELOG.md` to `## X.Y.Z` (dropping empty `###` subsections) and
+ puts a fresh, empty `## Unreleased` above it,
+ - writes `GOMEGA_VERSION` and stamps the version into every plugin manifest
+ (`plugins/*/.claude-plugin/plugin.json`), so the Claude Code plugin ships in lockstep,
+ - commits that on `master` as `vX.Y.Z (full)`, as `github-actions[bot]`,
+ - builds the released tree on `master-lite` and tags **that** commit `vX.Y.Z` (see below),
+ - pushes `master`, `master-lite`, and the tag together (`git push --atomic`, fast-forward only),
+ - creates the GitHub release `vX.Y.Z`, whose notes are the body of `## X.Y.Z`.
+
+## master and master-lite
+
+Gomega uses Ginkgo for its own tests, and the go toolchain pulls a dependency's *test* dependencies
+into consuming projects as indirect requirements — so a project that uses only Gomega would end up
+with all of Ginkgo in its `go.mod`. Since 1.40.0, releases therefore ship a stripped-down tree:
+
+- `master` holds the real repository, tests and all. The release commit there is `vX.Y.Z (full)`,
+ and it is **not** what the go toolchain resolves.
+- `master-lite` holds the released trees: the same tree with every `_test.go` file deleted and
+ `go.mod` re-tidied, which drops Ginkgo. `scripts/strip-tests.sh` does that, and asserts that the
+ result still builds and no longer requires Ginkgo.
+- Each release adds one commit to `master-lite`: a merge whose tree is the stripped tree and whose
+ parents are the previous `master-lite` commit and the `vX.Y.Z (full)` commit on `master`. So
+ `master-lite`'s history connects to master's, and `git log master-lite` reads as the release
+ history.
+- The `vX.Y.Z` tag is on that `master-lite` commit. It is what `go get github.com/onsi/gomega`
+ resolves, so `go build` never even sees the test files.
+
+The test workflow's **Check the released (lite) tree** job runs `scripts/strip-tests.sh` on every
+push. If a non-test file ever imports Ginkgo, that job fails long before release day — the released
+module could not be built otherwise.
+
+Release tags are not on `master`, so `git describe` on master does not find them. `GOMEGA_VERSION`
+in `gomega_dsl.go` is the version of record, and `git tag --sort=version:refname | tail -n1` names
+the latest release.
+
+If this release process ever causes unexpected changes for a project, please open an issue.
+
+### Never merge master-lite into master
+
+`master-lite` always looks ahead of `master`, because its newest commit merges master's release
+commit. But its *tree* has the tests taken out, so merging or rebasing it back into master deletes
+every `_test.go` file and drops Ginkgo from `go.mod` — cleanly, with no conflicts. GitHub's
+"master-lite had recent pushes — Compare & pull request" banner is the one click to avoid.
+
+Nothing you do locally needs `master-lite`: the release workflow writes it from a fresh checkout. A
+stale local `master-lite` branch is harmless, and you can delete it.
+
+`scripts/check-full-tree.sh` guards against a stripped master: it asserts that a checkout has
+`_test.go` files and that `go.mod` requires Ginkgo. The test workflow runs it on every push and
+`scripts/release.sh` runs it before cutting a release, so a stripped master gets reported plainly
+instead of turning into a test run with nothing in it.
+
+### Cutting one release after another
+
+Work on master as usual between releases. The `vX.Y.Z (full)` commit the workflow pushed is an
+ordinary commit: `git pull` fast-forwards onto it, it carries the released `CHANGELOG.md` and
+`GOMEGA_VERSION`, and you add new `## Unreleased` entries above it. The next release repeats the
+same two steps — a new `vX.Y.Z (full)` commit on master, and a new merge on `master-lite` whose
+tree is the stripped version of it, carrying the tag.
+
+Nothing accumulates between releases, and nothing needs reconciling in either direction: each
+`master-lite` commit's tree is built from the release commit rather than merged into the previous
+one, so `git diff vX.Y.Z vX.Y.Z+1` over two releases shows only the real changes.
+
+## The changelog
+
+`CHANGELOG.md` starts with an `## Unreleased` section:
+
+```markdown
+## Unreleased
+
+### Features
+
+### Fixes
+
+### Maintenance
+
+## 1.43.0
+...
+```
+
+Add an entry under `## Unreleased` with each user-facing change, as you make it. Never edit a
+released section. Empty subsections are dropped when the section is released, so leaving
+`### Maintenance` empty costs nothing.
+
+If `## Unreleased` has no entries (only blank lines and `###` headings), the release stops before
+changing anything — and so does a re-run after a successful release.
+
+To draft entries from the commits since the last release:
+
+```bash
+git log --pretty=format:'- %s [%h]' "$(git tag --sort=version:refname | tail -n1)"..HEAD
+```
+
+Categorize what you keep into
+
+- Breaking changes (these need a major version, which this workflow does not cut)
+- `### Features` (minor version)
+- `### Fixes` (patch version)
+- `### Maintenance` (in general, changes with no user impact don't belong in the changelog at all)
+
+## If a release fails
+
+Open the failed run and click **Re-run failed jobs**. A re-run checks out the same commit as the
+first attempt and computes the same version. It resumes based on what already exists:
+
+| Where it failed | What a re-run does |
+|---|---|
+| Tests, or before the push | Nothing reached GitHub. The re-run starts over. |
+| The push (master or master-lite moved during the run) | The re-run fails the same way. Start a new run from the current master. |
+| After the push (the tag `vX.Y.Z` is on GitHub) | The re-run builds from the tag instead of making new commits. |
+| Creating the GitHub release | The release is created, or its notes are refreshed if it already exists. |
+
+Both branches and the tag are pushed together, so the tag being on GitHub means both release
+commits are there too.
+
+## Trying the release script locally
+
+`GOMEGA_RELEASE_DRY_RUN=1 scripts/release.sh patch` does the whole release locally — the changelog
+and version rewrites, the `master` commit, the stripped `master-lite` commit and the tag on it —
+then skips the push and the GitHub release. It still checks `origin` for an existing tag and needs
+`origin/master-lite`, so run it in a throwaway clone whose `origin` is a local bare repository, not
+in your working copy.
+
+`scripts/strip-tests.sh` rewrites the working tree in place, so run *it* only on a throwaway
+checkout too.
+
+The version and changelog logic lives in `scripts/release`, with its own Ginkgo suite
+(`scripts/release/release_test.go`) that runs with the rest of the suites.
diff --git a/vendor/github.com/onsi/gomega/gomega_dsl.go b/vendor/github.com/onsi/gomega/gomega_dsl.go
index 967d90d0d..cf4eaefae 100644
--- a/vendor/github.com/onsi/gomega/gomega_dsl.go
+++ b/vendor/github.com/onsi/gomega/gomega_dsl.go
@@ -22,7 +22,7 @@ import (
"github.com/onsi/gomega/types"
)
-const GOMEGA_VERSION = "1.42.0"
+const GOMEGA_VERSION = "1.44.0"
const nilGomegaPanic = `You are trying to make an assertion, but haven't registered Gomega's fail handler.
If you're using Ginkgo then you probably forgot to put your assertion in an It().
diff --git a/vendor/github.com/onsi/gomega/matchers.go b/vendor/github.com/onsi/gomega/matchers.go
index bf5722605..e3e01f665 100644
--- a/vendor/github.com/onsi/gomega/matchers.go
+++ b/vendor/github.com/onsi/gomega/matchers.go
@@ -291,6 +291,8 @@ func HaveSuffix(suffix string, args ...any) types.GomegaMatcher {
// MatchJSON succeeds if actual is a string or stringer of JSON that matches
// the expected JSON. The JSONs are decoded and the resulting objects are compared via
// reflect.DeepEqual so things like key-ordering and whitespace shouldn't matter.
+// Numbers are compared as float64s, except for integers too large to be represented
+// exactly by a float64 (beyond ±2^53), which are compared exactly.
func MatchJSON(json any) types.GomegaMatcher {
return &matchers.MatchJSONMatcher{
JSONToMatch: json,
@@ -300,6 +302,8 @@ func MatchJSON(json any) types.GomegaMatcher {
// MatchXML succeeds if actual is a string or stringer of XML that matches
// the expected XML. The XMLs are decoded and the resulting objects are compared via
// reflect.DeepEqual so things like whitespaces shouldn't matter.
+// Namespace prefixes are ignored: element and attribute names are compared by
+// namespace URI, and the namespace URIs declared on each element must match.
func MatchXML(xml any) types.GomegaMatcher {
return &matchers.MatchXMLMatcher{
XMLToMatch: xml,
@@ -309,6 +313,8 @@ func MatchXML(xml any) types.GomegaMatcher {
// MatchYAML succeeds if actual is a string or stringer of YAML that matches
// the expected YAML. The YAML's are decoded and the resulting objects are compared via
// reflect.DeepEqual so things like key-ordering and whitespace shouldn't matter.
+// Multi-document YAML streams are compared document by document; empty documents
+// (e.g. from a leading or trailing "---") are ignored.
func MatchYAML(yaml any) types.GomegaMatcher {
return &matchers.MatchYAMLMatcher{
YAMLToMatch: yaml,
diff --git a/vendor/github.com/onsi/gomega/matchers/attributes_slice.go b/vendor/github.com/onsi/gomega/matchers/attributes_slice.go
index 355b362f4..ea8e5ba1d 100644
--- a/vendor/github.com/onsi/gomega/matchers/attributes_slice.go
+++ b/vendor/github.com/onsi/gomega/matchers/attributes_slice.go
@@ -9,6 +9,12 @@ type attributesSlice []xml.Attr
func (attrs attributesSlice) Len() int { return len(attrs) }
func (attrs attributesSlice) Less(i, j int) bool {
- return strings.Compare(attrs[i].Name.Local, attrs[j].Name.Local) == -1
+ if attrs[i].Name.Local != attrs[j].Name.Local {
+ return strings.Compare(attrs[i].Name.Local, attrs[j].Name.Local) == -1
+ }
+ if attrs[i].Name.Space != attrs[j].Name.Space {
+ return strings.Compare(attrs[i].Name.Space, attrs[j].Name.Space) == -1
+ }
+ return strings.Compare(attrs[i].Value, attrs[j].Value) == -1
}
func (attrs attributesSlice) Swap(i, j int) { attrs[i], attrs[j] = attrs[j], attrs[i] }
diff --git a/vendor/github.com/onsi/gomega/matchers/be_numerically_matcher.go b/vendor/github.com/onsi/gomega/matchers/be_numerically_matcher.go
index 7e6ce154e..02839f349 100644
--- a/vendor/github.com/onsi/gomega/matchers/be_numerically_matcher.go
+++ b/vendor/github.com/onsi/gomega/matchers/be_numerically_matcher.go
@@ -5,6 +5,7 @@ package matchers
import (
"fmt"
"math"
+ "math/big"
"github.com/onsi/gomega/format"
)
@@ -60,18 +61,12 @@ func (matcher *BeNumericallyMatcher) Match(actual any) (success bool, err error)
secondOperand = toFloat(matcher.CompareTo[1])
}
success = matcher.matchFloats(toFloat(actual), toFloat(matcher.CompareTo[0]), secondOperand)
- } else if isInteger(actual) {
- var secondOperand int64 = 0
+ } else if isInteger(actual) || isUnsignedInteger(actual) {
+ var threshold any = 0
if len(matcher.CompareTo) == 2 {
- secondOperand = toInteger(matcher.CompareTo[1])
+ threshold = matcher.CompareTo[1]
}
- success = matcher.matchIntegers(toInteger(actual), toInteger(matcher.CompareTo[0]), secondOperand)
- } else if isUnsignedInteger(actual) {
- var secondOperand uint64 = 0
- if len(matcher.CompareTo) == 2 {
- secondOperand = toUnsignedInteger(matcher.CompareTo[1])
- }
- success = matcher.matchUnsignedIntegers(toUnsignedInteger(actual), toUnsignedInteger(matcher.CompareTo[0]), secondOperand)
+ success = matcher.matchIntegers(toBigInt(actual), toBigInt(matcher.CompareTo[0]), threshold)
} else {
return false, fmt.Errorf("Failed to compare:\n%s\n%s:\n%s", format.Object(actual, 1), matcher.Comparator, format.Object(matcher.CompareTo[0], 1))
}
@@ -79,40 +74,35 @@ func (matcher *BeNumericallyMatcher) Match(actual any) (success bool, err error)
return success, nil
}
-func (matcher *BeNumericallyMatcher) matchIntegers(actual, compareTo, threshold int64) (success bool) {
+// matchIntegers compares signed and unsigned integers by their exact mathematical value, using math/big so
+// that neither mixing signedness nor computing the distance between the two values can overflow
+func (matcher *BeNumericallyMatcher) matchIntegers(actual, compareTo *big.Int, threshold any) (success bool) {
switch matcher.Comparator {
case "==", "~":
- diff := actual - compareTo
- return -threshold <= diff && diff <= threshold
+ distance := new(big.Int).Sub(actual, compareTo)
+ return isWithinThreshold(distance.Abs(distance), threshold)
case ">":
- return (actual > compareTo)
+ return actual.Cmp(compareTo) > 0
case ">=":
- return (actual >= compareTo)
+ return actual.Cmp(compareTo) >= 0
case "<":
- return (actual < compareTo)
+ return actual.Cmp(compareTo) < 0
case "<=":
- return (actual <= compareTo)
+ return actual.Cmp(compareTo) <= 0
}
return false
}
-func (matcher *BeNumericallyMatcher) matchUnsignedIntegers(actual, compareTo, threshold uint64) (success bool) {
- switch matcher.Comparator {
- case "==", "~":
- if actual < compareTo {
- actual, compareTo = compareTo, actual
+// isWithinThreshold reports whether the (non-negative) distance is no greater than the threshold, which may be any number
+func isWithinThreshold(distance *big.Int, threshold any) bool {
+ if isFloat(threshold) {
+ t := toFloat(threshold)
+ if math.IsNaN(t) {
+ return false
}
- return actual-compareTo <= threshold
- case ">":
- return (actual > compareTo)
- case ">=":
- return (actual >= compareTo)
- case "<":
- return (actual < compareTo)
- case "<=":
- return (actual <= compareTo)
+ return new(big.Float).SetInt(distance).Cmp(big.NewFloat(t)) <= 0
}
- return false
+ return distance.Cmp(toBigInt(threshold)) <= 0
}
func (matcher *BeNumericallyMatcher) matchFloats(actual, compareTo, threshold float64) (success bool) {
@@ -120,6 +110,10 @@ func (matcher *BeNumericallyMatcher) matchFloats(actual, compareTo, threshold fl
case "~":
return math.Abs(actual-compareTo) <= threshold
case "==":
+ // an explicit threshold is honored, as it is for integers; without one == means exact equality
+ if len(matcher.CompareTo) == 2 {
+ return math.Abs(actual-compareTo) <= threshold
+ }
return (actual == compareTo)
case ">":
return (actual > compareTo)
diff --git a/vendor/github.com/onsi/gomega/matchers/have_exact_elements.go b/vendor/github.com/onsi/gomega/matchers/have_exact_elements.go
index 8b2d297c5..18f7b2846 100644
--- a/vendor/github.com/onsi/gomega/matchers/have_exact_elements.go
+++ b/vendor/github.com/onsi/gomega/matchers/have_exact_elements.go
@@ -79,7 +79,7 @@ func (matcher *HaveExactElementsMatcher) Match(actual any) (success bool, err er
if i >= lenMatchers {
matcher.extraIndex = i
success = false
- continue
+ return
}
if i >= lenValues {
@@ -110,10 +110,10 @@ func (matcher *HaveExactElementsMatcher) Match(actual any) (success bool, err er
func (matcher *HaveExactElementsMatcher) FailureMessage(actual any) (message string) {
message = format.Message(actual, "to have exact elements with", presentable(matcher.Elements))
- if matcher.missingIndex > 0 {
+ if matcher.missingIndex >= 0 {
message = fmt.Sprintf("%s\nthe missing elements start from index %d", message, matcher.missingIndex)
}
- if matcher.extraIndex > 0 {
+ if matcher.extraIndex >= 0 {
message = fmt.Sprintf("%s\nthe extra elements start from index %d", message, matcher.extraIndex)
}
if len(matcher.mismatchFailures) != 0 {
@@ -131,6 +131,7 @@ func (matcher *HaveExactElementsMatcher) NegatedFailureMessage(actual any) (mess
func (matcher *HaveExactElementsMatcher) resetState() {
matcher.mismatchFailures = nil
- matcher.missingIndex = 0
- matcher.extraIndex = 0
+ // -1 means "no missing/extra elements"; 0 is a valid starting index
+ matcher.missingIndex = -1
+ matcher.extraIndex = -1
}
diff --git a/vendor/github.com/onsi/gomega/matchers/have_key_matcher.go b/vendor/github.com/onsi/gomega/matchers/have_key_matcher.go
index 16630c18e..5b27babed 100644
--- a/vendor/github.com/onsi/gomega/matchers/have_key_matcher.go
+++ b/vendor/github.com/onsi/gomega/matchers/have_key_matcher.go
@@ -24,31 +24,41 @@ func (matcher *HaveKeyMatcher) Match(actual any) (success bool, err error) {
keyMatcher = &EqualMatcher{Expected: matcher.Key}
}
+ // As with ContainElement, a key the key matcher accepts wins regardless of
+ // errors on other keys; the matcher's (last) error is only reported when
+ // no key matches.
+ var lastError error
if miter.IsSeq2(actual) {
- var success bool
- var err error
+ found := false
miter.IterateKV(actual, func(k, v reflect.Value) bool {
- success, err = keyMatcher.Match(k.Interface())
+ success, err := keyMatcher.Match(k.Interface())
if err != nil {
- err = fmt.Errorf("HaveKey's key matcher failed with:\n%s%s", format.Indent, err.Error())
- return false
+ lastError = err
+ return true
}
- return !success
+ found = success
+ return !found
})
- return success, err
- }
-
- keys := reflect.ValueOf(actual).MapKeys()
- for i := range keys {
- success, err := keyMatcher.Match(keys[i].Interface())
- if err != nil {
- return false, fmt.Errorf("HaveKey's key matcher failed with:\n%s%s", format.Indent, err.Error())
- }
- if success {
+ if found {
return true, nil
}
+ } else {
+ keys := reflect.ValueOf(actual).MapKeys()
+ for i := range keys {
+ success, err := keyMatcher.Match(keys[i].Interface())
+ if err != nil {
+ lastError = err
+ continue
+ }
+ if success {
+ return true, nil
+ }
+ }
}
+ if lastError != nil {
+ return false, fmt.Errorf("HaveKey's key matcher failed with:\n%s%s", format.Indent, lastError.Error())
+ }
return false, nil
}
diff --git a/vendor/github.com/onsi/gomega/matchers/have_key_with_value_matcher.go b/vendor/github.com/onsi/gomega/matchers/have_key_with_value_matcher.go
index 0cd708153..29410a5fd 100644
--- a/vendor/github.com/onsi/gomega/matchers/have_key_with_value_matcher.go
+++ b/vendor/github.com/onsi/gomega/matchers/have_key_with_value_matcher.go
@@ -30,44 +30,46 @@ func (matcher *HaveKeyWithValueMatcher) Match(actual any) (success bool, err err
valueMatcher = &EqualMatcher{Expected: matcher.Value}
}
+ // As with ContainElement, an entry whose key and value both match wins
+ // regardless of errors on other entries; the (last) key or value matcher
+ // error is only reported when no entry matches.
+ var lastError error
+ entryMatches := func(k, v reflect.Value) bool {
+ success, err := keyMatcher.Match(k.Interface())
+ if err != nil {
+ lastError = fmt.Errorf("HaveKeyWithValue's key matcher failed with:\n%s%s", format.Indent, err.Error())
+ return false
+ }
+ if !success {
+ return false
+ }
+ success, err = valueMatcher.Match(v.Interface())
+ if err != nil {
+ lastError = fmt.Errorf("HaveKeyWithValue's value matcher failed with:\n%s%s", format.Indent, err.Error())
+ return false
+ }
+ return success
+ }
+
if miter.IsSeq2(actual) {
- var success bool
- var err error
+ found := false
miter.IterateKV(actual, func(k, v reflect.Value) bool {
- success, err = keyMatcher.Match(k.Interface())
- if err != nil {
- err = fmt.Errorf("HaveKey's key matcher failed with:\n%s%s", format.Indent, err.Error())
- return false
- }
- if success {
- success, err = valueMatcher.Match(v.Interface())
- if err != nil {
- err = fmt.Errorf("HaveKeyWithValue's value matcher failed with:\n%s%s", format.Indent, err.Error())
- return false
- }
- }
- return !success
+ found = entryMatches(k, v)
+ return !found
})
- return success, err
- }
-
- keys := reflect.ValueOf(actual).MapKeys()
- for i := range keys {
- success, err := keyMatcher.Match(keys[i].Interface())
- if err != nil {
- return false, fmt.Errorf("HaveKeyWithValue's key matcher failed with:\n%s%s", format.Indent, err.Error())
+ if found {
+ return true, nil
}
- if success {
- actualValue := reflect.ValueOf(actual).MapIndex(keys[i])
- success, err := valueMatcher.Match(actualValue.Interface())
- if err != nil {
- return false, fmt.Errorf("HaveKeyWithValue's value matcher failed with:\n%s%s", format.Indent, err.Error())
+ } else {
+ value := reflect.ValueOf(actual)
+ for _, k := range value.MapKeys() {
+ if entryMatches(k, value.MapIndex(k)) {
+ return true, nil
}
- return success, nil
}
}
- return false, nil
+ return false, lastError
}
func (matcher *HaveKeyWithValueMatcher) FailureMessage(actual any) (message string) {
diff --git a/vendor/github.com/onsi/gomega/matchers/match_json_matcher.go b/vendor/github.com/onsi/gomega/matchers/match_json_matcher.go
index 331f289ab..96f5246f9 100644
--- a/vendor/github.com/onsi/gomega/matchers/match_json_matcher.go
+++ b/vendor/github.com/onsi/gomega/matchers/match_json_matcher.go
@@ -4,6 +4,9 @@ import (
"bytes"
"encoding/json"
"fmt"
+ "math/big"
+ "strconv"
+ "strings"
"github.com/onsi/gomega/format"
)
@@ -22,14 +25,103 @@ func (matcher *MatchJSONMatcher) Match(actual any) (success bool, err error) {
var aval any
var eval any
- // this is guarded by prettyPrint
- json.Unmarshal([]byte(actualString), &aval)
- json.Unmarshal([]byte(expectedString), &eval)
+ // prettyPrint has already checked the syntax, so decoding is not expected to fail
+ if aval, err = decodeJSON(actualString); err != nil {
+ return false, fmt.Errorf("Actual '%s' should be valid JSON, but it is not.\nUnderlying error:%s", actualString, err)
+ }
+ if eval, err = decodeJSON(expectedString); err != nil {
+ return false, fmt.Errorf("Expected '%s' should be valid JSON, but it is not.\nUnderlying error:%s", expectedString, err)
+ }
var equal bool
equal, matcher.firstFailurePath = deepEqual(aval, eval)
return equal, nil
}
+// decodeJSON decodes s as json.Unmarshal would into an any, except that
+// integers too large to be represented exactly by a float64 are decoded as
+// canonicalJSONNumbers, so that they are compared exactly rather than after
+// rounding to the nearest float64.
+func decodeJSON(s string) (any, error) {
+ decoder := json.NewDecoder(strings.NewReader(s))
+ decoder.UseNumber()
+ var value any
+ if err := decoder.Decode(&value); err != nil {
+ return nil, err
+ }
+ return decodeJSONNumbers(value), nil
+}
+
+func decodeJSONNumbers(value any) any {
+ switch v := value.(type) {
+ case []any:
+ for i, element := range v {
+ v[i] = decodeJSONNumbers(element)
+ }
+ case map[string]any:
+ for key, element := range v {
+ v[key] = decodeJSONNumbers(element)
+ }
+ case json.Number:
+ return decodeJSONNumber(v)
+ }
+ return value
+}
+
+// canonicalJSONNumber is a JSON number written as its significant digits
+// followed by a base-10 exponent, e.g. 12345678901234567890 and
+// 1.234567890123456789e19 are both 123456789012345678900e1. Two JSON numbers
+// have the same value exactly when they have the same canonical form.
+type canonicalJSONNumber string
+
+// maxExactFloat64Integer is 2^53: every integer with a magnitude no greater
+// than this is represented exactly by a float64.
+var maxExactFloat64Integer = new(big.Int).Lsh(big.NewInt(1), 53)
+
+// decodeJSONNumber returns integers whose magnitude exceeds 2^53 in canonical
+// form, and every other number as the float64 that json.Unmarshal would
+// produce. Numbers that are not integers but are too large for a float64 are
+// also returned in canonical form.
+func decodeJSONNumber(n json.Number) any {
+ s, sign := string(n), ""
+ if rest, negative := strings.CutPrefix(s, "-"); negative {
+ s, sign = rest, "-"
+ }
+ mantissa, exponentString, _ := strings.Cut(strings.ToLower(s), "e")
+ integerPart, fractionPart, _ := strings.Cut(mantissa, ".")
+
+ digits := strings.TrimLeft(integerPart+fractionPart, "0")
+ significantDigits := strings.TrimRight(digits, "0")
+
+ // the exponent is parsed as a big.Int as JSON puts no limit on its size
+ exponent := new(big.Int)
+ if exponentString != "" {
+ exponent.SetString(exponentString, 10) // the syntax has been checked by the decoder
+ }
+ exponent.Add(exponent, big.NewInt(int64(len(digits)-len(significantDigits)-len(fractionPart))))
+ canonical := canonicalJSONNumber(sign + significantDigits + "e" + exponent.String())
+
+ if significantDigits != "" && exponent.Sign() >= 0 && exceedsMaxExactFloat64Integer(significantDigits, exponent) {
+ return canonical
+ }
+ f, err := strconv.ParseFloat(string(n), 64)
+ if err != nil {
+ // the syntax has been checked, so the number must be too large for a float64
+ return canonical
+ }
+ return f
+}
+
+// exceedsMaxExactFloat64Integer reports whether significantDigits * 10^exponent,
+// with exponent >= 0, is greater than 2^53.
+func exceedsMaxExactFloat64Integer(significantDigits string, exponent *big.Int) bool {
+ if exponent.Cmp(big.NewInt(16)) >= 0 {
+ return true // 10^16 > 2^53
+ }
+ value, _ := new(big.Int).SetString(significantDigits, 10)
+ value.Mul(value, new(big.Int).Exp(big.NewInt(10), exponent, nil))
+ return value.Cmp(maxExactFloat64Integer) > 0
+}
+
func (matcher *MatchJSONMatcher) FailureMessage(actual any) (message string) {
actualString, expectedString, _ := matcher.prettyPrint(actual)
return formattedMessage(format.Message(actualString, "to match JSON of", expectedString), matcher.firstFailurePath)
diff --git a/vendor/github.com/onsi/gomega/matchers/match_xml_matcher.go b/vendor/github.com/onsi/gomega/matchers/match_xml_matcher.go
index f7dcaf6fd..86bf2f2dc 100644
--- a/vendor/github.com/onsi/gomega/matchers/match_xml_matcher.go
+++ b/vendor/github.com/onsi/gomega/matchers/match_xml_matcher.go
@@ -83,9 +83,9 @@ func parseXmlContent(content string) (*xmlNode, error) {
switch tok := tok.(type) {
case xml.StartElement:
- attrs := attributesSlice(tok.Attr)
+ attrs := withNormalizedNamespaceDeclarations(tok.Attr)
sort.Sort(attrs)
- allNodes = append(allNodes, &xmlNode{XMLName: tok.Name, XMLAttr: tok.Attr})
+ allNodes = append(allNodes, &xmlNode{XMLName: tok.Name, XMLAttr: attrs})
case xml.EndElement:
if len(allNodes) > 1 {
allNodes[lastNodeIndex-1].Nodes = append(allNodes[lastNodeIndex-1].Nodes, lastNode)
@@ -109,6 +109,22 @@ func parseXmlContent(content string) (*xmlNode, error) {
return firstNode, nil
}
+// withNormalizedNamespaceDeclarations replaces the name of each xmlns="..." and
+// xmlns:prefix="..." attribute with the same placeholder name, so that only the
+// namespace URIs declared on the element are compared, not the prefixes bound
+// to them. The decoder has already resolved element and attribute names to
+// namespace URIs, so the prefixes play no other part in the comparison.
+func withNormalizedNamespaceDeclarations(attrs []xml.Attr) attributesSlice {
+ normalized := make(attributesSlice, len(attrs))
+ for i, attr := range attrs {
+ if attr.Name.Space == "xmlns" || (attr.Name.Space == "" && attr.Name.Local == "xmlns") {
+ attr.Name = xml.Name{Space: "xmlns"}
+ }
+ normalized[i] = attr
+ }
+ return normalized
+}
+
func newXmlDecoder(reader io.Reader) *xml.Decoder {
dec := xml.NewDecoder(reader)
dec.CharsetReader = charset.NewReaderLabel
diff --git a/vendor/github.com/onsi/gomega/matchers/match_yaml_matcher.go b/vendor/github.com/onsi/gomega/matchers/match_yaml_matcher.go
index c3da9bd48..a6c558d9c 100644
--- a/vendor/github.com/onsi/gomega/matchers/match_yaml_matcher.go
+++ b/vendor/github.com/onsi/gomega/matchers/match_yaml_matcher.go
@@ -1,7 +1,9 @@
package matchers
import (
+ "errors"
"fmt"
+ "io"
"strings"
"github.com/onsi/gomega/format"
@@ -11,37 +13,60 @@ import (
type MatchYAMLMatcher struct {
YAMLToMatch any
firstFailurePath []any
+ // the 1-based number of the first mismatched document when comparing
+ // multi-document streams; 0 otherwise
+ firstFailureDocument int
}
func (matcher *MatchYAMLMatcher) Match(actual any) (success bool, err error) {
+ matcher.firstFailurePath = nil
+ matcher.firstFailureDocument = 0
+
actualString, expectedString, err := matcher.toStrings(actual)
if err != nil {
return false, err
}
- var aval any
- var eval any
-
- if err := yaml.Unmarshal([]byte(actualString), &aval); err != nil {
+ adocs, err := decodeYAMLDocuments(actualString)
+ if err != nil {
return false, fmt.Errorf("Actual '%s' should be valid YAML, but it is not.\nUnderlying error:%s", actualString, err)
}
- if err := yaml.Unmarshal([]byte(expectedString), &eval); err != nil {
+ edocs, err := decodeYAMLDocuments(expectedString)
+ if err != nil {
return false, fmt.Errorf("Expected '%s' should be valid YAML, but it is not.\nUnderlying error:%s", expectedString, err)
}
- var equal bool
- equal, matcher.firstFailurePath = deepEqual(aval, eval)
- return equal, nil
+ if len(adocs) != len(edocs) {
+ return false, nil
+ }
+ for i := range adocs {
+ var equal bool
+ equal, matcher.firstFailurePath = deepEqual(adocs[i], edocs[i])
+ if !equal {
+ if len(adocs) > 1 {
+ matcher.firstFailureDocument = i + 1
+ }
+ return false, nil
+ }
+ }
+ return true, nil
}
func (matcher *MatchYAMLMatcher) FailureMessage(actual any) (message string) {
actualString, expectedString, _ := matcher.toNormalisedStrings(actual)
- return formattedMessage(format.Message(actualString, "to match YAML of", expectedString), matcher.firstFailurePath)
+ return matcher.formattedMessage(format.Message(actualString, "to match YAML of", expectedString))
}
func (matcher *MatchYAMLMatcher) NegatedFailureMessage(actual any) (message string) {
actualString, expectedString, _ := matcher.toNormalisedStrings(actual)
- return formattedMessage(format.Message(actualString, "not to match YAML of", expectedString), matcher.firstFailurePath)
+ return matcher.formattedMessage(format.Message(actualString, "not to match YAML of", expectedString))
+}
+
+func (matcher *MatchYAMLMatcher) formattedMessage(comparisonMessage string) string {
+ if matcher.firstFailureDocument > 0 {
+ comparisonMessage = fmt.Sprintf("%s\n\nfirst mismatched document: %d (counting from 1)", comparisonMessage, matcher.firstFailureDocument)
+ }
+ return formattedMessage(comparisonMessage, matcher.firstFailurePath)
}
func (matcher *MatchYAMLMatcher) toNormalisedStrings(actual any) (actualFormatted, expectedFormatted string, err error) {
@@ -50,16 +75,63 @@ func (matcher *MatchYAMLMatcher) toNormalisedStrings(actual any) (actualFormatte
}
func normalise(input string) string {
- var val any
- err := yaml.Unmarshal([]byte(input), &val)
+ docs, err := decodeYAMLDocuments(input)
if err != nil {
- panic(err) // unreachable since Match already calls Unmarshal
+ panic(err) // unreachable since Match already decodes the input
}
- output, err := yaml.Marshal(val)
- if err != nil {
- panic(err) // untested section, unreachable since we Unmarshal above
+ outputs := make([]string, len(docs))
+ for i, doc := range docs {
+ output, err := yaml.Marshal(doc)
+ if err != nil {
+ panic(err) // untested section, unreachable since we decode above
+ }
+ outputs[i] = string(output)
+ }
+ return strings.TrimSpace(strings.Join(outputs, "---\n"))
+}
+
+// decodeYAMLDocuments decodes every document in a YAML stream.
+//
+// Empty documents - such as those produced by a leading or trailing "---" - are
+// skipped, so "---\na: 1\n---\n" is the single document "a: 1". A stream with
+// no documents at all is treated as a single null document, as yaml.Unmarshal
+// does.
+func decodeYAMLDocuments(input string) ([]any, error) {
+ docs := []any{}
+ decoder := yaml.NewDecoder(strings.NewReader(input))
+ for {
+ var node yaml.Node
+ err := decoder.Decode(&node)
+ if errors.Is(err, io.EOF) {
+ break
+ }
+ if err != nil {
+ return nil, err
+ }
+ if isEmptyYAMLDocument(&node) {
+ continue
+ }
+ var doc any
+ if err := node.Decode(&doc); err != nil {
+ return nil, err
+ }
+ docs = append(docs, doc)
+ }
+ if len(docs) == 0 {
+ docs = append(docs, nil)
+ }
+ return docs, nil
+}
+
+// isEmptyYAMLDocument reports whether a document has no content at all.
+// Explicit nulls (e.g. "~" or "null") are content.
+func isEmptyYAMLDocument(document *yaml.Node) bool {
+ if len(document.Content) != 1 {
+ return false
}
- return strings.TrimSpace(string(output))
+ content := document.Content[0]
+ return content.Kind == yaml.ScalarNode && content.ShortTag() == "!!null" && content.Value == "" &&
+ content.Style == 0 && content.Anchor == ""
}
func (matcher *MatchYAMLMatcher) toStrings(actual any) (actualFormatted, expectedFormatted string, err error) {
diff --git a/vendor/github.com/onsi/gomega/matchers/type_support.go b/vendor/github.com/onsi/gomega/matchers/type_support.go
index d020dedc3..89056f447 100644
--- a/vendor/github.com/onsi/gomega/matchers/type_support.go
+++ b/vendor/github.com/onsi/gomega/matchers/type_support.go
@@ -14,6 +14,7 @@ package matchers
import (
"encoding/json"
"fmt"
+ "math/big"
"reflect"
"github.com/onsi/gomega/matchers/internal/miter"
@@ -52,26 +53,11 @@ func isFloat(a any) bool {
return reflect.Float32 <= kind && kind <= reflect.Float64
}
-func toInteger(a any) int64 {
+func toBigInt(a any) *big.Int {
if isInteger(a) {
- return reflect.ValueOf(a).Int()
- } else if isUnsignedInteger(a) {
- return int64(reflect.ValueOf(a).Uint())
- } else if isFloat(a) {
- return int64(reflect.ValueOf(a).Float())
- }
- panic(fmt.Sprintf("Expected a number! Got <%T> %#v", a, a))
-}
-
-func toUnsignedInteger(a any) uint64 {
- if isInteger(a) {
- return uint64(reflect.ValueOf(a).Int())
- } else if isUnsignedInteger(a) {
- return reflect.ValueOf(a).Uint()
- } else if isFloat(a) {
- return uint64(reflect.ValueOf(a).Float())
+ return big.NewInt(reflect.ValueOf(a).Int())
}
- panic(fmt.Sprintf("Expected a number! Got <%T> %#v", a, a))
+ return new(big.Int).SetUint64(reflect.ValueOf(a).Uint())
}
func toFloat(a any) float64 {
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/~/Library/Application Support/go/telemetry/local/cgo@go1.26.3-go1.26.3-darwin-arm64-2026-06-30.v1.count b/vendor/github.com/prometheus/client_golang/prometheus/~/Library/Application Support/go/telemetry/local/cgo@go1.26.3-go1.26.3-darwin-arm64-2026-06-30.v1.count
deleted file mode 100644
index 09ce56ae8..000000000
Binary files a/vendor/github.com/prometheus/client_golang/prometheus/~/Library/Application Support/go/telemetry/local/cgo@go1.26.3-go1.26.3-darwin-arm64-2026-06-30.v1.count and /dev/null differ
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/~/Library/Application Support/go/telemetry/local/weekends b/vendor/github.com/prometheus/client_golang/prometheus/~/Library/Application Support/go/telemetry/local/weekends
deleted file mode 100644
index 7ed6ff82d..000000000
--- a/vendor/github.com/prometheus/client_golang/prometheus/~/Library/Application Support/go/telemetry/local/weekends
+++ /dev/null
@@ -1 +0,0 @@
-5
diff --git a/vendor/go.yaml.in/yaml/v3/parserc.go b/vendor/go.yaml.in/yaml/v3/parserc.go
index 25fe82363..f35829db4 100644
--- a/vendor/go.yaml.in/yaml/v3/parserc.go
+++ b/vendor/go.yaml.in/yaml/v3/parserc.go
@@ -226,9 +226,9 @@ func yaml_parser_state_machine(parser *yaml_parser_t, event *yaml_event_t) bool
}
// Parse the production:
-// stream ::= STREAM-START implicit_document? explicit_document* STREAM-END
//
-// ************
+// stream ::= STREAM-START implicit_document? explicit_document* STREAM-END
+// ************
func yaml_parser_parse_stream_start(parser *yaml_parser_t, event *yaml_event_t) bool {
token := peek_token(parser)
if token == nil {
@@ -249,13 +249,11 @@ func yaml_parser_parse_stream_start(parser *yaml_parser_t, event *yaml_event_t)
}
// Parse the productions:
-// implicit_document ::= block_node DOCUMENT-END*
-//
-// *
//
-// explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
-//
-// *************************
+// implicit_document ::= block_node DOCUMENT-END*
+// *
+// explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
+// *************************
func yaml_parser_parse_document_start(parser *yaml_parser_t, event *yaml_event_t, implicit bool) bool {
token := peek_token(parser)
@@ -359,9 +357,9 @@ func yaml_parser_parse_document_start(parser *yaml_parser_t, event *yaml_event_t
}
// Parse the productions:
-// explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
//
-// ***********
+// explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
+// ***********
func yaml_parser_parse_document_content(parser *yaml_parser_t, event *yaml_event_t) bool {
token := peek_token(parser)
if token == nil {
@@ -382,11 +380,10 @@ func yaml_parser_parse_document_content(parser *yaml_parser_t, event *yaml_event
}
// Parse the productions:
-// implicit_document ::= block_node DOCUMENT-END*
-//
-// *************
//
-// explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
+// implicit_document ::= block_node DOCUMENT-END*
+// *************
+// explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
func yaml_parser_parse_document_end(parser *yaml_parser_t, event *yaml_event_t) bool {
token := peek_token(parser)
if token == nil {
@@ -432,42 +429,32 @@ func yaml_parser_set_event_comments(parser *yaml_parser_t, event *yaml_event_t)
}
// Parse the productions:
-// block_node_or_indentless_sequence ::=
-//
-// ALIAS
-// *****
-// | properties (block_content | indentless_block_sequence)?
-// ********** *
-// | block_content | indentless_block_sequence
-// *
-//
-// block_node ::= ALIAS
-//
-// *****
-// | properties block_content?
-// ********** *
-// | block_content
-// *
-//
-// flow_node ::= ALIAS
-//
-// *****
-// | properties flow_content?
-// ********** *
-// | flow_content
-// *
-//
-// properties ::= TAG ANCHOR? | ANCHOR TAG?
-//
-// *************************
-//
-// block_content ::= block_collection | flow_collection | SCALAR
-//
-// ******
//
-// flow_content ::= flow_collection | SCALAR
-//
-// ******
+// block_node_or_indentless_sequence ::=
+// ALIAS
+// *****
+// | properties (block_content | indentless_block_sequence)?
+// ********** *
+// | block_content | indentless_block_sequence
+// *
+// block_node ::= ALIAS
+// *****
+// | properties block_content?
+// ********** *
+// | block_content
+// *
+// flow_node ::= ALIAS
+// *****
+// | properties flow_content?
+// ********** *
+// | flow_content
+// *
+// properties ::= TAG ANCHOR? | ANCHOR TAG?
+// *************************
+// block_content ::= block_collection | flow_collection | SCALAR
+// ******
+// flow_content ::= flow_collection | SCALAR
+// ******
func yaml_parser_parse_node(parser *yaml_parser_t, event *yaml_event_t, block, indentless_sequence bool) bool {
//defer trace("yaml_parser_parse_node", "block:", block, "indentless_sequence:", indentless_sequence)()
@@ -697,9 +684,9 @@ func yaml_parser_parse_node(parser *yaml_parser_t, event *yaml_event_t, block, i
}
// Parse the productions:
-// block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END
//
-// ******************** *********** * *********
+// block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END
+// ******************** *********** * *********
func yaml_parser_parse_block_sequence_entry(parser *yaml_parser_t, event *yaml_event_t, first bool) bool {
if first {
token := peek_token(parser)
@@ -755,9 +742,9 @@ func yaml_parser_parse_block_sequence_entry(parser *yaml_parser_t, event *yaml_e
}
// Parse the productions:
-// indentless_sequence ::= (BLOCK-ENTRY block_node?)+
//
-// *********** *
+// indentless_sequence ::= (BLOCK-ENTRY block_node?)+
+// *********** *
func yaml_parser_parse_indentless_sequence_entry(parser *yaml_parser_t, event *yaml_event_t) bool {
token := peek_token(parser)
if token == nil {
@@ -821,15 +808,15 @@ func yaml_parser_split_stem_comment(parser *yaml_parser_t, stem_len int) {
}
// Parse the productions:
-// block_mapping ::= BLOCK-MAPPING_START
//
-// *******************
-// ((KEY block_node_or_indentless_sequence?)?
-// *** *
-// (VALUE block_node_or_indentless_sequence?)?)*
+// block_mapping ::= BLOCK-MAPPING_START
+// *******************
+// ((KEY block_node_or_indentless_sequence?)?
+// *** *
+// (VALUE block_node_or_indentless_sequence?)?)*
//
-// BLOCK-END
-// *********
+// BLOCK-END
+// *********
func yaml_parser_parse_block_mapping_key(parser *yaml_parser_t, event *yaml_event_t, first bool) bool {
if first {
token := peek_token(parser)
@@ -896,13 +883,14 @@ func yaml_parser_parse_block_mapping_key(parser *yaml_parser_t, event *yaml_even
}
// Parse the productions:
-// block_mapping ::= BLOCK-MAPPING_START
//
-// ((KEY block_node_or_indentless_sequence?)?
+// block_mapping ::= BLOCK-MAPPING_START
+//
+// ((KEY block_node_or_indentless_sequence?)?
//
-// (VALUE block_node_or_indentless_sequence?)?)*
-// ***** *
-// BLOCK-END
+// (VALUE block_node_or_indentless_sequence?)?)*
+// ***** *
+// BLOCK-END
func yaml_parser_parse_block_mapping_value(parser *yaml_parser_t, event *yaml_event_t) bool {
token := peek_token(parser)
if token == nil {
@@ -929,19 +917,17 @@ func yaml_parser_parse_block_mapping_value(parser *yaml_parser_t, event *yaml_ev
}
// Parse the productions:
-// flow_sequence ::= FLOW-SEQUENCE-START
-//
-// *******************
-// (flow_sequence_entry FLOW-ENTRY)*
-// * **********
-// flow_sequence_entry?
-// *
-// FLOW-SEQUENCE-END
-// *****************
//
-// flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
-//
-// *
+// flow_sequence ::= FLOW-SEQUENCE-START
+// *******************
+// (flow_sequence_entry FLOW-ENTRY)*
+// * **********
+// flow_sequence_entry?
+// *
+// FLOW-SEQUENCE-END
+// *****************
+// flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+// *
func yaml_parser_parse_flow_sequence_entry(parser *yaml_parser_t, event *yaml_event_t, first bool) bool {
if first {
token := peek_token(parser)
@@ -1005,9 +991,9 @@ func yaml_parser_parse_flow_sequence_entry(parser *yaml_parser_t, event *yaml_ev
}
// Parse the productions:
-// flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
//
-// *** *
+// flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+// *** *
func yaml_parser_parse_flow_sequence_entry_mapping_key(parser *yaml_parser_t, event *yaml_event_t) bool {
token := peek_token(parser)
if token == nil {
@@ -1026,9 +1012,9 @@ func yaml_parser_parse_flow_sequence_entry_mapping_key(parser *yaml_parser_t, ev
}
// Parse the productions:
-// flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
//
-// ***** *
+// flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+// ***** *
func yaml_parser_parse_flow_sequence_entry_mapping_value(parser *yaml_parser_t, event *yaml_event_t) bool {
token := peek_token(parser)
if token == nil {
@@ -1050,9 +1036,9 @@ func yaml_parser_parse_flow_sequence_entry_mapping_value(parser *yaml_parser_t,
}
// Parse the productions:
-// flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
//
-// *
+// flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+// *
func yaml_parser_parse_flow_sequence_entry_mapping_end(parser *yaml_parser_t, event *yaml_event_t) bool {
token := peek_token(parser)
if token == nil {
@@ -1068,18 +1054,17 @@ func yaml_parser_parse_flow_sequence_entry_mapping_end(parser *yaml_parser_t, ev
}
// Parse the productions:
-// flow_mapping ::= FLOW-MAPPING-START
-//
-// ******************
-// (flow_mapping_entry FLOW-ENTRY)*
-// * **********
-// flow_mapping_entry?
-// ******************
-// FLOW-MAPPING-END
-// ****************
//
-// flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
-// - *** *
+// flow_mapping ::= FLOW-MAPPING-START
+// ******************
+// (flow_mapping_entry FLOW-ENTRY)*
+// * **********
+// flow_mapping_entry?
+// ******************
+// FLOW-MAPPING-END
+// ****************
+// flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+// * *** *
func yaml_parser_parse_flow_mapping_key(parser *yaml_parser_t, event *yaml_event_t, first bool) bool {
if first {
token := peek_token(parser)
@@ -1144,8 +1129,9 @@ func yaml_parser_parse_flow_mapping_key(parser *yaml_parser_t, event *yaml_event
}
// Parse the productions:
-// flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
-// - ***** *
+//
+// flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+// * ***** *
func yaml_parser_parse_flow_mapping_value(parser *yaml_parser_t, event *yaml_event_t, empty bool) bool {
token := peek_token(parser)
if token == nil {
diff --git a/vendor/go.yaml.in/yaml/v3/yamlh.go b/vendor/go.yaml.in/yaml/v3/yamlh.go
index f59aa40f6..07c442361 100644
--- a/vendor/go.yaml.in/yaml/v3/yamlh.go
+++ b/vendor/go.yaml.in/yaml/v3/yamlh.go
@@ -433,21 +433,19 @@ type yaml_document_t struct {
// The prototype of a read handler.
//
-// The read handler is called when the parser needs to read more bytes from the
-// source. The handler should write not more than size bytes to the buffer.
-// The number of written bytes should be set to the size_read variable.
+// The read handler is called when the parser needs to read more bytes from the
+// source. The handler should write not more than size bytes to the buffer.
+// The number of written bytes should be set to the size_read variable.
//
-// [in,out] data A pointer to an application data specified by
+// [in,out] data A pointer to an application data specified by
+// yaml_parser_set_input().
+// [out] buffer The buffer to write the data from the source.
+// [in] size The size of the buffer.
+// [out] size_read The actual number of bytes read from the source.
//
-// yaml_parser_set_input().
-//
-// [out] buffer The buffer to write the data from the source.
-// [in] size The size of the buffer.
-// [out] size_read The actual number of bytes read from the source.
-//
-// On success, the handler should return 1. If the handler failed,
-// the returned value should be 0. On EOF, the handler should set the
-// size_read to 0 and return 1.
+// On success, the handler should return 1. If the handler failed,
+// the returned value should be 0. On EOF, the handler should set the
+// size_read to 0 and return 1.
type yaml_read_handler_t func(parser *yaml_parser_t, buffer []byte) (n int, err error)
// This structure holds information about a potential simple key.
@@ -655,19 +653,17 @@ type yaml_comment_t struct {
// The prototype of a write handler.
//
-// The write handler is called when the emitter needs to flush the accumulated
-// characters to the output. The handler should write @a size bytes of the
-// @a buffer to the output.
-//
-// @param[in,out] data A pointer to an application data specified by
-//
-// yaml_emitter_set_output().
+// The write handler is called when the emitter needs to flush the accumulated
+// characters to the output. The handler should write @a size bytes of the
+// @a buffer to the output.
//
-// @param[in] buffer The buffer with bytes to be written.
-// @param[in] size The size of the buffer.
+// @param[in,out] data A pointer to an application data specified by
+// yaml_emitter_set_output().
+// @param[in] buffer The buffer with bytes to be written.
+// @param[in] size The size of the buffer.
//
-// @returns On success, the handler should return @c 1. If the handler failed,
-// the returned value should be @c 0.
+// @returns On success, the handler should return @c 1. If the handler failed,
+// the returned value should be @c 0.
type yaml_write_handler_t func(emitter *yaml_emitter_t, buffer []byte) error
type yaml_emitter_state_t int
diff --git a/vendor/golang.org/x/net/html/entity.go b/vendor/golang.org/x/net/html/entity.go
index b628880a0..4e8d5d55f 100644
--- a/vendor/golang.org/x/net/html/entity.go
+++ b/vendor/golang.org/x/net/html/entity.go
@@ -2156,9 +2156,8 @@ var entity = map[string]rune{
// HTML entities that are two unicode codepoints.
var entity2 = map[string][2]rune{
- // TODO(nigeltao): Handle replacements that are wider than their names.
- // "nLt;": {'\u226A', '\u20D2'},
- // "nGt;": {'\u226B', '\u20D2'},
+ "nLt;": {'\u226A', '\u20D2'},
+ "nGt;": {'\u226B', '\u20D2'},
"NotEqualTilde;": {'\u2242', '\u0338'},
"NotGreaterFullEqual;": {'\u2267', '\u0338'},
"NotGreaterGreater;": {'\u226B', '\u0338'},
diff --git a/vendor/golang.org/x/net/html/escape.go b/vendor/golang.org/x/net/html/escape.go
index 12f227370..df3edc5b1 100644
--- a/vendor/golang.org/x/net/html/escape.go
+++ b/vendor/golang.org/x/net/html/escape.go
@@ -6,6 +6,7 @@ package html
import (
"bytes"
+ "slices"
"strings"
"unicode/utf8"
)
@@ -50,25 +51,24 @@ var replacementTable = [...]rune{
// 0x0D->'\u000D' is a no-op.
}
-// unescapeEntity reads an entity like "<" from b[src:] and writes the
-// corresponding "<" to b[dst:], returning the incremented dst and src cursors.
-// Precondition: b[src] == '&' && dst <= src.
-// attribute should be true if parsing an attribute value.
-func unescapeEntity(b []byte, dst, src int, attribute bool) (dst1, src1 int) {
+// unescapeEntity attempts to consume a character reference from s[src:],
+// returning the rune, potential second rune, and number of bytes consumed
+// (which indicates the length of the character reference). It is assumed that
+// the first byte of s is '&'. attribute should be true if parsing an attribute
+// value.
+func unescapeEntity(s []byte, attribute bool) (rune, rune, int) {
// https://html.spec.whatwg.org/multipage/syntax.html#consume-a-character-reference
// i starts at 1 because we already know that s[0] == '&'.
- i, s := 1, b[src:]
+ i := 1
if len(s) <= 1 {
- b[dst] = b[src]
- return dst + 1, src + 1
+ return '&', 0, 1
}
if s[i] == '#' {
- if len(s) <= 3 { // We need to have at least ".".
- b[dst] = b[src]
- return dst + 1, src + 1
+ if len(s) <= 2 { // We need to have at least "".
+ return '&', 0, 1
}
i++
c := s[i]
@@ -78,34 +78,43 @@ func unescapeEntity(b []byte, dst, src int, attribute bool) (dst1, src1 int) {
i++
}
+ i0 := i
x := '\x00'
for i < len(s) {
c = s[i]
- i++
+ var d rune
+ var mult rune
if hex {
+ mult = 16
if '0' <= c && c <= '9' {
- x = 16*x + rune(c) - '0'
- continue
+ d = rune(c) - '0'
} else if 'a' <= c && c <= 'f' {
- x = 16*x + rune(c) - 'a' + 10
- continue
+ d = rune(c) - 'a' + 10
} else if 'A' <= c && c <= 'F' {
- x = 16*x + rune(c) - 'A' + 10
- continue
+ d = rune(c) - 'A' + 10
+ } else {
+ break
+ }
+ } else {
+ mult = 10
+ if '0' <= c && c <= '9' {
+ d = rune(c) - '0'
+ } else {
+ break
}
- } else if '0' <= c && c <= '9' {
- x = 10*x + rune(c) - '0'
- continue
}
- if c != ';' {
- i--
+ if x <= 0x10FFFF {
+ x = mult*x + d
}
- break
+ i++
+ }
+
+ if i == i0 { // No characters matched.
+ return '&', 0, 1
}
- if i <= 3 { // No characters matched.
- b[dst] = b[src]
- return dst + 1, src + 1
+ if i < len(s) && s[i] == ';' {
+ i++
}
if 0x80 <= x && x <= 0x9F {
@@ -116,7 +125,7 @@ func unescapeEntity(b []byte, dst, src int, attribute bool) (dst1, src1 int) {
x = '\uFFFD'
}
- return dst + utf8.EncodeRune(b[dst:], x), src + i
+ return x, 0, i
}
// Consume the maximum number of characters possible, with the
@@ -141,10 +150,9 @@ func unescapeEntity(b []byte, dst, src int, attribute bool) (dst1, src1 int) {
} else if attribute && entityName[len(entityName)-1] != ';' && len(s) > i && s[i] == '=' {
// No-op.
} else if x := entity[entityName]; x != 0 {
- return dst + utf8.EncodeRune(b[dst:], x), src + i
+ return x, 0, i
} else if x := entity2[entityName]; x[0] != 0 {
- dst1 := dst + utf8.EncodeRune(b[dst:], x[0])
- return dst1 + utf8.EncodeRune(b[dst1:], x[1]), src + i
+ return x[0], x[1], i
} else if !attribute {
maxLen := len(entityName) - 1
if maxLen > longestEntityWithoutSemicolon {
@@ -152,35 +160,67 @@ func unescapeEntity(b []byte, dst, src int, attribute bool) (dst1, src1 int) {
}
for j := maxLen; j > 1; j-- {
if x := entity[entityName[:j]]; x != 0 {
- return dst + utf8.EncodeRune(b[dst:], x), src + j + 1
+ return x, 0, j + 1
}
}
}
- dst1, src1 = dst+i, src+i
- copy(b[dst:dst1], b[src:src1])
- return dst1, src1
+ return '&', 0, 1
}
-// unescape unescapes b's entities in-place, so that "a<b" becomes "a entityNameLen {
+ if reusingB {
+ out = slices.Clone(out)
+ reusingB = false
}
- return b[0:dst]
+ out = slices.Grow(out, replLen)
+ }
+ out = utf8.AppendRune(out, r1)
+ if r2 != 0 {
+ out = utf8.AppendRune(out, r2)
}
+
+ src += entityNameLen
}
- return b
+
+ return out
}
// lower lower-cases the A-Z bytes in b in-place, so that "aBc" becomes "abc".
diff --git a/vendor/golang.org/x/net/html/foreign.go b/vendor/golang.org/x/net/html/foreign.go
index e8515d8e8..65d01d1ed 100644
--- a/vendor/golang.org/x/net/html/foreign.go
+++ b/vendor/golang.org/x/net/html/foreign.go
@@ -23,7 +23,7 @@ func adjustForeignAttributes(aa []Attribute) {
}
switch a.Key {
case "xlink:actuate", "xlink:arcrole", "xlink:href", "xlink:role", "xlink:show",
- "xlink:title", "xlink:type", "xml:base", "xml:lang", "xml:space", "xmlns:xlink":
+ "xlink:title", "xlink:type", "xml:lang", "xml:space", "xmlns:xlink":
j := strings.Index(a.Key, ":")
aa[i].Namespace = a.Key[:j]
aa[i].Key = a.Key[j+1:]
diff --git a/vendor/golang.org/x/net/html/parse.go b/vendor/golang.org/x/net/html/parse.go
index b3d2a2558..165b6108d 100644
--- a/vendor/golang.org/x/net/html/parse.go
+++ b/vendor/golang.org/x/net/html/parse.go
@@ -63,7 +63,7 @@ func (p *parser) top() *Node {
// Stop tags for use in popUntil. These come from section 12.2.4.2.
var (
defaultScopeStopTags = map[string][]a.Atom{
- "": {a.Applet, a.Caption, a.Html, a.Table, a.Td, a.Th, a.Marquee, a.Object, a.Template},
+ "": {a.Applet, a.Caption, a.Html, a.Table, a.Td, a.Th, a.Marquee, a.Object, a.Template, a.Select},
"math": {a.AnnotationXml, a.Mi, a.Mn, a.Mo, a.Ms, a.Mtext},
"svg": {a.Desc, a.ForeignObject, a.Title},
}
@@ -78,7 +78,6 @@ const (
tableScope
tableRowScope
tableBodyScope
- selectScope
)
// popUntil pops the stack of open elements at the highest element whose tag
@@ -133,10 +132,6 @@ func (p *parser) indexOfElementInScope(s scope, matchTags ...a.Atom) int {
if tagAtom == a.Html || tagAtom == a.Table || tagAtom == a.Template {
return -1
}
- case selectScope:
- if tagAtom != a.Optgroup && tagAtom != a.Option {
- return -1
- }
default:
panic(fmt.Sprintf("html: internal error: indexOfElementInScope unknown scope: %d", s))
}
@@ -460,21 +455,6 @@ func (p *parser) resetInsertionMode() {
}
switch n.DataAtom {
- case a.Select:
- if !last {
- for ancestor, first := n, p.oe[0]; ancestor != first; {
- ancestor = p.oe[p.oe.index(ancestor)-1]
- switch ancestor.DataAtom {
- case a.Template:
- p.im = inSelectIM
- return
- case a.Table:
- p.im = inSelectInTableIM
- return
- }
- }
- }
- p.im = inSelectIM
case a.Td, a.Th:
// TODO: remove this divergence from the HTML5 spec.
//
@@ -1002,7 +982,10 @@ func inBodyIM(p *parser) bool {
p.popUntil(buttonScope, a.P)
p.addElement()
case a.Button:
- p.popUntil(defaultScope, a.Button)
+ if p.elementInScope(defaultScope, a.Button) {
+ p.generateImpliedEndTags()
+ p.popUntil(defaultScope, a.Button)
+ }
p.reconstructActiveFormattingElements()
p.addElement()
p.framesetOK = false
@@ -1040,7 +1023,18 @@ func inBodyIM(p *parser) bool {
p.framesetOK = false
p.im = inTableIM
return true
- case a.Area, a.Br, a.Embed, a.Img, a.Input, a.Keygen, a.Wbr:
+ case a.Area, a.Br, a.Embed, a.Img, a.Keygen, a.Wbr:
+ p.reconstructActiveFormattingElements()
+ p.addElement()
+ p.oe.pop()
+ p.acknowledgeSelfClosingTag()
+ p.framesetOK = false
+ case a.Input:
+ if p.fragment && p.context.DataAtom == a.Select {
+ // Ignore the token.
+ return true
+ }
+ p.popUntil(defaultScope, a.Select)
p.reconstructActiveFormattingElements()
p.addElement()
p.oe.pop()
@@ -1061,7 +1055,13 @@ func inBodyIM(p *parser) bool {
p.oe.pop()
p.acknowledgeSelfClosingTag()
case a.Hr:
- p.popUntil(buttonScope, a.P)
+ if p.elementInScope(buttonScope, a.P) {
+ p.generateImpliedEndTags("p")
+ p.popUntil(defaultScope, a.P)
+ }
+ if p.elementInScope(defaultScope, a.Select) {
+ p.generateImpliedEndTags()
+ }
p.addElement()
p.oe.pop()
p.acknowledgeSelfClosingTag()
@@ -1095,13 +1095,30 @@ func inBodyIM(p *parser) bool {
// Don't let the tokenizer go into raw text mode when scripting is disabled.
p.tokenizer.NextIsNotRawText()
case a.Select:
+ if p.fragment && p.context.DataAtom == a.Select {
+ // Ignore the token.
+ return true
+ } else if p.popUntil(defaultScope, a.Select) {
+ return true
+ }
p.reconstructActiveFormattingElements()
p.addElement()
p.framesetOK = false
- p.im = inSelectIM
return true
- case a.Optgroup, a.Option:
- if p.top().DataAtom == a.Option {
+ case a.Option:
+ if p.elementInScope(defaultScope, a.Select) {
+ p.generateImpliedEndTags("optgroup")
+ // If oe has option element in scope, parse error?
+ } else if p.top().DataAtom == a.Option {
+ p.oe.pop()
+ }
+ p.reconstructActiveFormattingElements()
+ p.addElement()
+ case a.Optgroup:
+ if p.elementInScope(defaultScope, a.Select) {
+ p.generateImpliedEndTags()
+ // If oe has option or optgroup element in scope, parse error?
+ } else if p.top().DataAtom == a.Option {
p.oe.pop()
}
p.reconstructActiveFormattingElements()
@@ -1149,7 +1166,12 @@ func inBodyIM(p *parser) bool {
return false
}
return true
- case a.Address, a.Article, a.Aside, a.Blockquote, a.Button, a.Center, a.Details, a.Dialog, a.Dir, a.Div, a.Dl, a.Fieldset, a.Figcaption, a.Figure, a.Footer, a.Header, a.Hgroup, a.Listing, a.Main, a.Menu, a.Nav, a.Ol, a.Pre, a.Search, a.Section, a.Summary, a.Ul:
+ case a.Address, a.Article, a.Aside, a.Blockquote, a.Button, a.Center, a.Details, a.Dialog, a.Dir, a.Div, a.Dl, a.Fieldset, a.Figcaption, a.Figure, a.Footer, a.Header, a.Hgroup, a.Listing, a.Main, a.Menu, a.Nav, a.Ol, a.Pre, a.Search, a.Section, a.Select, a.Summary, a.Ul:
+ if !p.elementInScope(defaultScope, p.tok.DataAtom) {
+ // Ignore the token.
+ return true
+ }
+ p.generateImpliedEndTags()
p.popUntil(defaultScope, p.tok.DataAtom)
case a.Form:
if p.oe.contains(a.Template) {
@@ -1488,17 +1510,6 @@ func inTableIM(p *parser) bool {
}
p.addElement()
p.form = p.oe.pop()
- case a.Select:
- p.reconstructActiveFormattingElements()
- switch p.top().DataAtom {
- case a.Table, a.Tbody, a.Tfoot, a.Thead, a.Tr:
- p.fosterParenting = true
- }
- p.addElement()
- p.fosterParenting = false
- p.framesetOK = false
- p.im = inSelectInTableIM
- return true
}
case EndTagToken:
switch p.tok.DataAtom {
@@ -1547,12 +1558,6 @@ func inCaptionIM(p *parser) bool {
p.clearActiveFormattingElements()
p.im = inTableIM
return false
- case a.Select:
- p.reconstructActiveFormattingElements()
- p.addElement()
- p.framesetOK = false
- p.im = inSelectInTableIM
- return true
}
case EndTagToken:
switch p.tok.DataAtom {
@@ -1762,12 +1767,6 @@ func inCellIM(p *parser) bool {
}
// Ignore the token.
return true
- case a.Select:
- p.reconstructActiveFormattingElements()
- p.addElement()
- p.framesetOK = false
- p.im = inSelectInTableIM
- return true
}
case EndTagToken:
switch p.tok.DataAtom {
@@ -1798,118 +1797,6 @@ func inCellIM(p *parser) bool {
return inBodyIM(p)
}
-// Section 12.2.6.4.16.
-func inSelectIM(p *parser) bool {
- switch p.tok.Type {
- case TextToken:
- p.addText(strings.Replace(p.tok.Data, "\x00", "", -1))
- case StartTagToken:
- switch p.tok.DataAtom {
- case a.Html:
- return inBodyIM(p)
- case a.Option:
- if p.top().DataAtom == a.Option {
- p.oe.pop()
- }
- p.addElement()
- case a.Optgroup:
- if p.top().DataAtom == a.Option {
- p.oe.pop()
- }
- if p.top().DataAtom == a.Optgroup {
- p.oe.pop()
- }
- p.addElement()
- case a.Select:
- if !p.popUntil(selectScope, a.Select) {
- // Ignore the token.
- return true
- }
- p.resetInsertionMode()
- case a.Input, a.Keygen, a.Textarea:
- if p.elementInScope(selectScope, a.Select) {
- p.parseImpliedToken(EndTagToken, a.Select, a.Select.String())
- return false
- }
- // In order to properly ignore