├── vendor ├── github.com │ ├── klauspost │ │ └── compress │ │ │ ├── s2sx.sum │ │ │ ├── huff0 │ │ │ └── .gitignore │ │ │ ├── .gitattributes │ │ │ ├── s2sx.mod │ │ │ ├── gen.sh │ │ │ ├── internal │ │ │ └── cpuinfo │ │ │ │ ├── cpuinfo_amd64.go │ │ │ │ └── cpuinfo_amd64.s │ │ │ ├── zstd │ │ │ └── internal │ │ │ │ └── xxhash │ │ │ │ ├── xxhash_safe.go │ │ │ │ └── xxhash_asm.go │ │ │ └── .gitignore │ ├── RoaringBitmap │ │ └── roaring │ │ │ ├── .gitmodules │ │ │ ├── .gitignore │ │ │ ├── setutil_arm64.go │ │ │ ├── clz.go │ │ │ ├── ctz.go │ │ │ ├── popcnt.go │ │ │ ├── AUTHORS │ │ │ ├── internal │ │ │ └── pools.go │ │ │ ├── .drone.yml │ │ │ ├── serializationfuzz.go │ │ │ ├── CONTRIBUTORS │ │ │ ├── serialization.go │ │ │ ├── popcnt_generic.go │ │ │ ├── popcnt_compat.go │ │ │ ├── clz_compat.go │ │ │ ├── manyiterator.go │ │ │ └── popcnt_slices.go │ ├── karlseguin │ │ └── ccache │ │ │ └── v2 │ │ │ ├── .gitignore │ │ │ └── Makefile │ ├── matttproud │ │ └── golang_protobuf_extensions │ │ │ ├── pbutil │ │ │ ├── .gitignore │ │ │ ├── Makefile │ │ │ └── doc.go │ │ │ └── NOTICE │ ├── prometheus │ │ ├── procfs │ │ │ ├── .gitignore │ │ │ ├── MAINTAINERS.md │ │ │ ├── CODE_OF_CONDUCT.md │ │ │ ├── SECURITY.md │ │ │ ├── .golangci.yml │ │ │ ├── NOTICE │ │ │ ├── cpuinfo_s390x.go │ │ │ ├── cpuinfo_loong64.go │ │ │ ├── cpuinfo_armx.go │ │ │ ├── cpuinfo_x86.go │ │ │ ├── cpuinfo_ppcx.go │ │ │ ├── cpuinfo_riscvx.go │ │ │ └── cpuinfo_mipsx.go │ │ ├── client_golang │ │ │ ├── prometheus │ │ │ │ ├── .gitignore │ │ │ │ ├── README.md │ │ │ │ ├── get_pid_gopherjs.go │ │ │ │ ├── num_threads_gopherjs.go │ │ │ │ ├── get_pid.go │ │ │ │ └── process_collector_js.go │ │ │ └── NOTICE │ │ ├── client_model │ │ │ └── NOTICE │ │ └── common │ │ │ ├── NOTICE │ │ │ └── model │ │ │ └── model.go │ ├── kr │ │ ├── pretty │ │ │ ├── .gitignore │ │ │ └── Readme │ │ └── text │ │ │ ├── doc.go │ │ │ └── Readme │ ├── ohler55 │ │ └── ojg │ │ │ ├── .coveralls.yml │ │ │ ├── alt │ │ │ ├── Makefile │ │ │ ├── attrsetter.go │ │ │ └── simplifier.go │ │ │ ├── gen │ │ │ ├── Makefile │ │ │ ├── error.go │ │ │ ├── node.go │ │ │ ├── big.go │ │ │ ├── doc.go │ │ │ ├── int.go │ │ │ ├── float.go │ │ │ ├── string.go │ │ │ ├── key.go │ │ │ └── bool.go │ │ │ ├── jp │ │ │ ├── Makefile │ │ │ ├── doc.go │ │ │ ├── frag.go │ │ │ ├── indexed.go │ │ │ ├── at.go │ │ │ ├── root.go │ │ │ ├── bracket.go │ │ │ └── keyed.go │ │ │ ├── .gitignore │ │ │ ├── go.yml │ │ │ ├── Makefile │ │ │ ├── numconvmethod.go │ │ │ └── error.go │ ├── cockroachdb │ │ ├── tokenbucket │ │ │ └── README.md │ │ ├── redact │ │ │ ├── .travis.yml │ │ │ ├── .gitignore │ │ │ ├── README.md │ │ │ └── internal │ │ │ │ └── rfmt │ │ │ │ └── refresh.sh │ │ ├── errors │ │ │ ├── errorspb │ │ │ │ ├── hintdetail.proto │ │ │ │ ├── testing.proto │ │ │ │ ├── markers.proto │ │ │ │ ├── tags.proto │ │ │ │ ├── testing.go │ │ │ │ ├── markers.go │ │ │ │ └── errors.go │ │ │ ├── .gitignore │ │ │ ├── errbase │ │ │ │ ├── oserror_pre116.go │ │ │ │ └── oserror_go116.go │ │ │ └── errutil │ │ │ │ └── doc.go │ │ ├── pebble │ │ │ ├── .gitignore │ │ │ ├── .editorconfig │ │ │ ├── internal │ │ │ │ ├── cache │ │ │ │ │ ├── cgo_enabled.go │ │ │ │ │ ├── cgo_disabled.go │ │ │ │ │ ├── clockpro_normal.go │ │ │ │ │ └── clockpro_tracing.go │ │ │ │ ├── invariants │ │ │ │ │ ├── race_on.go │ │ │ │ │ ├── race_off.go │ │ │ │ │ ├── on.go │ │ │ │ │ ├── off.go │ │ │ │ │ ├── finalizer_off.go │ │ │ │ │ └── finalizer_on.go │ │ │ │ ├── manual │ │ │ │ │ ├── manual_mips.go │ │ │ │ │ ├── manual_32bit.go │ │ │ │ │ ├── manual_nocgo.go │ │ │ │ │ └── manual_64bit.go │ │ │ │ ├── fastrand │ │ │ │ │ └── fastrand.go │ │ │ │ ├── intern │ │ │ │ │ └── intern.go │ │ │ │ ├── keyspan │ │ │ │ │ └── doc.go │ │ │ │ ├── constants │ │ │ │ │ └── constants.go │ │ │ │ ├── private │ │ │ │ │ └── batch.go │ │ │ │ └── rawalloc │ │ │ │ │ ├── rawalloc_mips.go │ │ │ │ │ ├── rawalloc_32bit.go │ │ │ │ │ └── rawalloc_gccgo.go │ │ │ ├── vfs │ │ │ │ ├── fadvise_generic.go │ │ │ │ ├── errors_windows.go │ │ │ │ ├── errors_unix.go │ │ │ │ ├── fadvise_linux.go │ │ │ │ ├── disk_usage_windows.go │ │ │ │ ├── file_lock_generic.go │ │ │ │ ├── disk_usage_netbsd.go │ │ │ │ ├── disk_usage_openbsd.go │ │ │ │ └── disk_usage_unix.go │ │ │ ├── logger.go │ │ │ ├── objstorage │ │ │ │ └── remote │ │ │ │ │ └── factory.go │ │ │ └── cache.go │ │ ├── logtags │ │ │ └── .gitignore │ │ └── fifo │ │ │ ├── .gitignore │ │ │ ├── invariants_on.go │ │ │ └── invariants_off.go │ ├── getsentry │ │ └── sentry-go │ │ │ ├── profiler_other.go │ │ │ ├── internal │ │ │ ├── ratelimit │ │ │ │ ├── doc.go │ │ │ │ └── deadline.go │ │ │ └── traceparser │ │ │ │ └── README.md │ │ │ ├── MIGRATION.md │ │ │ ├── doc.go │ │ │ ├── .gitignore │ │ │ ├── .gitattributes │ │ │ ├── .craft.yml │ │ │ ├── .codecov.yml │ │ │ ├── stacktrace_below_go1.20.go │ │ │ ├── stacktrace_go1.20.go │ │ │ ├── traces_sampler.go │ │ │ └── profiler_windows.go │ ├── google │ │ ├── uuid │ │ │ ├── CONTRIBUTORS │ │ │ ├── doc.go │ │ │ ├── node_js.go │ │ │ └── README.md │ │ └── cel-go │ │ │ ├── common │ │ │ ├── overloads │ │ │ │ └── BUILD.bazel │ │ │ ├── operators │ │ │ │ └── BUILD.bazel │ │ │ ├── functions │ │ │ │ └── BUILD.bazel │ │ │ ├── debug │ │ │ │ └── BUILD.bazel │ │ │ ├── runes │ │ │ │ └── BUILD.bazel │ │ │ ├── types │ │ │ │ ├── ref │ │ │ │ │ └── BUILD.bazel │ │ │ │ ├── doc.go │ │ │ │ ├── traits │ │ │ │ │ ├── BUILD.bazel │ │ │ │ │ ├── zeroer.go │ │ │ │ │ ├── sizer.go │ │ │ │ │ └── matcher.go │ │ │ │ └── any_value.go │ │ │ ├── containers │ │ │ │ └── BUILD.bazel │ │ │ ├── doc.go │ │ │ ├── stdlib │ │ │ │ └── BUILD.bazel │ │ │ └── BUILD.bazel │ │ │ ├── checker │ │ │ └── decls │ │ │ │ └── BUILD.bazel │ │ │ ├── parser │ │ │ └── gen │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── doc.go │ │ │ │ ├── CEL.tokens │ │ │ │ └── CELLexer.tokens │ │ │ └── cel │ │ │ └── cel.go │ ├── bits-and-blooms │ │ └── bitset │ │ │ ├── SECURITY.md │ │ │ ├── trailing_zeros_19.go │ │ │ ├── .gitignore │ │ │ ├── trailing_zeros_18.go │ │ │ ├── popcnt_generic.go │ │ │ └── .travis.yml │ ├── pkg │ │ └── errors │ │ │ ├── .travis.yml │ │ │ ├── .gitignore │ │ │ └── appveyor.yml │ ├── golang │ │ ├── protobuf │ │ │ ├── AUTHORS │ │ │ └── CONTRIBUTORS │ │ └── snappy │ │ │ ├── .gitignore │ │ │ ├── decode_asm.go │ │ │ ├── AUTHORS │ │ │ └── encode_asm.go │ ├── sourcegraph │ │ └── conc │ │ │ ├── internal │ │ │ └── multierror │ │ │ │ ├── multierror_go120.go │ │ │ │ └── multierror_go119.go │ │ │ ├── .golangci.yml │ │ │ └── panics │ │ │ └── try.go │ ├── stretchr │ │ └── testify │ │ │ ├── require │ │ │ ├── require_forward.go.tmpl │ │ │ ├── require.go.tmpl │ │ │ └── forward_requirements.go │ │ │ └── assert │ │ │ ├── assertion_format.go.tmpl │ │ │ ├── assertion_forward.go.tmpl │ │ │ ├── errors.go │ │ │ └── forward_assertions.go │ ├── mschoch │ │ └── smat │ │ │ ├── .gitignore │ │ │ └── .travis.yml │ ├── stoewer │ │ └── go-strcase │ │ │ ├── .gitignore │ │ │ ├── doc.go │ │ │ ├── .golangci.yml │ │ │ └── kebab.go │ ├── antlr4-go │ │ └── antlr │ │ │ └── v4 │ │ │ ├── .gitignore │ │ │ ├── atn_type.go │ │ │ ├── char_stream.go │ │ │ ├── int_stream.go │ │ │ ├── token_source.go │ │ │ ├── token_stream.go │ │ │ └── stats_data.go │ ├── cespare │ │ └── xxhash │ │ │ └── v2 │ │ │ ├── testall.sh │ │ │ ├── xxhash_asm.go │ │ │ └── xxhash_safe.go │ ├── DataDog │ │ └── zstd │ │ │ └── travis_test_32.sh │ ├── gogo │ │ └── protobuf │ │ │ ├── AUTHORS │ │ │ └── CONTRIBUTORS │ ├── rogpeppe │ │ └── go-internal │ │ │ └── fmtsort │ │ │ ├── mapelem.go │ │ │ └── mapelem_1.11.go │ └── davecgh │ │ └── go-spew │ │ └── LICENSE ├── golang.org │ └── x │ │ ├── sys │ │ ├── unix │ │ │ ├── .gitignore │ │ │ ├── ptrace_ios.go │ │ │ ├── syscall_linux_amd64_gc.go │ │ │ ├── endian_big.go │ │ │ ├── ptrace_darwin.go │ │ │ ├── constants.go │ │ │ ├── mmap_nomremap.go │ │ │ ├── endian_little.go │ │ │ ├── aliases.go │ │ │ ├── pagesize_unix.go │ │ │ ├── readdirent_getdents.go │ │ │ ├── sysvshm_unix_other.go │ │ │ ├── asm_aix_ppc64.s │ │ │ ├── syscall_linux_gc_arm.go │ │ │ ├── asm_solaris_amd64.s │ │ │ ├── fcntl_linux_32bit.go │ │ │ ├── syscall_linux_alarm.go │ │ │ ├── gccgo_linux_amd64.go │ │ │ ├── syscall_linux_gc.go │ │ │ ├── syscall_hurd_386.go │ │ │ ├── sysvshm_linux.go │ │ │ ├── sockcmsg_dragonfly.go │ │ │ ├── race0.go │ │ │ ├── syscall_linux_gc_386.go │ │ │ ├── syscall_linux_gccgo_arm.go │ │ │ ├── syscall_unix_gc.go │ │ │ ├── syscall_solaris_amd64.go │ │ │ ├── race.go │ │ │ ├── syscall_hurd.go │ │ │ ├── env_unix.go │ │ │ ├── readdirent_getdirentries.go │ │ │ ├── asm_bsd_arm.s │ │ │ ├── zptrace_linux_arm64.go │ │ │ ├── asm_openbsd_mips64.s │ │ │ ├── asm_bsd_386.s │ │ │ ├── asm_bsd_arm64.s │ │ │ ├── asm_bsd_riscv64.s │ │ │ ├── asm_bsd_amd64.s │ │ │ ├── asm_bsd_ppc64.s │ │ │ ├── bluetooth_linux.go │ │ │ ├── dev_aix_ppc.go │ │ │ ├── dev_darwin.go │ │ │ ├── syscall_unix_gc_ppc64x.go │ │ │ ├── fdset.go │ │ │ ├── fcntl_darwin.go │ │ │ └── dev_zos.go │ │ ├── windows │ │ │ ├── empty.s │ │ │ ├── aliases.go │ │ │ ├── mksyscall.go │ │ │ ├── race0.go │ │ │ ├── str.go │ │ │ ├── race.go │ │ │ └── eventlog.go │ │ └── execabs │ │ │ ├── execabs_go118.go │ │ │ └── execabs_go119.go │ │ └── text │ │ ├── internal │ │ └── language │ │ │ ├── common.go │ │ │ └── coverage.go │ │ └── width │ │ ├── trieval.go │ │ └── kind_string.go ├── go.uber.org │ ├── multierr │ │ ├── .gitignore │ │ ├── glide.yaml │ │ ├── .codecov.yml │ │ └── README.md │ └── atomic │ │ ├── .gitignore │ │ ├── .travis.yml │ │ └── .codecov.yml ├── google.golang.org │ └── protobuf │ │ ├── internal │ │ ├── editiondefaults │ │ │ ├── editions_defaults.binpb │ │ │ └── defaults.go │ │ ├── flags │ │ │ ├── proto_legacy_enable.go │ │ │ └── proto_legacy_disable.go │ │ ├── impl │ │ │ ├── codec_map_go112.go │ │ │ ├── codec_unsafe.go │ │ │ ├── enum.go │ │ │ └── codec_map_go111.go │ │ ├── errors │ │ │ └── is_go113.go │ │ ├── genid │ │ │ ├── doc.go │ │ │ ├── wrappers.go │ │ │ ├── map_entry.go │ │ │ ├── empty_gen.go │ │ │ └── goname.go │ │ └── strs │ │ │ └── strings_pure.go │ │ ├── encoding │ │ ├── prototext │ │ │ └── doc.go │ │ └── protojson │ │ │ └── doc.go │ │ ├── runtime │ │ └── protoiface │ │ │ └── legacy.go │ │ └── proto │ │ ├── proto_reflect.go │ │ └── proto_methods.go └── gopkg.in │ └── yaml.v3 │ └── NOTICE ├── Makefile ├── shell.nix ├── utils.go ├── groupid_test.go ├── flake.nix ├── README.md ├── .github └── workflows │ └── go.yaml └── .gitignore /vendor/github.com/klauspost/compress/s2sx.sum: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /vendor/github.com/RoaringBitmap/roaring/.gitmodules: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /vendor/github.com/karlseguin/ccache/v2/.gitignore: -------------------------------------------------------------------------------- 1 | vendor/ 2 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/.gitignore: -------------------------------------------------------------------------------- 1 | _obj/ 2 | unix.test 3 | -------------------------------------------------------------------------------- /vendor/github.com/klauspost/compress/huff0/.gitignore: -------------------------------------------------------------------------------- 1 | /huff0-fuzz.zip 2 | -------------------------------------------------------------------------------- /vendor/github.com/klauspost/compress/.gitattributes: -------------------------------------------------------------------------------- 1 | * -text 2 | *.bin -text -diff 3 | -------------------------------------------------------------------------------- /vendor/github.com/matttproud/golang_protobuf_extensions/pbutil/.gitignore: -------------------------------------------------------------------------------- 1 | cover.dat 2 | -------------------------------------------------------------------------------- /vendor/github.com/prometheus/procfs/.gitignore: -------------------------------------------------------------------------------- 1 | /testdata/fixtures/ 2 | /fixtures 3 | -------------------------------------------------------------------------------- /vendor/go.uber.org/multierr/.gitignore: -------------------------------------------------------------------------------- 1 | /vendor 2 | cover.html 3 | cover.out 4 | /bin 5 | -------------------------------------------------------------------------------- /vendor/github.com/kr/pretty/.gitignore: -------------------------------------------------------------------------------- 1 | [568].out 2 | _go* 3 | _test* 4 | _obj 5 | /.idea 6 | -------------------------------------------------------------------------------- /vendor/github.com/ohler55/ojg/.coveralls.yml: -------------------------------------------------------------------------------- 1 | repo_token: t2TmOT2IIY7dLqAxhiyOoManIEpVx3z5m 2 | -------------------------------------------------------------------------------- /vendor/github.com/prometheus/client_golang/prometheus/.gitignore: -------------------------------------------------------------------------------- 1 | command-line-arguments.test 2 | -------------------------------------------------------------------------------- /vendor/github.com/karlseguin/ccache/v2/Makefile: -------------------------------------------------------------------------------- 1 | t: 2 | go test ./... 3 | 4 | f: 5 | go fmt ./... 6 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/tokenbucket/README.md: -------------------------------------------------------------------------------- 1 | # tokenbucket 2 | Token bucket implementation in Go 3 | -------------------------------------------------------------------------------- /vendor/github.com/klauspost/compress/s2sx.mod: -------------------------------------------------------------------------------- 1 | module github.com/klauspost/compress 2 | 3 | go 1.16 4 | 5 | -------------------------------------------------------------------------------- /vendor/github.com/klauspost/compress/gen.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | 3 | cd s2/cmd/_s2sx/ || exit 1 4 | go generate . 5 | -------------------------------------------------------------------------------- /vendor/github.com/matttproud/golang_protobuf_extensions/NOTICE: -------------------------------------------------------------------------------- 1 | Copyright 2012 Matt T. Proud (matt.proud@gmail.com) 2 | -------------------------------------------------------------------------------- /vendor/github.com/RoaringBitmap/roaring/.gitignore: -------------------------------------------------------------------------------- 1 | *~ 2 | roaring-fuzz.zip 3 | workdir 4 | coverage.out 5 | testdata/all3.classic 6 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/redact/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | 3 | go: 4 | - 1.12.x 5 | - 1.13.x 6 | - 1.14.x 7 | - 1.15.x 8 | -------------------------------------------------------------------------------- /vendor/github.com/getsentry/sentry-go/profiler_other.go: -------------------------------------------------------------------------------- 1 | //go:build !windows 2 | 3 | package sentry 4 | 5 | func onProfilerStart() {} 6 | -------------------------------------------------------------------------------- /vendor/github.com/kr/text/doc.go: -------------------------------------------------------------------------------- 1 | // Package text provides rudimentary functions for manipulating text in 2 | // paragraphs. 3 | package text 4 | -------------------------------------------------------------------------------- /vendor/github.com/prometheus/procfs/MAINTAINERS.md: -------------------------------------------------------------------------------- 1 | * Johannes 'fish' Ziemke @discordianfish 2 | * Paul Gier @pgier 3 | -------------------------------------------------------------------------------- /vendor/github.com/kr/text/Readme: -------------------------------------------------------------------------------- 1 | This is a Go package for manipulating paragraphs of text. 2 | 3 | See http://go.pkgdoc.org/github.com/kr/text for full documentation. 4 | -------------------------------------------------------------------------------- /vendor/github.com/ohler55/ojg/alt/Makefile: -------------------------------------------------------------------------------- 1 | 2 | all: cover 3 | 4 | cover: 5 | go test -coverpkg github.com/ohler55/ojg/alt -coverprofile=cov.out 6 | 7 | .PHONY: all cover 8 | -------------------------------------------------------------------------------- /vendor/github.com/ohler55/ojg/gen/Makefile: -------------------------------------------------------------------------------- 1 | 2 | all: cover 3 | 4 | cover: 5 | go test -coverpkg github.com/ohler55/ojg/gen -coverprofile=cov.out 6 | 7 | .PHONY: all cover 8 | -------------------------------------------------------------------------------- /vendor/github.com/ohler55/ojg/jp/Makefile: -------------------------------------------------------------------------------- 1 | 2 | all: cover 3 | 4 | cover: 5 | go test -coverpkg github.com/ohler55/ojg/jp -coverprofile=cov.out 6 | 7 | .PHONY: all cover 8 | -------------------------------------------------------------------------------- /vendor/github.com/google/uuid/CONTRIBUTORS: -------------------------------------------------------------------------------- 1 | Paul Borman 2 | bmatsuo 3 | shawnps 4 | theory 5 | jboverfelt 6 | dsymonds 7 | cd1 8 | wallclockbuilder 9 | dansouza 10 | -------------------------------------------------------------------------------- /vendor/go.uber.org/atomic/.gitignore: -------------------------------------------------------------------------------- 1 | /bin 2 | .DS_Store 3 | /vendor 4 | cover.html 5 | cover.out 6 | lint.log 7 | 8 | # Binaries 9 | *.test 10 | 11 | # Profiling output 12 | *.prof 13 | -------------------------------------------------------------------------------- /vendor/github.com/getsentry/sentry-go/internal/ratelimit/doc.go: -------------------------------------------------------------------------------- 1 | // Package ratelimit provides tools to work with rate limits imposed by Sentry's 2 | // data ingestion pipeline. 3 | package ratelimit 4 | -------------------------------------------------------------------------------- /vendor/github.com/matttproud/golang_protobuf_extensions/pbutil/Makefile: -------------------------------------------------------------------------------- 1 | all: 2 | 3 | cover: 4 | go test -cover -v -coverprofile=cover.dat ./... 5 | go tool cover -func cover.dat 6 | 7 | .PHONY: cover 8 | -------------------------------------------------------------------------------- /vendor/github.com/bits-and-blooms/bitset/SECURITY.md: -------------------------------------------------------------------------------- 1 | # Security Policy 2 | 3 | ## Reporting a Vulnerability 4 | 5 | You can report privately a vulnerability by email at daniel@lemire.me (current maintainer). 6 | -------------------------------------------------------------------------------- /vendor/github.com/pkg/errors/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | go_import_path: github.com/pkg/errors 3 | go: 4 | - 1.11.x 5 | - 1.12.x 6 | - 1.13.x 7 | - tip 8 | 9 | script: 10 | - make check 11 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/editiondefaults/editions_defaults.binpb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/inngest/expr/HEAD/vendor/google.golang.org/protobuf/internal/editiondefaults/editions_defaults.binpb -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | .PHONY: itest 2 | itest: 3 | go test . -v -count=1 -race 4 | 5 | .PHONY: utest 6 | utest: 7 | go test -test.v -short -race 8 | 9 | .PHONY: lint 10 | lint: 11 | golangci-lint run --verbose 12 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/errors/errorspb/hintdetail.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto3"; 2 | package cockroach.errorspb; 3 | option go_package = "errorspb"; 4 | 5 | message StringPayload { 6 | string msg = 1; 7 | } 8 | -------------------------------------------------------------------------------- /vendor/github.com/prometheus/procfs/CODE_OF_CONDUCT.md: -------------------------------------------------------------------------------- 1 | # Prometheus Community Code of Conduct 2 | 3 | Prometheus follows the [CNCF Code of Conduct](https://github.com/cncf/foundation/blob/main/code-of-conduct.md). 4 | -------------------------------------------------------------------------------- /vendor/github.com/golang/protobuf/AUTHORS: -------------------------------------------------------------------------------- 1 | # This source code refers to The Go Authors for copyright purposes. 2 | # The master list of authors is in the main Go distribution, 3 | # visible at http://tip.golang.org/AUTHORS. 4 | -------------------------------------------------------------------------------- /vendor/github.com/golang/protobuf/CONTRIBUTORS: -------------------------------------------------------------------------------- 1 | # This source code was written by the Go contributors. 2 | # The master list of contributors is in the main Go distribution, 3 | # visible at http://tip.golang.org/CONTRIBUTORS. 4 | -------------------------------------------------------------------------------- /vendor/github.com/sourcegraph/conc/internal/multierror/multierror_go120.go: -------------------------------------------------------------------------------- 1 | //go:build go1.20 2 | // +build go1.20 3 | 4 | package multierror 5 | 6 | import "errors" 7 | 8 | var ( 9 | Join = errors.Join 10 | ) 11 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/errors/errorspb/testing.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto3"; 2 | package cockroach.errorspb; 3 | option go_package = "errorspb"; 4 | 5 | // TestError is meant for use in testing only. 6 | message TestError{} 7 | -------------------------------------------------------------------------------- /vendor/go.uber.org/multierr/glide.yaml: -------------------------------------------------------------------------------- 1 | package: go.uber.org/multierr 2 | import: 3 | - package: go.uber.org/atomic 4 | version: ^1 5 | testImport: 6 | - package: github.com/stretchr/testify 7 | subpackages: 8 | - assert 9 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/pebble/.gitignore: -------------------------------------------------------------------------------- 1 | # Github action artifacts. 2 | artifacts 3 | # Profiling artifacts. 4 | cpu.*.prof 5 | heap.prof 6 | mutex.prof 7 | coverprofile.out 8 | # Testing artifacts 9 | meta.*.test 10 | -------------------------------------------------------------------------------- /vendor/github.com/prometheus/client_golang/prometheus/README.md: -------------------------------------------------------------------------------- 1 | See [![Go Reference](https://pkg.go.dev/badge/github.com/prometheus/client_golang/prometheus.svg)](https://pkg.go.dev/github.com/prometheus/client_golang/prometheus). 2 | -------------------------------------------------------------------------------- /vendor/github.com/prometheus/client_model/NOTICE: -------------------------------------------------------------------------------- 1 | Data model artifacts for Prometheus. 2 | Copyright 2012-2015 The Prometheus Authors 3 | 4 | This product includes software developed at 5 | SoundCloud Ltd. (http://soundcloud.com/). 6 | -------------------------------------------------------------------------------- /vendor/github.com/prometheus/common/NOTICE: -------------------------------------------------------------------------------- 1 | Common libraries shared by Prometheus Go components. 2 | Copyright 2015 The Prometheus Authors 3 | 4 | This product includes software developed at 5 | SoundCloud Ltd. (http://soundcloud.com/). 6 | -------------------------------------------------------------------------------- /vendor/github.com/prometheus/procfs/SECURITY.md: -------------------------------------------------------------------------------- 1 | # Reporting a security issue 2 | 3 | The Prometheus security policy, including how to report vulnerabilities, can be 4 | found here: 5 | 6 | 7 | -------------------------------------------------------------------------------- /vendor/github.com/kr/pretty/Readme: -------------------------------------------------------------------------------- 1 | package pretty 2 | 3 | import "github.com/kr/pretty" 4 | 5 | Package pretty provides pretty-printing for Go values. 6 | 7 | Documentation 8 | 9 | http://godoc.org/github.com/kr/pretty 10 | -------------------------------------------------------------------------------- /vendor/github.com/sourcegraph/conc/internal/multierror/multierror_go119.go: -------------------------------------------------------------------------------- 1 | //go:build !go1.20 2 | // +build !go1.20 3 | 4 | package multierror 5 | 6 | import "go.uber.org/multierr" 7 | 8 | var ( 9 | Join = multierr.Combine 10 | ) 11 | -------------------------------------------------------------------------------- /vendor/github.com/prometheus/procfs/.golangci.yml: -------------------------------------------------------------------------------- 1 | --- 2 | linters: 3 | enable: 4 | - godot 5 | - revive 6 | 7 | linter-settings: 8 | godot: 9 | capital: true 10 | exclude: 11 | # Ignore "See: URL" 12 | - 'See:' 13 | -------------------------------------------------------------------------------- /vendor/github.com/getsentry/sentry-go/MIGRATION.md: -------------------------------------------------------------------------------- 1 | # `raven-go` to `sentry-go` Migration Guide 2 | 3 | A [`raven-go` to `sentry-go` migration guide](https://docs.sentry.io/platforms/go/migration/) is available at the official Sentry documentation site. 4 | -------------------------------------------------------------------------------- /vendor/github.com/bits-and-blooms/bitset/trailing_zeros_19.go: -------------------------------------------------------------------------------- 1 | //go:build go1.9 2 | // +build go1.9 3 | 4 | package bitset 5 | 6 | import "math/bits" 7 | 8 | func trailingZeroes64(v uint64) uint { 9 | return uint(bits.TrailingZeros64(v)) 10 | } 11 | -------------------------------------------------------------------------------- /vendor/github.com/sourcegraph/conc/.golangci.yml: -------------------------------------------------------------------------------- 1 | linters: 2 | disable-all: true 3 | enable: 4 | - errcheck 5 | - godot 6 | - gosimple 7 | - govet 8 | - ineffassign 9 | - staticcheck 10 | - typecheck 11 | - unused 12 | -------------------------------------------------------------------------------- /vendor/github.com/stretchr/testify/require/require_forward.go.tmpl: -------------------------------------------------------------------------------- 1 | {{.CommentWithoutT "a"}} 2 | func (a *Assertions) {{.DocInfo.Name}}({{.Params}}) { 3 | if h, ok := a.t.(tHelper); ok { h.Helper() } 4 | {{.DocInfo.Name}}(a.t, {{.ForwardedParams}}) 5 | } 6 | -------------------------------------------------------------------------------- /vendor/github.com/RoaringBitmap/roaring/setutil_arm64.go: -------------------------------------------------------------------------------- 1 | //go:build arm64 && !gccgo && !appengine 2 | // +build arm64,!gccgo,!appengine 3 | 4 | package roaring 5 | 6 | //go:noescape 7 | func union2by2(set1 []uint16, set2 []uint16, buffer []uint16) (size int) 8 | -------------------------------------------------------------------------------- /vendor/github.com/mschoch/smat/.gitignore: -------------------------------------------------------------------------------- 1 | #* 2 | *.sublime-* 3 | *~ 4 | .#* 5 | .project 6 | .settings 7 | **/.idea/ 8 | **/*.iml 9 | /examples/bolt/boltsmat-fuzz.zip 10 | /examples/bolt/workdir/ 11 | .DS_Store 12 | coverage.out 13 | *.test 14 | tags 15 | -------------------------------------------------------------------------------- /vendor/github.com/stretchr/testify/assert/assertion_format.go.tmpl: -------------------------------------------------------------------------------- 1 | {{.CommentFormat}} 2 | func {{.DocInfo.Name}}f(t TestingT, {{.ParamsFormat}}) bool { 3 | if h, ok := t.(tHelper); ok { h.Helper() } 4 | return {{.DocInfo.Name}}(t, {{.ForwardedParamsFormat}}) 5 | } 6 | -------------------------------------------------------------------------------- /vendor/github.com/stretchr/testify/assert/assertion_forward.go.tmpl: -------------------------------------------------------------------------------- 1 | {{.CommentWithoutT "a"}} 2 | func (a *Assertions) {{.DocInfo.Name}}({{.Params}}) bool { 3 | if h, ok := a.t.(tHelper); ok { h.Helper() } 4 | return {{.DocInfo.Name}}(a.t, {{.ForwardedParams}}) 5 | } 6 | -------------------------------------------------------------------------------- /vendor/github.com/stretchr/testify/require/require.go.tmpl: -------------------------------------------------------------------------------- 1 | {{.Comment}} 2 | func {{.DocInfo.Name}}(t TestingT, {{.Params}}) { 3 | if h, ok := t.(tHelper); ok { h.Helper() } 4 | if assert.{{.DocInfo.Name}}(t, {{.ForwardedParams}}) { return } 5 | t.FailNow() 6 | } 7 | -------------------------------------------------------------------------------- /vendor/github.com/getsentry/sentry-go/doc.go: -------------------------------------------------------------------------------- 1 | /* 2 | Package repository: https://github.com/getsentry/sentry-go/ 3 | 4 | For more information about Sentry and SDK features, please have a look at the official documentation site: https://docs.sentry.io/platforms/go/ 5 | */ 6 | package sentry 7 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/errors/.gitignore: -------------------------------------------------------------------------------- 1 | # Binaries for programs and plugins 2 | *.exe 3 | *.exe~ 4 | *.dll 5 | *.so 6 | *.dylib 7 | 8 | # Test binary, build with `go test -c` 9 | *.test 10 | 11 | # Output of the go coverage tool, specifically when used with LiteIDE 12 | *.out 13 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/logtags/.gitignore: -------------------------------------------------------------------------------- 1 | # Binaries for programs and plugins 2 | *.exe 3 | *.exe~ 4 | *.dll 5 | *.so 6 | *.dylib 7 | 8 | # Test binary, build with `go test -c` 9 | *.test 10 | 11 | # Output of the go coverage tool, specifically when used with LiteIDE 12 | *.out 13 | -------------------------------------------------------------------------------- /vendor/github.com/getsentry/sentry-go/.gitignore: -------------------------------------------------------------------------------- 1 | # Code coverage artifacts 2 | coverage.txt 3 | coverage.out 4 | coverage.html 5 | .coverage/ 6 | 7 | # Just my personal way of tracking stuff — Kamil 8 | FIXME.md 9 | TODO.md 10 | !NOTES.md 11 | 12 | # IDE system files 13 | .idea 14 | .vscode 15 | -------------------------------------------------------------------------------- /vendor/github.com/prometheus/procfs/NOTICE: -------------------------------------------------------------------------------- 1 | procfs provides functions to retrieve system, kernel and process 2 | metrics from the pseudo-filesystem proc. 3 | 4 | Copyright 2014-2015 The Prometheus Authors 5 | 6 | This product includes software developed at 7 | SoundCloud Ltd. (http://soundcloud.com/). 8 | -------------------------------------------------------------------------------- /vendor/github.com/stoewer/go-strcase/.gitignore: -------------------------------------------------------------------------------- 1 | # Compiled Object files, Static and Dynamic libs (Shared Objects) 2 | *.o 3 | *.a 4 | *.so 5 | 6 | # Folders 7 | vendor 8 | doc 9 | 10 | # Temporary files 11 | *~ 12 | *.swp 13 | 14 | # Editor and IDE config 15 | .idea 16 | *.iml 17 | .vscode 18 | -------------------------------------------------------------------------------- /vendor/github.com/getsentry/sentry-go/.gitattributes: -------------------------------------------------------------------------------- 1 | # Tell Git to use LF for line endings on all platforms. 2 | # Required to have correct test data on Windows. 3 | # https://github.com/mvdan/github-actions-golang#caveats 4 | # https://github.com/actions/checkout/issues/135#issuecomment-613361104 5 | * text eol=lf 6 | -------------------------------------------------------------------------------- /vendor/github.com/antlr4-go/antlr/v4/.gitignore: -------------------------------------------------------------------------------- 1 | ### Go template 2 | 3 | # Binaries for programs and plugins 4 | *.exe 5 | *.exe~ 6 | *.dll 7 | *.so 8 | *.dylib 9 | 10 | # Test binary, built with `go test -c` 11 | *.test 12 | 13 | 14 | # Go workspace file 15 | go.work 16 | 17 | # No Goland stuff in this repo 18 | .idea 19 | -------------------------------------------------------------------------------- /vendor/github.com/klauspost/compress/internal/cpuinfo/cpuinfo_amd64.go: -------------------------------------------------------------------------------- 1 | //go:build amd64 && !appengine && !noasm && gc 2 | // +build amd64,!appengine,!noasm,gc 3 | 4 | package cpuinfo 5 | 6 | // go:noescape 7 | func x86extensions() (bmi1, bmi2 bool) 8 | 9 | func init() { 10 | hasBMI1, hasBMI2 = x86extensions() 11 | } 12 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/pebble/.editorconfig: -------------------------------------------------------------------------------- 1 | # See http://editorconfig.org 2 | 3 | [*] 4 | end_of_line = lf 5 | insert_final_newline = true 6 | charset = utf-8 7 | 8 | # For non-go files, we indent with two spaces. In go files we indent 9 | # with tabs but still set indent_size to control the github web viewer. 10 | indent_size=2 11 | -------------------------------------------------------------------------------- /vendor/github.com/getsentry/sentry-go/.craft.yml: -------------------------------------------------------------------------------- 1 | minVersion: 0.35.0 2 | changelogPolicy: simple 3 | artifactProvider: 4 | name: none 5 | targets: 6 | - name: github 7 | tagPrefix: v 8 | - name: github 9 | tagPrefix: otel/v 10 | tagOnly: true 11 | - name: registry 12 | sdks: 13 | github:getsentry/sentry-go: 14 | -------------------------------------------------------------------------------- /vendor/github.com/RoaringBitmap/roaring/clz.go: -------------------------------------------------------------------------------- 1 | //go:build go1.9 2 | // +build go1.9 3 | 4 | // "go1.9", from Go version 1.9 onward 5 | // See https://golang.org/pkg/go/build/#hdr-Build_Constraints 6 | 7 | package roaring 8 | 9 | import "math/bits" 10 | 11 | func countLeadingZeros(x uint64) int { 12 | return bits.LeadingZeros64(x) 13 | } 14 | -------------------------------------------------------------------------------- /vendor/github.com/RoaringBitmap/roaring/ctz.go: -------------------------------------------------------------------------------- 1 | //go:build go1.9 2 | // +build go1.9 3 | 4 | // "go1.9", from Go version 1.9 onward 5 | // See https://golang.org/pkg/go/build/#hdr-Build_Constraints 6 | 7 | package roaring 8 | 9 | import "math/bits" 10 | 11 | func countTrailingZeros(x uint64) int { 12 | return bits.TrailingZeros64(x) 13 | } 14 | -------------------------------------------------------------------------------- /vendor/github.com/RoaringBitmap/roaring/popcnt.go: -------------------------------------------------------------------------------- 1 | //go:build go1.9 2 | // +build go1.9 3 | 4 | // "go1.9", from Go version 1.9 onward 5 | // See https://golang.org/pkg/go/build/#hdr-Build_Constraints 6 | 7 | package roaring 8 | 9 | import "math/bits" 10 | 11 | func popcount(x uint64) uint64 { 12 | return uint64(bits.OnesCount64(x)) 13 | } 14 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/encoding/prototext/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Package prototext marshals and unmarshals protocol buffer messages as the 6 | // textproto format. 7 | package prototext 8 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/pebble/internal/cache/cgo_enabled.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The LevelDB-Go and Pebble Authors. All rights reserved. Use 2 | // of this source code is governed by a BSD-style license that can be found in 3 | // the LICENSE file. 4 | 5 | //go:build cgo 6 | // +build cgo 7 | 8 | package cache 9 | 10 | const cgoEnabled = true 11 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/flags/proto_legacy_enable.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build protolegacy 6 | // +build protolegacy 7 | 8 | package flags 9 | 10 | const protoLegacy = true 11 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/pebble/internal/cache/cgo_disabled.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The LevelDB-Go and Pebble Authors. All rights reserved. Use 2 | // of this source code is governed by a BSD-style license that can be found in 3 | // the LICENSE file. 4 | 5 | //go:build !cgo 6 | // +build !cgo 7 | 8 | package cache 9 | 10 | const cgoEnabled = false 11 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/flags/proto_legacy_disable.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build !protolegacy 6 | // +build !protolegacy 7 | 8 | package flags 9 | 10 | const protoLegacy = false 11 | -------------------------------------------------------------------------------- /vendor/github.com/cespare/xxhash/v2/testall.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | set -eu -o pipefail 3 | 4 | # Small convenience script for running the tests with various combinations of 5 | # arch/tags. This assumes we're running on amd64 and have qemu available. 6 | 7 | go test ./... 8 | go test -tags purego ./... 9 | GOARCH=arm64 go test 10 | GOARCH=arm64 go test -tags purego 11 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/ptrace_ios.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build ios 6 | 7 | package unix 8 | 9 | func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) { 10 | return ENOTSUP 11 | } 12 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/empty.s: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build !go1.12 6 | 7 | // This file is here to allow bodyless functions with go:linkname for Go 1.11 8 | // and earlier (see https://golang.org/issue/23311). 9 | -------------------------------------------------------------------------------- /vendor/github.com/RoaringBitmap/roaring/AUTHORS: -------------------------------------------------------------------------------- 1 | # This is the official list of roaring authors for copyright purposes. 2 | 3 | Todd Gruben (@tgruben), 4 | Daniel Lemire (@lemire), 5 | Elliot Murphy (@statik), 6 | Bob Potter (@bpot), 7 | Tyson Maly (@tvmaly), 8 | Will Glynn (@willglynn), 9 | Brent Pedersen (@brentp) 10 | Maciej Biłas (@maciej), 11 | Joe Nall (@joenall) 12 | -------------------------------------------------------------------------------- /shell.nix: -------------------------------------------------------------------------------- 1 | let pkgs = import { }; 2 | 3 | in pkgs.mkShell { 4 | nativeBuildInputs = [ 5 | # Go 6 | pkgs.go 7 | pkgs.golangci-lint 8 | pkgs.gotests 9 | pkgs.gomodifytags 10 | pkgs.gore 11 | pkgs.gotools 12 | pkgs.gocode 13 | pkgs.protoc-gen-go 14 | pkgs.goreleaser 15 | 16 | # LSP 17 | pkgs.gopls 18 | ]; 19 | } 20 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/redact/.gitignore: -------------------------------------------------------------------------------- 1 | # Binaries for programs and plugins 2 | *.exe 3 | *.exe~ 4 | *.dll 5 | *.so 6 | *.dylib 7 | 8 | # Test binary, built with `go test -c` 9 | *.test 10 | 11 | # Output of the go coverage tool, specifically when used with LiteIDE 12 | *.out 13 | 14 | # Dependency directories (remove the comment below to include it) 15 | # vendor/ 16 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/aliases.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build windows && go1.9 6 | 7 | package windows 8 | 9 | import "syscall" 10 | 11 | type Errno = syscall.Errno 12 | type SysProcAttr = syscall.SysProcAttr 13 | -------------------------------------------------------------------------------- /vendor/github.com/ohler55/ojg/jp/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2020, Peter Ohler, All rights reserved. 2 | 3 | // Package jp provides JSONPath implementation that operations on simple go 4 | // types, generic (gen package), and public struct with public members. Get, 5 | // set, and delete operations can be evaluated on data. When needed reflection 6 | // is used to follow a path. 7 | package jp 8 | -------------------------------------------------------------------------------- /vendor/github.com/sourcegraph/conc/panics/try.go: -------------------------------------------------------------------------------- 1 | package panics 2 | 3 | // Try executes f, catching and returning any panic it might spawn. 4 | // 5 | // The recovered panic can be propagated with panic(), or handled as a normal error with 6 | // (*panics.Recovered).AsError(). 7 | func Try(f func()) *Recovered { 8 | var c Catcher 9 | c.Try(f) 10 | return c.Recovered() 11 | } 12 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/pebble/internal/cache/clockpro_normal.go: -------------------------------------------------------------------------------- 1 | // Copyright 2022 The LevelDB-Go and Pebble Authors. All rights reserved. Use 2 | // of this source code is governed by a BSD-style license that can be found in 3 | // the LICENSE file. 4 | 5 | //go:build !tracing 6 | // +build !tracing 7 | 8 | package cache 9 | 10 | func (c *Cache) trace(_ string, _ int64) {} 11 | -------------------------------------------------------------------------------- /utils.go: -------------------------------------------------------------------------------- 1 | package expr 2 | 3 | import "github.com/sourcegraph/conc/pool" 4 | 5 | type errPoolOpts struct { 6 | concurrency int64 7 | firstErr bool 8 | } 9 | 10 | func newErrPool(opts errPoolOpts) *pool.ErrorPool { 11 | p := pool.New().WithErrors().WithMaxGoroutines(int(opts.concurrency)) 12 | 13 | if opts.firstErr { 14 | p = p.WithFirstError() 15 | } 16 | 17 | return p 18 | } 19 | -------------------------------------------------------------------------------- /vendor/github.com/ohler55/ojg/alt/attrsetter.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2020, Peter Ohler, All rights reserved. 2 | 3 | package alt 4 | 5 | // AttrSetter interface is for objects that can set attributes using the 6 | // SetAttr() function. 7 | type AttrSetter interface { 8 | 9 | // SetAttr sets an attribute of the object associated with the path. 10 | SetAttr(attr string, val any) error 11 | } 12 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_linux_amd64_gc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build amd64 && linux && gc 6 | 7 | package unix 8 | 9 | import "syscall" 10 | 11 | //go:noescape 12 | func gettimeofday(tv *Timeval) (err syscall.Errno) 13 | -------------------------------------------------------------------------------- /vendor/github.com/antlr4-go/antlr/v4/atn_type.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2012-2022 The ANTLR Project. All rights reserved. 2 | // Use of this file is governed by the BSD 3-clause license that 3 | // can be found in the LICENSE.txt file in the project root. 4 | 5 | package antlr 6 | 7 | // Represent the type of recognizer an ATN applies to. 8 | const ( 9 | ATNTypeLexer = 0 10 | ATNTypeParser = 1 11 | ) 12 | -------------------------------------------------------------------------------- /vendor/github.com/ohler55/ojg/.gitignore: -------------------------------------------------------------------------------- 1 | # Binaries for programs and plugins 2 | *.exe 3 | *.exe~ 4 | *.dll 5 | *.so 6 | *.dylib 7 | .DS_Store 8 | 9 | # Test binary, built with `go test -c` 10 | *.test 11 | 12 | # Output of the go coverage tool, specifically when used with LiteIDE 13 | *.out 14 | cpu.prof 15 | 16 | # Dependency directories (remove the comment below to include it) 17 | # vendor/ 18 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/endian_big.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | // 5 | //go:build armbe || arm64be || m68k || mips || mips64 || mips64p32 || ppc || ppc64 || s390 || s390x || shbe || sparc || sparc64 6 | 7 | package unix 8 | 9 | const isBigEndian = true 10 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/ptrace_darwin.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build darwin && !ios 6 | 7 | package unix 8 | 9 | func ptrace(request int, pid int, addr uintptr, data uintptr) error { 10 | return ptrace1(request, pid, addr, data) 11 | } 12 | -------------------------------------------------------------------------------- /vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_safe.go: -------------------------------------------------------------------------------- 1 | package xxhash 2 | 3 | // Sum64String computes the 64-bit xxHash digest of s. 4 | func Sum64String(s string) uint64 { 5 | return Sum64([]byte(s)) 6 | } 7 | 8 | // WriteString adds more data to d. It always returns len(s), nil. 9 | func (d *Digest) WriteString(s string) (n int, err error) { 10 | return d.Write([]byte(s)) 11 | } 12 | -------------------------------------------------------------------------------- /vendor/github.com/cespare/xxhash/v2/xxhash_asm.go: -------------------------------------------------------------------------------- 1 | //go:build (amd64 || arm64) && !appengine && gc && !purego 2 | // +build amd64 arm64 3 | // +build !appengine 4 | // +build gc 5 | // +build !purego 6 | 7 | package xxhash 8 | 9 | // Sum64 computes the 64-bit xxHash digest of b. 10 | // 11 | //go:noescape 12 | func Sum64(b []byte) uint64 13 | 14 | //go:noescape 15 | func writeBlocks(d *Digest, b []byte) int 16 | -------------------------------------------------------------------------------- /vendor/github.com/pkg/errors/.gitignore: -------------------------------------------------------------------------------- 1 | # Compiled Object files, Static and Dynamic libs (Shared Objects) 2 | *.o 3 | *.a 4 | *.so 5 | 6 | # Folders 7 | _obj 8 | _test 9 | 10 | # Architecture specific extensions/prefixes 11 | *.[568vq] 12 | [568vq].out 13 | 14 | *.cgo1.go 15 | *.cgo2.c 16 | _cgo_defun.c 17 | _cgo_gotypes.go 18 | _cgo_export.* 19 | 20 | _testmain.go 21 | 22 | *.exe 23 | *.test 24 | *.prof 25 | -------------------------------------------------------------------------------- /vendor/github.com/stretchr/testify/assert/errors.go: -------------------------------------------------------------------------------- 1 | package assert 2 | 3 | import ( 4 | "errors" 5 | ) 6 | 7 | // AnError is an error instance useful for testing. If the code does not care 8 | // about error specifics, and only needs to return the error for example, this 9 | // error should be used to make the test code more readable. 10 | var AnError = errors.New("assert.AnError general error for testing") 11 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/constants.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos 6 | 7 | package unix 8 | 9 | const ( 10 | R_OK = 0x4 11 | W_OK = 0x2 12 | X_OK = 0x1 13 | ) 14 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/impl/codec_map_go112.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build go1.12 6 | // +build go1.12 7 | 8 | package impl 9 | 10 | import "reflect" 11 | 12 | func mapRange(v reflect.Value) *reflect.MapIter { return v.MapRange() } 13 | -------------------------------------------------------------------------------- /vendor/github.com/google/cel-go/common/overloads/BUILD.bazel: -------------------------------------------------------------------------------- 1 | load("@io_bazel_rules_go//go:def.bzl", "go_library") 2 | 3 | package( 4 | default_visibility = ["//visibility:public"], 5 | licenses = ["notice"], # Apache 2.0 6 | ) 7 | 8 | go_library( 9 | name = "go_default_library", 10 | srcs = [ 11 | "overloads.go", 12 | ], 13 | importpath = "github.com/google/cel-go/common/overloads", 14 | ) 15 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/errors/is_go113.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build go1.13 6 | // +build go1.13 7 | 8 | package errors 9 | 10 | import "errors" 11 | 12 | // Is is errors.Is. 13 | func Is(err, target error) bool { return errors.Is(err, target) } 14 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/pebble/internal/invariants/race_on.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The LevelDB-Go and Pebble Authors. All rights reserved. Use 2 | // of this source code is governed by a BSD-style license that can be found in 3 | // the LICENSE file. 4 | 5 | //go:build race 6 | // +build race 7 | 8 | package invariants 9 | 10 | // RaceEnabled is true if we were built with the "race" build tag. 11 | const RaceEnabled = true 12 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/mmap_nomremap.go: -------------------------------------------------------------------------------- 1 | // Copyright 2023 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build aix || darwin || dragonfly || freebsd || openbsd || solaris 6 | 7 | package unix 8 | 9 | var mapper = &mmapper{ 10 | active: make(map[*byte][]byte), 11 | mmap: mmap, 12 | munmap: munmap, 13 | } 14 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/pebble/internal/invariants/race_off.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The LevelDB-Go and Pebble Authors. All rights reserved. Use 2 | // of this source code is governed by a BSD-style license that can be found in 3 | // the LICENSE file. 4 | 5 | //go:build !race 6 | // +build !race 7 | 8 | package invariants 9 | 10 | // RaceEnabled is true if we were built with the "race" build tag. 11 | const RaceEnabled = false 12 | -------------------------------------------------------------------------------- /vendor/github.com/google/cel-go/common/operators/BUILD.bazel: -------------------------------------------------------------------------------- 1 | load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test") 2 | 3 | package( 4 | default_visibility = ["//visibility:public"], 5 | licenses = ["notice"], # Apache 2.0 6 | ) 7 | 8 | go_library( 9 | name = "go_default_library", 10 | srcs = [ 11 | "operators.go", 12 | ], 13 | importpath = "github.com/google/cel-go/common/operators", 14 | ) 15 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/endian_little.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | // 5 | //go:build 386 || amd64 || amd64p32 || alpha || arm || arm64 || loong64 || mipsle || mips64le || mips64p32le || nios2 || ppc64le || riscv || riscv64 || sh 6 | 7 | package unix 8 | 9 | const isBigEndian = false 10 | -------------------------------------------------------------------------------- /vendor/github.com/bits-and-blooms/bitset/.gitignore: -------------------------------------------------------------------------------- 1 | # Compiled Object files, Static and Dynamic libs (Shared Objects) 2 | *.o 3 | *.a 4 | *.so 5 | 6 | # Folders 7 | _obj 8 | _test 9 | 10 | # Architecture specific extensions/prefixes 11 | *.[568vq] 12 | [568vq].out 13 | 14 | *.cgo1.go 15 | *.cgo2.c 16 | _cgo_defun.c 17 | _cgo_gotypes.go 18 | _cgo_export.* 19 | 20 | _testmain.go 21 | 22 | *.exe 23 | *.test 24 | *.prof 25 | 26 | target 27 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/mksyscall.go: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build generate 6 | 7 | package windows 8 | 9 | //go:generate go run golang.org/x/sys/windows/mkwinsyscall -output zsyscall_windows.go eventlog.go service.go syscall_windows.go security_windows.go setupapi_windows.go 10 | -------------------------------------------------------------------------------- /vendor/github.com/ohler55/ojg/alt/simplifier.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2020, Peter Ohler, All rights reserved. 2 | 3 | package alt 4 | 5 | // Simplifier interface is for objects that can decompose themselves into 6 | // simple data. 7 | type Simplifier interface { 8 | 9 | // Simplify should return one of the simple types which are: nil, bool, 10 | // int64, float64, string, time.Time, []any, or 11 | // map[string]any. 12 | Simplify() any 13 | } 14 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/runtime/protoiface/legacy.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package protoiface 6 | 7 | type MessageV1 interface { 8 | Reset() 9 | String() string 10 | ProtoMessage() 11 | } 12 | 13 | type ExtensionRangeV1 struct { 14 | Start, End int32 // both inclusive 15 | } 16 | -------------------------------------------------------------------------------- /vendor/github.com/RoaringBitmap/roaring/internal/pools.go: -------------------------------------------------------------------------------- 1 | package internal 2 | 3 | import ( 4 | "sync" 5 | ) 6 | 7 | var ( 8 | // ByteInputAdapterPool shared pool 9 | ByteInputAdapterPool = sync.Pool{ 10 | New: func() interface{} { 11 | return &ByteInputAdapter{} 12 | }, 13 | } 14 | 15 | // ByteBufferPool shared pool 16 | ByteBufferPool = sync.Pool{ 17 | New: func() interface{} { 18 | return &ByteBuffer{} 19 | }, 20 | } 21 | ) 22 | -------------------------------------------------------------------------------- /vendor/github.com/stoewer/go-strcase/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2017, A. Stoewer 2 | // All rights reserved. 3 | 4 | // Package strcase converts between different kinds of naming formats such as camel case 5 | // (CamelCase), snake case (snake_case) or kebab case (kebab-case). The package is designed 6 | // to work only with strings consisting of standard ASCII letters. Unicode is currently not 7 | // supported. 8 | package strcase 9 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/execabs/execabs_go118.go: -------------------------------------------------------------------------------- 1 | // Copyright 2022 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build !go1.19 6 | 7 | package execabs 8 | 9 | import "os/exec" 10 | 11 | func isGo119ErrDot(err error) bool { 12 | return false 13 | } 14 | 15 | func isGo119ErrFieldSet(cmd *exec.Cmd) bool { 16 | return false 17 | } 18 | -------------------------------------------------------------------------------- /vendor/golang.org/x/text/internal/language/common.go: -------------------------------------------------------------------------------- 1 | // Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT. 2 | 3 | package language 4 | 5 | // This file contains code common to the maketables.go and the package code. 6 | 7 | // AliasType is the type of an alias in AliasMap. 8 | type AliasType int8 9 | 10 | const ( 11 | Deprecated AliasType = iota 12 | Macro 13 | Legacy 14 | 15 | AliasTypeUnknown AliasType = -1 16 | ) 17 | -------------------------------------------------------------------------------- /vendor/github.com/antlr4-go/antlr/v4/char_stream.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2012-2022 The ANTLR Project. All rights reserved. 2 | // Use of this file is governed by the BSD 3-clause license that 3 | // can be found in the LICENSE.txt file in the project root. 4 | 5 | package antlr 6 | 7 | type CharStream interface { 8 | IntStream 9 | GetText(int, int) string 10 | GetTextFromTokens(start, end Token) string 11 | GetTextFromInterval(Interval) string 12 | } 13 | -------------------------------------------------------------------------------- /vendor/github.com/RoaringBitmap/roaring/.drone.yml: -------------------------------------------------------------------------------- 1 | kind: pipeline 2 | name: default 3 | 4 | workspace: 5 | base: /go 6 | path: src/github.com/RoaringBitmap/roaring 7 | 8 | steps: 9 | - name: test 10 | image: golang 11 | commands: 12 | - go get -t 13 | - go test 14 | - go build -tags appengine 15 | - go test -tags appengine 16 | - GOARCH=386 go build 17 | - GOARCH=386 go test 18 | - GOARCH=arm go build 19 | - GOARCH=arm64 go build 20 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/pebble/internal/invariants/on.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The LevelDB-Go and Pebble Authors. All rights reserved. Use 2 | // of this source code is governed by a BSD-style license that can be found in 3 | // the LICENSE file. 4 | 5 | //go:build invariants || race 6 | // +build invariants race 7 | 8 | package invariants 9 | 10 | // Enabled is true if we were built with the "invariants" or "race" build tags. 11 | const Enabled = true 12 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/pebble/vfs/fadvise_generic.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The LevelDB-Go and Pebble Authors. All rights reserved. Use 2 | // of this source code is governed by a BSD-style license that can be found in 3 | // the LICENSE file. 4 | 5 | //go:build !linux 6 | // +build !linux 7 | 8 | package vfs 9 | 10 | func fadviseRandom(f uintptr) error { 11 | return nil 12 | } 13 | 14 | func fadviseSequential(f uintptr) error { 15 | return nil 16 | } 17 | -------------------------------------------------------------------------------- /vendor/github.com/stoewer/go-strcase/.golangci.yml: -------------------------------------------------------------------------------- 1 | run: 2 | deadline: 10m 3 | 4 | linters: 5 | enable: 6 | - dupl 7 | - goconst 8 | - gocyclo 9 | - godox 10 | - gosec 11 | - interfacer 12 | - lll 13 | - maligned 14 | - misspell 15 | - prealloc 16 | - stylecheck 17 | - unconvert 18 | - unparam 19 | - errcheck 20 | - golint 21 | - gofmt 22 | disable: [] 23 | fast: false 24 | 25 | issues: 26 | exclude-use-default: false 27 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/pebble/internal/invariants/off.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The LevelDB-Go and Pebble Authors. All rights reserved. Use 2 | // of this source code is governed by a BSD-style license that can be found in 3 | // the LICENSE file. 4 | 5 | //go:build !invariants && !race 6 | // +build !invariants,!race 7 | 8 | package invariants 9 | 10 | // Enabled is true if we were built with the "invariants" or "race" build tags. 11 | const Enabled = false 12 | -------------------------------------------------------------------------------- /vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_asm.go: -------------------------------------------------------------------------------- 1 | //go:build (amd64 || arm64) && !appengine && gc && !purego && !noasm 2 | // +build amd64 arm64 3 | // +build !appengine 4 | // +build gc 5 | // +build !purego 6 | // +build !noasm 7 | 8 | package xxhash 9 | 10 | // Sum64 computes the 64-bit xxHash digest of b. 11 | // 12 | //go:noescape 13 | func Sum64(b []byte) uint64 14 | 15 | //go:noescape 16 | func writeBlocks(s *Digest, b []byte) int 17 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/editiondefaults/defaults.go: -------------------------------------------------------------------------------- 1 | // Copyright 2024 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Package editiondefaults contains the binary representation of the editions 6 | // defaults. 7 | package editiondefaults 8 | 9 | import _ "embed" 10 | 11 | //go:embed editions_defaults.binpb 12 | var Defaults []byte 13 | -------------------------------------------------------------------------------- /vendor/github.com/golang/snappy/.gitignore: -------------------------------------------------------------------------------- 1 | cmd/snappytool/snappytool 2 | testdata/bench 3 | 4 | # These explicitly listed benchmark data files are for an obsolete version of 5 | # snappy_test.go. 6 | testdata/alice29.txt 7 | testdata/asyoulik.txt 8 | testdata/fireworks.jpeg 9 | testdata/geo.protodata 10 | testdata/html 11 | testdata/html_x_4 12 | testdata/kppkn.gtb 13 | testdata/lcet10.txt 14 | testdata/paper-100k.pdf 15 | testdata/plrabn12.txt 16 | testdata/urls.10K 17 | -------------------------------------------------------------------------------- /vendor/github.com/golang/snappy/decode_asm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Snappy-Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !appengine 6 | // +build gc 7 | // +build !noasm 8 | // +build amd64 arm64 9 | 10 | package snappy 11 | 12 | // decode has the same semantics as in decode_other.go. 13 | // 14 | //go:noescape 15 | func decode(dst, src []byte) int 16 | -------------------------------------------------------------------------------- /groupid_test.go: -------------------------------------------------------------------------------- 1 | package expr 2 | 3 | import ( 4 | "testing" 5 | 6 | "github.com/stretchr/testify/require" 7 | ) 8 | 9 | func TestGroupID(t *testing.T) { 10 | for i := uint16(0); i < 128; i++ { 11 | gid := newGroupID(i, 0x0) 12 | 13 | require.NotEmpty(t, gid[2:]) 14 | require.Equal(t, i, gid.Size()) 15 | 16 | // check unsafe size method works 17 | // gid := internedGID.Value() 18 | // require.EqualValues(t, int(i), int(internedGID.Size())) 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /vendor/github.com/antlr4-go/antlr/v4/int_stream.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2012-2022 The ANTLR Project. All rights reserved. 2 | // Use of this file is governed by the BSD 3-clause license that 3 | // can be found in the LICENSE.txt file in the project root. 4 | 5 | package antlr 6 | 7 | type IntStream interface { 8 | Consume() 9 | LA(int) int 10 | Mark() int 11 | Release(marker int) 12 | Index() int 13 | Seek(index int) 14 | Size() int 15 | GetSourceName() string 16 | } 17 | -------------------------------------------------------------------------------- /vendor/github.com/ohler55/ojg/gen/error.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2020, Peter Ohler, All rights reserved. 2 | 3 | package gen 4 | 5 | import "fmt" 6 | 7 | // ParseError represents a parse error. 8 | type ParseError struct { 9 | Message string 10 | Line int 11 | Column int 12 | } 13 | 14 | // Error returns a string representation of the error. 15 | func (err *ParseError) Error() string { 16 | return fmt.Sprintf("%s at %d:%d", err.Message, err.Line, err.Column) 17 | } 18 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/aliases.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos 6 | 7 | package unix 8 | 9 | import "syscall" 10 | 11 | type Signal = syscall.Signal 12 | type Errno = syscall.Errno 13 | type SysProcAttr = syscall.SysProcAttr 14 | -------------------------------------------------------------------------------- /vendor/github.com/stoewer/go-strcase/kebab.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2017, A. Stoewer 2 | // All rights reserved. 3 | 4 | package strcase 5 | 6 | // KebabCase converts a string into kebab case. 7 | func KebabCase(s string) string { 8 | return delimiterCase(s, '-', false) 9 | } 10 | 11 | // UpperKebabCase converts a string into kebab case with capital letters. 12 | func UpperKebabCase(s string) string { 13 | return delimiterCase(s, '-', true) 14 | } 15 | -------------------------------------------------------------------------------- /vendor/github.com/google/uuid/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Google Inc. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Package uuid generates and inspects UUIDs. 6 | // 7 | // UUIDs are based on RFC 4122 and DCE 1.1: Authentication and Security 8 | // Services. 9 | // 10 | // A UUID is a 16 byte (128 bit) array. UUIDs may be used as keys to 11 | // maps or compared directly. 12 | package uuid 13 | -------------------------------------------------------------------------------- /vendor/github.com/mschoch/smat/.travis.yml: -------------------------------------------------------------------------------- 1 | sudo: false 2 | language: go 3 | go: 4 | - 1.6 5 | script: 6 | - go get golang.org/x/tools/cmd/cover 7 | - go get github.com/mattn/goveralls 8 | - go get github.com/kisielk/errcheck 9 | - go test -v -race 10 | - go vet 11 | - errcheck ./... 12 | - go test -coverprofile=profile.out -covermode=count 13 | - goveralls -service=travis-ci -coverprofile=profile.out -repotoken $COVERALLS 14 | notifications: 15 | email: 16 | - marty.schoch@gmail.com 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/pagesize_unix.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris 6 | 7 | // For Unix, get the pagesize from the runtime. 8 | 9 | package unix 10 | 11 | import "syscall" 12 | 13 | func Getpagesize() int { 14 | return syscall.Getpagesize() 15 | } 16 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/readdirent_getdents.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build aix || dragonfly || freebsd || linux || netbsd || openbsd 6 | 7 | package unix 8 | 9 | // ReadDirent reads directory entries from fd and writes them into buf. 10 | func ReadDirent(fd int, buf []byte) (n int, err error) { 11 | return Getdents(fd, buf) 12 | } 13 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/sysvshm_unix_other.go: -------------------------------------------------------------------------------- 1 | // Copyright 2021 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build darwin && !ios 6 | 7 | package unix 8 | 9 | // SysvShmCtl performs control operations on the shared memory segment 10 | // specified by id. 11 | func SysvShmCtl(id, cmd int, desc *SysvShmDesc) (result int, err error) { 12 | return shmctl(id, cmd, desc) 13 | } 14 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/errors/errorspb/markers.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto3"; 2 | package cockroach.errorspb; 3 | option go_package = "errorspb"; 4 | 5 | import "errorspb/errors.proto"; 6 | import "gogoproto/gogo.proto"; 7 | 8 | // MarkPayload is the error payload for a forced marker. 9 | // See errors/markers/markers.go and the RFC on 10 | // error handling for details. 11 | message MarkPayload { 12 | string msg = 1; 13 | repeated ErrorTypeMark types = 2 [(gogoproto.nullable) = false]; 14 | } 15 | -------------------------------------------------------------------------------- /vendor/github.com/getsentry/sentry-go/.codecov.yml: -------------------------------------------------------------------------------- 1 | codecov: 2 | # across 3 | notify: 4 | # Do not notify until at least this number of reports have been uploaded 5 | # from the CI pipeline. We normally have more than that number, but 6 6 | # should be enough to get a first notification. 7 | after_n_builds: 6 8 | coverage: 9 | status: 10 | project: 11 | default: 12 | # Do not fail the commit status if the coverage was reduced up to this value 13 | threshold: 0.5% 14 | -------------------------------------------------------------------------------- /vendor/github.com/google/cel-go/common/functions/BUILD.bazel: -------------------------------------------------------------------------------- 1 | load("@io_bazel_rules_go//go:def.bzl", "go_library") 2 | 3 | package( 4 | default_visibility = ["//visibility:public"], 5 | licenses = ["notice"], # Apache 2.0 6 | ) 7 | 8 | go_library( 9 | name = "go_default_library", 10 | srcs = [ 11 | "functions.go", 12 | ], 13 | importpath = "github.com/google/cel-go/common/functions", 14 | deps = [ 15 | "//common/types/ref:go_default_library", 16 | ], 17 | ) 18 | -------------------------------------------------------------------------------- /vendor/github.com/ohler55/ojg/go.yml: -------------------------------------------------------------------------------- 1 | name: Go 2 | 3 | on: 4 | push: 5 | branches: [ develop ] 6 | pull_request: 7 | branches: [ develop ] 8 | 9 | jobs: 10 | 11 | build: 12 | runs-on: ubuntu-latest 13 | steps: 14 | - uses: actions/checkout@v2 15 | 16 | - name: Set up Go 17 | uses: actions/setup-go@v2 18 | with: 19 | go-version: 1.19 20 | 21 | - name: Build 22 | run: go build -v ./... 23 | 24 | - name: Test 25 | run: go test -v ./... 26 | -------------------------------------------------------------------------------- /vendor/go.uber.org/atomic/.travis.yml: -------------------------------------------------------------------------------- 1 | sudo: false 2 | language: go 3 | go_import_path: go.uber.org/atomic 4 | 5 | env: 6 | global: 7 | - GO111MODULE=on 8 | 9 | matrix: 10 | include: 11 | - go: oldstable 12 | - go: stable 13 | env: LINT=1 14 | 15 | cache: 16 | directories: 17 | - vendor 18 | 19 | before_install: 20 | - go version 21 | 22 | script: 23 | - test -z "$LINT" || make lint 24 | - make cover 25 | 26 | after_success: 27 | - bash <(curl -s https://codecov.io/bash) 28 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/execabs/execabs_go119.go: -------------------------------------------------------------------------------- 1 | // Copyright 2022 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build go1.19 6 | 7 | package execabs 8 | 9 | import ( 10 | "errors" 11 | "os/exec" 12 | ) 13 | 14 | func isGo119ErrDot(err error) bool { 15 | return errors.Is(err, exec.ErrDot) 16 | } 17 | 18 | func isGo119ErrFieldSet(cmd *exec.Cmd) bool { 19 | return cmd.Err != nil 20 | } 21 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/redact/README.md: -------------------------------------------------------------------------------- 1 | # redact 2 | Utilities to redact Go strings for confidentiality 3 | 4 | ![Build Status](https://github.com/cockroachdb/redact/actions/workflows/ci.yaml/badge.svg?branch=master) 5 | [![Go Reference](https://pkg.go.dev/badge/github.com/cockroachdb/redact.svg)](https://pkg.go.dev/github.com/cockroachdb/redact) 6 | 7 | Some explanations about how this is used in e.g. CockroachDB: 8 | 9 | https://wiki.crdb.io/wiki/spaces/CRDB/pages/1824817806/Log+and+error+redactability 10 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_aix_ppc64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build gc 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System calls for ppc64, AIX are implemented in runtime/syscall_aix.go 11 | // 12 | 13 | TEXT ·syscall6(SB),NOSPLIT,$0-88 14 | JMP syscall·syscall6(SB) 15 | 16 | TEXT ·rawSyscall6(SB),NOSPLIT,$0-88 17 | JMP syscall·rawSyscall6(SB) 18 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_linux_gc_arm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build arm && gc && linux 6 | 7 | package unix 8 | 9 | import "syscall" 10 | 11 | // Underlying system call writes to newoffset via pointer. 12 | // Implemented in assembly to avoid allocation. 13 | func seek(fd int, offset int64, whence int) (newoffset int64, err syscall.Errno) 14 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/genid/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Package genid contains constants for declarations in descriptor.proto 6 | // and the well-known types. 7 | package genid 8 | 9 | import protoreflect "google.golang.org/protobuf/reflect/protoreflect" 10 | 11 | const GoogleProtobuf_package protoreflect.FullName = "google.protobuf" 12 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/pebble/internal/manual/manual_mips.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The LevelDB-Go and Pebble Authors. All rights reserved. Use 2 | // of this source code is governed by a BSD-style license that can be found in 3 | // the LICENSE file. 4 | 5 | //go:build mips || mipsle || mips64p32 || mips64p32le 6 | // +build mips mipsle mips64p32 mips64p32le 7 | 8 | package manual 9 | 10 | const ( 11 | // MaxArrayLen is a safe maximum length for slices on this architecture. 12 | MaxArrayLen = 1 << 30 13 | ) 14 | -------------------------------------------------------------------------------- /vendor/github.com/DataDog/zstd/travis_test_32.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | # Get utilities 3 | yum -y -q -e 0 install wget tar unzip gcc 4 | 5 | # Get Go 6 | wget -q https://dl.google.com/go/go1.13.linux-386.tar.gz 7 | tar -C /usr/local -xzf go1.13.linux-386.tar.gz 8 | export PATH=$PATH:/usr/local/go/bin 9 | 10 | # Get payload 11 | wget -q https://github.com/DataDog/zstd/files/2246767/mr.zip 12 | unzip mr.zip 13 | 14 | # Build and run tests 15 | go build 16 | PAYLOAD=$(pwd)/mr go test -v 17 | PAYLOAD=$(pwd)/mr go test -bench . 18 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/pebble/internal/manual/manual_32bit.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The LevelDB-Go and Pebble Authors. All rights reserved. Use 2 | // of this source code is governed by a BSD-style license that can be found in 3 | // the LICENSE file. 4 | 5 | //go:build 386 || amd64p32 || arm || armbe || ppc || sparc 6 | // +build 386 amd64p32 arm armbe ppc sparc 7 | 8 | package manual 9 | 10 | const ( 11 | // MaxArrayLen is a safe maximum length for slices on this architecture. 12 | MaxArrayLen = 1<<31 - 1 13 | ) 14 | -------------------------------------------------------------------------------- /vendor/github.com/cespare/xxhash/v2/xxhash_safe.go: -------------------------------------------------------------------------------- 1 | //go:build appengine 2 | // +build appengine 3 | 4 | // This file contains the safe implementations of otherwise unsafe-using code. 5 | 6 | package xxhash 7 | 8 | // Sum64String computes the 64-bit xxHash digest of s. 9 | func Sum64String(s string) uint64 { 10 | return Sum64([]byte(s)) 11 | } 12 | 13 | // WriteString adds more data to d. It always returns len(s), nil. 14 | func (d *Digest) WriteString(s string) (n int, err error) { 15 | return d.Write([]byte(s)) 16 | } 17 | -------------------------------------------------------------------------------- /vendor/github.com/RoaringBitmap/roaring/serializationfuzz.go: -------------------------------------------------------------------------------- 1 | //go:build gofuzz 2 | // +build gofuzz 3 | 4 | package roaring 5 | 6 | import "bytes" 7 | 8 | func FuzzSerializationStream(data []byte) int { 9 | newrb := NewBitmap() 10 | if _, err := newrb.ReadFrom(bytes.NewReader(data)); err != nil { 11 | return 0 12 | } 13 | return 1 14 | } 15 | 16 | func FuzzSerializationBuffer(data []byte) int { 17 | newrb := NewBitmap() 18 | if _, err := newrb.FromBuffer(data); err != nil { 19 | return 0 20 | } 21 | return 1 22 | } 23 | -------------------------------------------------------------------------------- /vendor/github.com/getsentry/sentry-go/stacktrace_below_go1.20.go: -------------------------------------------------------------------------------- 1 | //go:build !go1.20 2 | 3 | package sentry 4 | 5 | import "strings" 6 | 7 | func isCompilerGeneratedSymbol(name string) bool { 8 | // In versions of Go below 1.20 a prefix of "type." and "go." is a 9 | // compiler-generated symbol that doesn't belong to any package. 10 | // See variable reservedimports in cmd/compile/internal/gc/subr.go 11 | if strings.HasPrefix(name, "go.") || strings.HasPrefix(name, "type.") { 12 | return true 13 | } 14 | return false 15 | } 16 | -------------------------------------------------------------------------------- /vendor/github.com/getsentry/sentry-go/stacktrace_go1.20.go: -------------------------------------------------------------------------------- 1 | //go:build go1.20 2 | 3 | package sentry 4 | 5 | import "strings" 6 | 7 | func isCompilerGeneratedSymbol(name string) bool { 8 | // In versions of Go 1.20 and above a prefix of "type:" and "go:" is a 9 | // compiler-generated symbol that doesn't belong to any package. 10 | // See variable reservedimports in cmd/compile/internal/gc/subr.go 11 | if strings.HasPrefix(name, "go:") || strings.HasPrefix(name, "type:") { 12 | return true 13 | } 14 | return false 15 | } 16 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_solaris_amd64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2014 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build gc 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System calls for amd64, Solaris are implemented in runtime/syscall_solaris.go 11 | // 12 | 13 | TEXT ·sysvicall6(SB),NOSPLIT,$0-88 14 | JMP syscall·sysvicall6(SB) 15 | 16 | TEXT ·rawSysvicall6(SB),NOSPLIT,$0-88 17 | JMP syscall·rawSysvicall6(SB) 18 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/fcntl_linux_32bit.go: -------------------------------------------------------------------------------- 1 | // Copyright 2014 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (linux && 386) || (linux && arm) || (linux && mips) || (linux && mipsle) || (linux && ppc) 6 | 7 | package unix 8 | 9 | func init() { 10 | // On 32-bit Linux systems, the fcntl syscall that matches Go's 11 | // Flock_t type is SYS_FCNTL64, not SYS_FCNTL. 12 | fcntl64Syscall = SYS_FCNTL64 13 | } 14 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_linux_alarm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2022 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build linux && (386 || amd64 || mips || mipsle || mips64 || mipsle || ppc64 || ppc64le || ppc || s390x || sparc64) 6 | 7 | package unix 8 | 9 | // SYS_ALARM is not defined on arm or riscv, but is available for other GOARCH 10 | // values. 11 | 12 | //sys Alarm(seconds uint) (remaining uint, err error) 13 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/errors/errorspb/tags.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto3"; 2 | package cockroach.errorspb; 3 | option go_package = "errorspb"; 4 | 5 | import "gogoproto/gogo.proto"; 6 | 7 | // TagsPayload is the error payload for a WithContext 8 | // marker. 9 | // See errors/contexttags/withcontext.go and the RFC on 10 | // error handling for details. 11 | message TagsPayload { 12 | repeated TagPayload tags = 1 [(gogoproto.nullable) = false]; 13 | } 14 | 15 | message TagPayload { 16 | string tag = 1; 17 | string value = 2; 18 | } 19 | -------------------------------------------------------------------------------- /vendor/github.com/bits-and-blooms/bitset/trailing_zeros_18.go: -------------------------------------------------------------------------------- 1 | //go:build !go1.9 2 | // +build !go1.9 3 | 4 | package bitset 5 | 6 | var deBruijn = [...]byte{ 7 | 0, 1, 56, 2, 57, 49, 28, 3, 61, 58, 42, 50, 38, 29, 17, 4, 8 | 62, 47, 59, 36, 45, 43, 51, 22, 53, 39, 33, 30, 24, 18, 12, 5, 9 | 63, 55, 48, 27, 60, 41, 37, 16, 46, 35, 44, 21, 52, 32, 23, 11, 10 | 54, 26, 40, 15, 34, 20, 31, 10, 25, 14, 19, 9, 13, 8, 7, 6, 11 | } 12 | 13 | func trailingZeroes64(v uint64) uint { 14 | return uint(deBruijn[((v&-v)*0x03f79d71b4ca8b09)>>58]) 15 | } 16 | -------------------------------------------------------------------------------- /vendor/github.com/klauspost/compress/.gitignore: -------------------------------------------------------------------------------- 1 | # Compiled Object files, Static and Dynamic libs (Shared Objects) 2 | *.o 3 | *.a 4 | *.so 5 | 6 | # Folders 7 | _obj 8 | _test 9 | 10 | # Architecture specific extensions/prefixes 11 | *.[568vq] 12 | [568vq].out 13 | 14 | *.cgo1.go 15 | *.cgo2.c 16 | _cgo_defun.c 17 | _cgo_gotypes.go 18 | _cgo_export.* 19 | 20 | _testmain.go 21 | 22 | *.exe 23 | *.test 24 | *.prof 25 | /s2/cmd/_s2sx/sfx-exe 26 | 27 | # Linux perf files 28 | perf.data 29 | perf.data.old 30 | 31 | # gdb history 32 | .gdb_history 33 | -------------------------------------------------------------------------------- /vendor/github.com/stretchr/testify/assert/forward_assertions.go: -------------------------------------------------------------------------------- 1 | package assert 2 | 3 | // Assertions provides assertion methods around the 4 | // TestingT interface. 5 | type Assertions struct { 6 | t TestingT 7 | } 8 | 9 | // New makes a new Assertions object for the specified TestingT. 10 | func New(t TestingT) *Assertions { 11 | return &Assertions{ 12 | t: t, 13 | } 14 | } 15 | 16 | //go:generate sh -c "cd ../_codegen && go build && cd - && ../_codegen/_codegen -output-package=assert -template=assertion_forward.go.tmpl -include-format-funcs" 17 | -------------------------------------------------------------------------------- /vendor/github.com/ohler55/ojg/jp/frag.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2020, Peter Ohler, All rights reserved. 2 | 3 | package jp 4 | 5 | // Frag represents a JSONPath fragment. A JSONPath expression is composed of 6 | // fragments (Frag) linked together to form a full path expression. 7 | type Frag interface { 8 | 9 | // Append a fragment string representation of the fragment to the buffer 10 | // then returning the expanded buffer. 11 | Append(buf []byte, bracket, first bool) []byte 12 | 13 | locate(pp Expr, data any, rest Expr, max int) (locs []Expr) 14 | } 15 | -------------------------------------------------------------------------------- /vendor/github.com/stretchr/testify/require/forward_requirements.go: -------------------------------------------------------------------------------- 1 | package require 2 | 3 | // Assertions provides assertion methods around the 4 | // TestingT interface. 5 | type Assertions struct { 6 | t TestingT 7 | } 8 | 9 | // New makes a new Assertions object for the specified TestingT. 10 | func New(t TestingT) *Assertions { 11 | return &Assertions{ 12 | t: t, 13 | } 14 | } 15 | 16 | //go:generate sh -c "cd ../_codegen && go build && cd - && ../_codegen/_codegen -output-package=require -template=require_forward.go.tmpl -include-format-funcs" 17 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/genid/wrappers.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package genid 6 | 7 | import protoreflect "google.golang.org/protobuf/reflect/protoreflect" 8 | 9 | // Generic field name and number for messages in wrappers.proto. 10 | const ( 11 | WrapperValue_Value_field_name protoreflect.Name = "value" 12 | WrapperValue_Value_field_number protoreflect.FieldNumber = 1 13 | ) 14 | -------------------------------------------------------------------------------- /vendor/github.com/antlr4-go/antlr/v4/token_source.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2012-2022 The ANTLR Project. All rights reserved. 2 | // Use of this file is governed by the BSD 3-clause license that 3 | // can be found in the LICENSE.txt file in the project root. 4 | 5 | package antlr 6 | 7 | type TokenSource interface { 8 | NextToken() Token 9 | Skip() 10 | More() 11 | GetLine() int 12 | GetCharPositionInLine() int 13 | GetInputStream() CharStream 14 | GetSourceName() string 15 | setTokenFactory(factory TokenFactory) 16 | GetTokenFactory() TokenFactory 17 | } 18 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/gccgo_linux_amd64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build gccgo && linux && amd64 6 | 7 | package unix 8 | 9 | import "syscall" 10 | 11 | //extern gettimeofday 12 | func realGettimeofday(*Timeval, *byte) int32 13 | 14 | func gettimeofday(tv *Timeval) (err syscall.Errno) { 15 | r := realGettimeofday(tv, nil) 16 | if r < 0 { 17 | return syscall.GetErrno() 18 | } 19 | return 0 20 | } 21 | -------------------------------------------------------------------------------- /vendor/github.com/RoaringBitmap/roaring/CONTRIBUTORS: -------------------------------------------------------------------------------- 1 | # This is the official list of roaring contributors 2 | 3 | Todd Gruben (@tgruben), 4 | Daniel Lemire (@lemire), 5 | Elliot Murphy (@statik), 6 | Bob Potter (@bpot), 7 | Tyson Maly (@tvmaly), 8 | Will Glynn (@willglynn), 9 | Brent Pedersen (@brentp), 10 | Jason E. Aten (@glycerine), 11 | Vali Malinoiu (@0x4139), 12 | Forud Ghafouri (@fzerorubigd), 13 | Joe Nall (@joenall), 14 | (@fredim), 15 | Edd Robinson (@e-dard), 16 | Alexander Petrov (@alldroll), 17 | Guy Molinari (@guymolinari), 18 | Ling Jin (@JinLingChristopher) 19 | -------------------------------------------------------------------------------- /vendor/github.com/google/uuid/node_js.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 Google Inc. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build js 6 | 7 | package uuid 8 | 9 | // getHardwareInterface returns nil values for the JS version of the code. 10 | // This removes the "net" dependency, because it is not used in the browser. 11 | // Using the "net" library inflates the size of the transpiled JS code by 673k bytes. 12 | func getHardwareInterface(name string) (string, []byte) { return "", nil } 13 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/pebble/internal/cache/clockpro_tracing.go: -------------------------------------------------------------------------------- 1 | // Copyright 2022 The LevelDB-Go and Pebble Authors. All rights reserved. Use 2 | // of this source code is governed by a BSD-style license that can be found in 3 | // the LICENSE file. 4 | 5 | //go:build tracing 6 | // +build tracing 7 | 8 | package cache 9 | 10 | import ( 11 | "fmt" 12 | "runtime/debug" 13 | ) 14 | 15 | func (c *Cache) trace(msg string, refs int64) { 16 | s := fmt.Sprintf("%s: refs=%d\n%s", msg, refs, debug.Stack()) 17 | c.tr.Lock() 18 | c.tr.msgs = append(c.tr.msgs, s) 19 | c.tr.Unlock() 20 | } 21 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_linux_gc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build linux && gc 6 | 7 | package unix 8 | 9 | // SyscallNoError may be used instead of Syscall for syscalls that don't fail. 10 | func SyscallNoError(trap, a1, a2, a3 uintptr) (r1, r2 uintptr) 11 | 12 | // RawSyscallNoError may be used instead of RawSyscall for syscalls that don't 13 | // fail. 14 | func RawSyscallNoError(trap, a1, a2, a3 uintptr) (r1, r2 uintptr) 15 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/encoding/protojson/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Package protojson marshals and unmarshals protocol buffer messages as JSON 6 | // format. It follows the guide at 7 | // https://protobuf.dev/programming-guides/proto3#json. 8 | // 9 | // This package produces a different output than the standard [encoding/json] 10 | // package, which does not operate correctly on protocol buffer messages. 11 | package protojson 12 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/race0.go: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build windows && !race 6 | 7 | package windows 8 | 9 | import ( 10 | "unsafe" 11 | ) 12 | 13 | const raceenabled = false 14 | 15 | func raceAcquire(addr unsafe.Pointer) { 16 | } 17 | 18 | func raceReleaseMerge(addr unsafe.Pointer) { 19 | } 20 | 21 | func raceReadRange(addr unsafe.Pointer, len int) { 22 | } 23 | 24 | func raceWriteRange(addr unsafe.Pointer, len int) { 25 | } 26 | -------------------------------------------------------------------------------- /vendor/github.com/RoaringBitmap/roaring/serialization.go: -------------------------------------------------------------------------------- 1 | package roaring 2 | 3 | import ( 4 | "encoding/binary" 5 | "io" 6 | ) 7 | 8 | // writeTo for runContainer16 follows this 9 | // spec: https://github.com/RoaringBitmap/RoaringFormatSpec 10 | func (b *runContainer16) writeTo(stream io.Writer) (int, error) { 11 | buf := make([]byte, 2+4*len(b.iv)) 12 | binary.LittleEndian.PutUint16(buf[0:], uint16(len(b.iv))) 13 | for i, v := range b.iv { 14 | binary.LittleEndian.PutUint16(buf[2+i*4:], v.start) 15 | binary.LittleEndian.PutUint16(buf[2+2+i*4:], v.length) 16 | } 17 | return stream.Write(buf) 18 | } 19 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/pebble/internal/invariants/finalizer_off.go: -------------------------------------------------------------------------------- 1 | // Copyright 2021 The LevelDB-Go and Pebble Authors. All rights reserved. Use 2 | // of this source code is governed by a BSD-style license that can be found in 3 | // the LICENSE file. 4 | 5 | //go:build (!invariants && !tracing) || race 6 | // +build !invariants,!tracing race 7 | 8 | package invariants 9 | 10 | // SetFinalizer is a wrapper around runtime.SetFinalizer that is a no-op under 11 | // race builds or if neither the invariants or tracing build tags are 12 | // specified. 13 | func SetFinalizer(obj, finalizer interface{}) { 14 | } 15 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/pebble/internal/manual/manual_nocgo.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The LevelDB-Go and Pebble Authors. All rights reserved. Use 2 | // of this source code is governed by a BSD-style license that can be found in 3 | // the LICENSE file. 4 | 5 | //go:build !cgo 6 | // +build !cgo 7 | 8 | package manual 9 | 10 | // Provides versions of New and Free when cgo is not available (e.g. cross 11 | // compilation). 12 | 13 | // New allocates a slice of size n. 14 | func New(n int) []byte { 15 | return make([]byte, n) 16 | } 17 | 18 | // Free frees the specified slice. 19 | func Free(b []byte) { 20 | } 21 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_hurd_386.go: -------------------------------------------------------------------------------- 1 | // Copyright 2022 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build 386 && hurd 6 | 7 | package unix 8 | 9 | const ( 10 | TIOCGETA = 0x62251713 11 | ) 12 | 13 | type Winsize struct { 14 | Row uint16 15 | Col uint16 16 | Xpixel uint16 17 | Ypixel uint16 18 | } 19 | 20 | type Termios struct { 21 | Iflag uint32 22 | Oflag uint32 23 | Cflag uint32 24 | Lflag uint32 25 | Cc [20]uint8 26 | Ispeed int32 27 | Ospeed int32 28 | } 29 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/pebble/internal/fastrand/fastrand.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The LevelDB-Go and Pebble Authors. All rights reserved. Use 2 | // of this source code is governed by a BSD-style license that can be found in 3 | // the LICENSE file. 4 | 5 | package fastrand 6 | 7 | import _ "unsafe" // required by go:linkname 8 | 9 | // Uint32 returns a lock free uint32 value. 10 | // 11 | //go:linkname Uint32 runtime.fastrand 12 | func Uint32() uint32 13 | 14 | // Uint32n returns a lock free uint32 value in the interval [0, n). 15 | // 16 | //go:linkname Uint32n runtime.fastrandn 17 | func Uint32n(n uint32) uint32 18 | -------------------------------------------------------------------------------- /vendor/github.com/ohler55/ojg/jp/indexed.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2023, Peter Ohler, All rights reserved. 2 | 3 | package jp 4 | 5 | // Indexed describes an interface for a collection that is indexed by a 6 | // integers similar to a []any. 7 | type Indexed interface { 8 | 9 | // ValueAtIndex should return the value at the provided index or nil if no 10 | // entry exists at the index. 11 | ValueAtIndex(index int) any 12 | 13 | // SetValueAtIndex should set the value at the provided index. 14 | SetValueAtIndex(index int, value any) 15 | 16 | // Size should return the size for the collection. 17 | Size() int 18 | } 19 | -------------------------------------------------------------------------------- /vendor/github.com/RoaringBitmap/roaring/popcnt_generic.go: -------------------------------------------------------------------------------- 1 | //go:build !amd64 || appengine || go1.9 2 | // +build !amd64 appengine go1.9 3 | 4 | package roaring 5 | 6 | func popcntSlice(s []uint64) uint64 { 7 | return popcntSliceGo(s) 8 | } 9 | 10 | func popcntMaskSlice(s, m []uint64) uint64 { 11 | return popcntMaskSliceGo(s, m) 12 | } 13 | 14 | func popcntAndSlice(s, m []uint64) uint64 { 15 | return popcntAndSliceGo(s, m) 16 | } 17 | 18 | func popcntOrSlice(s, m []uint64) uint64 { 19 | return popcntOrSliceGo(s, m) 20 | } 21 | 22 | func popcntXorSlice(s, m []uint64) uint64 { 23 | return popcntXorSliceGo(s, m) 24 | } 25 | -------------------------------------------------------------------------------- /vendor/github.com/ohler55/ojg/jp/at.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2020, Peter Ohler, All rights reserved. 2 | 3 | package jp 4 | 5 | // At is the @ in a JSON path representation. 6 | type At byte 7 | 8 | // Append a fragment string representation of the fragment to the buffer 9 | // then returning the expanded buffer. 10 | func (f At) Append(buf []byte, bracket, first bool) []byte { 11 | buf = append(buf, '@') 12 | return buf 13 | } 14 | 15 | func (f At) locate(pp Expr, data any, rest Expr, max int) (locs []Expr) { 16 | if 0 < len(rest) { 17 | locs = rest[0].locate(append(pp, f), data, rest[1:], max) 18 | } 19 | return 20 | } 21 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/pebble/internal/manual/manual_64bit.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The LevelDB-Go and Pebble Authors. All rights reserved. Use 2 | // of this source code is governed by a BSD-style license that can be found in 3 | // the LICENSE file. 4 | 5 | //go:build amd64 || arm64 || arm64be || ppc64 || ppc64le || mips64 || mips64le || s390x || sparc64 || riscv64 || loong64 6 | // +build amd64 arm64 arm64be ppc64 ppc64le mips64 mips64le s390x sparc64 riscv64 loong64 7 | 8 | package manual 9 | 10 | const ( 11 | // MaxArrayLen is a safe maximum length for slices on this architecture. 12 | MaxArrayLen = 1<<50 - 1 13 | ) 14 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/str.go: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build windows 6 | 7 | package windows 8 | 9 | func itoa(val int) string { // do it here rather than with fmt to avoid dependency 10 | if val < 0 { 11 | return "-" + itoa(-val) 12 | } 13 | var buf [32]byte // big enough for int64 14 | i := len(buf) - 1 15 | for val >= 10 { 16 | buf[i] = byte(val%10 + '0') 17 | i-- 18 | val /= 10 19 | } 20 | buf[i] = byte(val + '0') 21 | return string(buf[i:]) 22 | } 23 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/pebble/logger.go: -------------------------------------------------------------------------------- 1 | // Copyright 2011 The LevelDB-Go and Pebble Authors. All rights reserved. Use 2 | // of this source code is governed by a BSD-style license that can be found in 3 | // the LICENSE file. 4 | 5 | package pebble 6 | 7 | import "github.com/cockroachdb/pebble/internal/base" 8 | 9 | // Logger defines an interface for writing log messages. 10 | type Logger = base.Logger 11 | 12 | // DefaultLogger logs to the Go stdlib logs. 13 | var DefaultLogger = base.DefaultLogger 14 | 15 | // LoggerAndTracer defines an interface for logging and tracing. 16 | type LoggerAndTracer = base.LoggerAndTracer 17 | -------------------------------------------------------------------------------- /vendor/github.com/google/cel-go/common/debug/BUILD.bazel: -------------------------------------------------------------------------------- 1 | load("@io_bazel_rules_go//go:def.bzl", "go_library") 2 | 3 | package( 4 | default_visibility = ["//visibility:public"], 5 | licenses = ["notice"], # Apache 2.0 6 | ) 7 | 8 | go_library( 9 | name = "go_default_library", 10 | srcs = [ 11 | "debug.go", 12 | ], 13 | importpath = "github.com/google/cel-go/common/debug", 14 | deps = [ 15 | "//common:go_default_library", 16 | "//common/ast:go_default_library", 17 | "//common/types:go_default_library", 18 | "//common/types/ref:go_default_library", 19 | ], 20 | ) 21 | -------------------------------------------------------------------------------- /vendor/github.com/google/cel-go/common/runes/BUILD.bazel: -------------------------------------------------------------------------------- 1 | load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test") 2 | 3 | package( 4 | default_visibility = ["//visibility:public"], 5 | licenses = ["notice"], # Apache 2.0 6 | ) 7 | 8 | go_library( 9 | name = "go_default_library", 10 | srcs = [ 11 | "buffer.go", 12 | ], 13 | importpath = "github.com/google/cel-go/common/runes", 14 | ) 15 | 16 | go_test( 17 | name = "go_default_test", 18 | size = "small", 19 | srcs = [ 20 | "buffer_test.go", 21 | ], 22 | embed = [ 23 | ":go_default_library", 24 | ], 25 | ) 26 | -------------------------------------------------------------------------------- /vendor/gopkg.in/yaml.v3/NOTICE: -------------------------------------------------------------------------------- 1 | Copyright 2011-2016 Canonical Ltd. 2 | 3 | Licensed under the Apache License, Version 2.0 (the "License"); 4 | you may not use this file except in compliance with the License. 5 | You may obtain a copy of the License at 6 | 7 | http://www.apache.org/licenses/LICENSE-2.0 8 | 9 | Unless required by applicable law or agreed to in writing, software 10 | distributed under the License is distributed on an "AS IS" BASIS, 11 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | See the License for the specific language governing permissions and 13 | limitations under the License. 14 | -------------------------------------------------------------------------------- /vendor/github.com/antlr4-go/antlr/v4/token_stream.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2012-2022 The ANTLR Project. All rights reserved. 2 | // Use of this file is governed by the BSD 3-clause license that 3 | // can be found in the LICENSE.txt file in the project root. 4 | 5 | package antlr 6 | 7 | type TokenStream interface { 8 | IntStream 9 | 10 | LT(k int) Token 11 | Reset() 12 | 13 | Get(index int) Token 14 | GetTokenSource() TokenSource 15 | SetTokenSource(TokenSource) 16 | 17 | GetAllText() string 18 | GetTextFromInterval(Interval) string 19 | GetTextFromRuleContext(RuleContext) string 20 | GetTextFromTokens(Token, Token) string 21 | } 22 | -------------------------------------------------------------------------------- /vendor/github.com/bits-and-blooms/bitset/popcnt_generic.go: -------------------------------------------------------------------------------- 1 | //go:build !go1.9 && (!amd64 || appengine) 2 | // +build !go1.9 3 | // +build !amd64 appengine 4 | 5 | package bitset 6 | 7 | func popcntSlice(s []uint64) uint64 { 8 | return popcntSliceGo(s) 9 | } 10 | 11 | func popcntMaskSlice(s, m []uint64) uint64 { 12 | return popcntMaskSliceGo(s, m) 13 | } 14 | 15 | func popcntAndSlice(s, m []uint64) uint64 { 16 | return popcntAndSliceGo(s, m) 17 | } 18 | 19 | func popcntOrSlice(s, m []uint64) uint64 { 20 | return popcntOrSliceGo(s, m) 21 | } 22 | 23 | func popcntXorSlice(s, m []uint64) uint64 { 24 | return popcntXorSliceGo(s, m) 25 | } 26 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/sysvshm_linux.go: -------------------------------------------------------------------------------- 1 | // Copyright 2021 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build linux 6 | 7 | package unix 8 | 9 | import "runtime" 10 | 11 | // SysvShmCtl performs control operations on the shared memory segment 12 | // specified by id. 13 | func SysvShmCtl(id, cmd int, desc *SysvShmDesc) (result int, err error) { 14 | if runtime.GOARCH == "arm" || 15 | runtime.GOARCH == "mips64" || runtime.GOARCH == "mips64le" { 16 | cmd |= ipc_64 17 | } 18 | 19 | return shmctl(id, cmd, desc) 20 | } 21 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/proto/proto_reflect.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // The protoreflect build tag disables use of fast-path methods. 6 | //go:build protoreflect 7 | // +build protoreflect 8 | 9 | package proto 10 | 11 | import ( 12 | "google.golang.org/protobuf/reflect/protoreflect" 13 | "google.golang.org/protobuf/runtime/protoiface" 14 | ) 15 | 16 | const hasProtoMethods = false 17 | 18 | func protoMethods(m protoreflect.Message) *protoiface.Methods { 19 | return nil 20 | } 21 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/fifo/.gitignore: -------------------------------------------------------------------------------- 1 | # If you prefer the allow list template instead of the deny list, see community template: 2 | # https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore 3 | # 4 | # Binaries for programs and plugins 5 | *.exe 6 | *.exe~ 7 | *.dll 8 | *.so 9 | *.dylib 10 | 11 | # Test binary, built with `go test -c` 12 | *.test 13 | 14 | # Output of the go coverage tool, specifically when used with LiteIDE 15 | *.out 16 | 17 | # Dependency directories (remove the comment below to include it) 18 | # vendor/ 19 | 20 | # Go workspace file 21 | go.work 22 | go.work.sum 23 | 24 | .idea/ 25 | 26 | -------------------------------------------------------------------------------- /vendor/github.com/ohler55/ojg/jp/root.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2020, Peter Ohler, All rights reserved. 2 | 3 | package jp 4 | 5 | // Root represents a root $ in a JSON path representation. 6 | type Root byte 7 | 8 | // Append a fragment string representation of the fragment to the buffer 9 | // then returning the expanded buffer. 10 | func (f Root) Append(buf []byte, bracket, first bool) []byte { 11 | buf = append(buf, '$') 12 | return buf 13 | } 14 | 15 | func (f Root) locate(pp Expr, data any, rest Expr, max int) (locs []Expr) { 16 | if 0 < len(rest) { 17 | locs = rest[0].locate(append(pp, f), data, rest[1:], max) 18 | } 19 | return 20 | } 21 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/impl/codec_unsafe.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build !purego && !appengine 6 | // +build !purego,!appengine 7 | 8 | package impl 9 | 10 | // When using unsafe pointers, we can just treat enum values as int32s. 11 | 12 | var ( 13 | coderEnumNoZero = coderInt32NoZero 14 | coderEnum = coderInt32 15 | coderEnumPtr = coderInt32Ptr 16 | coderEnumSlice = coderInt32Slice 17 | coderEnumPackedSlice = coderInt32PackedSlice 18 | ) 19 | -------------------------------------------------------------------------------- /vendor/github.com/gogo/protobuf/AUTHORS: -------------------------------------------------------------------------------- 1 | # This is the official list of GoGo authors for copyright purposes. 2 | # This file is distinct from the CONTRIBUTORS file, which 3 | # lists people. For example, employees are listed in CONTRIBUTORS, 4 | # but not in AUTHORS, because the employer holds the copyright. 5 | 6 | # Names should be added to this file as one of 7 | # Organization's name 8 | # Individual's name 9 | # Individual's name 10 | 11 | # Please keep the list sorted. 12 | 13 | Sendgrid, Inc 14 | Vastech SA (PTY) LTD 15 | Walter Schulze 16 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/sockcmsg_dragonfly.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package unix 6 | 7 | // Round the length of a raw sockaddr up to align it properly. 8 | func cmsgAlignOf(salen int) int { 9 | salign := SizeofPtr 10 | if SizeofPtr == 8 && !supportsABI(_dragonflyABIChangeVersion) { 11 | // 64-bit Dragonfly before the September 2019 ABI changes still requires 12 | // 32-bit aligned access to network subsystem. 13 | salign = 4 14 | } 15 | return (salen + salign - 1) & ^(salign - 1) 16 | } 17 | -------------------------------------------------------------------------------- /vendor/github.com/RoaringBitmap/roaring/popcnt_compat.go: -------------------------------------------------------------------------------- 1 | //go:build !go1.9 2 | // +build !go1.9 3 | 4 | package roaring 5 | 6 | // bit population count, take from 7 | // https://code.google.com/p/go/issues/detail?id=4988#c11 8 | // credit: https://code.google.com/u/arnehormann/ 9 | // credit: https://play.golang.org/p/U7SogJ7psJ 10 | // credit: http://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetParallel 11 | func popcount(x uint64) uint64 { 12 | x -= (x >> 1) & 0x5555555555555555 13 | x = (x>>2)&0x3333333333333333 + x&0x3333333333333333 14 | x += x >> 4 15 | x &= 0x0f0f0f0f0f0f0f0f 16 | x *= 0x0101010101010101 17 | return x >> 56 18 | } 19 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/proto/proto_methods.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // The protoreflect build tag disables use of fast-path methods. 6 | //go:build !protoreflect 7 | // +build !protoreflect 8 | 9 | package proto 10 | 11 | import ( 12 | "google.golang.org/protobuf/reflect/protoreflect" 13 | "google.golang.org/protobuf/runtime/protoiface" 14 | ) 15 | 16 | const hasProtoMethods = true 17 | 18 | func protoMethods(m protoreflect.Message) *protoiface.Methods { 19 | return m.ProtoMethods() 20 | } 21 | -------------------------------------------------------------------------------- /vendor/github.com/golang/snappy/AUTHORS: -------------------------------------------------------------------------------- 1 | # This is the official list of Snappy-Go authors for copyright purposes. 2 | # This file is distinct from the CONTRIBUTORS files. 3 | # See the latter for an explanation. 4 | 5 | # Names should be added to this file as 6 | # Name or Organization 7 | # The email address is not required for organizations. 8 | 9 | # Please keep the list sorted. 10 | 11 | Amazon.com, Inc 12 | Damian Gryski 13 | Eric Buth 14 | Google Inc. 15 | Jan Mercl <0xjnml@gmail.com> 16 | Klaus Post 17 | Rodolfo Carvalho 18 | Sebastien Binet 19 | -------------------------------------------------------------------------------- /vendor/github.com/ohler55/ojg/jp/bracket.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2020, Peter Ohler, All rights reserved. 2 | 3 | package jp 4 | 5 | // Bracket is used as a flag to indicate the path should be displayed in a 6 | // bracketed representation. 7 | type Bracket byte 8 | 9 | // Append a fragment string representation of the fragment to the buffer 10 | // then returning the expanded buffer. 11 | func (f Bracket) Append(buf []byte, bracket, first bool) []byte { 12 | return buf 13 | } 14 | 15 | func (f Bracket) locate(pp Expr, data any, rest Expr, max int) (locs []Expr) { 16 | if 0 < len(rest) { 17 | locs = rest[0].locate(pp, data, rest[1:], max) 18 | } 19 | return 20 | } 21 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/genid/map_entry.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package genid 6 | 7 | import protoreflect "google.golang.org/protobuf/reflect/protoreflect" 8 | 9 | // Generic field names and numbers for synthetic map entry messages. 10 | const ( 11 | MapEntry_Key_field_name protoreflect.Name = "key" 12 | MapEntry_Value_field_name protoreflect.Name = "value" 13 | 14 | MapEntry_Key_field_number protoreflect.FieldNumber = 1 15 | MapEntry_Value_field_number protoreflect.FieldNumber = 2 16 | ) 17 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/genid/empty_gen.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Code generated by generate-protos. DO NOT EDIT. 6 | 7 | package genid 8 | 9 | import ( 10 | protoreflect "google.golang.org/protobuf/reflect/protoreflect" 11 | ) 12 | 13 | const File_google_protobuf_empty_proto = "google/protobuf/empty.proto" 14 | 15 | // Names for google.protobuf.Empty. 16 | const ( 17 | Empty_message_name protoreflect.Name = "Empty" 18 | Empty_message_fullname protoreflect.FullName = "google.protobuf.Empty" 19 | ) 20 | -------------------------------------------------------------------------------- /vendor/github.com/getsentry/sentry-go/traces_sampler.go: -------------------------------------------------------------------------------- 1 | package sentry 2 | 3 | // A SamplingContext is passed to a TracesSampler to determine a sampling 4 | // decision. 5 | // 6 | // TODO(tracing): possibly expand SamplingContext to include custom / 7 | // user-provided data. 8 | type SamplingContext struct { 9 | Span *Span // The current span, always non-nil. 10 | Parent *Span // The parent span, may be nil. 11 | } 12 | 13 | // The TracesSample type is an adapter to allow the use of ordinary 14 | // functions as a TracesSampler. 15 | type TracesSampler func(ctx SamplingContext) float64 16 | 17 | func (f TracesSampler) Sample(ctx SamplingContext) float64 { 18 | return f(ctx) 19 | } 20 | -------------------------------------------------------------------------------- /vendor/github.com/RoaringBitmap/roaring/clz_compat.go: -------------------------------------------------------------------------------- 1 | //go:build !go1.9 2 | // +build !go1.9 3 | 4 | package roaring 5 | 6 | // LeadingZeroBits returns the number of consecutive most significant zero 7 | // bits of x. 8 | func countLeadingZeros(i uint64) int { 9 | if i == 0 { 10 | return 64 11 | } 12 | n := 1 13 | x := uint32(i >> 32) 14 | if x == 0 { 15 | n += 32 16 | x = uint32(i) 17 | } 18 | if (x >> 16) == 0 { 19 | n += 16 20 | x <<= 16 21 | } 22 | if (x >> 24) == 0 { 23 | n += 8 24 | x <<= 8 25 | } 26 | if x>>28 == 0 { 27 | n += 4 28 | x <<= 4 29 | } 30 | if x>>30 == 0 { 31 | n += 2 32 | x <<= 2 33 | 34 | } 35 | n -= int(x >> 31) 36 | return n 37 | } 38 | -------------------------------------------------------------------------------- /vendor/github.com/getsentry/sentry-go/profiler_windows.go: -------------------------------------------------------------------------------- 1 | package sentry 2 | 3 | import ( 4 | "sync" 5 | "syscall" 6 | ) 7 | 8 | // This works around the ticker resolution on Windows being ~15ms by default. 9 | // See https://github.com/golang/go/issues/44343 10 | func setTimeTickerResolution() { 11 | var winmmDLL = syscall.NewLazyDLL("winmm.dll") 12 | if winmmDLL != nil { 13 | var timeBeginPeriod = winmmDLL.NewProc("timeBeginPeriod") 14 | if timeBeginPeriod != nil { 15 | timeBeginPeriod.Call(uintptr(1)) 16 | } 17 | } 18 | } 19 | 20 | var setupTickerResolutionOnce sync.Once 21 | 22 | func onProfilerStart() { 23 | setupTickerResolutionOnce.Do(setTimeTickerResolution) 24 | } 25 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/race0.go: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build aix || (darwin && !race) || (linux && !race) || (freebsd && !race) || netbsd || openbsd || solaris || dragonfly || zos 6 | 7 | package unix 8 | 9 | import ( 10 | "unsafe" 11 | ) 12 | 13 | const raceenabled = false 14 | 15 | func raceAcquire(addr unsafe.Pointer) { 16 | } 17 | 18 | func raceReleaseMerge(addr unsafe.Pointer) { 19 | } 20 | 21 | func raceReadRange(addr unsafe.Pointer, len int) { 22 | } 23 | 24 | func raceWriteRange(addr unsafe.Pointer, len int) { 25 | } 26 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_linux_gc_386.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build linux && gc && 386 6 | 7 | package unix 8 | 9 | import "syscall" 10 | 11 | // Underlying system call writes to newoffset via pointer. 12 | // Implemented in assembly to avoid allocation. 13 | func seek(fd int, offset int64, whence int) (newoffset int64, err syscall.Errno) 14 | 15 | func socketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, err syscall.Errno) 16 | func rawsocketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, err syscall.Errno) 17 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/pebble/internal/invariants/finalizer_on.go: -------------------------------------------------------------------------------- 1 | // Copyright 2021 The LevelDB-Go and Pebble Authors. All rights reserved. Use 2 | // of this source code is governed by a BSD-style license that can be found in 3 | // the LICENSE file. 4 | 5 | //go:build (invariants && !race) || (tracing && !race) 6 | // +build invariants,!race tracing,!race 7 | 8 | package invariants 9 | 10 | import "runtime" 11 | 12 | // SetFinalizer is a wrapper around runtime.SetFinalizer that is a no-op under 13 | // race builds or if neither the invariants or tracing build tags are 14 | // specified. 15 | func SetFinalizer(obj, finalizer interface{}) { 16 | runtime.SetFinalizer(obj, finalizer) 17 | } 18 | -------------------------------------------------------------------------------- /vendor/github.com/google/cel-go/checker/decls/BUILD.bazel: -------------------------------------------------------------------------------- 1 | load("@io_bazel_rules_go//go:def.bzl", "go_library") 2 | 3 | package( 4 | default_visibility = ["//visibility:public"], 5 | licenses = ["notice"], # Apache 2.0 6 | ) 7 | 8 | go_library( 9 | name = "go_default_library", 10 | srcs = [ 11 | "decls.go", 12 | ], 13 | importpath = "github.com/google/cel-go/checker/decls", 14 | deps = [ 15 | "@org_golang_google_genproto_googleapis_api//expr/v1alpha1:go_default_library", 16 | "@org_golang_google_protobuf//types/known/emptypb:go_default_library", 17 | "@org_golang_google_protobuf//types/known/structpb:go_default_library", 18 | ], 19 | ) 20 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/pebble/internal/intern/intern.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The LevelDB-Go and Pebble Authors. All rights reserved. Use 2 | // of this source code is governed by a BSD-style license that can be found in 3 | // the LICENSE file. 4 | 5 | package intern 6 | 7 | import "sync" 8 | 9 | var pool = sync.Pool{ 10 | New: func() interface{} { 11 | return make(map[string]string) 12 | }, 13 | } 14 | 15 | // Bytes returns b converted to a string, interned. 16 | func Bytes(b []byte) string { 17 | m := pool.Get().(map[string]string) 18 | c, ok := m[string(b)] 19 | if ok { 20 | pool.Put(m) 21 | return c 22 | } 23 | s := string(b) 24 | m[s] = s 25 | pool.Put(m) 26 | return s 27 | } 28 | -------------------------------------------------------------------------------- /vendor/github.com/ohler55/ojg/gen/node.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2020, Peter Ohler, All rights reserved. 2 | 3 | package gen 4 | 5 | import ( 6 | "fmt" 7 | ) 8 | 9 | // Node is the interface for typed generic data. 10 | type Node interface { 11 | fmt.Stringer 12 | 13 | // Alter converts the node into it's native type. Note this will modify 14 | // Objects and Arrays in place making them no longer usable as the 15 | // original type. Use with care! 16 | Alter() any 17 | 18 | // Simplify makes a copy of the node but as simple types. 19 | Simplify() any 20 | 21 | // Dup returns a deep duplicate of the node. 22 | Dup() Node 23 | 24 | // Empty returns true if the node is empty. 25 | Empty() bool 26 | } 27 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/redact/internal/rfmt/refresh.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | # 3 | # This file re-generates the sources in this directory from the Go 4 | # standard library. 5 | # 6 | set -euxo pipefail 7 | 8 | cp $GOROOT/src/fmt/format.go format.go 9 | patch -p0 fmtsort/"$n" 25 | done 26 | 27 | -------------------------------------------------------------------------------- /vendor/github.com/google/cel-go/common/types/ref/BUILD.bazel: -------------------------------------------------------------------------------- 1 | load("@io_bazel_rules_go//go:def.bzl", "go_library") 2 | 3 | package( 4 | default_visibility = ["//visibility:public"], 5 | licenses = ["notice"], # Apache 2.0 6 | ) 7 | 8 | go_library( 9 | name = "go_default_library", 10 | srcs = [ 11 | "provider.go", 12 | "reference.go", 13 | ], 14 | importpath = "github.com/google/cel-go/common/types/ref", 15 | deps = [ 16 | "@org_golang_google_genproto_googleapis_api//expr/v1alpha1:go_default_library", 17 | "@org_golang_google_protobuf//proto:go_default_library", 18 | "@org_golang_google_protobuf//reflect/protoreflect:go_default_library", 19 | ], 20 | ) 21 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/pebble/vfs/errors_windows.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The LevelDB-Go and Pebble Authors. All rights reserved. Use 2 | // of this source code is governed by a BSD-style license that can be found in 3 | // the LICENSE file. 4 | 5 | //go:build windows 6 | // +build windows 7 | 8 | package vfs 9 | 10 | import ( 11 | "github.com/cockroachdb/errors" 12 | "golang.org/x/sys/windows" 13 | ) 14 | 15 | var errNotEmpty = windows.ERROR_DIR_NOT_EMPTY 16 | 17 | // IsNoSpaceError returns true if the given error indicates that the disk is 18 | // out of space. 19 | func IsNoSpaceError(err error) bool { 20 | return errors.Is(err, windows.ERROR_DISK_FULL) || 21 | errors.Is(err, windows.ERROR_HANDLE_DISK_FULL) 22 | } 23 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_linux_gccgo_arm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build linux && gccgo && arm 6 | 7 | package unix 8 | 9 | import ( 10 | "syscall" 11 | "unsafe" 12 | ) 13 | 14 | func seek(fd int, offset int64, whence int) (int64, syscall.Errno) { 15 | var newoffset int64 16 | offsetLow := uint32(offset & 0xffffffff) 17 | offsetHigh := uint32((offset >> 32) & 0xffffffff) 18 | _, _, err := Syscall6(SYS__LLSEEK, uintptr(fd), uintptr(offsetHigh), uintptr(offsetLow), uintptr(unsafe.Pointer(&newoffset)), uintptr(whence), 0) 19 | return newoffset, err 20 | } 21 | -------------------------------------------------------------------------------- /vendor/github.com/RoaringBitmap/roaring/manyiterator.go: -------------------------------------------------------------------------------- 1 | package roaring 2 | 3 | type manyIterable interface { 4 | nextMany(hs uint32, buf []uint32) int 5 | nextMany64(hs uint64, buf []uint64) int 6 | } 7 | 8 | func (si *shortIterator) nextMany(hs uint32, buf []uint32) int { 9 | n := 0 10 | l := si.loc 11 | s := si.slice 12 | for n < len(buf) && l < len(s) { 13 | buf[n] = uint32(s[l]) | hs 14 | l++ 15 | n++ 16 | } 17 | si.loc = l 18 | return n 19 | } 20 | 21 | func (si *shortIterator) nextMany64(hs uint64, buf []uint64) int { 22 | n := 0 23 | l := si.loc 24 | s := si.slice 25 | for n < len(buf) && l < len(s) { 26 | buf[n] = uint64(s[l]) | hs 27 | l++ 28 | n++ 29 | } 30 | si.loc = l 31 | return n 32 | } 33 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/pebble/vfs/errors_unix.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The LevelDB-Go and Pebble Authors. All rights reserved. Use 2 | // of this source code is governed by a BSD-style license that can be found in 3 | // the LICENSE file. 4 | 5 | //go:build darwin || dragonfly || freebsd || linux || openbsd || netbsd 6 | // +build darwin dragonfly freebsd linux openbsd netbsd 7 | 8 | package vfs 9 | 10 | import ( 11 | "github.com/cockroachdb/errors" 12 | "golang.org/x/sys/unix" 13 | ) 14 | 15 | var errNotEmpty = unix.ENOTEMPTY 16 | 17 | // IsNoSpaceError returns true if the given error indicates that the disk is 18 | // out of space. 19 | func IsNoSpaceError(err error) bool { 20 | return errors.Is(err, unix.ENOSPC) 21 | } 22 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_unix_gc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (darwin || dragonfly || freebsd || (linux && !ppc64 && !ppc64le) || netbsd || openbsd || solaris) && gc 6 | 7 | package unix 8 | 9 | import "syscall" 10 | 11 | func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) 12 | func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) 13 | func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) 14 | func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) 15 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/impl/enum.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package impl 6 | 7 | import ( 8 | "reflect" 9 | 10 | "google.golang.org/protobuf/reflect/protoreflect" 11 | ) 12 | 13 | type EnumInfo struct { 14 | GoReflectType reflect.Type // int32 kind 15 | Desc protoreflect.EnumDescriptor 16 | } 17 | 18 | func (t *EnumInfo) New(n protoreflect.EnumNumber) protoreflect.Enum { 19 | return reflect.ValueOf(n).Convert(t.GoReflectType).Interface().(protoreflect.Enum) 20 | } 21 | func (t *EnumInfo) Descriptor() protoreflect.EnumDescriptor { return t.Desc } 22 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/pebble/internal/keyspan/doc.go: -------------------------------------------------------------------------------- 1 | // Package keyspan provides facilities for sorting, fragmenting and 2 | // iterating over spans of user keys. 3 | // 4 | // A Span represents a range of user key space with an inclusive start 5 | // key and exclusive end key. A span may hold any number of Keys which are 6 | // applied over the entirety of the span's keyspace. 7 | // 8 | // Spans are used within Pebble as an in-memory representation of range 9 | // deletion tombstones, and range key sets, unsets and deletes. Spans 10 | // are fragmented at overlapping key boundaries by the Fragmenter type. 11 | // This package's various iteration facilities require these 12 | // non-overlapping fragmented spans. 13 | package keyspan 14 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/pebble/vfs/fadvise_linux.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The LevelDB-Go and Pebble Authors. All rights reserved. Use 2 | // of this source code is governed by a BSD-style license that can be found in 3 | // the LICENSE file. 4 | 5 | //go:build linux 6 | // +build linux 7 | 8 | package vfs 9 | 10 | import "golang.org/x/sys/unix" 11 | 12 | // Calls Fadvise with FADV_RANDOM to disable readahead on a file descriptor. 13 | func fadviseRandom(f uintptr) error { 14 | return unix.Fadvise(int(f), 0, 0, unix.FADV_RANDOM) 15 | } 16 | 17 | // Calls Fadvise with FADV_SEQUENTIAL to enable readahead on a file descriptor. 18 | func fadviseSequential(f uintptr) error { 19 | return unix.Fadvise(int(f), 0, 0, unix.FADV_SEQUENTIAL) 20 | } 21 | -------------------------------------------------------------------------------- /vendor/github.com/rogpeppe/go-internal/fmtsort/mapelem.go: -------------------------------------------------------------------------------- 1 | //go:build go1.12 2 | // +build go1.12 3 | 4 | package fmtsort 5 | 6 | import "reflect" 7 | 8 | const brokenNaNs = false 9 | 10 | func mapElems(mapValue reflect.Value) ([]reflect.Value, []reflect.Value) { 11 | // Note: this code is arranged to not panic even in the presence 12 | // of a concurrent map update. The runtime is responsible for 13 | // yelling loudly if that happens. See issue 33275. 14 | n := mapValue.Len() 15 | key := make([]reflect.Value, 0, n) 16 | value := make([]reflect.Value, 0, n) 17 | iter := mapValue.MapRange() 18 | for iter.Next() { 19 | key = append(key, iter.Key()) 20 | value = append(value, iter.Value()) 21 | } 22 | return key, value 23 | } 24 | -------------------------------------------------------------------------------- /vendor/github.com/rogpeppe/go-internal/fmtsort/mapelem_1.11.go: -------------------------------------------------------------------------------- 1 | //go:build !go1.12 2 | // +build !go1.12 3 | 4 | package fmtsort 5 | 6 | import "reflect" 7 | 8 | const brokenNaNs = true 9 | 10 | func mapElems(mapValue reflect.Value) ([]reflect.Value, []reflect.Value) { 11 | key := mapValue.MapKeys() 12 | value := make([]reflect.Value, 0, len(key)) 13 | for _, k := range key { 14 | v := mapValue.MapIndex(k) 15 | if !v.IsValid() { 16 | // Note: we can't retrieve the value, probably because 17 | // the key is NaN, so just do the best we can and 18 | // add a zero value of the correct type in that case. 19 | v = reflect.Zero(mapValue.Type().Elem()) 20 | } 21 | value = append(value, v) 22 | } 23 | return key, value 24 | } 25 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/pebble/internal/constants/constants.go: -------------------------------------------------------------------------------- 1 | // Copyright 2023 The LevelDB-Go and Pebble Authors. All rights reserved. Use 2 | // of this source code is governed by a BSD-style license that can be found in 3 | // the LICENSE file. 4 | 5 | package constants 6 | 7 | const ( 8 | // oneIf64Bit is 1 on 64-bit platforms and 0 on 32-bit platforms. 9 | oneIf64Bit = ^uint(0) >> 63 10 | 11 | // MaxUint32OrInt returns min(MaxUint32, MaxInt), i.e 12 | // - MaxUint32 on 64-bit platforms; 13 | // - MaxInt on 32-bit platforms. 14 | // It is used when slices are limited to Uint32 on 64-bit platforms (the 15 | // length limit for slices is naturally MaxInt on 32-bit platforms). 16 | MaxUint32OrInt = (1<<31)<> cov.out 19 | $Q grep github sen/cov.out >> cov.out 20 | $Q grep github pretty/cov.out >> cov.out 21 | $Q grep github alt/cov.out >> cov.out 22 | $Q grep github jp/cov.out >> cov.out 23 | $Q grep github gen/cov.out >> cov.out 24 | $Q grep github asm/cov.out >> cov.out 25 | $Q go tool cover -func=cov.out | grep "total:" 26 | 27 | test: cover 28 | 29 | .PHONY: all lint cover test 30 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/pebble/vfs/file_lock_generic.go: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The LevelDB-Go and Pebble Authors. All rights reserved. Use 2 | // of this source code is governed by a BSD-style license that can be found in 3 | // the LICENSE file. 4 | 5 | //go:build !darwin && !dragonfly && !freebsd && !linux && !netbsd && !openbsd && !solaris && !windows 6 | // +build !darwin,!dragonfly,!freebsd,!linux,!netbsd,!openbsd,!solaris,!windows 7 | 8 | package vfs 9 | 10 | import ( 11 | "io" 12 | "runtime" 13 | 14 | "github.com/cockroachdb/errors" 15 | ) 16 | 17 | func (defFS) Lock(name string) (io.Closer, error) { 18 | return nil, errors.Errorf("pebble: file locking is not implemented on %s/%s", 19 | errors.Safe(runtime.GOOS), errors.Safe(runtime.GOARCH)) 20 | } 21 | -------------------------------------------------------------------------------- /vendor/github.com/getsentry/sentry-go/internal/ratelimit/deadline.go: -------------------------------------------------------------------------------- 1 | package ratelimit 2 | 3 | import "time" 4 | 5 | // A Deadline is a time instant when a rate limit expires. 6 | type Deadline time.Time 7 | 8 | // After reports whether the deadline d is after other. 9 | func (d Deadline) After(other Deadline) bool { 10 | return time.Time(d).After(time.Time(other)) 11 | } 12 | 13 | // Equal reports whether d and e represent the same deadline. 14 | func (d Deadline) Equal(e Deadline) bool { 15 | return time.Time(d).Equal(time.Time(e)) 16 | } 17 | 18 | // String returns the deadline formatted for debugging. 19 | func (d Deadline) String() string { 20 | // Like time.Time.String, but without the monotonic clock reading. 21 | return time.Time(d).Round(0).String() 22 | } 23 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Aggregate expression engines 2 | 3 | This repo contains Inngest's aggregate expression engine service, turning O(n^2) expression 4 | matching into O(n). 5 | 6 | It does this by: 7 | 8 | 1. Parsing each expression whilst lifting literals out of expressions 9 | 2. Breaking expressions down into subgroups (matching && comparators) 10 | 3. Storing each group's comparator in a matching engine for fast lookups 11 | 12 | When an event is received, instead of matching the event against every expression, we instead 13 | inspect each matching engine to filter out invalid expressions. This leaves us with a subset of 14 | expressions that are almost always matching for the event, simplifying the number of expressions 15 | to match against. 16 | 17 | Copyright Inngest 2024. 18 | -------------------------------------------------------------------------------- /vendor/github.com/klauspost/compress/internal/cpuinfo/cpuinfo_amd64.s: -------------------------------------------------------------------------------- 1 | // +build !appengine 2 | // +build gc 3 | // +build !noasm 4 | 5 | #include "textflag.h" 6 | #include "funcdata.h" 7 | #include "go_asm.h" 8 | 9 | TEXT ·x86extensions(SB), NOSPLIT, $0 10 | // 1. determine max EAX value 11 | XORQ AX, AX 12 | CPUID 13 | 14 | CMPQ AX, $7 15 | JB unsupported 16 | 17 | // 2. EAX = 7, ECX = 0 --- see Table 3-8 "Information Returned by CPUID Instruction" 18 | MOVQ $7, AX 19 | MOVQ $0, CX 20 | CPUID 21 | 22 | BTQ $3, BX // bit 3 = BMI1 23 | SETCS AL 24 | 25 | BTQ $8, BX // bit 8 = BMI2 26 | SETCS AH 27 | 28 | MOVB AL, bmi1+0(FP) 29 | MOVB AH, bmi2+1(FP) 30 | RET 31 | 32 | unsupported: 33 | XORQ AX, AX 34 | MOVB AL, bmi1+0(FP) 35 | MOVB AL, bmi2+1(FP) 36 | RET 37 | -------------------------------------------------------------------------------- /vendor/github.com/ohler55/ojg/gen/big.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2020, Peter Ohler, All rights reserved. 2 | 3 | package gen 4 | 5 | // Big represents a number too large to be an int64 or a float64. 6 | type Big string 7 | 8 | // String representation of the number. 9 | func (n Big) String() string { 10 | return string(n) 11 | } 12 | 13 | // Alter returns the backing string. 14 | func (n Big) Alter() any { 15 | return string(n) 16 | } 17 | 18 | // Simplify the Node into a string. 19 | func (n Big) Simplify() any { 20 | return string(n) 21 | } 22 | 23 | // Dup returns itself since it is immutable. 24 | func (n Big) Dup() Node { 25 | return n 26 | } 27 | 28 | // Empty returns true if the backing string is empty. 29 | func (n Big) Empty() bool { 30 | return len(string(n)) == 0 31 | } 32 | -------------------------------------------------------------------------------- /vendor/github.com/google/cel-go/parser/gen/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2021 Google LLC 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"); 4 | // you may not use this file except in compliance with the License. 5 | // You may obtain a copy of the License at 6 | // 7 | // http://www.apache.org/licenses/LICENSE-2.0 8 | // 9 | // Unless required by applicable law or agreed to in writing, software 10 | // distributed under the License is distributed on an "AS IS" BASIS, 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | // See the License for the specific language governing permissions and 13 | // limitations under the License. 14 | 15 | // Package gen contains all of the ANTLR-generated sources used by the cel-go parser. 16 | package gen 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/race.go: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (darwin && race) || (linux && race) || (freebsd && race) 6 | 7 | package unix 8 | 9 | import ( 10 | "runtime" 11 | "unsafe" 12 | ) 13 | 14 | const raceenabled = true 15 | 16 | func raceAcquire(addr unsafe.Pointer) { 17 | runtime.RaceAcquire(addr) 18 | } 19 | 20 | func raceReleaseMerge(addr unsafe.Pointer) { 21 | runtime.RaceReleaseMerge(addr) 22 | } 23 | 24 | func raceReadRange(addr unsafe.Pointer, len int) { 25 | runtime.RaceReadRange(addr, len) 26 | } 27 | 28 | func raceWriteRange(addr unsafe.Pointer, len int) { 29 | runtime.RaceWriteRange(addr, len) 30 | } 31 | -------------------------------------------------------------------------------- /vendor/github.com/ohler55/ojg/jp/keyed.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2023, Peter Ohler, All rights reserved. 2 | 3 | package jp 4 | 5 | // Keyed describes an interface for a collection that is indexed by a string 6 | // key similar to a map[string]any. 7 | type Keyed interface { 8 | 9 | // ValueForKey should return the value associated with the key or nil if 10 | // no entry exists for the key. 11 | ValueForKey(key string) (value any, has bool) 12 | 13 | // SetValueForKey sets the value for a key in the collection. 14 | SetValueForKey(key string, value any) 15 | 16 | // RemoveValueForKey removes the value for a key in the collection. 17 | RemoveValueForKey(key string) 18 | 19 | // Keys should return an list of the keys for all the entries in the 20 | // collection. 21 | Keys() []string 22 | } 23 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/strs/strings_pure.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build purego || appengine 6 | // +build purego appengine 7 | 8 | package strs 9 | 10 | import pref "google.golang.org/protobuf/reflect/protoreflect" 11 | 12 | func UnsafeString(b []byte) string { 13 | return string(b) 14 | } 15 | 16 | func UnsafeBytes(s string) []byte { 17 | return []byte(s) 18 | } 19 | 20 | type Builder struct{} 21 | 22 | func (*Builder) AppendFullName(prefix pref.FullName, name pref.Name) pref.FullName { 23 | return prefix.Append(name) 24 | } 25 | 26 | func (*Builder) MakeString(b []byte) string { 27 | return string(b) 28 | } 29 | -------------------------------------------------------------------------------- /vendor/github.com/google/cel-go/common/containers/BUILD.bazel: -------------------------------------------------------------------------------- 1 | load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test") 2 | 3 | package( 4 | default_visibility = ["//visibility:public"], 5 | licenses = ["notice"], # Apache 2.0 6 | ) 7 | 8 | go_library( 9 | name = "go_default_library", 10 | srcs = [ 11 | "container.go", 12 | ], 13 | importpath = "github.com/google/cel-go/common/containers", 14 | deps = [ 15 | "//common/ast:go_default_library", 16 | ], 17 | ) 18 | 19 | go_test( 20 | name = "go_default_test", 21 | size = "small", 22 | srcs = [ 23 | "container_test.go", 24 | ], 25 | embed = [ 26 | ":go_default_library", 27 | ], 28 | deps = [ 29 | "//common/ast:go_default_library", 30 | ], 31 | ) 32 | -------------------------------------------------------------------------------- /vendor/github.com/ohler55/ojg/numconvmethod.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2023, Peter Ohler, All rights reserved. 2 | 3 | package ojg 4 | 5 | // NumConvMethod specifies a json.Number conversion method. It is used by the 6 | // parsers and the recomposer to convert a json.Number to either a float64 or 7 | // to a string if used. 8 | type NumConvMethod byte 9 | 10 | const ( 11 | // NumConvNone leaves a json.Number as is. 12 | NumConvNone = NumConvMethod(0) 13 | 14 | // NumConvFloat64 convert json.Number to a float64. 15 | NumConvFloat64 = NumConvMethod('f') 16 | 17 | // NumConvString convert json.Number to a string 18 | NumConvString = NumConvMethod('s') 19 | ) 20 | 21 | // DefaultNumConvMethod is the default NumConvMethod for parsing and 22 | // recompose. 23 | var DefaultNumConvMethod = NumConvNone 24 | -------------------------------------------------------------------------------- /vendor/github.com/prometheus/procfs/cpuinfo_s390x.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The Prometheus Authors 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | //go:build linux 15 | // +build linux 16 | 17 | package procfs 18 | 19 | var parseCPUInfo = parseCPUInfoS390X 20 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_hurd.go: -------------------------------------------------------------------------------- 1 | // Copyright 2022 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build hurd 6 | 7 | package unix 8 | 9 | /* 10 | #include 11 | int ioctl(int, unsigned long int, uintptr_t); 12 | */ 13 | import "C" 14 | 15 | func ioctl(fd int, req uint, arg uintptr) (err error) { 16 | r0, er := C.ioctl(C.int(fd), C.ulong(req), C.uintptr_t(arg)) 17 | if r0 == -1 && er != nil { 18 | err = er 19 | } 20 | return 21 | } 22 | 23 | func ioctlPtr(fd int, req uint, arg unsafe.Pointer) (err error) { 24 | r0, er := C.ioctl(C.int(fd), C.ulong(req), C.uintptr_t(uintptr(arg))) 25 | if r0 == -1 && er != nil { 26 | err = er 27 | } 28 | return 29 | } 30 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/errors/errbase/oserror_pre116.go: -------------------------------------------------------------------------------- 1 | // Copyright 2021 The Cockroach Authors. 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"); 4 | // you may not use this file except in compliance with the License. 5 | // You may obtain a copy of the License at 6 | // 7 | // http://www.apache.org/licenses/LICENSE-2.0 8 | // 9 | // Unless required by applicable law or agreed to in writing, software 10 | // distributed under the License is distributed on an "AS IS" BASIS, 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 12 | // implied. See the License for the specific language governing 13 | // permissions and limitations under the License. 14 | 15 | // +build !go1.16 16 | 17 | package errbase 18 | 19 | func registerOsPathErrorMigration() {} 20 | -------------------------------------------------------------------------------- /vendor/github.com/prometheus/procfs/cpuinfo_loong64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2022 The Prometheus Authors 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | //go:build linux 15 | // +build linux 16 | 17 | package procfs 18 | 19 | var parseCPUInfo = parseCPUInfoLoong 20 | -------------------------------------------------------------------------------- /vendor/github.com/matttproud/golang_protobuf_extensions/pbutil/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2013 Matt T. Proud 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"); 4 | // you may not use this file except in compliance with the License. 5 | // You may obtain a copy of the License at 6 | // 7 | // http://www.apache.org/licenses/LICENSE-2.0 8 | // 9 | // Unless required by applicable law or agreed to in writing, software 10 | // distributed under the License is distributed on an "AS IS" BASIS, 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | // See the License for the specific language governing permissions and 13 | // limitations under the License. 14 | 15 | // Package pbutil provides record length-delimited Protocol Buffer streaming. 16 | package pbutil 17 | -------------------------------------------------------------------------------- /vendor/github.com/google/cel-go/common/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 Google LLC 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"); 4 | // you may not use this file except in compliance with the License. 5 | // You may obtain a copy of the License at 6 | // 7 | // http://www.apache.org/licenses/LICENSE-2.0 8 | // 9 | // Unless required by applicable law or agreed to in writing, software 10 | // distributed under the License is distributed on an "AS IS" BASIS, 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | // See the License for the specific language governing permissions and 13 | // limitations under the License. 14 | 15 | // Package common defines types and utilities common to expression parsing, 16 | // checking, and interpretation 17 | package common 18 | -------------------------------------------------------------------------------- /vendor/github.com/pkg/errors/appveyor.yml: -------------------------------------------------------------------------------- 1 | version: build-{build}.{branch} 2 | 3 | clone_folder: C:\gopath\src\github.com\pkg\errors 4 | shallow_clone: true # for startup speed 5 | 6 | environment: 7 | GOPATH: C:\gopath 8 | 9 | platform: 10 | - x64 11 | 12 | # http://www.appveyor.com/docs/installed-software 13 | install: 14 | # some helpful output for debugging builds 15 | - go version 16 | - go env 17 | # pre-installed MinGW at C:\MinGW is 32bit only 18 | # but MSYS2 at C:\msys64 has mingw64 19 | - set PATH=C:\msys64\mingw64\bin;%PATH% 20 | - gcc --version 21 | - g++ --version 22 | 23 | build_script: 24 | - go install -v ./... 25 | 26 | test_script: 27 | - set PATH=C:\gopath\bin;%PATH% 28 | - go test -v ./... 29 | 30 | #artifacts: 31 | # - path: '%GOPATH%\bin\*.exe' 32 | deploy: off 33 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/env_unix.go: -------------------------------------------------------------------------------- 1 | // Copyright 2010 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos 6 | 7 | // Unix environment variables. 8 | 9 | package unix 10 | 11 | import "syscall" 12 | 13 | func Getenv(key string) (value string, found bool) { 14 | return syscall.Getenv(key) 15 | } 16 | 17 | func Setenv(key, value string) error { 18 | return syscall.Setenv(key, value) 19 | } 20 | 21 | func Clearenv() { 22 | syscall.Clearenv() 23 | } 24 | 25 | func Environ() []string { 26 | return syscall.Environ() 27 | } 28 | 29 | func Unsetenv(key string) error { 30 | return syscall.Unsetenv(key) 31 | } 32 | -------------------------------------------------------------------------------- /vendor/github.com/ohler55/ojg/gen/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2020, Peter Ohler, All rights reserved. 2 | 3 | // Package gen provides type safe generic types. They are type safe in that array 4 | // and objects can only be constructed of other types in the package. The basic 5 | // types are: 6 | // 7 | // Bool 8 | // Int 9 | // Float 10 | // String 11 | // Time 12 | // 13 | // The collection types are Array and Object. All the types implement the Node 14 | // interface which is relatively simple interface defined primarily to restrict 15 | // what can be in the collection types. The Node interface should not be used to 16 | // define new generic types. 17 | // 18 | // Also included in the package are a builder and parser that behave like the 19 | // parser and builder in the oj package except for gen types. 20 | package gen 21 | -------------------------------------------------------------------------------- /vendor/github.com/ohler55/ojg/gen/int.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2020, Peter Ohler, All rights reserved. 2 | 3 | package gen 4 | 5 | import ( 6 | "strconv" 7 | ) 8 | 9 | // Int is a int64 Node. 10 | type Int int64 11 | 12 | // String returns a string representation of the Node. 13 | func (n Int) String() string { 14 | return strconv.FormatInt(int64(n), 10) 15 | } 16 | 17 | // Alter returns the backing int64 value of the Node. 18 | func (n Int) Alter() any { 19 | return int64(n) 20 | } 21 | 22 | // Simplify returns the backing int64 value of the Node. 23 | func (n Int) Simplify() any { 24 | return int64(n) 25 | } 26 | 27 | // Dup returns the backing int64 value of the Node. 28 | func (n Int) Dup() Node { 29 | return n 30 | } 31 | 32 | // Empty returns false. 33 | func (n Int) Empty() bool { 34 | return false 35 | } 36 | -------------------------------------------------------------------------------- /vendor/github.com/google/cel-go/common/types/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 Google LLC 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"); 4 | // you may not use this file except in compliance with the License. 5 | // You may obtain a copy of the License at 6 | // 7 | // http://www.apache.org/licenses/LICENSE-2.0 8 | // 9 | // Unless required by applicable law or agreed to in writing, software 10 | // distributed under the License is distributed on an "AS IS" BASIS, 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | // See the License for the specific language governing permissions and 13 | // limitations under the License. 14 | 15 | // Package types contains the types, traits, and utilities common to all 16 | // components of expression handling. 17 | package types 18 | -------------------------------------------------------------------------------- /vendor/github.com/prometheus/common/model/model.go: -------------------------------------------------------------------------------- 1 | // Copyright 2013 The Prometheus Authors 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | // Package model contains common data structures that are shared across 15 | // Prometheus components and libraries. 16 | package model 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/readdirent_getdirentries.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build darwin 6 | 7 | package unix 8 | 9 | import "unsafe" 10 | 11 | // ReadDirent reads directory entries from fd and writes them into buf. 12 | func ReadDirent(fd int, buf []byte) (n int, err error) { 13 | // Final argument is (basep *uintptr) and the syscall doesn't take nil. 14 | // 64 bits should be enough. (32 bits isn't even on 386). Since the 15 | // actual system call is getdirentries64, 64 is a good guess. 16 | // TODO(rsc): Can we use a single global basep for all calls? 17 | var base = (*uintptr)(unsafe.Pointer(new(uint64))) 18 | return Getdirentries(fd, buf, base) 19 | } 20 | -------------------------------------------------------------------------------- /vendor/github.com/google/cel-go/common/types/traits/BUILD.bazel: -------------------------------------------------------------------------------- 1 | load("@io_bazel_rules_go//go:def.bzl", "go_library") 2 | 3 | package( 4 | default_visibility = ["//visibility:public"], 5 | licenses = ["notice"], # Apache 2.0 6 | ) 7 | 8 | go_library( 9 | name = "go_default_library", 10 | srcs = [ 11 | "comparer.go", 12 | "container.go", 13 | "field_tester.go", 14 | "indexer.go", 15 | "iterator.go", 16 | "lister.go", 17 | "mapper.go", 18 | "matcher.go", 19 | "math.go", 20 | "receiver.go", 21 | "sizer.go", 22 | "traits.go", 23 | "zeroer.go", 24 | ], 25 | importpath = "github.com/google/cel-go/common/types/traits", 26 | deps = [ 27 | "//common/types/ref:go_default_library", 28 | ], 29 | ) 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_bsd_arm.s: -------------------------------------------------------------------------------- 1 | // Copyright 2021 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (freebsd || netbsd || openbsd) && gc 6 | 7 | #include "textflag.h" 8 | 9 | // System call support for ARM BSD 10 | 11 | // Just jump to package syscall's implementation for all these functions. 12 | // The runtime may know about them. 13 | 14 | TEXT ·Syscall(SB),NOSPLIT,$0-28 15 | B syscall·Syscall(SB) 16 | 17 | TEXT ·Syscall6(SB),NOSPLIT,$0-40 18 | B syscall·Syscall6(SB) 19 | 20 | TEXT ·Syscall9(SB),NOSPLIT,$0-52 21 | B syscall·Syscall9(SB) 22 | 23 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28 24 | B syscall·RawSyscall(SB) 25 | 26 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 27 | B syscall·RawSyscall6(SB) 28 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/zptrace_linux_arm64.go: -------------------------------------------------------------------------------- 1 | // Code generated by linux/mkall.go generatePtraceRegSet("arm64"). DO NOT EDIT. 2 | 3 | package unix 4 | 5 | import "unsafe" 6 | 7 | // PtraceGetRegSetArm64 fetches the registers used by arm64 binaries. 8 | func PtraceGetRegSetArm64(pid, addr int, regsout *PtraceRegsArm64) error { 9 | iovec := Iovec{(*byte)(unsafe.Pointer(regsout)), uint64(unsafe.Sizeof(*regsout))} 10 | return ptracePtr(PTRACE_GETREGSET, pid, uintptr(addr), unsafe.Pointer(&iovec)) 11 | } 12 | 13 | // PtraceSetRegSetArm64 sets the registers used by arm64 binaries. 14 | func PtraceSetRegSetArm64(pid, addr int, regs *PtraceRegsArm64) error { 15 | iovec := Iovec{(*byte)(unsafe.Pointer(regs)), uint64(unsafe.Sizeof(*regs))} 16 | return ptracePtr(PTRACE_SETREGSET, pid, uintptr(addr), unsafe.Pointer(&iovec)) 17 | } 18 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_openbsd_mips64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build gc 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for mips64, OpenBSD 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-56 17 | JMP syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 20 | JMP syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 23 | JMP syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 26 | JMP syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 29 | JMP syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/errors/errorspb/testing.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Cockroach Authors. 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"); 4 | // you may not use this file except in compliance with the License. 5 | // You may obtain a copy of the License at 6 | // 7 | // http://www.apache.org/licenses/LICENSE-2.0 8 | // 9 | // Unless required by applicable law or agreed to in writing, software 10 | // distributed under the License is distributed on an "AS IS" BASIS, 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 12 | // implied. See the License for the specific language governing 13 | // permissions and limitations under the License. 14 | 15 | package errorspb 16 | 17 | // Error implements the error interface. 18 | func (t *TestError) Error() string { return "test error" } 19 | -------------------------------------------------------------------------------- /vendor/github.com/prometheus/procfs/cpuinfo_armx.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The Prometheus Authors 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | //go:build linux && (arm || arm64) 15 | // +build linux 16 | // +build arm arm64 17 | 18 | package procfs 19 | 20 | var parseCPUInfo = parseCPUInfoARM 21 | -------------------------------------------------------------------------------- /vendor/github.com/prometheus/procfs/cpuinfo_x86.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The Prometheus Authors 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | //go:build linux && (386 || amd64) 15 | // +build linux 16 | // +build 386 amd64 17 | 18 | package procfs 19 | 20 | var parseCPUInfo = parseCPUInfoX86 21 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_bsd_386.s: -------------------------------------------------------------------------------- 1 | // Copyright 2021 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (freebsd || netbsd || openbsd) && gc 6 | 7 | #include "textflag.h" 8 | 9 | // System call support for 386 BSD 10 | 11 | // Just jump to package syscall's implementation for all these functions. 12 | // The runtime may know about them. 13 | 14 | TEXT ·Syscall(SB),NOSPLIT,$0-28 15 | JMP syscall·Syscall(SB) 16 | 17 | TEXT ·Syscall6(SB),NOSPLIT,$0-40 18 | JMP syscall·Syscall6(SB) 19 | 20 | TEXT ·Syscall9(SB),NOSPLIT,$0-52 21 | JMP syscall·Syscall9(SB) 22 | 23 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28 24 | JMP syscall·RawSyscall(SB) 25 | 26 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 27 | JMP syscall·RawSyscall6(SB) 28 | -------------------------------------------------------------------------------- /vendor/github.com/prometheus/procfs/cpuinfo_ppcx.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The Prometheus Authors 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | //go:build linux && (ppc64 || ppc64le) 15 | // +build linux 16 | // +build ppc64 ppc64le 17 | 18 | package procfs 19 | 20 | var parseCPUInfo = parseCPUInfoPPC 21 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/genid/goname.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package genid 6 | 7 | // Go names of implementation-specific struct fields in generated messages. 8 | const ( 9 | State_goname = "state" 10 | 11 | SizeCache_goname = "sizeCache" 12 | SizeCacheA_goname = "XXX_sizecache" 13 | 14 | WeakFields_goname = "weakFields" 15 | WeakFieldsA_goname = "XXX_weak" 16 | 17 | UnknownFields_goname = "unknownFields" 18 | UnknownFieldsA_goname = "XXX_unrecognized" 19 | 20 | ExtensionFields_goname = "extensionFields" 21 | ExtensionFieldsA_goname = "XXX_InternalExtensions" 22 | ExtensionFieldsB_goname = "XXX_extensions" 23 | 24 | WeakFieldPrefix_goname = "XXX_weak_" 25 | ) 26 | -------------------------------------------------------------------------------- /vendor/github.com/davecgh/go-spew/LICENSE: -------------------------------------------------------------------------------- 1 | ISC License 2 | 3 | Copyright (c) 2012-2016 Dave Collins 4 | 5 | Permission to use, copy, modify, and/or distribute this software for any 6 | purpose with or without fee is hereby granted, provided that the above 7 | copyright notice and this permission notice appear in all copies. 8 | 9 | THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 10 | WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 11 | MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 12 | ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 13 | WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 14 | ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 15 | OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 16 | -------------------------------------------------------------------------------- /vendor/github.com/prometheus/procfs/cpuinfo_riscvx.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The Prometheus Authors 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | //go:build linux && (riscv || riscv64) 15 | // +build linux 16 | // +build riscv riscv64 17 | 18 | package procfs 19 | 20 | var parseCPUInfo = parseCPUInfoRISCV 21 | -------------------------------------------------------------------------------- /vendor/go.uber.org/multierr/.codecov.yml: -------------------------------------------------------------------------------- 1 | coverage: 2 | range: 80..100 3 | round: down 4 | precision: 2 5 | 6 | status: 7 | project: # measuring the overall project coverage 8 | default: # context, you can create multiple ones with custom titles 9 | enabled: yes # must be yes|true to enable this status 10 | target: 100 # specify the target coverage for each commit status 11 | # option: "auto" (must increase from parent commit or pull request base) 12 | # option: "X%" a static target percentage to hit 13 | if_not_found: success # if parent is not found report status as success, error, or failure 14 | if_ci_failed: error # if ci fails report status as success, error, or failure 15 | 16 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_bsd_arm64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2021 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (darwin || freebsd || netbsd || openbsd) && gc 6 | 7 | #include "textflag.h" 8 | 9 | // System call support for ARM64 BSD 10 | 11 | // Just jump to package syscall's implementation for all these functions. 12 | // The runtime may know about them. 13 | 14 | TEXT ·Syscall(SB),NOSPLIT,$0-56 15 | JMP syscall·Syscall(SB) 16 | 17 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 18 | JMP syscall·Syscall6(SB) 19 | 20 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 21 | JMP syscall·Syscall9(SB) 22 | 23 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 24 | JMP syscall·RawSyscall(SB) 25 | 26 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 27 | JMP syscall·RawSyscall6(SB) 28 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_bsd_riscv64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2021 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (darwin || freebsd || netbsd || openbsd) && gc 6 | 7 | #include "textflag.h" 8 | 9 | // System call support for RISCV64 BSD 10 | 11 | // Just jump to package syscall's implementation for all these functions. 12 | // The runtime may know about them. 13 | 14 | TEXT ·Syscall(SB),NOSPLIT,$0-56 15 | JMP syscall·Syscall(SB) 16 | 17 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 18 | JMP syscall·Syscall6(SB) 19 | 20 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 21 | JMP syscall·Syscall9(SB) 22 | 23 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 24 | JMP syscall·RawSyscall(SB) 25 | 26 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 27 | JMP syscall·RawSyscall6(SB) 28 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/errors/errorspb/markers.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Cockroach Authors. 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"); 4 | // you may not use this file except in compliance with the License. 5 | // You may obtain a copy of the License at 6 | // 7 | // http://www.apache.org/licenses/LICENSE-2.0 8 | // 9 | // Unless required by applicable law or agreed to in writing, software 10 | // distributed under the License is distributed on an "AS IS" BASIS, 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 12 | // implied. See the License for the specific language governing 13 | // permissions and limitations under the License. 14 | 15 | package errorspb 16 | 17 | func (m ErrorTypeMark) Equals(o ErrorTypeMark) bool { 18 | return m.FamilyName == o.FamilyName && m.Extension == o.Extension 19 | } 20 | -------------------------------------------------------------------------------- /vendor/github.com/ohler55/ojg/gen/float.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2020, Peter Ohler, All rights reserved. 2 | 3 | package gen 4 | 5 | import ( 6 | "strconv" 7 | ) 8 | 9 | // Float is a float64 Node. 10 | type Float float64 11 | 12 | // String returns a string representation of the Node. 13 | func (n Float) String() string { 14 | return strconv.FormatFloat(float64(n), 'g', -1, 64) 15 | } 16 | 17 | // Alter returns the backing float64 value of the Node. 18 | func (n Float) Alter() any { 19 | return float64(n) 20 | } 21 | 22 | // Simplify returns the backing float64 value of the Node. 23 | func (n Float) Simplify() any { 24 | return float64(n) 25 | } 26 | 27 | // Dup returns the backing float64 value of the Node. 28 | func (n Float) Dup() Node { 29 | return n 30 | } 31 | 32 | // Empty returns false. 33 | func (n Float) Empty() bool { 34 | return false 35 | } 36 | -------------------------------------------------------------------------------- /vendor/github.com/ohler55/ojg/gen/string.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2020, Peter Ohler, All rights reserved. 2 | 3 | package gen 4 | 5 | // String is a string Node. 6 | type String string 7 | 8 | // String returns a string representation of the Node. 9 | func (n String) String() string { 10 | return `"` + string(n) + `"` 11 | } 12 | 13 | // Alter returns the backing float64 value of the Node. 14 | func (n String) Alter() any { 15 | return string(n) 16 | } 17 | 18 | // Simplify returns the backing float64 value of the Node. 19 | func (n String) Simplify() any { 20 | return string(n) 21 | } 22 | 23 | // Dup returns the backing float64 value of the Node. 24 | func (n String) Dup() Node { 25 | return n 26 | } 27 | 28 | // Empty returns false if the string has no characters and true otherwise. 29 | func (n String) Empty() bool { 30 | return len(string(n)) == 0 31 | } 32 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_bsd_amd64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2021 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (darwin || dragonfly || freebsd || netbsd || openbsd) && gc 6 | 7 | #include "textflag.h" 8 | 9 | // System call support for AMD64 BSD 10 | 11 | // Just jump to package syscall's implementation for all these functions. 12 | // The runtime may know about them. 13 | 14 | TEXT ·Syscall(SB),NOSPLIT,$0-56 15 | JMP syscall·Syscall(SB) 16 | 17 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 18 | JMP syscall·Syscall6(SB) 19 | 20 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 21 | JMP syscall·Syscall9(SB) 22 | 23 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 24 | JMP syscall·RawSyscall(SB) 25 | 26 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 27 | JMP syscall·RawSyscall6(SB) 28 | -------------------------------------------------------------------------------- /vendor/golang.org/x/text/width/trieval.go: -------------------------------------------------------------------------------- 1 | // Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT. 2 | 3 | package width 4 | 5 | // elem is an entry of the width trie. The high byte is used to encode the type 6 | // of the rune. The low byte is used to store the index to a mapping entry in 7 | // the inverseData array. 8 | type elem uint16 9 | 10 | const ( 11 | tagNeutral elem = iota << typeShift 12 | tagAmbiguous 13 | tagWide 14 | tagNarrow 15 | tagFullwidth 16 | tagHalfwidth 17 | ) 18 | 19 | const ( 20 | numTypeBits = 3 21 | typeShift = 16 - numTypeBits 22 | 23 | // tagNeedsFold is true for all fullwidth and halfwidth runes except for 24 | // the Won sign U+20A9. 25 | tagNeedsFold = 0x1000 26 | 27 | // The Korean Won sign is halfwidth, but SHOULD NOT be mapped to a wide 28 | // variant. 29 | wonSign rune = 0x20A9 30 | ) 31 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/fifo/invariants_on.go: -------------------------------------------------------------------------------- 1 | // Copyright 2024 The Cockroach Authors. 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"); 4 | // you may not use this file except in compliance with the License. 5 | // You may obtain a copy of the License at 6 | // 7 | // http://www.apache.org/licenses/LICENSE-2.0 8 | // 9 | // Unless required by applicable law or agreed to in writing, software 10 | // distributed under the License is distributed on an "AS IS" BASIS, 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 12 | // implied. See the License for the specific language governing 13 | // permissions and limitations under the License. 14 | 15 | //go:build fifo_invariants 16 | 17 | package fifo 18 | 19 | // invariants is true if we were built with the "fifo_invariants" build tag. 20 | const invariants = true 21 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_bsd_ppc64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2022 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (darwin || freebsd || netbsd || openbsd) && gc 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for ppc64, BSD 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-56 17 | JMP syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 20 | JMP syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 23 | JMP syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 26 | JMP syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 29 | JMP syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /vendor/github.com/bits-and-blooms/bitset/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | 3 | sudo: false 4 | 5 | branches: 6 | except: 7 | - release 8 | 9 | branches: 10 | only: 11 | - master 12 | - travis 13 | 14 | go: 15 | - "1.11.x" 16 | - tip 17 | 18 | matrix: 19 | allow_failures: 20 | - go: tip 21 | 22 | before_install: 23 | - if [ -n "$GH_USER" ]; then git config --global github.user ${GH_USER}; fi; 24 | - if [ -n "$GH_TOKEN" ]; then git config --global github.token ${GH_TOKEN}; fi; 25 | - go get github.com/mattn/goveralls 26 | 27 | before_script: 28 | - make deps 29 | 30 | script: 31 | - make qa 32 | 33 | after_failure: 34 | - cat ./target/test/report.xml 35 | 36 | after_success: 37 | - if [ "$TRAVIS_GO_VERSION" = "1.11.1" ]; then $HOME/gopath/bin/goveralls -covermode=count -coverprofile=target/report/coverage.out -service=travis-ci; fi; 38 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/pebble/vfs/disk_usage_netbsd.go: -------------------------------------------------------------------------------- 1 | // Copyright 2023 The LevelDB-Go and Pebble Authors. All rights reserved. Use 2 | // of this source code is governed by a BSD-style license that can be found in 3 | // the LICENSE file. 4 | 5 | //go:build netbsd 6 | // +build netbsd 7 | 8 | package vfs 9 | 10 | import "golang.org/x/sys/unix" 11 | 12 | func (defaultFS) GetDiskUsage(path string) (DiskUsage, error) { 13 | stat := unix.Statvfs_t{} 14 | if err := unix.Statvfs(path, &stat); err != nil { 15 | return DiskUsage{}, err 16 | } 17 | 18 | freeBytes := uint64(stat.Bsize) * uint64(stat.Bfree) 19 | availBytes := uint64(stat.Bsize) * uint64(stat.Bavail) 20 | totalBytes := uint64(stat.Bsize) * uint64(stat.Blocks) 21 | return DiskUsage{ 22 | AvailBytes: availBytes, 23 | TotalBytes: totalBytes, 24 | UsedBytes: totalBytes - freeBytes, 25 | }, nil 26 | } 27 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/bluetooth_linux.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Bluetooth sockets and messages 6 | 7 | package unix 8 | 9 | // Bluetooth Protocols 10 | const ( 11 | BTPROTO_L2CAP = 0 12 | BTPROTO_HCI = 1 13 | BTPROTO_SCO = 2 14 | BTPROTO_RFCOMM = 3 15 | BTPROTO_BNEP = 4 16 | BTPROTO_CMTP = 5 17 | BTPROTO_HIDP = 6 18 | BTPROTO_AVDTP = 7 19 | ) 20 | 21 | const ( 22 | HCI_CHANNEL_RAW = 0 23 | HCI_CHANNEL_USER = 1 24 | HCI_CHANNEL_MONITOR = 2 25 | HCI_CHANNEL_CONTROL = 3 26 | HCI_CHANNEL_LOGGING = 4 27 | ) 28 | 29 | // Socketoption Level 30 | const ( 31 | SOL_BLUETOOTH = 0x112 32 | SOL_HCI = 0x0 33 | SOL_L2CAP = 0x6 34 | SOL_RFCOMM = 0x12 35 | SOL_SCO = 0x11 36 | ) 37 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/fifo/invariants_off.go: -------------------------------------------------------------------------------- 1 | // Copyright 2024 The Cockroach Authors. 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"); 4 | // you may not use this file except in compliance with the License. 5 | // You may obtain a copy of the License at 6 | // 7 | // http://www.apache.org/licenses/LICENSE-2.0 8 | // 9 | // Unless required by applicable law or agreed to in writing, software 10 | // distributed under the License is distributed on an "AS IS" BASIS, 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 12 | // implied. See the License for the specific language governing 13 | // permissions and limitations under the License. 14 | 15 | //go:build !fifo_invariants 16 | 17 | package fifo 18 | 19 | // invariants is false if we were not built with the "fifo_invariants" build 20 | // tag. 21 | const invariants = false 22 | -------------------------------------------------------------------------------- /vendor/github.com/ohler55/ojg/gen/key.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2020, Peter Ohler, All rights reserved. 2 | 3 | package gen 4 | 5 | // Key use for parsing. 6 | type Key string 7 | 8 | // String returns the key as a string. 9 | func (k Key) String() string { 10 | return string(k) 11 | } 12 | 13 | // Alter converts the node into it's native type. Note this will modify 14 | // Objects and Arrays in place making them no longer usable as the 15 | // original type. Use with care! 16 | func (k Key) Alter() any { 17 | return string(k) 18 | } 19 | 20 | // Simplify makes a copy of the node but as simple types. 21 | func (k Key) Simplify() any { 22 | return string(k) 23 | } 24 | 25 | // Dup returns a deep duplicate of the node. 26 | func (k Key) Dup() Node { 27 | return k 28 | } 29 | 30 | // Empty returns true if the node is empty. 31 | func (k Key) Empty() bool { 32 | return false 33 | } 34 | -------------------------------------------------------------------------------- /vendor/github.com/prometheus/procfs/cpuinfo_mipsx.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The Prometheus Authors 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | //go:build linux && (mips || mipsle || mips64 || mips64le) 15 | // +build linux 16 | // +build mips mipsle mips64 mips64le 17 | 18 | package procfs 19 | 20 | var parseCPUInfo = parseCPUInfoMips 21 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/dev_aix_ppc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build aix && ppc 6 | 7 | // Functions to access/create device major and minor numbers matching the 8 | // encoding used by AIX. 9 | 10 | package unix 11 | 12 | // Major returns the major component of a Linux device number. 13 | func Major(dev uint64) uint32 { 14 | return uint32((dev >> 16) & 0xffff) 15 | } 16 | 17 | // Minor returns the minor component of a Linux device number. 18 | func Minor(dev uint64) uint32 { 19 | return uint32(dev & 0xffff) 20 | } 21 | 22 | // Mkdev returns a Linux device number generated from the given major and minor 23 | // components. 24 | func Mkdev(major, minor uint32) uint64 { 25 | return uint64(((major) << 16) | (minor)) 26 | } 27 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/dev_darwin.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Functions to access/create device major and minor numbers matching the 6 | // encoding used in Darwin's sys/types.h header. 7 | 8 | package unix 9 | 10 | // Major returns the major component of a Darwin device number. 11 | func Major(dev uint64) uint32 { 12 | return uint32((dev >> 24) & 0xff) 13 | } 14 | 15 | // Minor returns the minor component of a Darwin device number. 16 | func Minor(dev uint64) uint32 { 17 | return uint32(dev & 0xffffff) 18 | } 19 | 20 | // Mkdev returns a Darwin device number generated from the given major and minor 21 | // components. 22 | func Mkdev(major, minor uint32) uint64 { 23 | return (uint64(major) << 24) | uint64(minor) 24 | } 25 | -------------------------------------------------------------------------------- /.github/workflows/go.yaml: -------------------------------------------------------------------------------- 1 | name: Go 2 | 3 | on: 4 | push: 5 | branches: [main] 6 | pull_request: 7 | 8 | jobs: 9 | 10 | golangci: 11 | name: lint 12 | runs-on: ubuntu-latest 13 | steps: 14 | - uses: actions/checkout@v4 15 | - name: Set up Go 16 | uses: actions/setup-go@v5 17 | with: 18 | go-version-file: ./go.mod 19 | - name: Lint 20 | run: | 21 | curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s v2.1.2 22 | ./bin/golangci-lint run --verbose 23 | 24 | test-linux-race: 25 | runs-on: ubuntu-latest 26 | steps: 27 | - uses: actions/checkout@v4 28 | - name: Set up Go 29 | uses: actions/setup-go@v5 30 | with: 31 | go-version-file: ./go.mod 32 | - name: Test 33 | run: go test ./... -race -v -count=1 34 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/pebble/vfs/disk_usage_openbsd.go: -------------------------------------------------------------------------------- 1 | // Copyright 2023 The LevelDB-Go and Pebble Authors. All rights reserved. Use 2 | // of this source code is governed by a BSD-style license that can be found in 3 | // the LICENSE file. 4 | 5 | //go:build openbsd 6 | // +build openbsd 7 | 8 | package vfs 9 | 10 | import "golang.org/x/sys/unix" 11 | 12 | func (defaultFS) GetDiskUsage(path string) (DiskUsage, error) { 13 | stat := unix.Statfs_t{} 14 | if err := unix.Statfs(path, &stat); err != nil { 15 | return DiskUsage{}, err 16 | } 17 | 18 | freeBytes := uint64(stat.F_bsize) * uint64(stat.F_bfree) 19 | availBytes := uint64(stat.F_bsize) * uint64(stat.F_bavail) 20 | totalBytes := uint64(stat.F_bsize) * uint64(stat.F_blocks) 21 | return DiskUsage{ 22 | AvailBytes: availBytes, 23 | TotalBytes: totalBytes, 24 | UsedBytes: totalBytes - freeBytes, 25 | }, nil 26 | } 27 | -------------------------------------------------------------------------------- /vendor/golang.org/x/text/internal/language/coverage.go: -------------------------------------------------------------------------------- 1 | // Copyright 2014 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package language 6 | 7 | // BaseLanguages returns the list of all supported base languages. It generates 8 | // the list by traversing the internal structures. 9 | func BaseLanguages() []Language { 10 | base := make([]Language, 0, NumLanguages) 11 | for i := 0; i < langNoIndexOffset; i++ { 12 | // We included "und" already for the value 0. 13 | if i != nonCanonicalUnd { 14 | base = append(base, Language(i)) 15 | } 16 | } 17 | i := langNoIndexOffset 18 | for _, v := range langNoIndex { 19 | for k := 0; k < 8; k++ { 20 | if v&1 == 1 { 21 | base = append(base, Language(i)) 22 | } 23 | v >>= 1 24 | i++ 25 | } 26 | } 27 | return base 28 | } 29 | -------------------------------------------------------------------------------- /vendor/github.com/RoaringBitmap/roaring/popcnt_slices.go: -------------------------------------------------------------------------------- 1 | package roaring 2 | 3 | func popcntSliceGo(s []uint64) uint64 { 4 | cnt := uint64(0) 5 | for _, x := range s { 6 | cnt += popcount(x) 7 | } 8 | return cnt 9 | } 10 | 11 | func popcntMaskSliceGo(s, m []uint64) uint64 { 12 | cnt := uint64(0) 13 | for i := range s { 14 | cnt += popcount(s[i] &^ m[i]) 15 | } 16 | return cnt 17 | } 18 | 19 | func popcntAndSliceGo(s, m []uint64) uint64 { 20 | cnt := uint64(0) 21 | for i := range s { 22 | cnt += popcount(s[i] & m[i]) 23 | } 24 | return cnt 25 | } 26 | 27 | func popcntOrSliceGo(s, m []uint64) uint64 { 28 | cnt := uint64(0) 29 | for i := range s { 30 | cnt += popcount(s[i] | m[i]) 31 | } 32 | return cnt 33 | } 34 | 35 | func popcntXorSliceGo(s, m []uint64) uint64 { 36 | cnt := uint64(0) 37 | for i := range s { 38 | cnt += popcount(s[i] ^ m[i]) 39 | } 40 | return cnt 41 | } 42 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/errors/errorspb/errors.go: -------------------------------------------------------------------------------- 1 | // Copyright 2021 The Cockroach Authors. 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"); 4 | // you may not use this file except in compliance with the License. 5 | // You may obtain a copy of the License at 6 | // 7 | // http://www.apache.org/licenses/LICENSE-2.0 8 | // 9 | // Unless required by applicable law or agreed to in writing, software 10 | // distributed under the License is distributed on an "AS IS" BASIS, 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 12 | // implied. See the License for the specific language governing 13 | // permissions and limitations under the License. 14 | 15 | package errorspb 16 | 17 | // IsSet returns true if the EncodedError contains an error, or false if it is 18 | // empty. 19 | func (m *EncodedError) IsSet() bool { 20 | return m.Error != nil 21 | } 22 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/pebble/internal/rawalloc/rawalloc_mips.go: -------------------------------------------------------------------------------- 1 | // Copyright 2014 The Cockroach Authors. 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"); 4 | // you may not use this file except in compliance with the License. 5 | // You may obtain a copy of the License at 6 | // 7 | // http://www.apache.org/licenses/LICENSE-2.0 8 | // 9 | // Unless required by applicable law or agreed to in writing, software 10 | // distributed under the License is distributed on an "AS IS" BASIS, 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 12 | // implied. See the License for the specific language governing 13 | // permissions and limitations under the License. 14 | 15 | //go:build mips || mipsle || mips64p32 || mips64p32le 16 | // +build mips mipsle mips64p32 mips64p32le 17 | 18 | package rawalloc 19 | 20 | const ( 21 | maxArrayLen = 1 << 30 22 | ) 23 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/pebble/objstorage/remote/factory.go: -------------------------------------------------------------------------------- 1 | // Copyright 2023 The LevelDB-Go and Pebble Authors. All rights reserved. Use 2 | // of this source code is governed by a BSD-style license that can be found in 3 | // the LICENSE file. 4 | 5 | package remote 6 | 7 | import "github.com/pkg/errors" 8 | 9 | // MakeSimpleFactory returns a StorageFactory implementation that produces the given 10 | // Storage objects. 11 | func MakeSimpleFactory(m map[Locator]Storage) StorageFactory { 12 | return simpleFactory(m) 13 | } 14 | 15 | type simpleFactory map[Locator]Storage 16 | 17 | var _ StorageFactory = simpleFactory{} 18 | 19 | // CreateStorage is part of the StorageFactory interface. 20 | func (sf simpleFactory) CreateStorage(locator Locator) (Storage, error) { 21 | if s, ok := sf[locator]; ok { 22 | return s, nil 23 | } 24 | return nil, errors.Errorf("unknown locator '%s'", locator) 25 | } 26 | -------------------------------------------------------------------------------- /vendor/github.com/golang/snappy/encode_asm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Snappy-Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !appengine 6 | // +build gc 7 | // +build !noasm 8 | // +build amd64 arm64 9 | 10 | package snappy 11 | 12 | // emitLiteral has the same semantics as in encode_other.go. 13 | // 14 | //go:noescape 15 | func emitLiteral(dst, lit []byte) int 16 | 17 | // emitCopy has the same semantics as in encode_other.go. 18 | // 19 | //go:noescape 20 | func emitCopy(dst []byte, offset, length int) int 21 | 22 | // extendMatch has the same semantics as in encode_other.go. 23 | // 24 | //go:noescape 25 | func extendMatch(src []byte, i, j int) int 26 | 27 | // encodeBlock has the same semantics as in encode_other.go. 28 | // 29 | //go:noescape 30 | func encodeBlock(dst, src []byte) (d int) 31 | -------------------------------------------------------------------------------- /vendor/github.com/prometheus/client_golang/prometheus/get_pid_gopherjs.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Prometheus Authors 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | //go:build js && !wasm 15 | // +build js,!wasm 16 | 17 | package prometheus 18 | 19 | func getPIDFn() func() (int, error) { 20 | return func() (int, error) { 21 | return 1, nil 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/pebble/internal/rawalloc/rawalloc_32bit.go: -------------------------------------------------------------------------------- 1 | // Copyright 2014 The Cockroach Authors. 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"); 4 | // you may not use this file except in compliance with the License. 5 | // You may obtain a copy of the License at 6 | // 7 | // http://www.apache.org/licenses/LICENSE-2.0 8 | // 9 | // Unless required by applicable law or agreed to in writing, software 10 | // distributed under the License is distributed on an "AS IS" BASIS, 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 12 | // implied. See the License for the specific language governing 13 | // permissions and limitations under the License. 14 | 15 | //go:build 386 || amd64p32 || arm || armbe || ppc || sparc 16 | // +build 386 amd64p32 arm armbe ppc sparc 17 | 18 | package rawalloc 19 | 20 | const ( 21 | maxArrayLen = 1<<31 - 1 22 | ) 23 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/pebble/vfs/disk_usage_unix.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The LevelDB-Go and Pebble Authors. All rights reserved. Use 2 | // of this source code is governed by a BSD-style license that can be found in 3 | // the LICENSE file. 4 | 5 | //go:build darwin || dragonfly || freebsd 6 | // +build darwin dragonfly freebsd 7 | 8 | package vfs 9 | 10 | import "golang.org/x/sys/unix" 11 | 12 | func (defaultFS) GetDiskUsage(path string) (DiskUsage, error) { 13 | stat := unix.Statfs_t{} 14 | if err := unix.Statfs(path, &stat); err != nil { 15 | return DiskUsage{}, err 16 | } 17 | 18 | freeBytes := uint64(stat.Bsize) * uint64(stat.Bfree) 19 | availBytes := uint64(stat.Bsize) * uint64(stat.Bavail) 20 | totalBytes := uint64(stat.Bsize) * uint64(stat.Blocks) 21 | return DiskUsage{ 22 | AvailBytes: availBytes, 23 | TotalBytes: totalBytes, 24 | UsedBytes: totalBytes - freeBytes, 25 | }, nil 26 | } 27 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | .DS_Store 2 | .idea 3 | *.log 4 | tmp/ 5 | 6 | # Created by https://www.toptal.com/developers/gitignore/api/go,direnv 7 | # Edit at https://www.toptal.com/developers/gitignore?templates=go,direnv 8 | 9 | ### direnv ### 10 | .direnv 11 | .envrc 12 | 13 | ### Go ### 14 | # If you prefer the allow list template instead of the deny list, see community template: 15 | # https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore 16 | # 17 | # Binaries for programs and plugins 18 | *.exe 19 | *.exe~ 20 | *.dll 21 | *.so 22 | *.dylib 23 | 24 | # Test binary, built with `go test -c` 25 | *.test 26 | 27 | # Output of the go coverage tool, specifically when used with LiteIDE 28 | *.out 29 | 30 | # Dependency directories (remove the comment below to include it) 31 | # vendor/ 32 | 33 | # Go workspace file 34 | go.work 35 | 36 | # End of https://www.toptal.com/developers/gitignore/api/go,direnv 37 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_unix_gc_ppc64x.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build linux && (ppc64le || ppc64) && gc 6 | 7 | package unix 8 | 9 | import "syscall" 10 | 11 | func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) { 12 | return syscall.Syscall(trap, a1, a2, a3) 13 | } 14 | func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) { 15 | return syscall.Syscall6(trap, a1, a2, a3, a4, a5, a6) 16 | } 17 | func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) { 18 | return syscall.RawSyscall(trap, a1, a2, a3) 19 | } 20 | func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) { 21 | return syscall.RawSyscall6(trap, a1, a2, a3, a4, a5, a6) 22 | } 23 | -------------------------------------------------------------------------------- /vendor/github.com/prometheus/client_golang/prometheus/num_threads_gopherjs.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Prometheus Authors 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | //go:build js && !wasm 15 | // +build js,!wasm 16 | 17 | package prometheus 18 | 19 | // getRuntimeNumThreads returns the number of open OS threads. 20 | func getRuntimeNumThreads() float64 { 21 | return 1 22 | } 23 | -------------------------------------------------------------------------------- /vendor/go.uber.org/multierr/README.md: -------------------------------------------------------------------------------- 1 | # multierr [![GoDoc][doc-img]][doc] [![Build Status][ci-img]][ci] [![Coverage Status][cov-img]][cov] 2 | 3 | `multierr` allows combining one or more Go `error`s together. 4 | 5 | ## Installation 6 | 7 | go get -u go.uber.org/multierr 8 | 9 | ## Status 10 | 11 | Stable: No breaking changes will be made before 2.0. 12 | 13 | ------------------------------------------------------------------------------- 14 | 15 | Released under the [MIT License]. 16 | 17 | [MIT License]: LICENSE.txt 18 | [doc-img]: https://pkg.go.dev/badge/go.uber.org/multierr 19 | [doc]: https://pkg.go.dev/go.uber.org/multierr 20 | [ci-img]: https://github.com/uber-go/multierr/actions/workflows/go.yml/badge.svg 21 | [cov-img]: https://codecov.io/gh/uber-go/multierr/branch/master/graph/badge.svg 22 | [ci]: https://github.com/uber-go/multierr/actions/workflows/go.yml 23 | [cov]: https://codecov.io/gh/uber-go/multierr 24 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/pebble/internal/rawalloc/rawalloc_gccgo.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Cockroach Authors. 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"); 4 | // you may not use this file except in compliance with the License. 5 | // You may obtain a copy of the License at 6 | // 7 | // http://www.apache.org/licenses/LICENSE-2.0 8 | // 9 | // Unless required by applicable law or agreed to in writing, software 10 | // distributed under the License is distributed on an "AS IS" BASIS, 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 12 | // implied. See the License for the specific language governing 13 | // permissions and limitations under the License. 14 | 15 | //go:build gccgo 16 | // +build gccgo 17 | 18 | package rawalloc 19 | 20 | import "unsafe" 21 | 22 | //extern runtime.mallocgc 23 | func mallocgc(size uintptr, typ unsafe.Pointer, needzero bool) unsafe.Pointer 24 | -------------------------------------------------------------------------------- /vendor/github.com/google/cel-go/parser/gen/CEL.tokens: -------------------------------------------------------------------------------- 1 | EQUALS=1 2 | NOT_EQUALS=2 3 | IN=3 4 | LESS=4 5 | LESS_EQUALS=5 6 | GREATER_EQUALS=6 7 | GREATER=7 8 | LOGICAL_AND=8 9 | LOGICAL_OR=9 10 | LBRACKET=10 11 | RPRACKET=11 12 | LBRACE=12 13 | RBRACE=13 14 | LPAREN=14 15 | RPAREN=15 16 | DOT=16 17 | COMMA=17 18 | MINUS=18 19 | EXCLAM=19 20 | QUESTIONMARK=20 21 | COLON=21 22 | PLUS=22 23 | STAR=23 24 | SLASH=24 25 | PERCENT=25 26 | CEL_TRUE=26 27 | CEL_FALSE=27 28 | NUL=28 29 | WHITESPACE=29 30 | COMMENT=30 31 | NUM_FLOAT=31 32 | NUM_INT=32 33 | NUM_UINT=33 34 | STRING=34 35 | BYTES=35 36 | IDENTIFIER=36 37 | '=='=1 38 | '!='=2 39 | 'in'=3 40 | '<'=4 41 | '<='=5 42 | '>='=6 43 | '>'=7 44 | '&&'=8 45 | '||'=9 46 | '['=10 47 | ']'=11 48 | '{'=12 49 | '}'=13 50 | '('=14 51 | ')'=15 52 | '.'=16 53 | ','=17 54 | '-'=18 55 | '!'=19 56 | '?'=20 57 | ':'=21 58 | '+'=22 59 | '*'=23 60 | '/'=24 61 | '%'=25 62 | 'true'=26 63 | 'false'=27 64 | 'null'=28 65 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/fdset.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos 6 | 7 | package unix 8 | 9 | // Set adds fd to the set fds. 10 | func (fds *FdSet) Set(fd int) { 11 | fds.Bits[fd/NFDBITS] |= (1 << (uintptr(fd) % NFDBITS)) 12 | } 13 | 14 | // Clear removes fd from the set fds. 15 | func (fds *FdSet) Clear(fd int) { 16 | fds.Bits[fd/NFDBITS] &^= (1 << (uintptr(fd) % NFDBITS)) 17 | } 18 | 19 | // IsSet returns whether fd is in the set fds. 20 | func (fds *FdSet) IsSet(fd int) bool { 21 | return fds.Bits[fd/NFDBITS]&(1<<(uintptr(fd)%NFDBITS)) != 0 22 | } 23 | 24 | // Zero clears the set fds. 25 | func (fds *FdSet) Zero() { 26 | for i := range fds.Bits { 27 | fds.Bits[i] = 0 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /vendor/github.com/google/cel-go/cel/cel.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 Google LLC 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"); 4 | // you may not use this file except in compliance with the License. 5 | // You may obtain a copy of the License at 6 | // 7 | // http://www.apache.org/licenses/LICENSE-2.0 8 | // 9 | // Unless required by applicable law or agreed to in writing, software 10 | // distributed under the License is distributed on an "AS IS" BASIS, 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | // See the License for the specific language governing permissions and 13 | // limitations under the License. 14 | 15 | // Package cel defines the top-level interface for the Common Expression Language (CEL). 16 | // 17 | // CEL is a non-Turing complete expression language designed to parse, check, and evaluate 18 | // expressions against user-defined environments. 19 | package cel 20 | -------------------------------------------------------------------------------- /vendor/github.com/google/cel-go/parser/gen/CELLexer.tokens: -------------------------------------------------------------------------------- 1 | EQUALS=1 2 | NOT_EQUALS=2 3 | IN=3 4 | LESS=4 5 | LESS_EQUALS=5 6 | GREATER_EQUALS=6 7 | GREATER=7 8 | LOGICAL_AND=8 9 | LOGICAL_OR=9 10 | LBRACKET=10 11 | RPRACKET=11 12 | LBRACE=12 13 | RBRACE=13 14 | LPAREN=14 15 | RPAREN=15 16 | DOT=16 17 | COMMA=17 18 | MINUS=18 19 | EXCLAM=19 20 | QUESTIONMARK=20 21 | COLON=21 22 | PLUS=22 23 | STAR=23 24 | SLASH=24 25 | PERCENT=25 26 | CEL_TRUE=26 27 | CEL_FALSE=27 28 | NUL=28 29 | WHITESPACE=29 30 | COMMENT=30 31 | NUM_FLOAT=31 32 | NUM_INT=32 33 | NUM_UINT=33 34 | STRING=34 35 | BYTES=35 36 | IDENTIFIER=36 37 | '=='=1 38 | '!='=2 39 | 'in'=3 40 | '<'=4 41 | '<='=5 42 | '>='=6 43 | '>'=7 44 | '&&'=8 45 | '||'=9 46 | '['=10 47 | ']'=11 48 | '{'=12 49 | '}'=13 50 | '('=14 51 | ')'=15 52 | '.'=16 53 | ','=17 54 | '-'=18 55 | '!'=19 56 | '?'=20 57 | ':'=21 58 | '+'=22 59 | '*'=23 60 | '/'=24 61 | '%'=25 62 | 'true'=26 63 | 'false'=27 64 | 'null'=28 65 | -------------------------------------------------------------------------------- /vendor/github.com/ohler55/ojg/gen/bool.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2020, Peter Ohler, All rights reserved. 2 | 3 | package gen 4 | 5 | // Bool repreents a boolean value. 6 | type Bool bool 7 | 8 | // True is a true boolean value. 9 | var True = Bool(true) 10 | 11 | // False is a false boolean value. 12 | var False = Bool(false) 13 | 14 | // String returns a string representation of the Node. 15 | func (n Bool) String() (s string) { 16 | if n { 17 | s = "true" 18 | } else { 19 | s = "false" 20 | } 21 | return 22 | } 23 | 24 | // Alter returns the backing boolean value of the Node. 25 | func (n Bool) Alter() any { 26 | return bool(n) 27 | } 28 | 29 | // Simplify returns the backing boolean value. 30 | func (n Bool) Simplify() any { 31 | return bool(n) 32 | } 33 | 34 | // Dup returns itself. 35 | func (n Bool) Dup() Node { 36 | return n 37 | } 38 | 39 | // Empty returns false. 40 | func (n Bool) Empty() bool { 41 | return false 42 | } 43 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/fcntl_darwin.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package unix 6 | 7 | import "unsafe" 8 | 9 | // FcntlInt performs a fcntl syscall on fd with the provided command and argument. 10 | func FcntlInt(fd uintptr, cmd, arg int) (int, error) { 11 | return fcntl(int(fd), cmd, arg) 12 | } 13 | 14 | // FcntlFlock performs a fcntl syscall for the F_GETLK, F_SETLK or F_SETLKW command. 15 | func FcntlFlock(fd uintptr, cmd int, lk *Flock_t) error { 16 | _, err := fcntl(int(fd), cmd, int(uintptr(unsafe.Pointer(lk)))) 17 | return err 18 | } 19 | 20 | // FcntlFstore performs a fcntl syscall for the F_PREALLOCATE command. 21 | func FcntlFstore(fd uintptr, cmd int, fstore *Fstore_t) error { 22 | _, err := fcntl(int(fd), cmd, int(uintptr(unsafe.Pointer(fstore)))) 23 | return err 24 | } 25 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/eventlog.go: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build windows 6 | 7 | package windows 8 | 9 | const ( 10 | EVENTLOG_SUCCESS = 0 11 | EVENTLOG_ERROR_TYPE = 1 12 | EVENTLOG_WARNING_TYPE = 2 13 | EVENTLOG_INFORMATION_TYPE = 4 14 | EVENTLOG_AUDIT_SUCCESS = 8 15 | EVENTLOG_AUDIT_FAILURE = 16 16 | ) 17 | 18 | //sys RegisterEventSource(uncServerName *uint16, sourceName *uint16) (handle Handle, err error) [failretval==0] = advapi32.RegisterEventSourceW 19 | //sys DeregisterEventSource(handle Handle) (err error) = advapi32.DeregisterEventSource 20 | //sys ReportEvent(log Handle, etype uint16, category uint16, eventId uint32, usrSId uintptr, numStrings uint16, dataSize uint32, strings **uint16, rawData *byte) (err error) = advapi32.ReportEventW 21 | -------------------------------------------------------------------------------- /vendor/golang.org/x/text/width/kind_string.go: -------------------------------------------------------------------------------- 1 | // Code generated by "stringer -type=Kind"; DO NOT EDIT. 2 | 3 | package width 4 | 5 | import "strconv" 6 | 7 | func _() { 8 | // An "invalid array index" compiler error signifies that the constant values have changed. 9 | // Re-run the stringer command to generate them again. 10 | var x [1]struct{} 11 | _ = x[Neutral-0] 12 | _ = x[EastAsianAmbiguous-1] 13 | _ = x[EastAsianWide-2] 14 | _ = x[EastAsianNarrow-3] 15 | _ = x[EastAsianFullwidth-4] 16 | _ = x[EastAsianHalfwidth-5] 17 | } 18 | 19 | const _Kind_name = "NeutralEastAsianAmbiguousEastAsianWideEastAsianNarrowEastAsianFullwidthEastAsianHalfwidth" 20 | 21 | var _Kind_index = [...]uint8{0, 7, 25, 38, 53, 71, 89} 22 | 23 | func (i Kind) String() string { 24 | if i < 0 || i >= Kind(len(_Kind_index)-1) { 25 | return "Kind(" + strconv.FormatInt(int64(i), 10) + ")" 26 | } 27 | return _Kind_name[_Kind_index[i]:_Kind_index[i+1]] 28 | } 29 | -------------------------------------------------------------------------------- /vendor/github.com/antlr4-go/antlr/v4/stats_data.go: -------------------------------------------------------------------------------- 1 | package antlr 2 | 3 | // A JStatRec is a record of a particular use of a [JStore], [JMap] or JPCMap] collection. Typically, it will be 4 | // used to look for unused collections that wre allocated anyway, problems with hash bucket clashes, and anomalies 5 | // such as huge numbers of Gets with no entries found GetNoEnt. You can refer to the CollectionAnomalies() function 6 | // for ideas on what can be gleaned from these statistics about collections. 7 | type JStatRec struct { 8 | Source CollectionSource 9 | MaxSize int 10 | CurSize int 11 | Gets int 12 | GetHits int 13 | GetMisses int 14 | GetHashConflicts int 15 | GetNoEnt int 16 | Puts int 17 | PutHits int 18 | PutMisses int 19 | PutHashConflicts int 20 | MaxSlotSize int 21 | Description string 22 | CreateStack []byte 23 | } 24 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/pebble/cache.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The LevelDB-Go and Pebble Authors. All rights reserved. Use 2 | // of this source code is governed by a BSD-style license that can be found in 3 | // the LICENSE file. 4 | 5 | package pebble 6 | 7 | import "github.com/cockroachdb/pebble/internal/cache" 8 | 9 | // Cache exports the cache.Cache type. 10 | type Cache = cache.Cache 11 | 12 | // NewCache creates a new cache of the specified size. Memory for the cache is 13 | // allocated on demand, not during initialization. The cache is created with a 14 | // reference count of 1. Each DB it is associated with adds a reference, so the 15 | // creator of the cache should usually release their reference after the DB is 16 | // created. 17 | // 18 | // c := pebble.NewCache(...) 19 | // defer c.Unref() 20 | // d, err := pebble.Open(pebble.Options{Cache: c}) 21 | func NewCache(size int64) *cache.Cache { 22 | return cache.New(size) 23 | } 24 | -------------------------------------------------------------------------------- /vendor/github.com/google/cel-go/common/types/traits/zeroer.go: -------------------------------------------------------------------------------- 1 | // Copyright 2022 Google LLC 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"); 4 | // you may not use this file except in compliance with the License. 5 | // You may obtain a copy of the License at 6 | // 7 | // http://www.apache.org/licenses/LICENSE-2.0 8 | // 9 | // Unless required by applicable law or agreed to in writing, software 10 | // distributed under the License is distributed on an "AS IS" BASIS, 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | // See the License for the specific language governing permissions and 13 | // limitations under the License. 14 | 15 | package traits 16 | 17 | // Zeroer interface for testing whether a CEL value is a zero value for its type. 18 | type Zeroer interface { 19 | // IsZeroValue indicates whether the object is the zero value for the type. 20 | IsZeroValue() bool 21 | } 22 | -------------------------------------------------------------------------------- /vendor/github.com/prometheus/client_golang/prometheus/get_pid.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Prometheus Authors 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | //go:build !js || wasm 15 | // +build !js wasm 16 | 17 | package prometheus 18 | 19 | import "os" 20 | 21 | func getPIDFn() func() (int, error) { 22 | pid := os.Getpid() 23 | return func() (int, error) { 24 | return pid, nil 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /vendor/github.com/google/cel-go/common/stdlib/BUILD.bazel: -------------------------------------------------------------------------------- 1 | load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test") 2 | 3 | package( 4 | default_visibility = ["//visibility:public"], 5 | licenses = ["notice"], # Apache 2.0 6 | ) 7 | 8 | go_library( 9 | name = "go_default_library", 10 | srcs = [ 11 | "standard.go", 12 | ], 13 | importpath = "github.com/google/cel-go/common/stdlib", 14 | deps = [ 15 | "//checker/decls:go_default_library", 16 | "//common/decls:go_default_library", 17 | "//common/functions:go_default_library", 18 | "//common/operators:go_default_library", 19 | "//common/overloads:go_default_library", 20 | "//common/types:go_default_library", 21 | "//common/types/ref:go_default_library", 22 | "//common/types/traits:go_default_library", 23 | "@org_golang_google_genproto_googleapis_api//expr/v1alpha1:go_default_library", 24 | ], 25 | ) -------------------------------------------------------------------------------- /vendor/github.com/google/uuid/README.md: -------------------------------------------------------------------------------- 1 | # uuid 2 | The uuid package generates and inspects UUIDs based on 3 | [RFC 4122](https://datatracker.ietf.org/doc/html/rfc4122) 4 | and DCE 1.1: Authentication and Security Services. 5 | 6 | This package is based on the github.com/pborman/uuid package (previously named 7 | code.google.com/p/go-uuid). It differs from these earlier packages in that 8 | a UUID is a 16 byte array rather than a byte slice. One loss due to this 9 | change is the ability to represent an invalid UUID (vs a NIL UUID). 10 | 11 | ###### Install 12 | ```sh 13 | go get github.com/google/uuid 14 | ``` 15 | 16 | ###### Documentation 17 | [![Go Reference](https://pkg.go.dev/badge/github.com/google/uuid.svg)](https://pkg.go.dev/github.com/google/uuid) 18 | 19 | Full `go doc` style documentation for the package can be viewed online without 20 | installing this package by using the GoDoc site here: 21 | http://pkg.go.dev/github.com/google/uuid 22 | -------------------------------------------------------------------------------- /vendor/github.com/google/cel-go/common/types/any_value.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 Google LLC 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"); 4 | // you may not use this file except in compliance with the License. 5 | // You may obtain a copy of the License at 6 | // 7 | // http://www.apache.org/licenses/LICENSE-2.0 8 | // 9 | // Unless required by applicable law or agreed to in writing, software 10 | // distributed under the License is distributed on an "AS IS" BASIS, 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | // See the License for the specific language governing permissions and 13 | // limitations under the License. 14 | 15 | package types 16 | 17 | import ( 18 | "reflect" 19 | 20 | anypb "google.golang.org/protobuf/types/known/anypb" 21 | ) 22 | 23 | // anyValueType constant representing the reflected type of google.protobuf.Any. 24 | var anyValueType = reflect.TypeOf(&anypb.Any{}) 25 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/errors/errutil/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Cockroach Authors. 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"); 4 | // you may not use this file except in compliance with the License. 5 | // You may obtain a copy of the License at 6 | // 7 | // http://www.apache.org/licenses/LICENSE-2.0 8 | // 9 | // Unless required by applicable law or agreed to in writing, software 10 | // distributed under the License is distributed on an "AS IS" BASIS, 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 12 | // implied. See the License for the specific language governing 13 | // permissions and limitations under the License. 14 | 15 | // Package errutil combines primitives from the library, the Go errors 16 | // package and github.com/pkg/errors. It aims to serve as drop-in 17 | // replacement to github.com/pkg/errors and replace the legacy 18 | // implementation of `pgerrors`. 19 | package errutil 20 | -------------------------------------------------------------------------------- /vendor/github.com/prometheus/client_golang/prometheus/process_collector_js.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Prometheus Authors 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | //go:build js 15 | // +build js 16 | 17 | package prometheus 18 | 19 | func canCollectProcess() bool { 20 | return false 21 | } 22 | 23 | func (c *processCollector) processCollect(ch chan<- Metric) { 24 | // noop on this platform 25 | return 26 | } 27 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/impl/codec_map_go111.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build !go1.12 6 | // +build !go1.12 7 | 8 | package impl 9 | 10 | import "reflect" 11 | 12 | type mapIter struct { 13 | v reflect.Value 14 | keys []reflect.Value 15 | } 16 | 17 | // mapRange provides a less-efficient equivalent to 18 | // the Go 1.12 reflect.Value.MapRange method. 19 | func mapRange(v reflect.Value) *mapIter { 20 | return &mapIter{v: v} 21 | } 22 | 23 | func (i *mapIter) Next() bool { 24 | if i.keys == nil { 25 | i.keys = i.v.MapKeys() 26 | } else { 27 | i.keys = i.keys[1:] 28 | } 29 | return len(i.keys) > 0 30 | } 31 | 32 | func (i *mapIter) Key() reflect.Value { 33 | return i.keys[0] 34 | } 35 | 36 | func (i *mapIter) Value() reflect.Value { 37 | return i.v.MapIndex(i.keys[0]) 38 | } 39 | -------------------------------------------------------------------------------- /vendor/github.com/cockroachdb/errors/errbase/oserror_go116.go: -------------------------------------------------------------------------------- 1 | // Copyright 2021 The Cockroach Authors. 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"); 4 | // you may not use this file except in compliance with the License. 5 | // You may obtain a copy of the License at 6 | // 7 | // http://www.apache.org/licenses/LICENSE-2.0 8 | // 9 | // Unless required by applicable law or agreed to in writing, software 10 | // distributed under the License is distributed on an "AS IS" BASIS, 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 12 | // implied. See the License for the specific language governing 13 | // permissions and limitations under the License. 14 | 15 | // +build go1.16 16 | 17 | package errbase 18 | 19 | import "io/fs" 20 | 21 | func registerOsPathErrorMigration() { 22 | // The os.PathError type was migrated to io.fs.PathError in Go 1.16. 23 | RegisterTypeMigration("os", "*os.PathError", &fs.PathError{}) 24 | } 25 | -------------------------------------------------------------------------------- /vendor/github.com/gogo/protobuf/CONTRIBUTORS: -------------------------------------------------------------------------------- 1 | Anton Povarov 2 | Brian Goff 3 | Clayton Coleman 4 | Denis Smirnov 5 | DongYun Kang 6 | Dwayne Schultz 7 | Georg Apitz 8 | Gustav Paul 9 | Johan Brandhorst 10 | John Shahid 11 | John Tuley 12 | Laurent 13 | Patrick Lee 14 | Peter Edge 15 | Roger Johansson 16 | Sam Nguyen 17 | Sergio Arbeo 18 | Stephen J Day 19 | Tamir Duberstein 20 | Todd Eisenberger 21 | Tormod Erevik Lea 22 | Vyacheslav Kim 23 | Walter Schulze 24 | -------------------------------------------------------------------------------- /vendor/github.com/google/cel-go/common/types/traits/sizer.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 Google LLC 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"); 4 | // you may not use this file except in compliance with the License. 5 | // You may obtain a copy of the License at 6 | // 7 | // http://www.apache.org/licenses/LICENSE-2.0 8 | // 9 | // Unless required by applicable law or agreed to in writing, software 10 | // distributed under the License is distributed on an "AS IS" BASIS, 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | // See the License for the specific language governing permissions and 13 | // limitations under the License. 14 | 15 | package traits 16 | 17 | import ( 18 | "github.com/google/cel-go/common/types/ref" 19 | ) 20 | 21 | // Sizer interface for supporting 'size()' overloads. 22 | type Sizer interface { 23 | // Size returns the number of elements or length of the value. 24 | Size() ref.Val 25 | } 26 | -------------------------------------------------------------------------------- /vendor/github.com/prometheus/client_golang/NOTICE: -------------------------------------------------------------------------------- 1 | Prometheus instrumentation library for Go applications 2 | Copyright 2012-2015 The Prometheus Authors 3 | 4 | This product includes software developed at 5 | SoundCloud Ltd. (http://soundcloud.com/). 6 | 7 | 8 | The following components are included in this product: 9 | 10 | perks - a fork of https://github.com/bmizerany/perks 11 | https://github.com/beorn7/perks 12 | Copyright 2013-2015 Blake Mizerany, Björn Rabenstein 13 | See https://github.com/beorn7/perks/blob/master/README.md for license details. 14 | 15 | Go support for Protocol Buffers - Google's data interchange format 16 | http://github.com/golang/protobuf/ 17 | Copyright 2010 The Go Authors 18 | See source code for license details. 19 | 20 | Support for streaming Protocol Buffer messages for the Go language (golang). 21 | https://github.com/matttproud/golang_protobuf_extensions 22 | Copyright 2013 Matt T. Proud 23 | Licensed under the Apache License, Version 2.0 24 | -------------------------------------------------------------------------------- /vendor/github.com/google/cel-go/common/BUILD.bazel: -------------------------------------------------------------------------------- 1 | load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test") 2 | 3 | package( 4 | default_visibility = ["//visibility:public"], 5 | licenses = ["notice"], # Apache 2.0 6 | ) 7 | 8 | go_library( 9 | name = "go_default_library", 10 | srcs = [ 11 | "cost.go", 12 | "error.go", 13 | "errors.go", 14 | "location.go", 15 | "source.go", 16 | ], 17 | importpath = "github.com/google/cel-go/common", 18 | deps = [ 19 | "//common/runes:go_default_library", 20 | "@org_golang_google_genproto_googleapis_api//expr/v1alpha1:go_default_library", 21 | "@org_golang_x_text//width:go_default_library", 22 | ], 23 | ) 24 | 25 | go_test( 26 | name = "go_default_test", 27 | size = "small", 28 | srcs = [ 29 | "errors_test.go", 30 | "source_test.go", 31 | ], 32 | embed = [ 33 | ":go_default_library", 34 | ], 35 | ) 36 | -------------------------------------------------------------------------------- /vendor/github.com/ohler55/ojg/error.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2021, Peter Ohler, All rights reserved. 2 | 3 | package ojg 4 | 5 | import ( 6 | "fmt" 7 | "runtime/debug" 8 | ) 9 | 10 | // ErrorWithStack if true the Error() call will include the stack. 11 | var ErrorWithStack = false 12 | 13 | // Error struct to hold an error message and a stack trace. 14 | type Error struct { 15 | msg string 16 | stack []byte 17 | } 18 | 19 | // NewError creates a new Error instance, capturing the stack when created. 20 | func NewError(r any) *Error { 21 | return &Error{ 22 | msg: fmt.Sprintf("%v", r), 23 | stack: debug.Stack(), 24 | } 25 | } 26 | 27 | // Error returns a string representation of the instance. 28 | func (err *Error) Error() string { 29 | if ErrorWithStack { 30 | return string(append(append([]byte(err.msg), '\n'), err.stack...)) 31 | } 32 | return err.msg 33 | } 34 | 35 | // Stack returns the stack. 36 | func (err *Error) Stack() []byte { 37 | return err.stack 38 | } 39 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/dev_zos.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build zos && s390x 6 | 7 | // Functions to access/create device major and minor numbers matching the 8 | // encoding used by z/OS. 9 | // 10 | // The information below is extracted and adapted from macros. 11 | 12 | package unix 13 | 14 | // Major returns the major component of a z/OS device number. 15 | func Major(dev uint64) uint32 { 16 | return uint32((dev >> 16) & 0x0000FFFF) 17 | } 18 | 19 | // Minor returns the minor component of a z/OS device number. 20 | func Minor(dev uint64) uint32 { 21 | return uint32(dev & 0x0000FFFF) 22 | } 23 | 24 | // Mkdev returns a z/OS device number generated from the given major and minor 25 | // components. 26 | func Mkdev(major, minor uint32) uint64 { 27 | return (uint64(major) << 16) | uint64(minor) 28 | } 29 | -------------------------------------------------------------------------------- /vendor/github.com/getsentry/sentry-go/internal/traceparser/README.md: -------------------------------------------------------------------------------- 1 | ## Benchmark results 2 | 3 | ``` 4 | goos: windows 5 | goarch: amd64 6 | pkg: github.com/getsentry/sentry-go/internal/trace 7 | cpu: 12th Gen Intel(R) Core(TM) i7-12700K 8 | BenchmarkEqualBytes-20 44323621 26.08 ns/op 9 | BenchmarkStringEqual-20 60980257 18.27 ns/op 10 | BenchmarkEqualPrefix-20 41369181 31.12 ns/op 11 | BenchmarkFullParse-20 702012 1507 ns/op 1353.42 MB/s 1024 B/op 6 allocs/op 12 | BenchmarkFramesIterator-20 1229971 969.3 ns/op 896 B/op 5 allocs/op 13 | BenchmarkFramesReversedIterator-20 1271061 944.5 ns/op 896 B/op 5 allocs/op 14 | BenchmarkSplitOnly-20 2250800 534.0 ns/op 3818.23 MB/s 128 B/op 1 allocs/op 15 | ``` 16 | -------------------------------------------------------------------------------- /vendor/github.com/google/cel-go/common/types/traits/matcher.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 Google LLC 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"); 4 | // you may not use this file except in compliance with the License. 5 | // You may obtain a copy of the License at 6 | // 7 | // http://www.apache.org/licenses/LICENSE-2.0 8 | // 9 | // Unless required by applicable law or agreed to in writing, software 10 | // distributed under the License is distributed on an "AS IS" BASIS, 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | // See the License for the specific language governing permissions and 13 | // limitations under the License. 14 | 15 | package traits 16 | 17 | import "github.com/google/cel-go/common/types/ref" 18 | 19 | // Matcher interface for supporting 'matches()' overloads. 20 | type Matcher interface { 21 | // Match returns true if the pattern matches the current value. 22 | Match(pattern ref.Val) ref.Val 23 | } 24 | -------------------------------------------------------------------------------- /vendor/go.uber.org/atomic/.codecov.yml: -------------------------------------------------------------------------------- 1 | coverage: 2 | range: 80..100 3 | round: down 4 | precision: 2 5 | 6 | status: 7 | project: # measuring the overall project coverage 8 | default: # context, you can create multiple ones with custom titles 9 | enabled: yes # must be yes|true to enable this status 10 | target: 100 # specify the target coverage for each commit status 11 | # option: "auto" (must increase from parent commit or pull request base) 12 | # option: "X%" a static target percentage to hit 13 | if_not_found: success # if parent is not found report status as success, error, or failure 14 | if_ci_failed: error # if ci fails report status as success, error, or failure 15 | 16 | # Also update COVER_IGNORE_PKGS in the Makefile. 17 | ignore: 18 | - /internal/gen-atomicint/ 19 | - /internal/gen-valuewrapper/ 20 | --------------------------------------------------------------------------------