├── .envrc ├── vendor ├── github.com │ ├── alecthomas │ │ └── kong │ │ │ ├── .gitignore │ │ │ ├── kong.png │ │ │ ├── kong.sketch │ │ │ ├── guesswidth.go │ │ │ ├── error.go │ │ │ ├── global.go │ │ │ ├── defaults.go │ │ │ ├── hooks.go │ │ │ └── levenshtein.go │ ├── kevinburke │ │ └── ssh_config │ │ │ ├── .gitignore │ │ │ ├── .gitattributes │ │ │ ├── .mailmap │ │ │ ├── AUTHORS.txt │ │ │ ├── CHANGELOG.md │ │ │ ├── position.go │ │ │ └── Makefile │ ├── Microsoft │ │ └── go-winio │ │ │ ├── .gitattributes │ │ │ ├── CODEOWNERS │ │ │ ├── tools.go │ │ │ ├── .gitignore │ │ │ ├── syscall.go │ │ │ ├── pkg │ │ │ └── guid │ │ │ │ ├── guid_windows.go │ │ │ │ ├── guid_nonwindows.go │ │ │ │ └── variant_string.go │ │ │ └── internal │ │ │ └── socket │ │ │ └── rawaddr.go │ ├── go-git │ │ ├── go-billy │ │ │ └── v5 │ │ │ │ ├── .gitignore │ │ │ │ ├── Makefile │ │ │ │ └── osfs │ │ │ │ ├── os_posix.go │ │ │ │ └── os_js.go │ │ ├── go-git │ │ │ └── v5 │ │ │ │ ├── .gitignore │ │ │ │ ├── plumbing │ │ │ │ ├── format │ │ │ │ │ ├── objfile │ │ │ │ │ │ └── doc.go │ │ │ │ │ ├── packfile │ │ │ │ │ │ └── error.go │ │ │ │ │ └── config │ │ │ │ │ │ └── decoder.go │ │ │ │ ├── storer │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── index.go │ │ │ │ │ ├── shallow.go │ │ │ │ │ └── storer.go │ │ │ │ ├── revision.go │ │ │ │ ├── error.go │ │ │ │ └── protocol │ │ │ │ │ └── packp │ │ │ │ │ └── sideband │ │ │ │ │ └── common.go │ │ │ │ ├── utils │ │ │ │ ├── ioutil │ │ │ │ │ ├── pipe.go │ │ │ │ │ └── pipe_js.go │ │ │ │ └── sync │ │ │ │ │ └── bufio.go │ │ │ │ ├── internal │ │ │ │ └── revision │ │ │ │ │ └── token.go │ │ │ │ ├── doc.go │ │ │ │ ├── storage │ │ │ │ ├── filesystem │ │ │ │ │ ├── module.go │ │ │ │ │ └── deltaobject.go │ │ │ │ └── storer.go │ │ │ │ ├── common.go │ │ │ │ ├── worktree_linux.go │ │ │ │ ├── worktree_js.go │ │ │ │ ├── worktree_bsd.go │ │ │ │ ├── worktree_unix_other.go │ │ │ │ ├── worktree_plan9.go │ │ │ │ ├── worktree_windows.go │ │ │ │ └── Makefile │ │ └── gcfg │ │ │ ├── go1_0.go │ │ │ ├── types │ │ │ ├── doc.go │ │ │ ├── bool.go │ │ │ └── scan.go │ │ │ ├── go1_2.go │ │ │ ├── README │ │ │ └── errors.go │ ├── mattn │ │ ├── go-isatty │ │ │ ├── doc.go │ │ │ ├── go.test.sh │ │ │ ├── isatty_others.go │ │ │ ├── isatty_tcgets.go │ │ │ ├── isatty_plan9.go │ │ │ ├── isatty_bsd.go │ │ │ └── isatty_solaris.go │ │ ├── go-runewidth │ │ │ ├── runewidth_appengine.go │ │ │ ├── runewidth_js.go │ │ │ ├── runewidth_windows.go │ │ │ └── README.md │ │ └── go-colorable │ │ │ ├── go.test.sh │ │ │ ├── colorable_appengine.go │ │ │ └── colorable_others.go │ ├── acomagu │ │ └── bufpipe │ │ │ └── doc.go │ ├── muesli │ │ └── termenv │ │ │ ├── constants_linux.go │ │ │ ├── constants_solaris.go │ │ │ ├── .gitignore │ │ │ ├── notification.go │ │ │ ├── constants_unix.go │ │ │ ├── hyperlink.go │ │ │ ├── termenv_posix.go │ │ │ ├── termenv_solaris.go │ │ │ ├── .golangci.yml │ │ │ ├── termenv_other.go │ │ │ ├── .golangci-soft.yml │ │ │ └── copy.go │ ├── otiai10 │ │ └── copy │ │ │ ├── .gitignore │ │ │ ├── preserve_owner_x.go │ │ │ ├── preserve_ltimes_x.go │ │ │ ├── preserve_times.go │ │ │ ├── stat_times_x.go │ │ │ ├── copy_namedpipes_x.go │ │ │ ├── stat_times_js.go │ │ │ ├── stat_times_darwin.go │ │ │ ├── test_setup_x.go │ │ │ ├── stat_times_windows.go │ │ │ ├── preserve_ltimes.go │ │ │ ├── stat_times_freebsd.go │ │ │ ├── copy_namedpipes.go │ │ │ ├── preserve_owner.go │ │ │ ├── stat_times.go │ │ │ ├── test_setup.go │ │ │ ├── fileinfo_go1.15.go │ │ │ └── fileinfo_go1.16.go │ ├── pjbgf │ │ └── sha1cd │ │ │ ├── ubc │ │ │ └── doc.go │ │ │ ├── sha1cdblock_noasm.go │ │ │ ├── detection.go │ │ │ ├── Dockerfile.arm │ │ │ ├── Dockerfile.arm64 │ │ │ └── Makefile │ ├── cloudflare │ │ └── circl │ │ │ ├── sign │ │ │ └── ed25519 │ │ │ │ ├── pubkey112.go │ │ │ │ └── pubkey.go │ │ │ ├── dh │ │ │ ├── x448 │ │ │ │ ├── curve_noasm.go │ │ │ │ ├── curve_amd64.go │ │ │ │ └── doc.go │ │ │ └── x25519 │ │ │ │ ├── curve_noasm.go │ │ │ │ ├── curve_amd64.go │ │ │ │ └── doc.go │ │ │ ├── internal │ │ │ └── sha3 │ │ │ │ ├── keccakf_amd64.go │ │ │ │ ├── xor.go │ │ │ │ ├── rc.go │ │ │ │ └── xor_generic.go │ │ │ └── math │ │ │ ├── fp448 │ │ │ └── fp_noasm.go │ │ │ └── fp25519 │ │ │ └── fp_noasm.go │ ├── c2h5oh │ │ └── datasize │ │ │ ├── .travis.yml │ │ │ └── .gitignore │ ├── ProtonMail │ │ └── go-crypto │ │ │ ├── AUTHORS │ │ │ ├── CONTRIBUTORS │ │ │ └── openpgp │ │ │ ├── packet │ │ │ └── notation.go │ │ │ └── internal │ │ │ └── encoding │ │ │ └── encoding.go │ ├── imdario │ │ └── mergo │ │ │ ├── .deepsource.toml │ │ │ ├── .travis.yml │ │ │ └── .gitignore │ ├── cli │ │ ├── safeexec │ │ │ ├── lookpath_1.18.go │ │ │ └── lookpath.go │ │ ├── go-gh │ │ │ ├── .golangci.yml │ │ │ ├── pkg │ │ │ │ ├── term │ │ │ │ │ ├── console.go │ │ │ │ │ └── console_windows.go │ │ │ │ └── config │ │ │ │ │ └── errors.go │ │ │ └── internal │ │ │ │ ├── repository │ │ │ │ └── repository.go │ │ │ │ └── git │ │ │ │ └── git.go │ │ └── shurcooL-graphql │ │ │ └── .golangci.yml │ ├── xanzy │ │ └── ssh-agent │ │ │ └── .gitignore │ ├── henvic │ │ └── httpretty │ │ │ ├── .gitignore │ │ │ └── CONTRIBUTING.md │ ├── sergi │ │ └── go-diff │ │ │ └── diffmatchpatch │ │ │ ├── operation_string.go │ │ │ └── mathutil.go │ ├── skeema │ │ └── knownhosts │ │ │ └── NOTICE │ ├── emirpasic │ │ └── gods │ │ │ ├── containers │ │ │ └── serialization.go │ │ │ ├── trees │ │ │ └── trees.go │ │ │ └── utils │ │ │ └── sort.go │ ├── lucasb-eyer │ │ └── go-colorful │ │ │ ├── happy_palettegen.go │ │ │ └── warm_palettegen.go │ └── thlib │ │ └── go-timezone-local │ │ └── tzlocal │ │ └── tz.go ├── golang.org │ └── x │ │ ├── sys │ │ ├── unix │ │ │ ├── .gitignore │ │ │ ├── syscall_linux_amd64_gc.go │ │ │ ├── constants.go │ │ │ ├── endian_big.go │ │ │ ├── sysvshm_unix_other.go │ │ │ ├── asm_aix_ppc64.s │ │ │ ├── ptrace_ios.go │ │ │ ├── syscall_linux_gc_arm.go │ │ │ ├── endian_little.go │ │ │ ├── asm_solaris_amd64.s │ │ │ ├── readdirent_getdents.go │ │ │ ├── pagesize_unix.go │ │ │ ├── aliases.go │ │ │ ├── ptrace_darwin.go │ │ │ ├── fcntl_linux_32bit.go │ │ │ ├── gccgo_linux_amd64.go │ │ │ ├── syscall_linux_gc.go │ │ │ ├── syscall_linux_alarm.go │ │ │ ├── syscall_hurd_386.go │ │ │ ├── sockcmsg_dragonfly.go │ │ │ ├── sysvshm_linux.go │ │ │ ├── syscall_linux_gc_386.go │ │ │ ├── syscall_linux_gccgo_arm.go │ │ │ ├── race0.go │ │ │ ├── syscall_solaris_amd64.go │ │ │ ├── syscall_hurd.go │ │ │ ├── zptrace_linux_arm64.go │ │ │ ├── syscall_unix_gc.go │ │ │ ├── race.go │ │ │ ├── readdirent_getdirentries.go │ │ │ ├── asm_openbsd_mips64.s │ │ │ ├── bluetooth_linux.go │ │ │ ├── asm_bsd_arm.s │ │ │ ├── dev_darwin.go │ │ │ ├── env_unix.go │ │ │ ├── asm_bsd_386.s │ │ │ ├── dev_aix_ppc.go │ │ │ ├── asm_bsd_arm64.s │ │ │ ├── asm_bsd_riscv64.s │ │ │ ├── asm_bsd_ppc64.s │ │ │ ├── asm_bsd_amd64.s │ │ │ ├── fcntl_darwin.go │ │ │ ├── syscall_unix_gc_ppc64x.go │ │ │ ├── dev_zos.go │ │ │ ├── fdset.go │ │ │ ├── dev_aix_ppc64.go │ │ │ ├── syscall_netbsd_386.go │ │ │ ├── syscall_netbsd_amd64.go │ │ │ ├── syscall_netbsd_arm.go │ │ │ ├── syscall_netbsd_arm64.go │ │ │ └── dev_netbsd.go │ │ ├── plan9 │ │ │ ├── asm.s │ │ │ ├── pwd_go15_plan9.go │ │ │ ├── pwd_plan9.go │ │ │ ├── mksysnum_plan9.sh │ │ │ ├── race0.go │ │ │ ├── str.go │ │ │ ├── env_plan9.go │ │ │ ├── race.go │ │ │ ├── asm_plan9_arm.s │ │ │ ├── asm_plan9_386.s │ │ │ └── asm_plan9_amd64.s │ │ ├── cpu │ │ │ ├── cpu_zos.go │ │ │ ├── cpu_other_arm.go │ │ │ ├── cpu_riscv64.go │ │ │ ├── cpu_loong64.go │ │ │ ├── cpu_gc_arm64.go │ │ │ ├── cpu_mipsx.go │ │ │ ├── cpu_other_arm64.go │ │ │ ├── cpu_other_riscv64.go │ │ │ ├── cpu_other_mips64x.go │ │ │ ├── cpu_gccgo_arm64.go │ │ │ ├── cpu_linux_noinit.go │ │ │ ├── cpu_other_ppc64x.go │ │ │ ├── cpu_mips64x.go │ │ │ ├── cpu_openbsd_arm64.s │ │ │ ├── cpu_linux.go │ │ │ ├── cpu_ppc64x.go │ │ │ ├── runtime_auxv.go │ │ │ ├── runtime_auxv_go121.go │ │ │ ├── asm_aix_ppc64.s │ │ │ ├── cpu_wasm.go │ │ │ ├── endian_big.go │ │ │ ├── endian_little.go │ │ │ ├── cpu_gc_x86.go │ │ │ ├── cpu_linux_mips64x.go │ │ │ ├── cpu_zos_s390x.go │ │ │ ├── cpu_x86.s │ │ │ ├── cpu_aix.go │ │ │ ├── cpu_gc_s390x.go │ │ │ ├── syscall_aix_gccgo.go │ │ │ ├── cpu_arm64.s │ │ │ ├── cpu_linux_ppc64x.go │ │ │ └── cpu_gccgo_x86.go │ │ ├── windows │ │ │ ├── empty.s │ │ │ ├── aliases.go │ │ │ ├── registry │ │ │ │ └── mksyscall.go │ │ │ ├── mksyscall.go │ │ │ ├── race0.go │ │ │ ├── str.go │ │ │ ├── race.go │ │ │ ├── eventlog.go │ │ │ ├── types_windows_amd64.go │ │ │ ├── types_windows_arm64.go │ │ │ ├── types_windows_386.go │ │ │ └── types_windows_arm.go │ │ └── execabs │ │ │ ├── execabs_go118.go │ │ │ └── execabs_go119.go │ │ ├── term │ │ ├── codereview.cfg │ │ ├── term_unix_other.go │ │ ├── term_unix_bsd.go │ │ ├── README.md │ │ └── CONTRIBUTING.md │ │ ├── crypto │ │ ├── curve25519 │ │ │ └── internal │ │ │ │ └── field │ │ │ │ ├── sync.checkpoint │ │ │ │ ├── README │ │ │ │ ├── fe_arm64_noasm.go │ │ │ │ ├── fe_amd64_noasm.go │ │ │ │ ├── fe_arm64.go │ │ │ │ ├── fe_amd64.go │ │ │ │ └── sync.sh │ │ ├── internal │ │ │ └── poly1305 │ │ │ │ ├── mac_noasm.go │ │ │ │ └── bits_go1.13.go │ │ ├── sha3 │ │ │ ├── keccakf_amd64.go │ │ │ ├── register.go │ │ │ ├── shake_generic.go │ │ │ ├── xor.go │ │ │ ├── xor_generic.go │ │ │ └── hashes_generic.go │ │ ├── chacha20 │ │ │ ├── chacha_noasm.go │ │ │ ├── chacha_ppc64le.go │ │ │ ├── chacha_arm64.go │ │ │ └── chacha_s390x.go │ │ └── ssh │ │ │ └── doc.go │ │ ├── tools │ │ └── internal │ │ │ ├── pkgbits │ │ │ ├── flags.go │ │ │ ├── support.go │ │ │ ├── frames_go1.go │ │ │ ├── frames_go17.go │ │ │ └── reloc.go │ │ │ ├── event │ │ │ └── doc.go │ │ │ ├── gcimporter │ │ │ ├── unified_yes.go │ │ │ ├── unified_no.go │ │ │ ├── support_go117.go │ │ │ ├── newInterface11.go │ │ │ ├── ureader_no.go │ │ │ └── newInterface10.go │ │ │ ├── typeparams │ │ │ ├── enabled_go117.go │ │ │ └── enabled_go118.go │ │ │ └── typesinternal │ │ │ └── types_118.go │ │ └── net │ │ ├── context │ │ └── go19.go │ │ └── proxy │ │ └── direct.go └── gopkg.in │ └── yaml.v3 │ └── NOTICE ├── .gitignore ├── RESOURCES.md ├── .github └── workflows │ └── release.yml ├── helper.go ├── README.md ├── flake.nix └── main.go /.envrc: -------------------------------------------------------------------------------- 1 | use flake 2 | -------------------------------------------------------------------------------- /vendor/github.com/alecthomas/kong/.gitignore: -------------------------------------------------------------------------------- 1 | bin 2 | -------------------------------------------------------------------------------- /vendor/github.com/kevinburke/ssh_config/.gitignore: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | /gh-foreach 2 | /gh-foreach.exe 3 | /result 4 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/.gitignore: -------------------------------------------------------------------------------- 1 | _obj/ 2 | unix.test 3 | -------------------------------------------------------------------------------- /vendor/golang.org/x/term/codereview.cfg: -------------------------------------------------------------------------------- 1 | issuerepo: golang/go 2 | -------------------------------------------------------------------------------- /vendor/github.com/Microsoft/go-winio/.gitattributes: -------------------------------------------------------------------------------- 1 | * text=auto eol=lf -------------------------------------------------------------------------------- /vendor/github.com/Microsoft/go-winio/CODEOWNERS: -------------------------------------------------------------------------------- 1 | * @microsoft/containerplat 2 | -------------------------------------------------------------------------------- /vendor/github.com/kevinburke/ssh_config/.gitattributes: -------------------------------------------------------------------------------- 1 | testdata/dos-lines eol=crlf 2 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-billy/v5/.gitignore: -------------------------------------------------------------------------------- 1 | /coverage.txt 2 | /vendor 3 | Gopkg.lock 4 | Gopkg.toml 5 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/.gitignore: -------------------------------------------------------------------------------- 1 | coverage.out 2 | *~ 3 | coverage.txt 4 | profile.out 5 | .tmp/ -------------------------------------------------------------------------------- /vendor/github.com/kevinburke/ssh_config/.mailmap: -------------------------------------------------------------------------------- 1 | Kevin Burke Kevin Burke 2 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-isatty/doc.go: -------------------------------------------------------------------------------- 1 | // Package isatty implements interface to isatty 2 | package isatty 3 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/curve25519/internal/field/sync.checkpoint: -------------------------------------------------------------------------------- 1 | b0c49ae9f59d233526f8934262c5bbbe14d4358d 2 | -------------------------------------------------------------------------------- /RESOURCES.md: -------------------------------------------------------------------------------- 1 | # Resources 2 | 3 | - 4 | -------------------------------------------------------------------------------- /vendor/github.com/acomagu/bufpipe/doc.go: -------------------------------------------------------------------------------- 1 | // Package bufpipe provides a IO pipe, has variable-sized buffer. 2 | package bufpipe 3 | -------------------------------------------------------------------------------- /vendor/github.com/Microsoft/go-winio/tools.go: -------------------------------------------------------------------------------- 1 | //go:build tools 2 | 3 | package winio 4 | 5 | import _ "golang.org/x/tools/cmd/stringer" 6 | -------------------------------------------------------------------------------- /vendor/github.com/alecthomas/kong/kong.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mtoohey31/gh-foreach/HEAD/vendor/github.com/alecthomas/kong/kong.png -------------------------------------------------------------------------------- /vendor/github.com/alecthomas/kong/kong.sketch: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mtoohey31/gh-foreach/HEAD/vendor/github.com/alecthomas/kong/kong.sketch -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/plumbing/format/objfile/doc.go: -------------------------------------------------------------------------------- 1 | // Package objfile implements encoding and decoding of object files. 2 | package objfile 3 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/plumbing/storer/doc.go: -------------------------------------------------------------------------------- 1 | // Package storer defines the interfaces to store objects, references, etc. 2 | package storer 3 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/gcfg/go1_0.go: -------------------------------------------------------------------------------- 1 | // +build !go1.2 2 | 3 | package gcfg 4 | 5 | type textUnmarshaler interface { 6 | UnmarshalText(text []byte) error 7 | } 8 | -------------------------------------------------------------------------------- /vendor/github.com/Microsoft/go-winio/.gitignore: -------------------------------------------------------------------------------- 1 | .vscode/ 2 | 3 | *.exe 4 | 5 | # testing 6 | testdata 7 | 8 | # go workspaces 9 | go.work 10 | go.work.sum 11 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/gcfg/types/doc.go: -------------------------------------------------------------------------------- 1 | // Package types defines helpers for type conversions. 2 | // 3 | // The API for this package is not finalized yet. 4 | package types 5 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/gcfg/go1_2.go: -------------------------------------------------------------------------------- 1 | // +build go1.2 2 | 3 | package gcfg 4 | 5 | import ( 6 | "encoding" 7 | ) 8 | 9 | type textUnmarshaler encoding.TextUnmarshaler 10 | -------------------------------------------------------------------------------- /vendor/github.com/muesli/termenv/constants_linux.go: -------------------------------------------------------------------------------- 1 | package termenv 2 | 3 | import "golang.org/x/sys/unix" 4 | 5 | const ( 6 | tcgetattr = unix.TCGETS 7 | tcsetattr = unix.TCSETS 8 | ) 9 | -------------------------------------------------------------------------------- /vendor/github.com/muesli/termenv/constants_solaris.go: -------------------------------------------------------------------------------- 1 | package termenv 2 | 3 | import "golang.org/x/sys/unix" 4 | 5 | const ( 6 | tcgetattr = unix.TCGETS 7 | tcsetattr = unix.TCSETS 8 | ) 9 | -------------------------------------------------------------------------------- /vendor/github.com/otiai10/copy/.gitignore: -------------------------------------------------------------------------------- 1 | test/data.copy 2 | test/owned-by-root 3 | coverage.txt 4 | vendor 5 | .vagrant 6 | .idea/ 7 | 8 | # Test Specific 9 | test/data/case16/large.file 10 | -------------------------------------------------------------------------------- /vendor/github.com/pjbgf/sha1cd/ubc/doc.go: -------------------------------------------------------------------------------- 1 | // ubc package provides ways for SHA1 blocks to be checked for 2 | // Unavoidable Bit Conditions that arise from crypto analysis attacks. 3 | package ubc 4 | -------------------------------------------------------------------------------- /vendor/github.com/Microsoft/go-winio/syscall.go: -------------------------------------------------------------------------------- 1 | //go:build windows 2 | 3 | package winio 4 | 5 | //go:generate go run github.com/Microsoft/go-winio/tools/mkwinsyscall -output zsyscall_windows.go ./*.go 6 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/gcfg/README: -------------------------------------------------------------------------------- 1 | Gcfg reads INI-style configuration files into Go structs; 2 | supports user-defined types and subsections. 3 | 4 | Package docs: https://godoc.org/gopkg.in/gcfg.v1 5 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/utils/ioutil/pipe.go: -------------------------------------------------------------------------------- 1 | // +build !js 2 | 3 | package ioutil 4 | 5 | import "io" 6 | 7 | func Pipe() (PipeReader, PipeWriter) { 8 | return io.Pipe() 9 | } 10 | -------------------------------------------------------------------------------- /vendor/github.com/cloudflare/circl/sign/ed25519/pubkey112.go: -------------------------------------------------------------------------------- 1 | //go:build !go1.13 2 | // +build !go1.13 3 | 4 | package ed25519 5 | 6 | // PublicKey is the type of Ed25519 public keys. 7 | type PublicKey []byte 8 | -------------------------------------------------------------------------------- /vendor/github.com/pjbgf/sha1cd/sha1cdblock_noasm.go: -------------------------------------------------------------------------------- 1 | //go:build !amd64 || noasm || !gc 2 | // +build !amd64 noasm !gc 3 | 4 | package sha1cd 5 | 6 | func block(dig *digest, p []byte) { 7 | blockGeneric(dig, p) 8 | } 9 | -------------------------------------------------------------------------------- /vendor/github.com/c2h5oh/datasize/.travis.yml: -------------------------------------------------------------------------------- 1 | sudo: false 2 | 3 | language: go 4 | go: 5 | - 1.4 6 | - 1.5 7 | - 1.6 8 | - 1.7 9 | - 1.8 10 | - 1.9 11 | - tip 12 | 13 | script: 14 | - go test -v 15 | -------------------------------------------------------------------------------- /vendor/github.com/ProtonMail/go-crypto/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 https://tip.golang.org/AUTHORS. 4 | -------------------------------------------------------------------------------- /vendor/github.com/otiai10/copy/preserve_owner_x.go: -------------------------------------------------------------------------------- 1 | //go:build windows || plan9 2 | // +build windows plan9 3 | 4 | package copy 5 | 6 | func preserveOwner(src, dest string, info fileInfo) (err error) { 7 | return nil 8 | } 9 | -------------------------------------------------------------------------------- /vendor/github.com/ProtonMail/go-crypto/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 https://tip.golang.org/CONTRIBUTORS. 4 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/utils/ioutil/pipe_js.go: -------------------------------------------------------------------------------- 1 | // +build js 2 | 3 | package ioutil 4 | 5 | import "github.com/acomagu/bufpipe" 6 | 7 | func Pipe() (PipeReader, PipeWriter) { 8 | return bufpipe.New(nil) 9 | } 10 | -------------------------------------------------------------------------------- /vendor/github.com/otiai10/copy/preserve_ltimes_x.go: -------------------------------------------------------------------------------- 1 | //go:build windows || js || plan9 2 | // +build windows js plan9 3 | 4 | package copy 5 | 6 | func preserveLtimes(src, dest string) error { 7 | return nil // Unsupported 8 | } 9 | -------------------------------------------------------------------------------- /vendor/github.com/alecthomas/kong/guesswidth.go: -------------------------------------------------------------------------------- 1 | // +build appengine !linux,!freebsd,!darwin,!dragonfly,!netbsd,!openbsd 2 | 3 | package kong 4 | 5 | import "io" 6 | 7 | func guessWidth(w io.Writer) int { 8 | return 80 9 | } 10 | -------------------------------------------------------------------------------- /vendor/github.com/imdario/mergo/.deepsource.toml: -------------------------------------------------------------------------------- 1 | version = 1 2 | 3 | test_patterns = [ 4 | "*_test.go" 5 | ] 6 | 7 | [[analyzers]] 8 | name = "go" 9 | enabled = true 10 | 11 | [analyzers.meta] 12 | import_path = "github.com/imdario/mergo" -------------------------------------------------------------------------------- /vendor/github.com/cli/safeexec/lookpath_1.18.go: -------------------------------------------------------------------------------- 1 | //go:build !windows && !go1.19 2 | // +build !windows,!go1.19 3 | 4 | package safeexec 5 | 6 | import "os/exec" 7 | 8 | func LookPath(file string) (string, error) { 9 | return exec.LookPath(file) 10 | } 11 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-runewidth/runewidth_appengine.go: -------------------------------------------------------------------------------- 1 | //go:build appengine 2 | // +build appengine 3 | 4 | package runewidth 5 | 6 | // IsEastAsian return true if the current locale is CJK 7 | func IsEastAsian() bool { 8 | return false 9 | } 10 | -------------------------------------------------------------------------------- /vendor/github.com/cloudflare/circl/sign/ed25519/pubkey.go: -------------------------------------------------------------------------------- 1 | //go:build go1.13 2 | // +build go1.13 3 | 4 | package ed25519 5 | 6 | import cryptoEd25519 "crypto/ed25519" 7 | 8 | // PublicKey is the type of Ed25519 public keys. 9 | type PublicKey cryptoEd25519.PublicKey 10 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/plan9/asm.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 | #include "textflag.h" 6 | 7 | TEXT ·use(SB),NOSPLIT,$0 8 | RET 9 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-runewidth/runewidth_js.go: -------------------------------------------------------------------------------- 1 | //go:build js && !appengine 2 | // +build js,!appengine 3 | 4 | package runewidth 5 | 6 | func IsEastAsian() bool { 7 | // TODO: Implement this for the web. Detect east asian in a compatible way, and return true. 8 | return false 9 | } 10 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_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 | package cpu 6 | 7 | func archInit() { 8 | doinit() 9 | Initialized = true 10 | } 11 | -------------------------------------------------------------------------------- /vendor/github.com/otiai10/copy/preserve_times.go: -------------------------------------------------------------------------------- 1 | package copy 2 | 3 | import "os" 4 | 5 | func preserveTimes(srcinfo os.FileInfo, dest string) error { 6 | spec := getTimeSpec(srcinfo) 7 | if err := os.Chtimes(dest, spec.Atime, spec.Mtime); err != nil { 8 | return err 9 | } 10 | return nil 11 | } 12 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/plumbing/storer/index.go: -------------------------------------------------------------------------------- 1 | package storer 2 | 3 | import "github.com/go-git/go-git/v5/plumbing/format/index" 4 | 5 | // IndexStorer generic storage of index.Index 6 | type IndexStorer interface { 7 | SetIndex(*index.Index) error 8 | Index() (*index.Index, error) 9 | } 10 | -------------------------------------------------------------------------------- /vendor/github.com/cli/go-gh/.golangci.yml: -------------------------------------------------------------------------------- 1 | linters: 2 | enable: 3 | - gofmt 4 | - godot 5 | 6 | linters-settings: 7 | godot: 8 | # comments to be checked: `declarations`, `toplevel`, or `all` 9 | scope: declarations 10 | # check that each sentence starts with a capital letter 11 | capital: true 12 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-billy/v5/Makefile: -------------------------------------------------------------------------------- 1 | # Go parameters 2 | GOCMD = go 3 | GOTEST = $(GOCMD) test 4 | 5 | .PHONY: test 6 | test: 7 | $(GOTEST) -race ./... 8 | 9 | test-coverage: 10 | echo "" > $(COVERAGE_REPORT); \ 11 | $(GOTEST) -coverprofile=$(COVERAGE_REPORT) -coverpkg=./... -covermode=$(COVERAGE_MODE) ./... 12 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_other_arm.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 !linux && arm 6 | // +build !linux,arm 7 | 8 | package cpu 9 | 10 | func archInit() {} 11 | -------------------------------------------------------------------------------- /vendor/github.com/cli/shurcooL-graphql/.golangci.yml: -------------------------------------------------------------------------------- 1 | linters: 2 | enable: 3 | - gofmt 4 | - godot 5 | 6 | linters-settings: 7 | godot: 8 | # comments to be checked: `declarations`, `toplevel`, or `all` 9 | scope: declarations 10 | # check that each sentence starts with a capital letter 11 | capital: true 12 | -------------------------------------------------------------------------------- /vendor/golang.org/x/tools/internal/pkgbits/flags.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 | package pkgbits 6 | 7 | const ( 8 | flagSyncMarkers = 1 << iota // file format contains sync markers 9 | ) 10 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_riscv64.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 riscv64 6 | // +build riscv64 7 | 8 | package cpu 9 | 10 | const cacheLineSize = 32 11 | 12 | func initOptions() {} 13 | -------------------------------------------------------------------------------- /.github/workflows/release.yml: -------------------------------------------------------------------------------- 1 | name: release 2 | on: 3 | push: 4 | tags: 5 | - "v*" 6 | permissions: 7 | contents: write 8 | 9 | jobs: 10 | release: 11 | runs-on: ubuntu-latest 12 | steps: 13 | - uses: actions/checkout@v2 14 | - uses: cli/gh-extension-precompile@v1 15 | with: 16 | go_version: "1.18" 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_loong64.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 loong64 6 | // +build loong64 7 | 8 | package cpu 9 | 10 | const cacheLineSize = 64 11 | 12 | func initOptions() { 13 | } 14 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_gc_arm64.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 gc 6 | // +build gc 7 | 8 | package cpu 9 | 10 | func getisar0() uint64 11 | func getisar1() uint64 12 | func getpfr0() uint64 13 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_mipsx.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 mips || mipsle 6 | // +build mips mipsle 7 | 8 | package cpu 9 | 10 | const cacheLineSize = 32 11 | 12 | func initOptions() {} 13 | -------------------------------------------------------------------------------- /vendor/golang.org/x/tools/internal/event/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 event provides a set of packages that cover the main 6 | // concepts of telemetry in an implementation agnostic way. 7 | package event 8 | -------------------------------------------------------------------------------- /vendor/github.com/cli/go-gh/pkg/term/console.go: -------------------------------------------------------------------------------- 1 | //go:build !windows 2 | // +build !windows 3 | 4 | package term 5 | 6 | import ( 7 | "errors" 8 | "os" 9 | ) 10 | 11 | func enableVirtualTerminalProcessing(f *os.File) error { 12 | return errors.New("not implemented") 13 | } 14 | 15 | func openTTY() (*os.File, error) { 16 | return os.Open("/dev/tty") 17 | } 18 | -------------------------------------------------------------------------------- /vendor/github.com/imdario/mergo/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | arch: 3 | - amd64 4 | - ppc64le 5 | install: 6 | - go get -t 7 | - go get golang.org/x/tools/cmd/cover 8 | - go get github.com/mattn/goveralls 9 | script: 10 | - go test -race -v ./... 11 | after_script: 12 | - $HOME/gopath/bin/goveralls -service=travis-ci -repotoken $COVERALLS_TOKEN 13 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-isatty/go.test.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | set -e 4 | echo "" > coverage.txt 5 | 6 | for d in $(go list ./... | grep -v vendor); do 7 | go test -race -coverprofile=profile.out -covermode=atomic "$d" 8 | if [ -f profile.out ]; then 9 | cat profile.out >> coverage.txt 10 | rm profile.out 11 | fi 12 | done 13 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_other_arm64.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 !linux && !netbsd && !openbsd && arm64 6 | // +build !linux,!netbsd,!openbsd,arm64 7 | 8 | package cpu 9 | 10 | func doinit() {} 11 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_other_riscv64.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 && riscv64 6 | // +build !linux,riscv64 7 | 8 | package cpu 9 | 10 | func archInit() { 11 | Initialized = true 12 | } 13 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-colorable/go.test.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | set -e 4 | echo "" > coverage.txt 5 | 6 | for d in $(go list ./... | grep -v vendor); do 7 | go test -race -coverprofile=profile.out -covermode=atomic "$d" 8 | if [ -f profile.out ]; then 9 | cat profile.out >> coverage.txt 10 | rm profile.out 11 | fi 12 | done 13 | -------------------------------------------------------------------------------- /vendor/github.com/muesli/termenv/.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/github.com/pjbgf/sha1cd/detection.go: -------------------------------------------------------------------------------- 1 | package sha1cd 2 | 3 | import "hash" 4 | 5 | type CollisionResistantHash interface { 6 | // CollisionResistantSum extends on Sum by returning an additional boolean 7 | // which indicates whether a collision was found during the hashing process. 8 | CollisionResistantSum(b []byte) ([]byte, bool) 9 | 10 | hash.Hash 11 | } 12 | -------------------------------------------------------------------------------- /vendor/github.com/cli/safeexec/lookpath.go: -------------------------------------------------------------------------------- 1 | //go:build !windows && go1.19 2 | // +build !windows,go1.19 3 | 4 | package safeexec 5 | 6 | import ( 7 | "errors" 8 | "os/exec" 9 | ) 10 | 11 | func LookPath(file string) (string, error) { 12 | path, err := exec.LookPath(file) 13 | if errors.Is(err, exec.ErrDot) { 14 | return path, nil 15 | } 16 | return path, err 17 | } 18 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/plumbing/revision.go: -------------------------------------------------------------------------------- 1 | package plumbing 2 | 3 | // Revision represents a git revision 4 | // to get more details about git revisions 5 | // please check git manual page : 6 | // https://www.kernel.org/pub/software/scm/git/docs/gitrevisions.html 7 | type Revision string 8 | 9 | func (r Revision) String() string { 10 | return string(r) 11 | } 12 | -------------------------------------------------------------------------------- /vendor/github.com/alecthomas/kong/error.go: -------------------------------------------------------------------------------- 1 | package kong 2 | 3 | // ParseError is the error type returned by Kong.Parse(). 4 | // 5 | // It contains the parse Context that triggered the error. 6 | type ParseError struct { 7 | error 8 | Context *Context 9 | } 10 | 11 | // Unwrap returns the original cause of the error. 12 | func (p *ParseError) Unwrap() error { return p.error } 13 | -------------------------------------------------------------------------------- /vendor/golang.org/x/tools/internal/gcimporter/unified_yes.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.18 && goexperiment.unified 6 | // +build go1.18,goexperiment.unified 7 | 8 | package gcimporter 9 | 10 | const unifiedIR = true 11 | -------------------------------------------------------------------------------- /vendor/github.com/muesli/termenv/notification.go: -------------------------------------------------------------------------------- 1 | package termenv 2 | 3 | // Notify triggers a notification using OSC777. 4 | func Notify(title, body string) { 5 | output.Notify(title, body) 6 | } 7 | 8 | // Notify triggers a notification using OSC777. 9 | func (o *Output) Notify(title, body string) { 10 | _, _ = o.WriteString(OSC + "777;notify;" + title + ";" + body + ST) 11 | } 12 | -------------------------------------------------------------------------------- /vendor/golang.org/x/tools/internal/gcimporter/unified_no.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.18 && goexperiment.unified) 6 | // +build !go1.18 !goexperiment.unified 7 | 8 | package gcimporter 9 | 10 | const unifiedIR = false 11 | -------------------------------------------------------------------------------- /vendor/github.com/muesli/termenv/constants_unix.go: -------------------------------------------------------------------------------- 1 | //go:build (darwin || dragonfly || freebsd || netbsd || openbsd) && !solaris && !illumos 2 | // +build darwin dragonfly freebsd netbsd openbsd 3 | // +build !solaris 4 | // +build !illumos 5 | 6 | package termenv 7 | 8 | import "golang.org/x/sys/unix" 9 | 10 | const ( 11 | tcgetattr = unix.TIOCGETA 12 | tcsetattr = unix.TIOCSETA 13 | ) 14 | -------------------------------------------------------------------------------- /vendor/github.com/muesli/termenv/hyperlink.go: -------------------------------------------------------------------------------- 1 | package termenv 2 | 3 | // Hyperlink creates a hyperlink using OSC8. 4 | func Hyperlink(link, name string) string { 5 | return output.Hyperlink(link, name) 6 | } 7 | 8 | // Hyperlink creates a hyperlink using OSC8. 9 | func (o *Output) Hyperlink(link, name string) string { 10 | return OSC + "8;;" + link + ST + name + OSC + "8;;" + ST 11 | } 12 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_other_mips64x.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 !linux && (mips64 || mips64le) 6 | // +build !linux 7 | // +build mips64 mips64le 8 | 9 | package cpu 10 | 11 | func archInit() { 12 | Initialized = true 13 | } 14 | -------------------------------------------------------------------------------- /vendor/github.com/otiai10/copy/stat_times_x.go: -------------------------------------------------------------------------------- 1 | //go:build plan9 || netbsd 2 | // +build plan9 netbsd 3 | 4 | package copy 5 | 6 | import ( 7 | "os" 8 | ) 9 | 10 | // TODO: check plan9 netbsd in future 11 | func getTimeSpec(info os.FileInfo) timespec { 12 | times := timespec{ 13 | Mtime: info.ModTime(), 14 | Atime: info.ModTime(), 15 | Ctime: info.ModTime(), 16 | } 17 | return times 18 | } 19 | -------------------------------------------------------------------------------- /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 | // +build !go1.12 7 | 8 | // This file is here to allow bodyless functions with go:linkname for Go 1.11 9 | // and earlier (see https://golang.org/issue/23311). 10 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/internal/poly1305/mac_noasm.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 (!amd64 && !ppc64le && !s390x) || !gc || purego 6 | // +build !amd64,!ppc64le,!s390x !gc purego 7 | 8 | package poly1305 9 | 10 | type mac struct{ macGeneric } 11 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_gccgo_arm64.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 gccgo 6 | // +build gccgo 7 | 8 | package cpu 9 | 10 | func getisar0() uint64 { return 0 } 11 | func getisar1() uint64 { return 0 } 12 | func getpfr0() uint64 { return 0 } 13 | -------------------------------------------------------------------------------- /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 | // +build windows,go1.9 7 | 8 | package windows 9 | 10 | import "syscall" 11 | 12 | type Errno = syscall.Errno 13 | type SysProcAttr = syscall.SysProcAttr 14 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/registry/mksyscall.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 generate 6 | // +build generate 7 | 8 | package registry 9 | 10 | //go:generate go run golang.org/x/sys/windows/mkwinsyscall -output zsyscall_windows.go syscall.go 11 | -------------------------------------------------------------------------------- /vendor/github.com/c2h5oh/datasize/.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/go-git/go-git/v5/plumbing/storer/shallow.go: -------------------------------------------------------------------------------- 1 | package storer 2 | 3 | import "github.com/go-git/go-git/v5/plumbing" 4 | 5 | // ShallowStorer is a storage of references to shallow commits by hash, 6 | // meaning that these commits have missing parents because of a shallow fetch. 7 | type ShallowStorer interface { 8 | SetShallow([]plumbing.Hash) error 9 | Shallow() ([]plumbing.Hash, error) 10 | } 11 | -------------------------------------------------------------------------------- /vendor/github.com/xanzy/ssh-agent/.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/alecthomas/kong/global.go: -------------------------------------------------------------------------------- 1 | package kong 2 | 3 | import ( 4 | "os" 5 | ) 6 | 7 | // Parse constructs a new parser and parses the default command-line. 8 | func Parse(cli interface{}, options ...Option) *Context { 9 | parser, err := New(cli, options...) 10 | if err != nil { 11 | panic(err) 12 | } 13 | ctx, err := parser.Parse(os.Args[1:]) 14 | parser.FatalIfErrorf(err) 15 | return ctx 16 | } 17 | -------------------------------------------------------------------------------- /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 | // +build amd64,linux,gc 7 | 8 | package unix 9 | 10 | import "syscall" 11 | 12 | //go:noescape 13 | func gettimeofday(tv *Timeval) (err syscall.Errno) 14 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_linux_noinit.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 linux && !arm && !arm64 && !mips64 && !mips64le && !ppc64 && !ppc64le && !s390x 6 | // +build linux,!arm,!arm64,!mips64,!mips64le,!ppc64,!ppc64le,!s390x 7 | 8 | package cpu 9 | 10 | func doinit() {} 11 | -------------------------------------------------------------------------------- /vendor/github.com/kevinburke/ssh_config/AUTHORS.txt: -------------------------------------------------------------------------------- 1 | Carlos A Becker 2 | Dustin Spicuzza 3 | Eugene Terentev 4 | Kevin Burke 5 | Mark Nevill 6 | Scott Lessans 7 | Sergey Lukjanov 8 | Wayne Ashley Berry 9 | santosh653 <70637961+santosh653@users.noreply.github.com> 10 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/curve25519/internal/field/README: -------------------------------------------------------------------------------- 1 | This package is kept in sync with crypto/ed25519/internal/edwards25519/field in 2 | the standard library. 3 | 4 | If there are any changes in the standard library that need to be synced to this 5 | package, run sync.sh. It will not overwrite any local changes made since the 6 | previous sync, so it's ok to land changes in this package first, and then sync 7 | to the standard library later. 8 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/curve25519/internal/field/fe_arm64_noasm.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 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 !arm64 || !gc || purego 6 | // +build !arm64 !gc purego 7 | 8 | package field 9 | 10 | func (v *Element) carryPropagate() *Element { 11 | return v.carryPropagateGeneric() 12 | } 13 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/sha3/keccakf_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 amd64 && !purego && gc 6 | // +build amd64,!purego,gc 7 | 8 | package sha3 9 | 10 | // This function is implemented in keccakf_amd64.s. 11 | 12 | //go:noescape 13 | 14 | func keccakF1600(a *[25]uint64) 15 | -------------------------------------------------------------------------------- /vendor/golang.org/x/tools/internal/typeparams/enabled_go117.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 !go1.18 6 | // +build !go1.18 7 | 8 | package typeparams 9 | 10 | // Enabled reports whether type parameters are enabled in the current build 11 | // environment. 12 | const Enabled = false 13 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/internal/revision/token.go: -------------------------------------------------------------------------------- 1 | package revision 2 | 3 | // token represents a entity extracted from string parsing 4 | type token int 5 | 6 | const ( 7 | eof token = iota 8 | 9 | aslash 10 | asterisk 11 | at 12 | caret 13 | cbrace 14 | colon 15 | control 16 | dot 17 | emark 18 | minus 19 | number 20 | obrace 21 | obracket 22 | qmark 23 | slash 24 | space 25 | tilde 26 | tokenError 27 | word 28 | ) 29 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_other_ppc64x.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 !aix && !linux && (ppc64 || ppc64le) 6 | // +build !aix 7 | // +build !linux 8 | // +build ppc64 ppc64le 9 | 10 | package cpu 11 | 12 | func archInit() { 13 | PPC64.IsPOWER8 = true 14 | Initialized = true 15 | } 16 | -------------------------------------------------------------------------------- /vendor/golang.org/x/term/term_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 aix || linux || solaris || zos 6 | // +build aix linux solaris zos 7 | 8 | package term 9 | 10 | import "golang.org/x/sys/unix" 11 | 12 | const ioctlReadTermios = unix.TCGETS 13 | const ioctlWriteTermios = unix.TCSETS 14 | -------------------------------------------------------------------------------- /vendor/github.com/muesli/termenv/termenv_posix.go: -------------------------------------------------------------------------------- 1 | //go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd 2 | // +build darwin dragonfly freebsd linux netbsd openbsd 3 | 4 | package termenv 5 | 6 | import ( 7 | "golang.org/x/sys/unix" 8 | ) 9 | 10 | func isForeground(fd int) bool { 11 | pgrp, err := unix.IoctlGetInt(fd, unix.TIOCGPGRP) 12 | if err != nil { 13 | return false 14 | } 15 | 16 | return pgrp == unix.Getpgrp() 17 | } 18 | -------------------------------------------------------------------------------- /vendor/github.com/otiai10/copy/copy_namedpipes_x.go: -------------------------------------------------------------------------------- 1 | //go:build windows || plan9 || netbsd || aix || illumos || solaris || js 2 | // +build windows plan9 netbsd aix illumos solaris js 3 | 4 | package copy 5 | 6 | import ( 7 | "os" 8 | ) 9 | 10 | // TODO: check plan9 netbsd aix illumos solaris in future 11 | 12 | // pcopy is for just named pipes. Windows doesn't support them 13 | func pcopy(dest string, info os.FileInfo) error { 14 | return nil 15 | } 16 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_mips64x.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 mips64 || mips64le 6 | // +build mips64 mips64le 7 | 8 | package cpu 9 | 10 | const cacheLineSize = 32 11 | 12 | func initOptions() { 13 | options = []option{ 14 | {Name: "msa", Feature: &MIPS64X.HasMSA}, 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /vendor/github.com/muesli/termenv/termenv_solaris.go: -------------------------------------------------------------------------------- 1 | //go:build solaris || illumos 2 | // +build solaris illumos 3 | 4 | package termenv 5 | 6 | import ( 7 | "golang.org/x/sys/unix" 8 | ) 9 | 10 | func isForeground(fd int) bool { 11 | pgrp, err := unix.IoctlGetInt(fd, unix.TIOCGPGRP) 12 | if err != nil { 13 | return false 14 | } 15 | 16 | g, err := unix.Getpgrp() 17 | if err != nil { 18 | return false 19 | } 20 | 21 | return pgrp == g 22 | } 23 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_openbsd_arm64.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 | #include "textflag.h" 6 | 7 | TEXT libc_sysctl_trampoline<>(SB),NOSPLIT,$0-0 8 | JMP libc_sysctl(SB) 9 | 10 | GLOBL ·libc_sysctl_trampoline_addr(SB), RODATA, $8 11 | DATA ·libc_sysctl_trampoline_addr(SB)/8, $libc_sysctl_trampoline<>(SB) 12 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_linux.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 !386 && !amd64 && !amd64p32 && !arm64 6 | // +build !386,!amd64,!amd64p32,!arm64 7 | 8 | package cpu 9 | 10 | func archInit() { 11 | if err := readHWCAP(); err != nil { 12 | return 13 | } 14 | doinit() 15 | Initialized = true 16 | } 17 | -------------------------------------------------------------------------------- /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 | // +build generate 7 | 8 | package windows 9 | 10 | //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 11 | -------------------------------------------------------------------------------- /vendor/golang.org/x/tools/internal/gcimporter/support_go117.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 !go1.18 6 | // +build !go1.18 7 | 8 | package gcimporter 9 | 10 | import "go/types" 11 | 12 | const iexportVersion = iexportVersionGo1_11 13 | 14 | func additionalPredeclared() []types.Type { 15 | return nil 16 | } 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/tools/internal/pkgbits/support.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 | package pkgbits 6 | 7 | import "fmt" 8 | 9 | func assert(b bool) { 10 | if !b { 11 | panic("assertion failed") 12 | } 13 | } 14 | 15 | func errorf(format string, args ...interface{}) { 16 | panic(fmt.Errorf(format, args...)) 17 | } 18 | -------------------------------------------------------------------------------- /vendor/github.com/cloudflare/circl/dh/x448/curve_noasm.go: -------------------------------------------------------------------------------- 1 | //go:build !amd64 || purego 2 | // +build !amd64 purego 3 | 4 | package x448 5 | 6 | import fp "github.com/cloudflare/circl/math/fp448" 7 | 8 | func double(x, z *fp.Elt) { doubleGeneric(x, z) } 9 | func diffAdd(w *[5]fp.Elt, b uint) { diffAddGeneric(w, b) } 10 | func ladderStep(w *[5]fp.Elt, b uint) { ladderStepGeneric(w, b) } 11 | func mulA24(z, x *fp.Elt) { mulA24Generic(z, x) } 12 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/curve25519/internal/field/fe_amd64_noasm.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 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 !amd64 || !gc || purego 6 | // +build !amd64 !gc purego 7 | 8 | package field 9 | 10 | func feMul(v, x, y *Element) { feMulGeneric(v, x, y) } 11 | 12 | func feSquare(v, x *Element) { feSquareGeneric(v, x) } 13 | -------------------------------------------------------------------------------- /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 | // +build !go1.19 7 | 8 | package execabs 9 | 10 | import "os/exec" 11 | 12 | func isGo119ErrDot(err error) bool { 13 | return false 14 | } 15 | 16 | func isGo119ErrFieldSet(cmd *exec.Cmd) bool { 17 | return false 18 | } 19 | -------------------------------------------------------------------------------- /vendor/github.com/cloudflare/circl/dh/x25519/curve_noasm.go: -------------------------------------------------------------------------------- 1 | //go:build !amd64 || purego 2 | // +build !amd64 purego 3 | 4 | package x25519 5 | 6 | import fp "github.com/cloudflare/circl/math/fp25519" 7 | 8 | func double(x, z *fp.Elt) { doubleGeneric(x, z) } 9 | func diffAdd(w *[5]fp.Elt, b uint) { diffAddGeneric(w, b) } 10 | func ladderStep(w *[5]fp.Elt, b uint) { ladderStepGeneric(w, b) } 11 | func mulA24(z, x *fp.Elt) { mulA24Generic(z, x) } 12 | -------------------------------------------------------------------------------- /vendor/github.com/cloudflare/circl/internal/sha3/keccakf_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 amd64 && !appengine && !gccgo 6 | // +build amd64,!appengine,!gccgo 7 | 8 | package sha3 9 | 10 | // This function is implemented in keccakf_amd64.s. 11 | 12 | //go:noescape 13 | 14 | func KeccakF1600(state *[25]uint64) 15 | -------------------------------------------------------------------------------- /vendor/github.com/otiai10/copy/stat_times_js.go: -------------------------------------------------------------------------------- 1 | //go:build js 2 | // +build js 3 | 4 | package copy 5 | 6 | import ( 7 | "os" 8 | "syscall" 9 | "time" 10 | ) 11 | 12 | func getTimeSpec(info os.FileInfo) timespec { 13 | stat := info.Sys().(*syscall.Stat_t) 14 | times := timespec{ 15 | Mtime: info.ModTime(), 16 | Atime: time.Unix(int64(stat.Atime), int64(stat.AtimeNsec)), 17 | Ctime: time.Unix(int64(stat.Ctime), int64(stat.CtimeNsec)), 18 | } 19 | return times 20 | } 21 | -------------------------------------------------------------------------------- /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 | // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris zos 7 | 8 | package unix 9 | 10 | const ( 11 | R_OK = 0x4 12 | W_OK = 0x2 13 | X_OK = 0x1 14 | ) 15 | -------------------------------------------------------------------------------- /vendor/golang.org/x/term/term_unix_bsd.go: -------------------------------------------------------------------------------- 1 | // Copyright 2013 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 6 | // +build darwin dragonfly freebsd netbsd openbsd 7 | 8 | package term 9 | 10 | import "golang.org/x/sys/unix" 11 | 12 | const ioctlReadTermios = unix.TIOCGETA 13 | const ioctlWriteTermios = unix.TIOCSETA 14 | -------------------------------------------------------------------------------- /vendor/golang.org/x/tools/internal/gcimporter/newInterface11.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 go1.11 6 | // +build go1.11 7 | 8 | package gcimporter 9 | 10 | import "go/types" 11 | 12 | func newInterface(methods []*types.Func, embeddeds []types.Type) *types.Interface { 13 | return types.NewInterfaceType(methods, embeddeds) 14 | } 15 | -------------------------------------------------------------------------------- /vendor/github.com/otiai10/copy/stat_times_darwin.go: -------------------------------------------------------------------------------- 1 | //go:build darwin 2 | // +build darwin 3 | 4 | package copy 5 | 6 | import ( 7 | "os" 8 | "syscall" 9 | "time" 10 | ) 11 | 12 | func getTimeSpec(info os.FileInfo) timespec { 13 | stat := info.Sys().(*syscall.Stat_t) 14 | times := timespec{ 15 | Mtime: info.ModTime(), 16 | Atime: time.Unix(stat.Atimespec.Sec, stat.Atimespec.Nsec), 17 | Ctime: time.Unix(stat.Ctimespec.Sec, stat.Ctimespec.Nsec), 18 | } 19 | return times 20 | } 21 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/curve25519/internal/field/fe_arm64.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 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 arm64 && gc && !purego 6 | // +build arm64,gc,!purego 7 | 8 | package field 9 | 10 | //go:noescape 11 | func carryPropagate(v *Element) 12 | 13 | func (v *Element) carryPropagate() *Element { 14 | carryPropagate(v) 15 | return v 16 | } 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_ppc64x.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 ppc64 || ppc64le 6 | // +build ppc64 ppc64le 7 | 8 | package cpu 9 | 10 | const cacheLineSize = 128 11 | 12 | func initOptions() { 13 | options = []option{ 14 | {Name: "darn", Feature: &PPC64.HasDARN}, 15 | {Name: "scv", Feature: &PPC64.HasSCV}, 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/runtime_auxv.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 | package cpu 6 | 7 | // getAuxvFn is non-nil on Go 1.21+ (via runtime_auxv_go121.go init) 8 | // on platforms that use auxv. 9 | var getAuxvFn func() []uintptr 10 | 11 | func getAuxv() []uintptr { 12 | if getAuxvFn == nil { 13 | return nil 14 | } 15 | return getAuxvFn() 16 | } 17 | -------------------------------------------------------------------------------- /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 | // +build armbe arm64be m68k mips mips64 mips64p32 ppc ppc64 s390 s390x shbe sparc sparc64 7 | 8 | package unix 9 | 10 | const isBigEndian = true 11 | -------------------------------------------------------------------------------- /vendor/github.com/otiai10/copy/test_setup_x.go: -------------------------------------------------------------------------------- 1 | //go:build windows || plan9 || netbsd || aix || illumos || solaris || js 2 | // +build windows plan9 netbsd aix illumos solaris js 3 | 4 | package copy 5 | 6 | import ( 7 | "os" 8 | "testing" 9 | ) 10 | 11 | func setup(m *testing.M) { 12 | os.MkdirAll("test/data.copy", os.ModePerm) 13 | os.Symlink("test/data/case01", "test/data/case03/case01") 14 | os.Chmod("test/data/case07/dir_0555", 0555) 15 | os.Chmod("test/data/case07/file_0444", 0444) 16 | } 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/runtime_auxv_go121.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 go1.21 6 | // +build go1.21 7 | 8 | package cpu 9 | 10 | import ( 11 | _ "unsafe" // for linkname 12 | ) 13 | 14 | //go:linkname runtime_getAuxv runtime.getAuxv 15 | func runtime_getAuxv() []uintptr 16 | 17 | func init() { 18 | getAuxvFn = runtime_getAuxv 19 | } 20 | -------------------------------------------------------------------------------- /vendor/golang.org/x/tools/internal/typesinternal/types_118.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 go1.18 6 | // +build go1.18 7 | 8 | package typesinternal 9 | 10 | import ( 11 | "go/types" 12 | ) 13 | 14 | func init() { 15 | SetGoVersion = func(conf *types.Config, version string) bool { 16 | conf.GoVersion = version 17 | return true 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /vendor/github.com/otiai10/copy/stat_times_windows.go: -------------------------------------------------------------------------------- 1 | //go:build windows 2 | // +build windows 3 | 4 | package copy 5 | 6 | import ( 7 | "os" 8 | "syscall" 9 | "time" 10 | ) 11 | 12 | func getTimeSpec(info os.FileInfo) timespec { 13 | stat := info.Sys().(*syscall.Win32FileAttributeData) 14 | return timespec{ 15 | Mtime: time.Unix(0, stat.LastWriteTime.Nanoseconds()), 16 | Atime: time.Unix(0, stat.LastAccessTime.Nanoseconds()), 17 | Ctime: time.Unix(0, stat.CreationTime.Nanoseconds()), 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /vendor/github.com/otiai10/copy/preserve_ltimes.go: -------------------------------------------------------------------------------- 1 | //go:build !windows && !plan9 && !js 2 | // +build !windows,!plan9,!js 3 | 4 | package copy 5 | 6 | import ( 7 | "golang.org/x/sys/unix" 8 | ) 9 | 10 | func preserveLtimes(src, dest string) error { 11 | info := new(unix.Stat_t) 12 | if err := unix.Lstat(src, info); err != nil { 13 | return err 14 | } 15 | 16 | return unix.Lutimes(dest, []unix.Timeval{ 17 | unix.NsecToTimeval(info.Atim.Nano()), 18 | unix.NsecToTimeval(info.Mtim.Nano()), 19 | }) 20 | } 21 | -------------------------------------------------------------------------------- /vendor/github.com/otiai10/copy/stat_times_freebsd.go: -------------------------------------------------------------------------------- 1 | //go:build freebsd 2 | // +build freebsd 3 | 4 | package copy 5 | 6 | import ( 7 | "os" 8 | "syscall" 9 | "time" 10 | ) 11 | 12 | func getTimeSpec(info os.FileInfo) timespec { 13 | stat := info.Sys().(*syscall.Stat_t) 14 | times := timespec{ 15 | Mtime: info.ModTime(), 16 | Atime: time.Unix(int64(stat.Atimespec.Sec), int64(stat.Atimespec.Nsec)), 17 | Ctime: time.Unix(int64(stat.Ctimespec.Sec), int64(stat.Ctimespec.Nsec)), 18 | } 19 | return times 20 | } 21 | -------------------------------------------------------------------------------- /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 | // +build darwin,!ios 7 | 8 | package unix 9 | 10 | // SysvShmCtl performs control operations on the shared memory segment 11 | // specified by id. 12 | func SysvShmCtl(id, cmd int, desc *SysvShmDesc) (result int, err error) { 13 | return shmctl(id, cmd, desc) 14 | } 15 | -------------------------------------------------------------------------------- /vendor/github.com/Microsoft/go-winio/pkg/guid/guid_windows.go: -------------------------------------------------------------------------------- 1 | //go:build windows 2 | // +build windows 3 | 4 | package guid 5 | 6 | import "golang.org/x/sys/windows" 7 | 8 | // GUID represents a GUID/UUID. It has the same structure as 9 | // golang.org/x/sys/windows.GUID so that it can be used with functions expecting 10 | // that type. It is defined as its own type so that stringification and 11 | // marshaling can be supported. The representation matches that used by native 12 | // Windows code. 13 | type GUID windows.GUID 14 | -------------------------------------------------------------------------------- /vendor/github.com/alecthomas/kong/defaults.go: -------------------------------------------------------------------------------- 1 | package kong 2 | 3 | // ApplyDefaults if they are not already set. 4 | func ApplyDefaults(target interface{}, options ...Option) error { 5 | app, err := New(target, options...) 6 | if err != nil { 7 | return err 8 | } 9 | ctx, err := Trace(app, nil) 10 | if err != nil { 11 | return err 12 | } 13 | err = ctx.Resolve() 14 | if err != nil { 15 | return err 16 | } 17 | if err = ctx.ApplyDefaults(); err != nil { 18 | return err 19 | } 20 | return ctx.Validate() 21 | } 22 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/plumbing/storer/storer.go: -------------------------------------------------------------------------------- 1 | package storer 2 | 3 | // Storer is a basic storer for encoded objects and references. 4 | type Storer interface { 5 | EncodedObjectStorer 6 | ReferenceStorer 7 | } 8 | 9 | // Initializer should be implemented by storers that require to perform any 10 | // operation when creating a new repository (i.e. git init). 11 | type Initializer interface { 12 | // Init performs initialization of the storer and returns the error, if 13 | // any. 14 | Init() error 15 | } 16 | -------------------------------------------------------------------------------- /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 | // +build go1.19 7 | 8 | package execabs 9 | 10 | import ( 11 | "errors" 12 | "os/exec" 13 | ) 14 | 15 | func isGo119ErrDot(err error) bool { 16 | return errors.Is(err, exec.ErrDot) 17 | } 18 | 19 | func isGo119ErrFieldSet(cmd *exec.Cmd) bool { 20 | return cmd.Err != nil 21 | } 22 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/plan9/pwd_go15_plan9.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 go1.5 6 | // +build go1.5 7 | 8 | package plan9 9 | 10 | import "syscall" 11 | 12 | func fixwd() { 13 | syscall.Fixwd() 14 | } 15 | 16 | func Getwd() (wd string, err error) { 17 | return syscall.Getwd() 18 | } 19 | 20 | func Chdir(path string) error { 21 | return syscall.Chdir(path) 22 | } 23 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/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 | // +build gc 7 | 8 | #include "textflag.h" 9 | 10 | // 11 | // System calls for ppc64, AIX are implemented in runtime/syscall_aix.go 12 | // 13 | 14 | TEXT ·syscall6(SB),NOSPLIT,$0-88 15 | JMP syscall·syscall6(SB) 16 | 17 | TEXT ·rawSyscall6(SB),NOSPLIT,$0-88 18 | JMP syscall·rawSyscall6(SB) 19 | -------------------------------------------------------------------------------- /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 | // +build gc 7 | 8 | #include "textflag.h" 9 | 10 | // 11 | // System calls for ppc64, AIX are implemented in runtime/syscall_aix.go 12 | // 13 | 14 | TEXT ·syscall6(SB),NOSPLIT,$0-88 15 | JMP syscall·syscall6(SB) 16 | 17 | TEXT ·rawSyscall6(SB),NOSPLIT,$0-88 18 | JMP syscall·rawSyscall6(SB) 19 | -------------------------------------------------------------------------------- /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 | // +build ios 7 | 8 | package unix 9 | 10 | import "unsafe" 11 | 12 | func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) { 13 | return ENOTSUP 14 | } 15 | 16 | func ptracePtr(request int, pid int, addr uintptr, data unsafe.Pointer) (err error) { 17 | return ENOTSUP 18 | } 19 | -------------------------------------------------------------------------------- /vendor/github.com/cli/go-gh/internal/repository/repository.go: -------------------------------------------------------------------------------- 1 | package repository 2 | 3 | func New(host, owner, name string) repo { 4 | return repo{host: host, owner: owner, name: name} 5 | } 6 | 7 | // Implements repository.Repository interface. 8 | type repo struct { 9 | host string 10 | owner string 11 | name string 12 | } 13 | 14 | func (r repo) Host() string { 15 | return r.host 16 | } 17 | 18 | func (r repo) Owner() string { 19 | return r.owner 20 | } 21 | 22 | func (r repo) Name() string { 23 | return r.name 24 | } 25 | -------------------------------------------------------------------------------- /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 | // +build arm,gc,linux 7 | 8 | package unix 9 | 10 | import "syscall" 11 | 12 | // Underlying system call writes to newoffset via pointer. 13 | // Implemented in assembly to avoid allocation. 14 | func seek(fd int, offset int64, whence int) (newoffset int64, err syscall.Errno) 15 | -------------------------------------------------------------------------------- /vendor/github.com/cloudflare/circl/internal/sha3/xor.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 (!amd64 && !386 && !ppc64le) || appengine 6 | // +build !amd64,!386,!ppc64le appengine 7 | 8 | package sha3 9 | 10 | // A storageBuf is an aligned array of maxRate bytes. 11 | type storageBuf [maxRate]byte 12 | 13 | func (b *storageBuf) asBytes() *[maxRate]byte { 14 | return (*[maxRate]byte)(b) 15 | } 16 | -------------------------------------------------------------------------------- /vendor/github.com/otiai10/copy/copy_namedpipes.go: -------------------------------------------------------------------------------- 1 | //go:build !windows && !plan9 && !netbsd && !aix && !illumos && !solaris && !js 2 | // +build !windows,!plan9,!netbsd,!aix,!illumos,!solaris,!js 3 | 4 | package copy 5 | 6 | import ( 7 | "os" 8 | "path/filepath" 9 | "syscall" 10 | ) 11 | 12 | // pcopy is for just named pipes 13 | func pcopy(dest string, info os.FileInfo) error { 14 | if err := os.MkdirAll(filepath.Dir(dest), os.ModePerm); err != nil { 15 | return err 16 | } 17 | return syscall.Mkfifo(dest, uint32(info.Mode())) 18 | } 19 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/chacha20/chacha_noasm.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 (!arm64 && !s390x && !ppc64le) || (arm64 && !go1.11) || !gc || purego 6 | // +build !arm64,!s390x,!ppc64le arm64,!go1.11 !gc purego 7 | 8 | package chacha20 9 | 10 | const bufSize = blockSize 11 | 12 | func (s *Cipher) xorKeyStreamBlocks(dst, src []byte) { 13 | s.xorKeyStreamBlocksGeneric(dst, src) 14 | } 15 | -------------------------------------------------------------------------------- /vendor/github.com/cloudflare/circl/math/fp448/fp_noasm.go: -------------------------------------------------------------------------------- 1 | //go:build !amd64 || purego 2 | // +build !amd64 purego 3 | 4 | package fp448 5 | 6 | func cmov(x, y *Elt, n uint) { cmovGeneric(x, y, n) } 7 | func cswap(x, y *Elt, n uint) { cswapGeneric(x, y, n) } 8 | func add(z, x, y *Elt) { addGeneric(z, x, y) } 9 | func sub(z, x, y *Elt) { subGeneric(z, x, y) } 10 | func addsub(x, y *Elt) { addsubGeneric(x, y) } 11 | func mul(z, x, y *Elt) { mulGeneric(z, x, y) } 12 | func sqr(z, x *Elt) { sqrGeneric(z, x) } 13 | -------------------------------------------------------------------------------- /vendor/github.com/henvic/httpretty/.gitignore: -------------------------------------------------------------------------------- 1 | # Docs 2 | doc/*.md 3 | doc/*.1 4 | 5 | # Compiled Object files, Static and Dynamic libs (Shared Objects) 6 | *.o 7 | *.a 8 | *.so 9 | 10 | # Folders 11 | _obj 12 | _test 13 | 14 | # Architecture specific extensions/prefixes 15 | *.[568vq] 16 | [568vq].out 17 | 18 | *.cgo1.go 19 | *.cgo2.c 20 | _cgo_defun.c 21 | _cgo_gotypes.go 22 | _cgo_export.* 23 | 24 | _testmain.go 25 | 26 | *.exe 27 | *.test 28 | *.prof 29 | 30 | .cover 31 | 32 | coverage.html 33 | coverage.out 34 | 35 | *.coverprofile 36 | -------------------------------------------------------------------------------- /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 | // +build 386 amd64 amd64p32 alpha arm arm64 loong64 mipsle mips64le mips64p32le nios2 ppc64le riscv riscv64 sh 7 | 8 | package unix 9 | 10 | const isBigEndian = false 11 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/doc.go: -------------------------------------------------------------------------------- 1 | // A highly extensible git implementation in pure Go. 2 | // 3 | // go-git aims to reach the completeness of libgit2 or jgit, nowadays covers the 4 | // majority of the plumbing read operations and some of the main write 5 | // operations, but lacks the main porcelain operations such as merges. 6 | // 7 | // It is highly extensible, we have been following the open/close principle in 8 | // its design to facilitate extensions, mainly focusing the efforts on the 9 | // persistence of the objects. 10 | package git 11 | -------------------------------------------------------------------------------- /vendor/github.com/otiai10/copy/preserve_owner.go: -------------------------------------------------------------------------------- 1 | //go:build !windows && !plan9 2 | // +build !windows,!plan9 3 | 4 | package copy 5 | 6 | import ( 7 | "os" 8 | "syscall" 9 | ) 10 | 11 | func preserveOwner(src, dest string, info fileInfo) (err error) { 12 | if info == nil { 13 | if info, err = os.Stat(src); err != nil { 14 | return err 15 | } 16 | } 17 | if stat, ok := info.Sys().(*syscall.Stat_t); ok { 18 | if err := os.Chown(dest, int(stat.Uid), int(stat.Gid)); err != nil { 19 | return err 20 | } 21 | } 22 | return nil 23 | } 24 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/sha3/register.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 go1.4 6 | // +build go1.4 7 | 8 | package sha3 9 | 10 | import ( 11 | "crypto" 12 | ) 13 | 14 | func init() { 15 | crypto.RegisterHash(crypto.SHA3_224, New224) 16 | crypto.RegisterHash(crypto.SHA3_256, New256) 17 | crypto.RegisterHash(crypto.SHA3_384, New384) 18 | crypto.RegisterHash(crypto.SHA3_512, New512) 19 | } 20 | -------------------------------------------------------------------------------- /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 | // +build gc 7 | 8 | #include "textflag.h" 9 | 10 | // 11 | // System calls for amd64, Solaris are implemented in runtime/syscall_solaris.go 12 | // 13 | 14 | TEXT ·sysvicall6(SB),NOSPLIT,$0-88 15 | JMP syscall·sysvicall6(SB) 16 | 17 | TEXT ·rawSysvicall6(SB),NOSPLIT,$0-88 18 | JMP syscall·rawSysvicall6(SB) 19 | -------------------------------------------------------------------------------- /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 | // +build aix dragonfly freebsd linux netbsd openbsd 7 | 8 | package unix 9 | 10 | // ReadDirent reads directory entries from fd and writes them into buf. 11 | func ReadDirent(fd int, buf []byte) (n int, err error) { 12 | return Getdents(fd, buf) 13 | } 14 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-billy/v5/osfs/os_posix.go: -------------------------------------------------------------------------------- 1 | // +build !plan9,!windows,!js 2 | 3 | package osfs 4 | 5 | import ( 6 | "os" 7 | 8 | "golang.org/x/sys/unix" 9 | ) 10 | 11 | func (f *file) Lock() error { 12 | f.m.Lock() 13 | defer f.m.Unlock() 14 | 15 | return unix.Flock(int(f.File.Fd()), unix.LOCK_EX) 16 | } 17 | 18 | func (f *file) Unlock() error { 19 | f.m.Lock() 20 | defer f.m.Unlock() 21 | 22 | return unix.Flock(int(f.File.Fd()), unix.LOCK_UN) 23 | } 24 | 25 | func rename(from, to string) error { 26 | return os.Rename(from, to) 27 | } 28 | -------------------------------------------------------------------------------- /vendor/github.com/muesli/termenv/.golangci.yml: -------------------------------------------------------------------------------- 1 | run: 2 | tests: false 3 | 4 | issues: 5 | include: 6 | - EXC0001 7 | - EXC0005 8 | - EXC0011 9 | - EXC0012 10 | - EXC0013 11 | 12 | max-issues-per-linter: 0 13 | max-same-issues: 0 14 | 15 | linters: 16 | enable: 17 | - bodyclose 18 | - exportloopref 19 | - goimports 20 | - gosec 21 | - nilerr 22 | - predeclared 23 | - revive 24 | - rowserrcheck 25 | - sqlclosecheck 26 | - tparallel 27 | - unconvert 28 | - unparam 29 | - whitespace 30 | -------------------------------------------------------------------------------- /vendor/github.com/sergi/go-diff/diffmatchpatch/operation_string.go: -------------------------------------------------------------------------------- 1 | // Code generated by "stringer -type=Operation -trimprefix=Diff"; DO NOT EDIT. 2 | 3 | package diffmatchpatch 4 | 5 | import "fmt" 6 | 7 | const _Operation_name = "DeleteEqualInsert" 8 | 9 | var _Operation_index = [...]uint8{0, 6, 11, 17} 10 | 11 | func (i Operation) String() string { 12 | i -= -1 13 | if i < 0 || i >= Operation(len(_Operation_index)-1) { 14 | return fmt.Sprintf("Operation(%d)", i+-1) 15 | } 16 | return _Operation_name[_Operation_index[i]:_Operation_index[i+1]] 17 | } 18 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/curve25519/internal/field/fe_amd64.go: -------------------------------------------------------------------------------- 1 | // Code generated by command: go run fe_amd64_asm.go -out ../fe_amd64.s -stubs ../fe_amd64.go -pkg field. DO NOT EDIT. 2 | 3 | //go:build amd64 && gc && !purego 4 | // +build amd64,gc,!purego 5 | 6 | package field 7 | 8 | // feMul sets out = a * b. It works like feMulGeneric. 9 | // 10 | //go:noescape 11 | func feMul(out *Element, a *Element, b *Element) 12 | 13 | // feSquare sets out = a * a. It works like feSquareGeneric. 14 | // 15 | //go:noescape 16 | func feSquare(out *Element, a *Element) 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 | // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris 7 | 8 | // For Unix, get the pagesize from the runtime. 9 | 10 | package unix 11 | 12 | import "syscall" 13 | 14 | func Getpagesize() int { 15 | return syscall.Getpagesize() 16 | } 17 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/storage/filesystem/module.go: -------------------------------------------------------------------------------- 1 | package filesystem 2 | 3 | import ( 4 | "github.com/go-git/go-git/v5/plumbing/cache" 5 | "github.com/go-git/go-git/v5/storage" 6 | "github.com/go-git/go-git/v5/storage/filesystem/dotgit" 7 | ) 8 | 9 | type ModuleStorage struct { 10 | dir *dotgit.DotGit 11 | } 12 | 13 | func (s *ModuleStorage) Module(name string) (storage.Storer, error) { 14 | fs, err := s.dir.Module(name) 15 | if err != nil { 16 | return nil, err 17 | } 18 | 19 | return NewStorage(fs, cache.NewObjectLRUDefault()), nil 20 | } 21 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_wasm.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 wasm 6 | // +build wasm 7 | 8 | package cpu 9 | 10 | // We're compiling the cpu package for an unknown (software-abstracted) CPU. 11 | // Make CacheLinePad an empty struct and hope that the usual struct alignment 12 | // rules are good enough. 13 | 14 | const cacheLineSize = 0 15 | 16 | func initOptions() {} 17 | 18 | func archInit() {} 19 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/endian_big.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 armbe || arm64be || m68k || mips || mips64 || mips64p32 || ppc || ppc64 || s390 || s390x || shbe || sparc || sparc64 6 | // +build armbe arm64be m68k mips mips64 mips64p32 ppc ppc64 s390 s390x shbe sparc sparc64 7 | 8 | package cpu 9 | 10 | // IsBigEndian records whether the GOARCH's byte order is big endian. 11 | const IsBigEndian = true 12 | -------------------------------------------------------------------------------- /vendor/github.com/Microsoft/go-winio/pkg/guid/guid_nonwindows.go: -------------------------------------------------------------------------------- 1 | //go:build !windows 2 | // +build !windows 3 | 4 | package guid 5 | 6 | // GUID represents a GUID/UUID. It has the same structure as 7 | // golang.org/x/sys/windows.GUID so that it can be used with functions expecting 8 | // that type. It is defined as its own type as that is only available to builds 9 | // targeted at `windows`. The representation matches that used by native Windows 10 | // code. 11 | type GUID struct { 12 | Data1 uint32 13 | Data2 uint16 14 | Data3 uint16 15 | Data4 [8]byte 16 | } 17 | -------------------------------------------------------------------------------- /vendor/github.com/cli/go-gh/pkg/term/console_windows.go: -------------------------------------------------------------------------------- 1 | //go:build windows 2 | // +build windows 3 | 4 | package term 5 | 6 | import ( 7 | "os" 8 | 9 | "golang.org/x/sys/windows" 10 | ) 11 | 12 | func enableVirtualTerminalProcessing(f *os.File) error { 13 | stdout := windows.Handle(f.Fd()) 14 | 15 | var originalMode uint32 16 | windows.GetConsoleMode(stdout, &originalMode) 17 | return windows.SetConsoleMode(stdout, originalMode|windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING) 18 | } 19 | 20 | func openTTY() (*os.File, error) { 21 | return os.Open("CONOUT$") 22 | } 23 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/plan9/pwd_plan9.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 !go1.5 6 | // +build !go1.5 7 | 8 | package plan9 9 | 10 | func fixwd() { 11 | } 12 | 13 | func Getwd() (wd string, err error) { 14 | fd, err := open(".", O_RDONLY) 15 | if err != nil { 16 | return "", err 17 | } 18 | defer Close(fd) 19 | return Fd2path(fd) 20 | } 21 | 22 | func Chdir(path string) error { 23 | return chdir(path) 24 | } 25 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/common.go: -------------------------------------------------------------------------------- 1 | package git 2 | 3 | import "strings" 4 | 5 | // countLines returns the number of lines in a string à la git, this is 6 | // The newline character is assumed to be '\n'. The empty string 7 | // contains 0 lines. If the last line of the string doesn't end with a 8 | // newline, it will still be considered a line. 9 | func countLines(s string) int { 10 | if s == "" { 11 | return 0 12 | } 13 | 14 | nEOL := strings.Count(s, "\n") 15 | if strings.HasSuffix(s, "\n") { 16 | return nEOL 17 | } 18 | 19 | return nEOL + 1 20 | } 21 | -------------------------------------------------------------------------------- /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) && go1.9 6 | // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris zos 7 | // +build go1.9 8 | 9 | package unix 10 | 11 | import "syscall" 12 | 13 | type Signal = syscall.Signal 14 | type Errno = syscall.Errno 15 | type SysProcAttr = syscall.SysProcAttr 16 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/chacha20/chacha_ppc64le.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 gc && !purego 6 | // +build gc,!purego 7 | 8 | package chacha20 9 | 10 | const bufSize = 256 11 | 12 | //go:noescape 13 | func chaCha20_ctr32_vsx(out, inp *byte, len int, key *[8]uint32, counter *uint32) 14 | 15 | func (c *Cipher) xorKeyStreamBlocks(dst, src []byte) { 16 | chaCha20_ctr32_vsx(&dst[0], &src[0], len(src), &c.key, &c.counter) 17 | } 18 | -------------------------------------------------------------------------------- /vendor/golang.org/x/tools/internal/typeparams/enabled_go118.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 go1.18 6 | // +build go1.18 7 | 8 | package typeparams 9 | 10 | // Note: this constant is in a separate file as this is the only acceptable 11 | // diff between the <1.18 API of this package and the 1.18 API. 12 | 13 | // Enabled reports whether type parameters are enabled in the current build 14 | // environment. 15 | const Enabled = true 16 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-isatty/isatty_others.go: -------------------------------------------------------------------------------- 1 | //go:build appengine || js || nacl || wasm 2 | // +build appengine js nacl wasm 3 | 4 | package isatty 5 | 6 | // IsTerminal returns true if the file descriptor is terminal which 7 | // is always false on js and appengine classic which is a sandboxed PaaS. 8 | func IsTerminal(fd uintptr) bool { 9 | return false 10 | } 11 | 12 | // IsCygwinTerminal() return true if the file descriptor is a cygwin or msys2 13 | // terminal. This is also always false on this environment. 14 | func IsCygwinTerminal(fd uintptr) bool { 15 | return false 16 | } 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/chacha20/chacha_arm64.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 go1.11 && gc && !purego 6 | // +build go1.11,gc,!purego 7 | 8 | package chacha20 9 | 10 | const bufSize = 256 11 | 12 | //go:noescape 13 | func xorKeyStreamVX(dst, src []byte, key *[8]uint32, nonce *[3]uint32, counter *uint32) 14 | 15 | func (c *Cipher) xorKeyStreamBlocks(dst, src []byte) { 16 | xorKeyStreamVX(dst, src, &c.key, &c.nonce, &c.counter) 17 | } 18 | -------------------------------------------------------------------------------- /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 | // +build darwin,!ios 7 | 8 | package unix 9 | 10 | import "unsafe" 11 | 12 | func ptrace(request int, pid int, addr uintptr, data uintptr) error { 13 | return ptrace1(request, pid, addr, data) 14 | } 15 | 16 | func ptracePtr(request int, pid int, addr uintptr, data unsafe.Pointer) error { 17 | return ptrace1Ptr(request, pid, addr, data) 18 | } 19 | -------------------------------------------------------------------------------- /vendor/github.com/cloudflare/circl/math/fp25519/fp_noasm.go: -------------------------------------------------------------------------------- 1 | //go:build !amd64 || purego 2 | // +build !amd64 purego 3 | 4 | package fp25519 5 | 6 | func cmov(x, y *Elt, n uint) { cmovGeneric(x, y, n) } 7 | func cswap(x, y *Elt, n uint) { cswapGeneric(x, y, n) } 8 | func add(z, x, y *Elt) { addGeneric(z, x, y) } 9 | func sub(z, x, y *Elt) { subGeneric(z, x, y) } 10 | func addsub(x, y *Elt) { addsubGeneric(x, y) } 11 | func mul(z, x, y *Elt) { mulGeneric(z, x, y) } 12 | func sqr(z, x *Elt) { sqrGeneric(z, x) } 13 | func modp(z *Elt) { modpGeneric(z) } 14 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/worktree_linux.go: -------------------------------------------------------------------------------- 1 | // +build linux 2 | 3 | package git 4 | 5 | import ( 6 | "syscall" 7 | "time" 8 | 9 | "github.com/go-git/go-git/v5/plumbing/format/index" 10 | ) 11 | 12 | func init() { 13 | fillSystemInfo = func(e *index.Entry, sys interface{}) { 14 | if os, ok := sys.(*syscall.Stat_t); ok { 15 | e.CreatedAt = time.Unix(os.Ctim.Unix()) 16 | e.Dev = uint32(os.Dev) 17 | e.Inode = uint32(os.Ino) 18 | e.GID = os.Gid 19 | e.UID = os.Uid 20 | } 21 | } 22 | } 23 | 24 | func isSymlinkWindowsNonAdmin(err error) bool { 25 | return false 26 | } 27 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/plan9/mksysnum_plan9.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | # Copyright 2009 The Go Authors. All rights reserved. 3 | # Use of this source code is governed by a BSD-style 4 | # license that can be found in the LICENSE file. 5 | 6 | COMMAND="mksysnum_plan9.sh $@" 7 | 8 | cat <= 10 { 17 | buf[i] = byte(val%10 + '0') 18 | i-- 19 | val /= 10 20 | } 21 | buf[i] = byte(val + '0') 22 | return string(buf[i:]) 23 | } 24 | -------------------------------------------------------------------------------- /vendor/github.com/sergi/go-diff/diffmatchpatch/mathutil.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2012-2016 The go-diff authors. All rights reserved. 2 | // https://github.com/sergi/go-diff 3 | // See the included LICENSE file for license details. 4 | // 5 | // go-diff is a Go implementation of Google's Diff, Match, and Patch library 6 | // Original library is Copyright (c) 2006 Google Inc. 7 | // http://code.google.com/p/google-diff-match-patch/ 8 | 9 | package diffmatchpatch 10 | 11 | func min(x, y int) int { 12 | if x < y { 13 | return x 14 | } 15 | return y 16 | } 17 | 18 | func max(x, y int) int { 19 | if x > y { 20 | return x 21 | } 22 | return y 23 | } 24 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/internal/poly1305/bits_go1.13.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.13 6 | // +build go1.13 7 | 8 | package poly1305 9 | 10 | import "math/bits" 11 | 12 | func bitsAdd64(x, y, carry uint64) (sum, carryOut uint64) { 13 | return bits.Add64(x, y, carry) 14 | } 15 | 16 | func bitsSub64(x, y, borrow uint64) (diff, borrowOut uint64) { 17 | return bits.Sub64(x, y, borrow) 18 | } 19 | 20 | func bitsMul64(x, y uint64) (hi, lo uint64) { 21 | return bits.Mul64(x, y) 22 | } 23 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-isatty/isatty_plan9.go: -------------------------------------------------------------------------------- 1 | //go:build plan9 2 | // +build plan9 3 | 4 | package isatty 5 | 6 | import ( 7 | "syscall" 8 | ) 9 | 10 | // IsTerminal returns true if the given file descriptor is a terminal. 11 | func IsTerminal(fd uintptr) bool { 12 | path, err := syscall.Fd2path(int(fd)) 13 | if err != nil { 14 | return false 15 | } 16 | return path == "/dev/cons" || path == "/mnt/term/dev/cons" 17 | } 18 | 19 | // IsCygwinTerminal return true if the file descriptor is a cygwin or msys2 20 | // terminal. This is also always false on this environment. 21 | func IsCygwinTerminal(fd uintptr) bool { 22 | return false 23 | } 24 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-runewidth/runewidth_windows.go: -------------------------------------------------------------------------------- 1 | //go:build windows && !appengine 2 | // +build windows,!appengine 3 | 4 | package runewidth 5 | 6 | import ( 7 | "syscall" 8 | ) 9 | 10 | var ( 11 | kernel32 = syscall.NewLazyDLL("kernel32") 12 | procGetConsoleOutputCP = kernel32.NewProc("GetConsoleOutputCP") 13 | ) 14 | 15 | // IsEastAsian return true if the current locale is CJK 16 | func IsEastAsian() bool { 17 | r1, _, _ := procGetConsoleOutputCP.Call() 18 | if r1 == 0 { 19 | return false 20 | } 21 | 22 | switch int(r1) { 23 | case 932, 51932, 936, 949, 950: 24 | return true 25 | } 26 | 27 | return false 28 | } 29 | -------------------------------------------------------------------------------- /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/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 | // +build windows 7 | 8 | package windows 9 | 10 | func itoa(val int) string { // do it here rather than with fmt to avoid dependency 11 | if val < 0 { 12 | return "-" + itoa(-val) 13 | } 14 | var buf [32]byte // big enough for int64 15 | i := len(buf) - 1 16 | for val >= 10 { 17 | buf[i] = byte(val%10 + '0') 18 | i-- 19 | val /= 10 20 | } 21 | buf[i] = byte(val + '0') 22 | return string(buf[i:]) 23 | } 24 | -------------------------------------------------------------------------------- /vendor/golang.org/x/tools/internal/gcimporter/ureader_no.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.18 6 | // +build !go1.18 7 | 8 | package gcimporter 9 | 10 | import ( 11 | "fmt" 12 | "go/token" 13 | "go/types" 14 | ) 15 | 16 | func UImportData(fset *token.FileSet, imports map[string]*types.Package, data []byte, path string) (_ int, pkg *types.Package, err error) { 17 | err = fmt.Errorf("go/tools compiled with a Go version earlier than 1.18 cannot read unified IR export data") 18 | return 19 | } 20 | -------------------------------------------------------------------------------- /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 | // +build linux 7 | 8 | package unix 9 | 10 | import "runtime" 11 | 12 | // SysvShmCtl performs control operations on the shared memory segment 13 | // specified by id. 14 | func SysvShmCtl(id, cmd int, desc *SysvShmDesc) (result int, err error) { 15 | if runtime.GOARCH == "arm" || 16 | runtime.GOARCH == "mips64" || runtime.GOARCH == "mips64le" { 17 | cmd |= ipc_64 18 | } 19 | 20 | return shmctl(id, cmd, desc) 21 | } 22 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_linux_mips64x.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 linux && (mips64 || mips64le) 6 | // +build linux 7 | // +build mips64 mips64le 8 | 9 | package cpu 10 | 11 | // HWCAP bits. These are exposed by the Linux kernel 5.4. 12 | const ( 13 | // CPU features 14 | hwcap_MIPS_MSA = 1 << 1 15 | ) 16 | 17 | func doinit() { 18 | // HWCAP feature bits 19 | MIPS64X.HasMSA = isSet(hwCap, hwcap_MIPS_MSA) 20 | } 21 | 22 | func isSet(hwc uint, value uint) bool { 23 | return hwc&value != 0 24 | } 25 | -------------------------------------------------------------------------------- /vendor/github.com/henvic/httpretty/CONTRIBUTING.md: -------------------------------------------------------------------------------- 1 | # Contributing to httpretty 2 | ## Bug reports 3 | When reporting bugs, please add information about your operating system and Go version used to compile the code. 4 | 5 | If you can provide a code snippet reproducing the issue, please do so. 6 | 7 | ## Code 8 | Please write code that satisfies [Go Code Review Comments](https://github.com/golang/go/wiki/CodeReviewComments) before submitting a pull-request. 9 | Your code should be properly covered by extensive unit tests. 10 | 11 | ## Commit messages 12 | Please follow the Go [commit messages](https://github.com/golang/go/wiki/CommitMessage) convention when contributing code. 13 | -------------------------------------------------------------------------------- /vendor/github.com/imdario/mergo/.gitignore: -------------------------------------------------------------------------------- 1 | #### joe made this: http://goel.io/joe 2 | 3 | #### go #### 4 | # Binaries for programs and plugins 5 | *.exe 6 | *.dll 7 | *.so 8 | *.dylib 9 | 10 | # Test binary, build with `go test -c` 11 | *.test 12 | 13 | # Output of the go coverage tool, specifically when used with LiteIDE 14 | *.out 15 | 16 | # Project-local glide cache, RE: https://github.com/Masterminds/glide/issues/736 17 | .glide/ 18 | 19 | #### vim #### 20 | # Swap 21 | [._]*.s[a-v][a-z] 22 | [._]*.sw[a-p] 23 | [._]s[a-v][a-z] 24 | [._]sw[a-p] 25 | 26 | # Session 27 | Session.vim 28 | 29 | # Temporary 30 | .netrwhist 31 | *~ 32 | # Auto-generated tag files 33 | tags 34 | -------------------------------------------------------------------------------- /vendor/github.com/otiai10/copy/fileinfo_go1.15.go: -------------------------------------------------------------------------------- 1 | //go:build !go1.16 2 | // +build !go1.16 3 | 4 | package copy 5 | 6 | import "os" 7 | 8 | // This is a cloned definition of os.FileInfo (go1.15) or fs.FileInfo (go1.16~) 9 | // A FileInfo describes a file and is returned by Stat. 10 | type fileInfo interface { 11 | // Name() string // base name of the file 12 | // Size() int64 // length in bytes for regular files; system-dependent for others 13 | Mode() os.FileMode // file mode bits 14 | // ModTime() time.Time // modification time 15 | IsDir() bool // abbreviation for Mode().IsDir() 16 | Sys() interface{} // underlying data source (can return nil) 17 | } 18 | -------------------------------------------------------------------------------- /vendor/github.com/otiai10/copy/fileinfo_go1.16.go: -------------------------------------------------------------------------------- 1 | //go:build go1.16 2 | // +build go1.16 3 | 4 | package copy 5 | 6 | import "io/fs" 7 | 8 | // This is a cloned definition of os.FileInfo (go1.15) or fs.FileInfo (go1.16~) 9 | // A FileInfo describes a file and is returned by Stat. 10 | type fileInfo interface { 11 | // Name() string // base name of the file 12 | // Size() int64 // length in bytes for regular files; system-dependent for others 13 | Mode() fs.FileMode // file mode bits 14 | // ModTime() time.Time // modification time 15 | IsDir() bool // abbreviation for Mode().IsDir() 16 | Sys() interface{} // underlying data source (can return nil) 17 | } 18 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/sha3/shake_generic.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 !gc || purego || !s390x 6 | // +build !gc purego !s390x 7 | 8 | package sha3 9 | 10 | // newShake128Asm returns an assembly implementation of SHAKE-128 if available, 11 | // otherwise it returns nil. 12 | func newShake128Asm() ShakeHash { 13 | return nil 14 | } 15 | 16 | // newShake256Asm returns an assembly implementation of SHAKE-256 if available, 17 | // otherwise it returns nil. 18 | func newShake256Asm() ShakeHash { 19 | return nil 20 | } 21 | -------------------------------------------------------------------------------- /vendor/github.com/kevinburke/ssh_config/CHANGELOG.md: -------------------------------------------------------------------------------- 1 | # Changes 2 | 3 | ## Version 1.2 4 | 5 | Previously, if a Host declaration or a value had trailing whitespace, that 6 | whitespace would have been included as part of the value. This led to unexpected 7 | consequences. For example: 8 | 9 | ``` 10 | Host example # A comment 11 | HostName example.com # Another comment 12 | ``` 13 | 14 | Prior to version 1.2, the value for Host would have been "example " and the 15 | value for HostName would have been "example.com ". Both of these are 16 | unintuitive. 17 | 18 | Instead, we strip the trailing whitespace in the configuration, which leads to 19 | more intuitive behavior. 20 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-isatty/isatty_bsd.go: -------------------------------------------------------------------------------- 1 | //go:build (darwin || freebsd || openbsd || netbsd || dragonfly || hurd) && !appengine 2 | // +build darwin freebsd openbsd netbsd dragonfly hurd 3 | // +build !appengine 4 | 5 | package isatty 6 | 7 | import "golang.org/x/sys/unix" 8 | 9 | // IsTerminal return true if the file descriptor is terminal. 10 | func IsTerminal(fd uintptr) bool { 11 | _, err := unix.IoctlGetTermios(int(fd), unix.TIOCGETA) 12 | return err == nil 13 | } 14 | 15 | // IsCygwinTerminal return true if the file descriptor is a cygwin or msys2 16 | // terminal. This is also always false on this environment. 17 | func IsCygwinTerminal(fd uintptr) bool { 18 | return false 19 | } 20 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # gh-foreach 2 | 3 | Automatically clone and execute commands across multiple GitHub repositories. 4 | 5 | ## Usage 6 | 7 | Note: the minimum required version of the GitHub CLI (`gh`) is `v2.3.0`. 8 | 9 | ```bash 10 | gh extension install mtoohey31/gh-foreach 11 | gh foreach --help 12 | gh foreach run -a owner -v public -l go -s bash cat go.mod 13 | gh foreach run -a owner -l rust -- bat --pager=never Cargo.toml 14 | gh foreach run --no-confirm -v public -r '^\w{3}\d{3}.*project$' 'cat README.md | head -n 1' 15 | gh foreach run -ci -l svelte 'pnpm install; fish' 16 | ``` 17 | 18 | ![demo](https://user-images.githubusercontent.com/36740602/152471108-47cc7484-3f95-4da0-81e5-81b8fb35d1ea.gif) 19 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/gcfg/types/bool.go: -------------------------------------------------------------------------------- 1 | package types 2 | 3 | // BoolValues defines the name and value mappings for ParseBool. 4 | var BoolValues = map[string]interface{}{ 5 | "true": true, "yes": true, "on": true, "1": true, 6 | "false": false, "no": false, "off": false, "0": false, 7 | } 8 | 9 | var boolParser = func() *EnumParser { 10 | ep := &EnumParser{} 11 | ep.AddVals(BoolValues) 12 | return ep 13 | }() 14 | 15 | // ParseBool parses bool values according to the definitions in BoolValues. 16 | // Parsing is case-insensitive. 17 | func ParseBool(s string) (bool, error) { 18 | v, err := boolParser.Parse(s) 19 | if err != nil { 20 | return false, err 21 | } 22 | return v.(bool), nil 23 | } 24 | -------------------------------------------------------------------------------- /vendor/github.com/pjbgf/sha1cd/Dockerfile.arm: -------------------------------------------------------------------------------- 1 | FROM golang:1.20@sha256:2edf6aab2d57644f3fe7407132a0d1770846867465a39c2083770cf62734b05d 2 | 3 | ENV GOOS=linux 4 | ENV GOARCH=arm 5 | ENV CGO_ENABLED=1 6 | ENV CC=arm-linux-gnueabihf-gcc 7 | ENV PATH="/go/bin/${GOOS}_${GOARCH}:${PATH}" 8 | ENV PKG_CONFIG_PATH=/usr/lib/arm-linux-gnueabihf/pkgconfig 9 | 10 | RUN dpkg --add-architecture armhf \ 11 | && apt update \ 12 | && apt install -y --no-install-recommends \ 13 | upx \ 14 | gcc-arm-linux-gnueabihf \ 15 | libc6-dev-armhf-cross \ 16 | pkg-config \ 17 | && rm -rf /var/lib/apt/lists/* 18 | 19 | COPY . /src/workdir 20 | 21 | WORKDIR /src/workdir 22 | 23 | RUN go build ./... 24 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-isatty/isatty_solaris.go: -------------------------------------------------------------------------------- 1 | //go:build solaris && !appengine 2 | // +build solaris,!appengine 3 | 4 | package isatty 5 | 6 | import ( 7 | "golang.org/x/sys/unix" 8 | ) 9 | 10 | // IsTerminal returns true if the given file descriptor is a terminal. 11 | // see: https://src.illumos.org/source/xref/illumos-gate/usr/src/lib/libc/port/gen/isatty.c 12 | func IsTerminal(fd uintptr) bool { 13 | _, err := unix.IoctlGetTermio(int(fd), unix.TCGETA) 14 | return err == nil 15 | } 16 | 17 | // IsCygwinTerminal return true if the file descriptor is a cygwin or msys2 18 | // terminal. This is also always false on this environment. 19 | func IsCygwinTerminal(fd uintptr) bool { 20 | return false 21 | } 22 | -------------------------------------------------------------------------------- /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 | // +build linux,gc,386 7 | 8 | package unix 9 | 10 | import "syscall" 11 | 12 | // Underlying system call writes to newoffset via pointer. 13 | // Implemented in assembly to avoid allocation. 14 | func seek(fd int, offset int64, whence int) (newoffset int64, err syscall.Errno) 15 | 16 | func socketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, err syscall.Errno) 17 | func rawsocketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, err syscall.Errno) 18 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/plan9/env_plan9.go: -------------------------------------------------------------------------------- 1 | // Copyright 2011 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 | // Plan 9 environment variables. 6 | 7 | package plan9 8 | 9 | import ( 10 | "syscall" 11 | ) 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/pjbgf/sha1cd/Dockerfile.arm64: -------------------------------------------------------------------------------- 1 | FROM golang:1.20@sha256:2edf6aab2d57644f3fe7407132a0d1770846867465a39c2083770cf62734b05d 2 | 3 | ENV GOOS=linux 4 | ENV GOARCH=arm64 5 | ENV CGO_ENABLED=1 6 | ENV CC=aarch64-linux-gnu-gcc 7 | ENV PATH="/go/bin/${GOOS}_${GOARCH}:${PATH}" 8 | ENV PKG_CONFIG_PATH=/usr/lib/aarch64-linux-gnu/pkgconfig 9 | 10 | # install build & runtime dependencies 11 | RUN dpkg --add-architecture arm64 \ 12 | && apt update \ 13 | && apt install -y --no-install-recommends \ 14 | gcc-aarch64-linux-gnu \ 15 | libc6-dev-arm64-cross \ 16 | pkg-config \ 17 | && rm -rf /var/lib/apt/lists/* 18 | 19 | COPY . /src/workdir 20 | 21 | WORKDIR /src/workdir 22 | 23 | RUN go build ./... 24 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/curve25519/internal/field/sync.sh: -------------------------------------------------------------------------------- 1 | #! /bin/bash 2 | set -euo pipefail 3 | 4 | cd "$(git rev-parse --show-toplevel)" 5 | 6 | STD_PATH=src/crypto/ed25519/internal/edwards25519/field 7 | LOCAL_PATH=curve25519/internal/field 8 | LAST_SYNC_REF=$(cat $LOCAL_PATH/sync.checkpoint) 9 | 10 | git fetch https://go.googlesource.com/go master 11 | 12 | if git diff --quiet $LAST_SYNC_REF:$STD_PATH FETCH_HEAD:$STD_PATH; then 13 | echo "No changes." 14 | else 15 | NEW_REF=$(git rev-parse FETCH_HEAD | tee $LOCAL_PATH/sync.checkpoint) 16 | echo "Applying changes from $LAST_SYNC_REF to $NEW_REF..." 17 | git diff $LAST_SYNC_REF:$STD_PATH FETCH_HEAD:$STD_PATH | \ 18 | git apply -3 --directory=$LOCAL_PATH 19 | fi 20 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/sha3/xor.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 (!amd64 && !386 && !ppc64le) || purego 6 | // +build !amd64,!386,!ppc64le purego 7 | 8 | package sha3 9 | 10 | // A storageBuf is an aligned array of maxRate bytes. 11 | type storageBuf [maxRate]byte 12 | 13 | func (b *storageBuf) asBytes() *[maxRate]byte { 14 | return (*[maxRate]byte)(b) 15 | } 16 | 17 | var ( 18 | xorIn = xorInGeneric 19 | copyOut = copyOutGeneric 20 | xorInUnaligned = xorInGeneric 21 | copyOutUnaligned = copyOutGeneric 22 | ) 23 | 24 | const xorImplementationUnaligned = "generic" 25 | -------------------------------------------------------------------------------- /vendor/golang.org/x/tools/internal/gcimporter/newInterface10.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 !go1.11 6 | // +build !go1.11 7 | 8 | package gcimporter 9 | 10 | import "go/types" 11 | 12 | func newInterface(methods []*types.Func, embeddeds []types.Type) *types.Interface { 13 | named := make([]*types.Named, len(embeddeds)) 14 | for i, e := range embeddeds { 15 | var ok bool 16 | named[i], ok = e.(*types.Named) 17 | if !ok { 18 | panic("embedding of non-defined interfaces in interfaces is not supported before Go 1.11") 19 | } 20 | } 21 | return types.NewInterface(methods, named) 22 | } 23 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/gcfg/types/scan.go: -------------------------------------------------------------------------------- 1 | package types 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "reflect" 7 | ) 8 | 9 | // ScanFully uses fmt.Sscanf with verb to fully scan val into ptr. 10 | func ScanFully(ptr interface{}, val string, verb byte) error { 11 | t := reflect.ValueOf(ptr).Elem().Type() 12 | // attempt to read extra bytes to make sure the value is consumed 13 | var b []byte 14 | n, err := fmt.Sscanf(val, "%"+string(verb)+"%s", ptr, &b) 15 | switch { 16 | case n < 1 || n == 1 && err != io.EOF: 17 | return fmt.Errorf("failed to parse %q as %v: %v", val, t, err) 18 | case n > 1: 19 | return fmt.Errorf("failed to parse %q as %v: extra characters %q", val, t, string(b)) 20 | } 21 | // n == 1 && err == io.EOF 22 | return nil 23 | } 24 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/worktree_plan9.go: -------------------------------------------------------------------------------- 1 | package git 2 | 3 | import ( 4 | "syscall" 5 | "time" 6 | 7 | "github.com/go-git/go-git/v5/plumbing/format/index" 8 | ) 9 | 10 | func init() { 11 | fillSystemInfo = func(e *index.Entry, sys interface{}) { 12 | if os, ok := sys.(*syscall.Dir); ok { 13 | // Plan 9 doesn't have a CreatedAt field. 14 | e.CreatedAt = time.Unix(int64(os.Mtime), 0) 15 | 16 | e.Dev = uint32(os.Dev) 17 | 18 | // Plan 9 has no Inode. 19 | // ext2srv(4) appears to store Inode in Qid.Path. 20 | e.Inode = uint32(os.Qid.Path) 21 | 22 | // Plan 9 has string UID/GID 23 | e.GID = 0 24 | e.UID = 0 25 | } 26 | } 27 | } 28 | 29 | func isSymlinkWindowsNonAdmin(err error) bool { 30 | return true 31 | } 32 | -------------------------------------------------------------------------------- /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 | // +build linux,gccgo,arm 7 | 8 | package unix 9 | 10 | import ( 11 | "syscall" 12 | "unsafe" 13 | ) 14 | 15 | func seek(fd int, offset int64, whence int) (int64, syscall.Errno) { 16 | var newoffset int64 17 | offsetLow := uint32(offset & 0xffffffff) 18 | offsetHigh := uint32((offset >> 32) & 0xffffffff) 19 | _, _, err := Syscall6(SYS__LLSEEK, uintptr(fd), uintptr(offsetHigh), uintptr(offsetLow), uintptr(unsafe.Pointer(&newoffset)), uintptr(whence), 0) 20 | return newoffset, err 21 | } 22 | -------------------------------------------------------------------------------- /vendor/github.com/cloudflare/circl/internal/sha3/rc.go: -------------------------------------------------------------------------------- 1 | package sha3 2 | 3 | // RC stores the round constants for use in the ι step. 4 | var RC = [24]uint64{ 5 | 0x0000000000000001, 6 | 0x0000000000008082, 7 | 0x800000000000808A, 8 | 0x8000000080008000, 9 | 0x000000000000808B, 10 | 0x0000000080000001, 11 | 0x8000000080008081, 12 | 0x8000000000008009, 13 | 0x000000000000008A, 14 | 0x0000000000000088, 15 | 0x0000000080008009, 16 | 0x000000008000000A, 17 | 0x000000008000808B, 18 | 0x800000000000008B, 19 | 0x8000000000008089, 20 | 0x8000000000008003, 21 | 0x8000000000008002, 22 | 0x8000000000000080, 23 | 0x000000000000800A, 24 | 0x800000008000000A, 25 | 0x8000000080008081, 26 | 0x8000000000008080, 27 | 0x0000000080000001, 28 | 0x8000000080008008, 29 | } 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/plan9/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 plan9 && race 6 | // +build plan9,race 7 | 8 | package plan9 9 | 10 | import ( 11 | "runtime" 12 | "unsafe" 13 | ) 14 | 15 | const raceenabled = true 16 | 17 | func raceAcquire(addr unsafe.Pointer) { 18 | runtime.RaceAcquire(addr) 19 | } 20 | 21 | func raceReleaseMerge(addr unsafe.Pointer) { 22 | runtime.RaceReleaseMerge(addr) 23 | } 24 | 25 | func raceReadRange(addr unsafe.Pointer, len int) { 26 | runtime.RaceReadRange(addr, len) 27 | } 28 | 29 | func raceWriteRange(addr unsafe.Pointer, len int) { 30 | runtime.RaceWriteRange(addr, len) 31 | } 32 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/plan9/asm_plan9_arm.s: -------------------------------------------------------------------------------- 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 | #include "textflag.h" 6 | 7 | // System call support for plan9 on arm 8 | 9 | // Just jump to package syscall's implementation for all these functions. 10 | // The runtime may know about them. 11 | 12 | TEXT ·Syscall(SB),NOSPLIT,$0-32 13 | JMP syscall·Syscall(SB) 14 | 15 | TEXT ·Syscall6(SB),NOSPLIT,$0-44 16 | JMP syscall·Syscall6(SB) 17 | 18 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28 19 | JMP syscall·RawSyscall(SB) 20 | 21 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 22 | JMP syscall·RawSyscall6(SB) 23 | 24 | TEXT ·seek(SB),NOSPLIT,$0-36 25 | JMP syscall·exit(SB) 26 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_zos_s390x.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 | package cpu 6 | 7 | func initS390Xbase() { 8 | // get the facilities list 9 | facilities := stfle() 10 | 11 | // mandatory 12 | S390X.HasZARCH = facilities.Has(zarch) 13 | S390X.HasSTFLE = facilities.Has(stflef) 14 | S390X.HasLDISP = facilities.Has(ldisp) 15 | S390X.HasEIMM = facilities.Has(eimm) 16 | 17 | // optional 18 | S390X.HasETF3EH = facilities.Has(etf3eh) 19 | S390X.HasDFP = facilities.Has(dfp) 20 | S390X.HasMSA = facilities.Has(msa) 21 | S390X.HasVX = facilities.Has(vx) 22 | if S390X.HasVX { 23 | S390X.HasVXE = facilities.Has(vxe) 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /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 | // +build aix darwin,!race linux,!race freebsd,!race netbsd openbsd solaris dragonfly zos 7 | 8 | package unix 9 | 10 | import ( 11 | "unsafe" 12 | ) 13 | 14 | const raceenabled = false 15 | 16 | func raceAcquire(addr unsafe.Pointer) { 17 | } 18 | 19 | func raceReleaseMerge(addr unsafe.Pointer) { 20 | } 21 | 22 | func raceReadRange(addr unsafe.Pointer, len int) { 23 | } 24 | 25 | func raceWriteRange(addr unsafe.Pointer, len int) { 26 | } 27 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_solaris_amd64.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 amd64 && solaris 6 | // +build amd64,solaris 7 | 8 | package unix 9 | 10 | func setTimespec(sec, nsec int64) Timespec { 11 | return Timespec{Sec: sec, Nsec: nsec} 12 | } 13 | 14 | func setTimeval(sec, usec int64) Timeval { 15 | return Timeval{Sec: sec, Usec: usec} 16 | } 17 | 18 | func (iov *Iovec) SetLen(length int) { 19 | iov.Len = uint64(length) 20 | } 21 | 22 | func (msghdr *Msghdr) SetIovlen(length int) { 23 | msghdr.Iovlen = int32(length) 24 | } 25 | 26 | func (cmsg *Cmsghdr) SetLen(length int) { 27 | cmsg.Len = uint32(length) 28 | } 29 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/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 windows && race 6 | // +build windows,race 7 | 8 | package windows 9 | 10 | import ( 11 | "runtime" 12 | "unsafe" 13 | ) 14 | 15 | const raceenabled = true 16 | 17 | func raceAcquire(addr unsafe.Pointer) { 18 | runtime.RaceAcquire(addr) 19 | } 20 | 21 | func raceReleaseMerge(addr unsafe.Pointer) { 22 | runtime.RaceReleaseMerge(addr) 23 | } 24 | 25 | func raceReadRange(addr unsafe.Pointer, len int) { 26 | runtime.RaceReadRange(addr, len) 27 | } 28 | 29 | func raceWriteRange(addr unsafe.Pointer, len int) { 30 | runtime.RaceWriteRange(addr, len) 31 | } 32 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/plumbing/error.go: -------------------------------------------------------------------------------- 1 | package plumbing 2 | 3 | import "fmt" 4 | 5 | type PermanentError struct { 6 | Err error 7 | } 8 | 9 | func NewPermanentError(err error) *PermanentError { 10 | if err == nil { 11 | return nil 12 | } 13 | 14 | return &PermanentError{Err: err} 15 | } 16 | 17 | func (e *PermanentError) Error() string { 18 | return fmt.Sprintf("permanent client error: %s", e.Err.Error()) 19 | } 20 | 21 | type UnexpectedError struct { 22 | Err error 23 | } 24 | 25 | func NewUnexpectedError(err error) *UnexpectedError { 26 | if err == nil { 27 | return nil 28 | } 29 | 30 | return &UnexpectedError{Err: err} 31 | } 32 | 33 | func (e *UnexpectedError) Error() string { 34 | return fmt.Sprintf("unexpected client error: %s", e.Err.Error()) 35 | } 36 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_x86.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 (386 || amd64 || amd64p32) && gc 6 | // +build 386 amd64 amd64p32 7 | // +build gc 8 | 9 | #include "textflag.h" 10 | 11 | // func cpuid(eaxArg, ecxArg uint32) (eax, ebx, ecx, edx uint32) 12 | TEXT ·cpuid(SB), NOSPLIT, $0-24 13 | MOVL eaxArg+0(FP), AX 14 | MOVL ecxArg+4(FP), CX 15 | CPUID 16 | MOVL AX, eax+8(FP) 17 | MOVL BX, ebx+12(FP) 18 | MOVL CX, ecx+16(FP) 19 | MOVL DX, edx+20(FP) 20 | RET 21 | 22 | // func xgetbv() (eax, edx uint32) 23 | TEXT ·xgetbv(SB),NOSPLIT,$0-8 24 | MOVL $0, CX 25 | XGETBV 26 | MOVL AX, eax+0(FP) 27 | MOVL DX, edx+4(FP) 28 | RET 29 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_aix.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 6 | // +build aix 7 | 8 | package cpu 9 | 10 | const ( 11 | // getsystemcfg constants 12 | _SC_IMPL = 2 13 | _IMPL_POWER8 = 0x10000 14 | _IMPL_POWER9 = 0x20000 15 | ) 16 | 17 | func archInit() { 18 | impl := getsystemcfg(_SC_IMPL) 19 | if impl&_IMPL_POWER8 != 0 { 20 | PPC64.IsPOWER8 = true 21 | } 22 | if impl&_IMPL_POWER9 != 0 { 23 | PPC64.IsPOWER8 = true 24 | PPC64.IsPOWER9 = true 25 | } 26 | 27 | Initialized = true 28 | } 29 | 30 | func getsystemcfg(label int) (n uint64) { 31 | r0, _ := callgetsystemcfg(label) 32 | n = uint64(r0) 33 | return 34 | } 35 | -------------------------------------------------------------------------------- /vendor/golang.org/x/tools/internal/pkgbits/frames_go17.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 go1.7 6 | // +build go1.7 7 | 8 | package pkgbits 9 | 10 | import "runtime" 11 | 12 | // walkFrames calls visit for each call frame represented by pcs. 13 | // 14 | // pcs should be a slice of PCs, as returned by runtime.Callers. 15 | func walkFrames(pcs []uintptr, visit frameVisitor) { 16 | if len(pcs) == 0 { 17 | return 18 | } 19 | 20 | frames := runtime.CallersFrames(pcs) 21 | for { 22 | frame, more := frames.Next() 23 | visit(frame.File, frame.Line, frame.Function, frame.PC-frame.Entry) 24 | if !more { 25 | return 26 | } 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /flake.nix: -------------------------------------------------------------------------------- 1 | { 2 | description = "gh-foreach"; 3 | inputs = { 4 | utils.url = "github:numtide/flake-utils"; 5 | nixpkgs.url = "nixpkgs/nixpkgs-unstable"; 6 | }; 7 | outputs = { self, nixpkgs, utils }: 8 | utils.lib.eachDefaultSystem 9 | (system: 10 | with import nixpkgs { inherit system; }; { 11 | packages.default = buildGo118Module rec { 12 | name = "gh-foreach"; 13 | pname = name; 14 | src = ./.; 15 | vendorSha256 = null; 16 | }; 17 | 18 | devShells.default = mkShell { 19 | nativeBuildInputs = [ go_1_18 gopls ]; 20 | }; 21 | }) // { 22 | overlays.default = (final: _: { 23 | gh-foreach = self.packages."${final.system}".default; 24 | }); 25 | }; 26 | } 27 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/utils/sync/bufio.go: -------------------------------------------------------------------------------- 1 | package sync 2 | 3 | import ( 4 | "bufio" 5 | "io" 6 | "sync" 7 | ) 8 | 9 | var bufioReader = sync.Pool{ 10 | New: func() interface{} { 11 | return bufio.NewReader(nil) 12 | }, 13 | } 14 | 15 | // GetBufioReader returns a *bufio.Reader that is managed by a sync.Pool. 16 | // Returns a bufio.Reader that is resetted with reader and ready for use. 17 | // 18 | // After use, the *bufio.Reader should be put back into the sync.Pool 19 | // by calling PutBufioReader. 20 | func GetBufioReader(reader io.Reader) *bufio.Reader { 21 | r := bufioReader.Get().(*bufio.Reader) 22 | r.Reset(reader) 23 | return r 24 | } 25 | 26 | // PutBufioReader puts reader back into its sync.Pool. 27 | func PutBufioReader(reader *bufio.Reader) { 28 | bufioReader.Put(reader) 29 | } 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/net/context/go19.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 go1.9 6 | // +build go1.9 7 | 8 | package context 9 | 10 | import "context" // standard library's context, as of Go 1.7 11 | 12 | // A Context carries a deadline, a cancelation signal, and other values across 13 | // API boundaries. 14 | // 15 | // Context's methods may be called by multiple goroutines simultaneously. 16 | type Context = context.Context 17 | 18 | // A CancelFunc tells an operation to abandon its work. 19 | // A CancelFunc does not wait for the work to stop. 20 | // After the first call, subsequent calls to a CancelFunc do nothing. 21 | type CancelFunc = context.CancelFunc 22 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_gc_s390x.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 gc 6 | // +build gc 7 | 8 | package cpu 9 | 10 | // haveAsmFunctions reports whether the other functions in this file can 11 | // be safely called. 12 | func haveAsmFunctions() bool { return true } 13 | 14 | // The following feature detection functions are defined in cpu_s390x.s. 15 | // They are likely to be expensive to call so the results should be cached. 16 | func stfle() facilityList 17 | func kmQuery() queryResult 18 | func kmcQuery() queryResult 19 | func kmctrQuery() queryResult 20 | func kmaQuery() queryResult 21 | func kimdQuery() queryResult 22 | func klmdQuery() queryResult 23 | -------------------------------------------------------------------------------- /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 | // +build hurd 7 | 8 | package unix 9 | 10 | /* 11 | #include 12 | int ioctl(int, unsigned long int, uintptr_t); 13 | */ 14 | import "C" 15 | 16 | func ioctl(fd int, req uint, arg uintptr) (err error) { 17 | r0, er := C.ioctl(C.int(fd), C.ulong(req), C.uintptr_t(arg)) 18 | if r0 == -1 && er != nil { 19 | err = er 20 | } 21 | return 22 | } 23 | 24 | func ioctlPtr(fd int, req uint, arg unsafe.Pointer) (err error) { 25 | r0, er := C.ioctl(C.int(fd), C.ulong(req), C.uintptr_t(uintptr(arg))) 26 | if r0 == -1 && er != nil { 27 | err = er 28 | } 29 | return 30 | } 31 | -------------------------------------------------------------------------------- /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/term/README.md: -------------------------------------------------------------------------------- 1 | # Go terminal/console support 2 | 3 | [![Go Reference](https://pkg.go.dev/badge/golang.org/x/term.svg)](https://pkg.go.dev/golang.org/x/term) 4 | 5 | This repository provides Go terminal and console support packages. 6 | 7 | ## Download/Install 8 | 9 | The easiest way to install is to run `go get -u golang.org/x/term`. You can 10 | also manually git clone the repository to `$GOPATH/src/golang.org/x/term`. 11 | 12 | ## Report Issues / Send Patches 13 | 14 | This repository uses Gerrit for code changes. To learn how to submit changes to 15 | this repository, see https://golang.org/doc/contribute.html. 16 | 17 | The main issue tracker for the term repository is located at 18 | https://github.com/golang/go/issues. Prefix your issue with "x/term:" in the 19 | subject line, so it is easy to find. 20 | -------------------------------------------------------------------------------- /vendor/github.com/alecthomas/kong/hooks.go: -------------------------------------------------------------------------------- 1 | package kong 2 | 3 | // BeforeResolve is a documentation-only interface describing hooks that run before resolvers are applied. 4 | type BeforeResolve interface { 5 | // This is not the correct signature - see README for details. 6 | BeforeResolve(args ...interface{}) error 7 | } 8 | 9 | // BeforeApply is a documentation-only interface describing hooks that run before values are set. 10 | type BeforeApply interface { 11 | // This is not the correct signature - see README for details. 12 | BeforeApply(args ...interface{}) error 13 | } 14 | 15 | // AfterApply is a documentation-only interface describing hooks that run after values are set. 16 | type AfterApply interface { 17 | // This is not the correct signature - see README for details. 18 | AfterApply(args ...interface{}) error 19 | } 20 | -------------------------------------------------------------------------------- /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 | // +build darwin dragonfly freebsd linux,!ppc64,!ppc64le netbsd openbsd solaris 7 | // +build gc 8 | 9 | package unix 10 | 11 | import "syscall" 12 | 13 | func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) 14 | func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) 15 | func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) 16 | func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) 17 | -------------------------------------------------------------------------------- /vendor/github.com/emirpasic/gods/containers/serialization.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2015, Emir Pasic. 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 containers 6 | 7 | // JSONSerializer provides JSON serialization 8 | type JSONSerializer interface { 9 | // ToJSON outputs the JSON representation of containers's elements. 10 | ToJSON() ([]byte, error) 11 | // MarshalJSON @implements json.Marshaler 12 | MarshalJSON() ([]byte, error) 13 | } 14 | 15 | // JSONDeserializer provides JSON deserialization 16 | type JSONDeserializer interface { 17 | // FromJSON populates containers's elements from the input JSON representation. 18 | FromJSON([]byte) error 19 | // UnmarshalJSON @implements json.Unmarshaler 20 | UnmarshalJSON([]byte) error 21 | } 22 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/plumbing/format/packfile/error.go: -------------------------------------------------------------------------------- 1 | package packfile 2 | 3 | import "fmt" 4 | 5 | // Error specifies errors returned during packfile parsing. 6 | type Error struct { 7 | reason, details string 8 | } 9 | 10 | // NewError returns a new error. 11 | func NewError(reason string) *Error { 12 | return &Error{reason: reason} 13 | } 14 | 15 | // Error returns a text representation of the error. 16 | func (e *Error) Error() string { 17 | if e.details == "" { 18 | return e.reason 19 | } 20 | 21 | return fmt.Sprintf("%s: %s", e.reason, e.details) 22 | } 23 | 24 | // AddDetails adds details to an error, with additional text. 25 | func (e *Error) AddDetails(format string, args ...interface{}) *Error { 26 | return &Error{ 27 | reason: e.reason, 28 | details: fmt.Sprintf(format, args...), 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/sha3/xor_generic.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 | package sha3 6 | 7 | import "encoding/binary" 8 | 9 | // xorInGeneric xors the bytes in buf into the state; it 10 | // makes no non-portable assumptions about memory layout 11 | // or alignment. 12 | func xorInGeneric(d *state, buf []byte) { 13 | n := len(buf) / 8 14 | 15 | for i := 0; i < n; i++ { 16 | a := binary.LittleEndian.Uint64(buf) 17 | d.a[i] ^= a 18 | buf = buf[8:] 19 | } 20 | } 21 | 22 | // copyOutGeneric copies uint64s to a byte buffer. 23 | func copyOutGeneric(d *state, b []byte) { 24 | for i := 0; len(b) >= 8; i++ { 25 | binary.LittleEndian.PutUint64(b, d.a[i]) 26 | b = b[8:] 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /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 | // +build darwin,race linux,race freebsd,race 7 | 8 | package unix 9 | 10 | import ( 11 | "runtime" 12 | "unsafe" 13 | ) 14 | 15 | const raceenabled = true 16 | 17 | func raceAcquire(addr unsafe.Pointer) { 18 | runtime.RaceAcquire(addr) 19 | } 20 | 21 | func raceReleaseMerge(addr unsafe.Pointer) { 22 | runtime.RaceReleaseMerge(addr) 23 | } 24 | 25 | func raceReadRange(addr unsafe.Pointer, len int) { 26 | runtime.RaceReadRange(addr, len) 27 | } 28 | 29 | func raceWriteRange(addr unsafe.Pointer, len int) { 30 | runtime.RaceWriteRange(addr, len) 31 | } 32 | -------------------------------------------------------------------------------- /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 | // +build darwin 7 | 8 | package unix 9 | 10 | import "unsafe" 11 | 12 | // ReadDirent reads directory entries from fd and writes them into buf. 13 | func ReadDirent(fd int, buf []byte) (n int, err error) { 14 | // Final argument is (basep *uintptr) and the syscall doesn't take nil. 15 | // 64 bits should be enough. (32 bits isn't even on 386). Since the 16 | // actual system call is getdirentries64, 64 is a good guess. 17 | // TODO(rsc): Can we use a single global basep for all calls? 18 | var base = (*uintptr)(unsafe.Pointer(new(uint64))) 19 | return Getdirentries(fd, buf, base) 20 | } 21 | -------------------------------------------------------------------------------- /vendor/github.com/cloudflare/circl/dh/x448/curve_amd64.go: -------------------------------------------------------------------------------- 1 | //go:build amd64 && !purego 2 | // +build amd64,!purego 3 | 4 | package x448 5 | 6 | import ( 7 | fp "github.com/cloudflare/circl/math/fp448" 8 | "golang.org/x/sys/cpu" 9 | ) 10 | 11 | var hasBmi2Adx = cpu.X86.HasBMI2 && cpu.X86.HasADX 12 | 13 | var _ = hasBmi2Adx 14 | 15 | func double(x, z *fp.Elt) { doubleAmd64(x, z) } 16 | func diffAdd(w *[5]fp.Elt, b uint) { diffAddAmd64(w, b) } 17 | func ladderStep(w *[5]fp.Elt, b uint) { ladderStepAmd64(w, b) } 18 | func mulA24(z, x *fp.Elt) { mulA24Amd64(z, x) } 19 | 20 | //go:noescape 21 | func doubleAmd64(x, z *fp.Elt) 22 | 23 | //go:noescape 24 | func diffAddAmd64(w *[5]fp.Elt, b uint) 25 | 26 | //go:noescape 27 | func ladderStepAmd64(w *[5]fp.Elt, b uint) 28 | 29 | //go:noescape 30 | func mulA24Amd64(z, x *fp.Elt) 31 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/storage/filesystem/deltaobject.go: -------------------------------------------------------------------------------- 1 | package filesystem 2 | 3 | import ( 4 | "github.com/go-git/go-git/v5/plumbing" 5 | ) 6 | 7 | type deltaObject struct { 8 | plumbing.EncodedObject 9 | base plumbing.Hash 10 | hash plumbing.Hash 11 | size int64 12 | } 13 | 14 | func newDeltaObject( 15 | obj plumbing.EncodedObject, 16 | hash plumbing.Hash, 17 | base plumbing.Hash, 18 | size int64) plumbing.DeltaObject { 19 | return &deltaObject{ 20 | EncodedObject: obj, 21 | hash: hash, 22 | base: base, 23 | size: size, 24 | } 25 | } 26 | 27 | func (o *deltaObject) BaseHash() plumbing.Hash { 28 | return o.base 29 | } 30 | 31 | func (o *deltaObject) ActualSize() int64 { 32 | return o.size 33 | } 34 | 35 | func (o *deltaObject) ActualHash() plumbing.Hash { 36 | return o.hash 37 | } 38 | -------------------------------------------------------------------------------- /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 | // +build gc 7 | 8 | #include "textflag.h" 9 | 10 | // 11 | // System call support for mips64, OpenBSD 12 | // 13 | 14 | // Just jump to package syscall's implementation for all these functions. 15 | // The runtime may know about them. 16 | 17 | TEXT ·Syscall(SB),NOSPLIT,$0-56 18 | JMP syscall·Syscall(SB) 19 | 20 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 21 | JMP syscall·Syscall6(SB) 22 | 23 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 24 | JMP syscall·Syscall9(SB) 25 | 26 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 27 | JMP syscall·RawSyscall(SB) 28 | 29 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 30 | JMP syscall·RawSyscall6(SB) 31 | -------------------------------------------------------------------------------- /vendor/github.com/Microsoft/go-winio/internal/socket/rawaddr.go: -------------------------------------------------------------------------------- 1 | package socket 2 | 3 | import ( 4 | "unsafe" 5 | ) 6 | 7 | // RawSockaddr allows structs to be used with [Bind] and [ConnectEx]. The 8 | // struct must meet the Win32 sockaddr requirements specified here: 9 | // https://docs.microsoft.com/en-us/windows/win32/winsock/sockaddr-2 10 | // 11 | // Specifically, the struct size must be least larger than an int16 (unsigned short) 12 | // for the address family. 13 | type RawSockaddr interface { 14 | // Sockaddr returns a pointer to the RawSockaddr and its struct size, allowing 15 | // for the RawSockaddr's data to be overwritten by syscalls (if necessary). 16 | // 17 | // It is the callers responsibility to validate that the values are valid; invalid 18 | // pointers or size can cause a panic. 19 | Sockaddr() (unsafe.Pointer, int32, error) 20 | } 21 | -------------------------------------------------------------------------------- /vendor/github.com/cloudflare/circl/dh/x25519/curve_amd64.go: -------------------------------------------------------------------------------- 1 | //go:build amd64 && !purego 2 | // +build amd64,!purego 3 | 4 | package x25519 5 | 6 | import ( 7 | fp "github.com/cloudflare/circl/math/fp25519" 8 | "golang.org/x/sys/cpu" 9 | ) 10 | 11 | var hasBmi2Adx = cpu.X86.HasBMI2 && cpu.X86.HasADX 12 | 13 | var _ = hasBmi2Adx 14 | 15 | func double(x, z *fp.Elt) { doubleAmd64(x, z) } 16 | func diffAdd(w *[5]fp.Elt, b uint) { diffAddAmd64(w, b) } 17 | func ladderStep(w *[5]fp.Elt, b uint) { ladderStepAmd64(w, b) } 18 | func mulA24(z, x *fp.Elt) { mulA24Amd64(z, x) } 19 | 20 | //go:noescape 21 | func ladderStepAmd64(w *[5]fp.Elt, b uint) 22 | 23 | //go:noescape 24 | func diffAddAmd64(w *[5]fp.Elt, b uint) 25 | 26 | //go:noescape 27 | func doubleAmd64(x, z *fp.Elt) 28 | 29 | //go:noescape 30 | func mulA24Amd64(z, x *fp.Elt) 31 | -------------------------------------------------------------------------------- /vendor/github.com/kevinburke/ssh_config/position.go: -------------------------------------------------------------------------------- 1 | package ssh_config 2 | 3 | import "fmt" 4 | 5 | // Position of a document element within a SSH document. 6 | // 7 | // Line and Col are both 1-indexed positions for the element's line number and 8 | // column number, respectively. Values of zero or less will cause Invalid(), 9 | // to return true. 10 | type Position struct { 11 | Line int // line within the document 12 | Col int // column within the line 13 | } 14 | 15 | // String representation of the position. 16 | // Displays 1-indexed line and column numbers. 17 | func (p Position) String() string { 18 | return fmt.Sprintf("(%d, %d)", p.Line, p.Col) 19 | } 20 | 21 | // Invalid returns whether or not the position is valid (i.e. with negative or 22 | // null values) 23 | func (p Position) Invalid() bool { 24 | return p.Line <= 0 || p.Col <= 0 25 | } 26 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/plan9/asm_plan9_386.s: -------------------------------------------------------------------------------- 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 | #include "textflag.h" 6 | 7 | // 8 | // System call support for 386, Plan 9 9 | // 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-32 15 | JMP syscall·Syscall(SB) 16 | 17 | TEXT ·Syscall6(SB),NOSPLIT,$0-44 18 | JMP syscall·Syscall6(SB) 19 | 20 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28 21 | JMP syscall·RawSyscall(SB) 22 | 23 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 24 | JMP syscall·RawSyscall6(SB) 25 | 26 | TEXT ·seek(SB),NOSPLIT,$0-36 27 | JMP syscall·seek(SB) 28 | 29 | TEXT ·exit(SB),NOSPLIT,$4-4 30 | JMP syscall·exit(SB) 31 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/plan9/asm_plan9_amd64.s: -------------------------------------------------------------------------------- 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 | #include "textflag.h" 6 | 7 | // 8 | // System call support for amd64, Plan 9 9 | // 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-64 15 | JMP syscall·Syscall(SB) 16 | 17 | TEXT ·Syscall6(SB),NOSPLIT,$0-88 18 | JMP syscall·Syscall6(SB) 19 | 20 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 21 | JMP syscall·RawSyscall(SB) 22 | 23 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 24 | JMP syscall·RawSyscall6(SB) 25 | 26 | TEXT ·seek(SB),NOSPLIT,$0-56 27 | JMP syscall·seek(SB) 28 | 29 | TEXT ·exit(SB),NOSPLIT,$8-8 30 | JMP syscall·exit(SB) 31 | -------------------------------------------------------------------------------- /vendor/github.com/ProtonMail/go-crypto/openpgp/packet/notation.go: -------------------------------------------------------------------------------- 1 | package packet 2 | 3 | // Notation type represents a Notation Data subpacket 4 | // see https://tools.ietf.org/html/rfc4880#section-5.2.3.16 5 | type Notation struct { 6 | Name string 7 | Value []byte 8 | IsCritical bool 9 | IsHumanReadable bool 10 | } 11 | 12 | func (notation *Notation) getData() []byte { 13 | nameData := []byte(notation.Name) 14 | nameLen := len(nameData) 15 | valueLen := len(notation.Value) 16 | 17 | data := make([]byte, 8+nameLen+valueLen) 18 | if notation.IsHumanReadable { 19 | data[0] = 0x80 20 | } 21 | 22 | data[4] = byte(nameLen >> 8) 23 | data[5] = byte(nameLen) 24 | data[6] = byte(valueLen >> 8) 25 | data[7] = byte(valueLen) 26 | copy(data[8:8+nameLen], nameData) 27 | copy(data[8+nameLen:], notation.Value) 28 | return data 29 | } 30 | -------------------------------------------------------------------------------- /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/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 | // +build freebsd netbsd openbsd 7 | // +build gc 8 | 9 | #include "textflag.h" 10 | 11 | // System call support for ARM BSD 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-28 17 | B syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-40 20 | B syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-52 23 | B syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28 26 | B syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 29 | B syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /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 | -------------------------------------------------------------------------------- /vendor/github.com/cloudflare/circl/dh/x448/doc.go: -------------------------------------------------------------------------------- 1 | /* 2 | Package x448 provides Diffie-Hellman functions as specified in RFC-7748. 3 | 4 | Validation of public keys. 5 | 6 | The Diffie-Hellman function, as described in RFC-7748 [1], works for any 7 | public key. However, if a different protocol requires contributory 8 | behaviour [2,3], then the public keys must be validated against low-order 9 | points [3,4]. To do that, the Shared function performs this validation 10 | internally and returns false when the public key is invalid (i.e., it 11 | is a low-order point). 12 | 13 | References: 14 | - [1] RFC7748 by Langley, Hamburg, Turner (https://rfc-editor.org/rfc/rfc7748.txt) 15 | - [2] Curve25519 by Bernstein (https://cr.yp.to/ecdh.html) 16 | - [3] Bernstein (https://cr.yp.to/ecdh.html#validate) 17 | - [4] Cremers&Jackson (https://eprint.iacr.org/2019/526) 18 | */ 19 | package x448 20 | -------------------------------------------------------------------------------- /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 | // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris zos 7 | 8 | // Unix environment variables. 9 | 10 | package unix 11 | 12 | import "syscall" 13 | 14 | func Getenv(key string) (value string, found bool) { 15 | return syscall.Getenv(key) 16 | } 17 | 18 | func Setenv(key, value string) error { 19 | return syscall.Setenv(key, value) 20 | } 21 | 22 | func Clearenv() { 23 | syscall.Clearenv() 24 | } 25 | 26 | func Environ() []string { 27 | return syscall.Environ() 28 | } 29 | 30 | func Unsetenv(key string) error { 31 | return syscall.Unsetenv(key) 32 | } 33 | -------------------------------------------------------------------------------- /vendor/github.com/kevinburke/ssh_config/Makefile: -------------------------------------------------------------------------------- 1 | BUMP_VERSION := $(GOPATH)/bin/bump_version 2 | STATICCHECK := $(GOPATH)/bin/staticcheck 3 | WRITE_MAILMAP := $(GOPATH)/bin/write_mailmap 4 | 5 | $(STATICCHECK): 6 | go get honnef.co/go/tools/cmd/staticcheck 7 | 8 | lint: $(STATICCHECK) 9 | go vet ./... 10 | $(STATICCHECK) 11 | 12 | test: lint 13 | @# the timeout helps guard against infinite recursion 14 | go test -timeout=250ms ./... 15 | 16 | race-test: lint 17 | go test -timeout=500ms -race ./... 18 | 19 | $(BUMP_VERSION): 20 | go get -u github.com/kevinburke/bump_version 21 | 22 | $(WRITE_MAILMAP): 23 | go get -u github.com/kevinburke/write_mailmap 24 | 25 | release: test | $(BUMP_VERSION) 26 | $(BUMP_VERSION) --tag-prefix=v minor config.go 27 | 28 | force: ; 29 | 30 | AUTHORS.txt: force | $(WRITE_MAILMAP) 31 | $(WRITE_MAILMAP) > AUTHORS.txt 32 | 33 | authors: AUTHORS.txt 34 | -------------------------------------------------------------------------------- /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 | // +build freebsd netbsd openbsd 7 | // +build gc 8 | 9 | #include "textflag.h" 10 | 11 | // System call support for 386 BSD 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-28 17 | JMP syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-40 20 | JMP syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-52 23 | JMP syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28 26 | JMP syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 29 | JMP syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /vendor/github.com/cloudflare/circl/dh/x25519/doc.go: -------------------------------------------------------------------------------- 1 | /* 2 | Package x25519 provides Diffie-Hellman functions as specified in RFC-7748. 3 | 4 | Validation of public keys. 5 | 6 | The Diffie-Hellman function, as described in RFC-7748 [1], works for any 7 | public key. However, if a different protocol requires contributory 8 | behaviour [2,3], then the public keys must be validated against low-order 9 | points [3,4]. To do that, the Shared function performs this validation 10 | internally and returns false when the public key is invalid (i.e., it 11 | is a low-order point). 12 | 13 | References: 14 | - [1] RFC7748 by Langley, Hamburg, Turner (https://rfc-editor.org/rfc/rfc7748.txt) 15 | - [2] Curve25519 by Bernstein (https://cr.yp.to/ecdh.html) 16 | - [3] Bernstein (https://cr.yp.to/ecdh.html#validate) 17 | - [4] Cremers&Jackson (https://eprint.iacr.org/2019/526) 18 | */ 19 | package x25519 20 | -------------------------------------------------------------------------------- /vendor/github.com/lucasb-eyer/go-colorful/happy_palettegen.go: -------------------------------------------------------------------------------- 1 | package colorful 2 | 3 | import ( 4 | "math/rand" 5 | ) 6 | 7 | // Uses the HSV color space to generate colors with similar S,V but distributed 8 | // evenly along their Hue. This is fast but not always pretty. 9 | // If you've got time to spare, use Lab (the non-fast below). 10 | func FastHappyPalette(colorsCount int) (colors []Color) { 11 | colors = make([]Color, colorsCount) 12 | 13 | for i := 0; i < colorsCount; i++ { 14 | colors[i] = Hsv(float64(i)*(360.0/float64(colorsCount)), 0.8+rand.Float64()*0.2, 0.65+rand.Float64()*0.2) 15 | } 16 | return 17 | } 18 | 19 | func HappyPalette(colorsCount int) ([]Color, error) { 20 | pimpy := func(l, a, b float64) bool { 21 | _, c, _ := LabToHcl(l, a, b) 22 | return 0.3 <= c && 0.4 <= l && l <= 0.8 23 | } 24 | return SoftPaletteEx(colorsCount, SoftPaletteSettings{pimpy, 50, true}) 25 | } 26 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/syscall_aix_gccgo.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 | // Recreate a getsystemcfg syscall handler instead of 6 | // using the one provided by x/sys/unix to avoid having 7 | // the dependency between them. (See golang.org/issue/32102) 8 | // Moreover, this file will be used during the building of 9 | // gccgo's libgo and thus must not used a CGo method. 10 | 11 | //go:build aix && gccgo 12 | // +build aix,gccgo 13 | 14 | package cpu 15 | 16 | import ( 17 | "syscall" 18 | ) 19 | 20 | //extern getsystemcfg 21 | func gccgoGetsystemcfg(label uint32) (r uint64) 22 | 23 | func callgetsystemcfg(label int) (r1 uintptr, e1 syscall.Errno) { 24 | r1 = uintptr(gccgoGetsystemcfg(uint32(label))) 25 | e1 = syscall.GetErrno() 26 | return 27 | } 28 | -------------------------------------------------------------------------------- /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 | // +build aix,ppc 7 | 8 | // Functions to access/create device major and minor numbers matching the 9 | // encoding used by AIX. 10 | 11 | package unix 12 | 13 | // Major returns the major component of a Linux device number. 14 | func Major(dev uint64) uint32 { 15 | return uint32((dev >> 16) & 0xffff) 16 | } 17 | 18 | // Minor returns the minor component of a Linux device number. 19 | func Minor(dev uint64) uint32 { 20 | return uint32(dev & 0xffff) 21 | } 22 | 23 | // Mkdev returns a Linux device number generated from the given major and minor 24 | // components. 25 | func Mkdev(major, minor uint32) uint64 { 26 | return uint64(((major) << 16) | (minor)) 27 | } 28 | -------------------------------------------------------------------------------- /vendor/github.com/ProtonMail/go-crypto/openpgp/internal/encoding/encoding.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 | // Package encoding implements openpgp packet field encodings as specified in 6 | // RFC 4880 and 6637. 7 | package encoding 8 | 9 | import "io" 10 | 11 | // Field is an encoded field of an openpgp packet. 12 | type Field interface { 13 | // Bytes returns the decoded data. 14 | Bytes() []byte 15 | 16 | // BitLength is the size in bits of the decoded data. 17 | BitLength() uint16 18 | 19 | // EncodedBytes returns the encoded data. 20 | EncodedBytes() []byte 21 | 22 | // EncodedLength is the size in bytes of the encoded data. 23 | EncodedLength() uint16 24 | 25 | // ReadFrom reads the next Field from r. 26 | ReadFrom(r io.Reader) (int64, error) 27 | } 28 | -------------------------------------------------------------------------------- /vendor/github.com/lucasb-eyer/go-colorful/warm_palettegen.go: -------------------------------------------------------------------------------- 1 | package colorful 2 | 3 | import ( 4 | "math/rand" 5 | ) 6 | 7 | // Uses the HSV color space to generate colors with similar S,V but distributed 8 | // evenly along their Hue. This is fast but not always pretty. 9 | // If you've got time to spare, use Lab (the non-fast below). 10 | func FastWarmPalette(colorsCount int) (colors []Color) { 11 | colors = make([]Color, colorsCount) 12 | 13 | for i := 0; i < colorsCount; i++ { 14 | colors[i] = Hsv(float64(i)*(360.0/float64(colorsCount)), 0.55+rand.Float64()*0.2, 0.35+rand.Float64()*0.2) 15 | } 16 | return 17 | } 18 | 19 | func WarmPalette(colorsCount int) ([]Color, error) { 20 | warmy := func(l, a, b float64) bool { 21 | _, c, _ := LabToHcl(l, a, b) 22 | return 0.1 <= c && c <= 0.4 && 0.2 <= l && l <= 0.5 23 | } 24 | return SoftPaletteEx(colorsCount, SoftPaletteSettings{warmy, 50, true}) 25 | } 26 | -------------------------------------------------------------------------------- /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 | // +build darwin freebsd netbsd openbsd 7 | // +build gc 8 | 9 | #include "textflag.h" 10 | 11 | // System call support for ARM64 BSD 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/Microsoft/go-winio/pkg/guid/variant_string.go: -------------------------------------------------------------------------------- 1 | // Code generated by "stringer -type=Variant -trimprefix=Variant -linecomment"; DO NOT EDIT. 2 | 3 | package guid 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[VariantUnknown-0] 12 | _ = x[VariantNCS-1] 13 | _ = x[VariantRFC4122-2] 14 | _ = x[VariantMicrosoft-3] 15 | _ = x[VariantFuture-4] 16 | } 17 | 18 | const _Variant_name = "UnknownNCSRFC 4122MicrosoftFuture" 19 | 20 | var _Variant_index = [...]uint8{0, 7, 10, 18, 27, 33} 21 | 22 | func (i Variant) String() string { 23 | if i >= Variant(len(_Variant_index)-1) { 24 | return "Variant(" + strconv.FormatInt(int64(i), 10) + ")" 25 | } 26 | return _Variant_name[_Variant_index[i]:_Variant_index[i+1]] 27 | } 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 | // +build darwin freebsd netbsd openbsd 7 | // +build gc 8 | 9 | #include "textflag.h" 10 | 11 | // System call support for RISCV64 BSD 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/cli/go-gh/internal/git/git.go: -------------------------------------------------------------------------------- 1 | package git 2 | 3 | import ( 4 | "bytes" 5 | "fmt" 6 | "os/exec" 7 | 8 | "github.com/cli/safeexec" 9 | ) 10 | 11 | func Exec(args ...string) (stdOut, stdErr bytes.Buffer, err error) { 12 | path, err := path() 13 | if err != nil { 14 | err = fmt.Errorf("could not find git executable in PATH. error: %w", err) 15 | return 16 | } 17 | return run(path, nil, args...) 18 | } 19 | 20 | func path() (string, error) { 21 | return safeexec.LookPath("git") 22 | } 23 | 24 | func run(path string, env []string, args ...string) (stdOut, stdErr bytes.Buffer, err error) { 25 | cmd := exec.Command(path, args...) 26 | cmd.Stdout = &stdOut 27 | cmd.Stderr = &stdErr 28 | if env != nil { 29 | cmd.Env = env 30 | } 31 | err = cmd.Run() 32 | if err != nil { 33 | err = fmt.Errorf("failed to run git: %s. error: %w", stdErr.String(), err) 34 | return 35 | } 36 | return 37 | } 38 | -------------------------------------------------------------------------------- /vendor/github.com/emirpasic/gods/trees/trees.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2015, Emir Pasic. 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 trees provides an abstract Tree interface. 6 | // 7 | // In computer science, a tree is a widely used abstract data type (ADT) or data structure implementing this ADT that simulates a hierarchical tree structure, with a root value and subtrees of children with a parent node, represented as a set of linked nodes. 8 | // 9 | // Reference: https://en.wikipedia.org/wiki/Tree_%28data_structure%29 10 | package trees 11 | 12 | import "github.com/emirpasic/gods/containers" 13 | 14 | // Tree interface that all trees implement 15 | type Tree interface { 16 | containers.Container 17 | // Empty() bool 18 | // Size() int 19 | // Clear() 20 | // Values() []interface{} 21 | // String() string 22 | } 23 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/chacha20/chacha_s390x.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 gc && !purego 6 | // +build gc,!purego 7 | 8 | package chacha20 9 | 10 | import "golang.org/x/sys/cpu" 11 | 12 | var haveAsm = cpu.S390X.HasVX 13 | 14 | const bufSize = 256 15 | 16 | // xorKeyStreamVX is an assembly implementation of XORKeyStream. It must only 17 | // be called when the vector facility is available. Implementation in asm_s390x.s. 18 | // 19 | //go:noescape 20 | func xorKeyStreamVX(dst, src []byte, key *[8]uint32, nonce *[3]uint32, counter *uint32) 21 | 22 | func (c *Cipher) xorKeyStreamBlocks(dst, src []byte) { 23 | if cpu.S390X.HasVX { 24 | xorKeyStreamVX(dst, src, &c.key, &c.nonce, &c.counter) 25 | } else { 26 | c.xorKeyStreamBlocksGeneric(dst, src) 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /vendor/github.com/emirpasic/gods/utils/sort.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2015, Emir Pasic. 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 utils 6 | 7 | import "sort" 8 | 9 | // Sort sorts values (in-place) with respect to the given comparator. 10 | // 11 | // Uses Go's sort (hybrid of quicksort for large and then insertion sort for smaller slices). 12 | func Sort(values []interface{}, comparator Comparator) { 13 | sort.Sort(sortable{values, comparator}) 14 | } 15 | 16 | type sortable struct { 17 | values []interface{} 18 | comparator Comparator 19 | } 20 | 21 | func (s sortable) Len() int { 22 | return len(s.values) 23 | } 24 | func (s sortable) Swap(i, j int) { 25 | s.values[i], s.values[j] = s.values[j], s.values[i] 26 | } 27 | func (s sortable) Less(i, j int) bool { 28 | return s.comparator(s.values[i], s.values[j]) < 0 29 | } 30 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/worktree_windows.go: -------------------------------------------------------------------------------- 1 | // +build windows 2 | 3 | package git 4 | 5 | import ( 6 | "os" 7 | "syscall" 8 | "time" 9 | 10 | "github.com/go-git/go-git/v5/plumbing/format/index" 11 | ) 12 | 13 | func init() { 14 | fillSystemInfo = func(e *index.Entry, sys interface{}) { 15 | if os, ok := sys.(*syscall.Win32FileAttributeData); ok { 16 | seconds := os.CreationTime.Nanoseconds() / 1000000000 17 | nanoseconds := os.CreationTime.Nanoseconds() - seconds*1000000000 18 | e.CreatedAt = time.Unix(seconds, nanoseconds) 19 | } 20 | } 21 | } 22 | 23 | func isSymlinkWindowsNonAdmin(err error) bool { 24 | const ERROR_PRIVILEGE_NOT_HELD syscall.Errno = 1314 25 | 26 | if err != nil { 27 | if errLink, ok := err.(*os.LinkError); ok { 28 | if errNo, ok := errLink.Err.(syscall.Errno); ok { 29 | return errNo == ERROR_PRIVILEGE_NOT_HELD 30 | } 31 | } 32 | } 33 | 34 | return false 35 | } 36 | -------------------------------------------------------------------------------- /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 | // +build darwin freebsd netbsd openbsd 7 | // +build gc 8 | 9 | #include "textflag.h" 10 | 11 | // 12 | // System call support for ppc64, BSD 13 | // 14 | 15 | // Just jump to package syscall's implementation for all these functions. 16 | // The runtime may know about them. 17 | 18 | TEXT ·Syscall(SB),NOSPLIT,$0-56 19 | JMP syscall·Syscall(SB) 20 | 21 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 22 | JMP syscall·Syscall6(SB) 23 | 24 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 25 | JMP syscall·Syscall9(SB) 26 | 27 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 28 | JMP syscall·RawSyscall(SB) 29 | 30 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 31 | JMP syscall·RawSyscall6(SB) 32 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_arm64.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 | // +build gc 7 | 8 | #include "textflag.h" 9 | 10 | // func getisar0() uint64 11 | TEXT ·getisar0(SB),NOSPLIT,$0-8 12 | // get Instruction Set Attributes 0 into x0 13 | // mrs x0, ID_AA64ISAR0_EL1 = d5380600 14 | WORD $0xd5380600 15 | MOVD R0, ret+0(FP) 16 | RET 17 | 18 | // func getisar1() uint64 19 | TEXT ·getisar1(SB),NOSPLIT,$0-8 20 | // get Instruction Set Attributes 1 into x0 21 | // mrs x0, ID_AA64ISAR1_EL1 = d5380620 22 | WORD $0xd5380620 23 | MOVD R0, ret+0(FP) 24 | RET 25 | 26 | // func getpfr0() uint64 27 | TEXT ·getpfr0(SB),NOSPLIT,$0-8 28 | // get Processor Feature Register 0 into x0 29 | // mrs x0, ID_AA64PFR0_EL1 = d5380400 30 | WORD $0xd5380400 31 | MOVD R0, ret+0(FP) 32 | RET 33 | -------------------------------------------------------------------------------- /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 | // +build darwin dragonfly freebsd netbsd openbsd 7 | // +build gc 8 | 9 | #include "textflag.h" 10 | 11 | // System call support for AMD64 BSD 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/muesli/termenv/termenv_other.go: -------------------------------------------------------------------------------- 1 | //go:build js || plan9 || aix 2 | // +build js plan9 aix 3 | 4 | package termenv 5 | 6 | import "io" 7 | 8 | // ColorProfile returns the supported color profile: 9 | // ANSI256 10 | func (o Output) ColorProfile() Profile { 11 | return ANSI256 12 | } 13 | 14 | func (o Output) foregroundColor() Color { 15 | // default gray 16 | return ANSIColor(7) 17 | } 18 | 19 | func (o Output) backgroundColor() Color { 20 | // default black 21 | return ANSIColor(0) 22 | } 23 | 24 | // EnableVirtualTerminalProcessing enables virtual terminal processing on 25 | // Windows for w and returns a function that restores w to its previous state. 26 | // On non-Windows platforms, or if w does not refer to a terminal, then it 27 | // returns a non-nil no-op function and no error. 28 | func EnableVirtualTerminalProcessing(w io.Writer) (func() error, error) { 29 | return func() error { return nil }, nil 30 | } 31 | -------------------------------------------------------------------------------- /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/github.com/cli/go-gh/pkg/config/errors.go: -------------------------------------------------------------------------------- 1 | package config 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | // InvalidConfigFileError represents an error when trying to read a config file. 8 | type InvalidConfigFileError struct { 9 | Path string 10 | Err error 11 | } 12 | 13 | // Allow InvalidConfigFileError to satisfy error interface. 14 | func (e InvalidConfigFileError) Error() string { 15 | return fmt.Sprintf("invalid config file %s: %s", e.Path, e.Err) 16 | } 17 | 18 | // Allow InvalidConfigFileError to be unwrapped. 19 | func (e InvalidConfigFileError) Unwrap() error { 20 | return e.Err 21 | } 22 | 23 | // KeyNotFoundError represents an error when trying to find a config key 24 | // that does not exist. 25 | type KeyNotFoundError struct { 26 | Key string 27 | } 28 | 29 | // Allow KeyNotFoundError to satisfy error interface. 30 | func (e KeyNotFoundError) Error() string { 31 | return fmt.Sprintf("could not find key %q", e.Key) 32 | } 33 | -------------------------------------------------------------------------------- /vendor/github.com/muesli/termenv/.golangci-soft.yml: -------------------------------------------------------------------------------- 1 | run: 2 | tests: false 3 | 4 | issues: 5 | include: 6 | - EXC0001 7 | - EXC0005 8 | - EXC0011 9 | - EXC0012 10 | - EXC0013 11 | 12 | max-issues-per-linter: 0 13 | max-same-issues: 0 14 | 15 | linters: 16 | enable: 17 | # - dupl 18 | - exhaustive 19 | # - exhaustivestruct 20 | - goconst 21 | - godot 22 | - godox 23 | - gomnd 24 | - gomoddirectives 25 | - goprintffuncname 26 | - ifshort 27 | # - lll 28 | - misspell 29 | - nakedret 30 | - nestif 31 | - noctx 32 | - nolintlint 33 | - prealloc 34 | - wrapcheck 35 | 36 | # disable default linters, they are already enabled in .golangci.yml 37 | disable: 38 | - deadcode 39 | - errcheck 40 | - gosimple 41 | - govet 42 | - ineffassign 43 | - staticcheck 44 | - structcheck 45 | - typecheck 46 | - unused 47 | - varcheck 48 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/plumbing/format/config/decoder.go: -------------------------------------------------------------------------------- 1 | package config 2 | 3 | import ( 4 | "io" 5 | 6 | "github.com/go-git/gcfg" 7 | ) 8 | 9 | // A Decoder reads and decodes config files from an input stream. 10 | type Decoder struct { 11 | io.Reader 12 | } 13 | 14 | // NewDecoder returns a new decoder that reads from r. 15 | func NewDecoder(r io.Reader) *Decoder { 16 | return &Decoder{r} 17 | } 18 | 19 | // Decode reads the whole config from its input and stores it in the 20 | // value pointed to by config. 21 | func (d *Decoder) Decode(config *Config) error { 22 | cb := func(s string, ss string, k string, v string, bv bool) error { 23 | if ss == "" && k == "" { 24 | config.Section(s) 25 | return nil 26 | } 27 | 28 | if ss != "" && k == "" { 29 | config.Section(s).Subsection(ss) 30 | return nil 31 | } 32 | 33 | config.AddOption(s, ss, k, v) 34 | return nil 35 | } 36 | return gcfg.ReadWithCallback(d, cb) 37 | } 38 | -------------------------------------------------------------------------------- /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 | // +build windows 7 | 8 | package windows 9 | 10 | const ( 11 | EVENTLOG_SUCCESS = 0 12 | EVENTLOG_ERROR_TYPE = 1 13 | EVENTLOG_WARNING_TYPE = 2 14 | EVENTLOG_INFORMATION_TYPE = 4 15 | EVENTLOG_AUDIT_SUCCESS = 8 16 | EVENTLOG_AUDIT_FAILURE = 16 17 | ) 18 | 19 | //sys RegisterEventSource(uncServerName *uint16, sourceName *uint16) (handle Handle, err error) [failretval==0] = advapi32.RegisterEventSourceW 20 | //sys DeregisterEventSource(handle Handle) (err error) = advapi32.DeregisterEventSource 21 | //sys ReportEvent(log Handle, etype uint16, category uint16, eventId uint32, usrSId uintptr, numStrings uint16, dataSize uint32, strings **uint16, rawData *byte) (err error) = advapi32.ReportEventW 22 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-runewidth/README.md: -------------------------------------------------------------------------------- 1 | go-runewidth 2 | ============ 3 | 4 | [![Build Status](https://github.com/mattn/go-runewidth/workflows/test/badge.svg?branch=master)](https://github.com/mattn/go-runewidth/actions?query=workflow%3Atest) 5 | [![Codecov](https://codecov.io/gh/mattn/go-runewidth/branch/master/graph/badge.svg)](https://codecov.io/gh/mattn/go-runewidth) 6 | [![GoDoc](https://godoc.org/github.com/mattn/go-runewidth?status.svg)](http://godoc.org/github.com/mattn/go-runewidth) 7 | [![Go Report Card](https://goreportcard.com/badge/github.com/mattn/go-runewidth)](https://goreportcard.com/report/github.com/mattn/go-runewidth) 8 | 9 | Provides functions to get fixed width of the character or string. 10 | 11 | Usage 12 | ----- 13 | 14 | ```go 15 | runewidth.StringWidth("つのだ☆HIRO") == 12 16 | ``` 17 | 18 | 19 | Author 20 | ------ 21 | 22 | Yasuhiro Matsumoto 23 | 24 | License 25 | ------- 26 | 27 | under the MIT License: http://mattn.mit-license.org/2013 28 | -------------------------------------------------------------------------------- /vendor/github.com/alecthomas/kong/levenshtein.go: -------------------------------------------------------------------------------- 1 | package kong 2 | 3 | import "unicode/utf8" 4 | 5 | // https://en.wikibooks.org/wiki/Algorithm_Implementation/Strings/Levenshtein_distance#Go 6 | // License: https://creativecommons.org/licenses/by-sa/3.0/ 7 | func levenshtein(a, b string) int { 8 | f := make([]int, utf8.RuneCountInString(b)+1) 9 | 10 | for j := range f { 11 | f[j] = j 12 | } 13 | 14 | for _, ca := range a { 15 | j := 1 16 | fj1 := f[0] // fj1 is the value of f[j - 1] in last iteration 17 | f[0]++ 18 | for _, cb := range b { 19 | mn := min(f[j]+1, f[j-1]+1) // delete & insert 20 | if cb != ca { 21 | mn = min(mn, fj1+1) // change 22 | } else { 23 | mn = min(mn, fj1) // matched 24 | } 25 | 26 | fj1, f[j] = f[j], mn // save f[j] to fj1(j is about to increase), update f[j] to mn 27 | j++ 28 | } 29 | } 30 | 31 | return f[len(f)-1] 32 | } 33 | 34 | func min(a, b int) int { 35 | if a <= b { 36 | return a 37 | } 38 | return b 39 | } 40 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_linux_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 && (ppc64 || ppc64le) 6 | // +build linux 7 | // +build ppc64 ppc64le 8 | 9 | package cpu 10 | 11 | // HWCAP/HWCAP2 bits. These are exposed by the kernel. 12 | const ( 13 | // ISA Level 14 | _PPC_FEATURE2_ARCH_2_07 = 0x80000000 15 | _PPC_FEATURE2_ARCH_3_00 = 0x00800000 16 | 17 | // CPU features 18 | _PPC_FEATURE2_DARN = 0x00200000 19 | _PPC_FEATURE2_SCV = 0x00100000 20 | ) 21 | 22 | func doinit() { 23 | // HWCAP2 feature bits 24 | PPC64.IsPOWER8 = isSet(hwCap2, _PPC_FEATURE2_ARCH_2_07) 25 | PPC64.IsPOWER9 = isSet(hwCap2, _PPC_FEATURE2_ARCH_3_00) 26 | PPC64.HasDARN = isSet(hwCap2, _PPC_FEATURE2_DARN) 27 | PPC64.HasSCV = isSet(hwCap2, _PPC_FEATURE2_SCV) 28 | } 29 | 30 | func isSet(hwc uint, value uint) bool { 31 | return hwc&value != 0 32 | } 33 | -------------------------------------------------------------------------------- /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 | // +build linux 7 | // +build ppc64le ppc64 8 | // +build gc 9 | 10 | package unix 11 | 12 | import "syscall" 13 | 14 | func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) { 15 | return syscall.Syscall(trap, a1, a2, a3) 16 | } 17 | func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) { 18 | return syscall.Syscall6(trap, a1, a2, a3, a4, a5, a6) 19 | } 20 | func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) { 21 | return syscall.RawSyscall(trap, a1, a2, a3) 22 | } 23 | func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) { 24 | return syscall.RawSyscall6(trap, a1, a2, a3, a4, a5, a6) 25 | } 26 | -------------------------------------------------------------------------------- /vendor/golang.org/x/net/proxy/direct.go: -------------------------------------------------------------------------------- 1 | // Copyright 2011 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 proxy 6 | 7 | import ( 8 | "context" 9 | "net" 10 | ) 11 | 12 | type direct struct{} 13 | 14 | // Direct implements Dialer by making network connections directly using net.Dial or net.DialContext. 15 | var Direct = direct{} 16 | 17 | var ( 18 | _ Dialer = Direct 19 | _ ContextDialer = Direct 20 | ) 21 | 22 | // Dial directly invokes net.Dial with the supplied parameters. 23 | func (direct) Dial(network, addr string) (net.Conn, error) { 24 | return net.Dial(network, addr) 25 | } 26 | 27 | // DialContext instantiates a net.Dialer and invokes its DialContext receiver with the supplied parameters. 28 | func (direct) DialContext(ctx context.Context, network, addr string) (net.Conn, error) { 29 | var d net.Dialer 30 | return d.DialContext(ctx, network, addr) 31 | } 32 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/sha3/hashes_generic.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 !gc || purego || !s390x 6 | // +build !gc purego !s390x 7 | 8 | package sha3 9 | 10 | import ( 11 | "hash" 12 | ) 13 | 14 | // new224Asm returns an assembly implementation of SHA3-224 if available, 15 | // otherwise it returns nil. 16 | func new224Asm() hash.Hash { return nil } 17 | 18 | // new256Asm returns an assembly implementation of SHA3-256 if available, 19 | // otherwise it returns nil. 20 | func new256Asm() hash.Hash { return nil } 21 | 22 | // new384Asm returns an assembly implementation of SHA3-384 if available, 23 | // otherwise it returns nil. 24 | func new384Asm() hash.Hash { return nil } 25 | 26 | // new512Asm returns an assembly implementation of SHA3-512 if available, 27 | // otherwise it returns nil. 28 | func new512Asm() hash.Hash { return nil } 29 | -------------------------------------------------------------------------------- /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 | // +build zos,s390x 7 | 8 | // Functions to access/create device major and minor numbers matching the 9 | // encoding used by z/OS. 10 | // 11 | // The information below is extracted and adapted from macros. 12 | 13 | package unix 14 | 15 | // Major returns the major component of a z/OS device number. 16 | func Major(dev uint64) uint32 { 17 | return uint32((dev >> 16) & 0x0000FFFF) 18 | } 19 | 20 | // Minor returns the minor component of a z/OS device number. 21 | func Minor(dev uint64) uint32 { 22 | return uint32(dev & 0x0000FFFF) 23 | } 24 | 25 | // Mkdev returns a z/OS device number generated from the given major and minor 26 | // components. 27 | func Mkdev(major, minor uint32) uint64 { 28 | return (uint64(major) << 16) | uint64(minor) 29 | } 30 | -------------------------------------------------------------------------------- /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 | // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris zos 7 | 8 | package unix 9 | 10 | // Set adds fd to the set fds. 11 | func (fds *FdSet) Set(fd int) { 12 | fds.Bits[fd/NFDBITS] |= (1 << (uintptr(fd) % NFDBITS)) 13 | } 14 | 15 | // Clear removes fd from the set fds. 16 | func (fds *FdSet) Clear(fd int) { 17 | fds.Bits[fd/NFDBITS] &^= (1 << (uintptr(fd) % NFDBITS)) 18 | } 19 | 20 | // IsSet returns whether fd is in the set fds. 21 | func (fds *FdSet) IsSet(fd int) bool { 22 | return fds.Bits[fd/NFDBITS]&(1<<(uintptr(fd)%NFDBITS)) != 0 23 | } 24 | 25 | // Zero clears the set fds. 26 | func (fds *FdSet) Zero() { 27 | for i := range fds.Bits { 28 | fds.Bits[i] = 0 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/types_windows_amd64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2011 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 windows 6 | 7 | type WSAData struct { 8 | Version uint16 9 | HighVersion uint16 10 | MaxSockets uint16 11 | MaxUdpDg uint16 12 | VendorInfo *byte 13 | Description [WSADESCRIPTION_LEN + 1]byte 14 | SystemStatus [WSASYS_STATUS_LEN + 1]byte 15 | } 16 | 17 | type Servent struct { 18 | Name *byte 19 | Aliases **byte 20 | Proto *byte 21 | Port uint16 22 | } 23 | 24 | type JOBOBJECT_BASIC_LIMIT_INFORMATION struct { 25 | PerProcessUserTimeLimit int64 26 | PerJobUserTimeLimit int64 27 | LimitFlags uint32 28 | MinimumWorkingSetSize uintptr 29 | MaximumWorkingSetSize uintptr 30 | ActiveProcessLimit uint32 31 | Affinity uintptr 32 | PriorityClass uint32 33 | SchedulingClass uint32 34 | } 35 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/types_windows_arm64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2011 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 windows 6 | 7 | type WSAData struct { 8 | Version uint16 9 | HighVersion uint16 10 | MaxSockets uint16 11 | MaxUdpDg uint16 12 | VendorInfo *byte 13 | Description [WSADESCRIPTION_LEN + 1]byte 14 | SystemStatus [WSASYS_STATUS_LEN + 1]byte 15 | } 16 | 17 | type Servent struct { 18 | Name *byte 19 | Aliases **byte 20 | Proto *byte 21 | Port uint16 22 | } 23 | 24 | type JOBOBJECT_BASIC_LIMIT_INFORMATION struct { 25 | PerProcessUserTimeLimit int64 26 | PerJobUserTimeLimit int64 27 | LimitFlags uint32 28 | MinimumWorkingSetSize uintptr 29 | MaximumWorkingSetSize uintptr 30 | ActiveProcessLimit uint32 31 | Affinity uintptr 32 | PriorityClass uint32 33 | SchedulingClass uint32 34 | } 35 | -------------------------------------------------------------------------------- /vendor/github.com/cloudflare/circl/internal/sha3/xor_generic.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 (!amd64 || appengine) && (!386 || appengine) && (!ppc64le || appengine) 6 | // +build !amd64 appengine 7 | // +build !386 appengine 8 | // +build !ppc64le appengine 9 | 10 | package sha3 11 | 12 | import "encoding/binary" 13 | 14 | // xorIn xors the bytes in buf into the state; it 15 | // makes no non-portable assumptions about memory layout 16 | // or alignment. 17 | func xorIn(d *State, buf []byte) { 18 | n := len(buf) / 8 19 | 20 | for i := 0; i < n; i++ { 21 | a := binary.LittleEndian.Uint64(buf) 22 | d.a[i] ^= a 23 | buf = buf[8:] 24 | } 25 | } 26 | 27 | // copyOut copies ulint64s to a byte buffer. 28 | func copyOut(d *State, b []byte) { 29 | for i := 0; len(b) >= 8; i++ { 30 | binary.LittleEndian.PutUint64(b, d.a[i]) 31 | b = b[8:] 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/plumbing/protocol/packp/sideband/common.go: -------------------------------------------------------------------------------- 1 | package sideband 2 | 3 | // Type sideband type "side-band" or "side-band-64k" 4 | type Type int8 5 | 6 | const ( 7 | // Sideband legacy sideband type up to 1000-byte messages 8 | Sideband Type = iota 9 | // Sideband64k sideband type up to 65519-byte messages 10 | Sideband64k Type = iota 11 | 12 | // MaxPackedSize for Sideband type 13 | MaxPackedSize = 1000 14 | // MaxPackedSize64k for Sideband64k type 15 | MaxPackedSize64k = 65520 16 | ) 17 | 18 | // Channel sideband channel 19 | type Channel byte 20 | 21 | // WithPayload encode the payload as a message 22 | func (ch Channel) WithPayload(payload []byte) []byte { 23 | return append([]byte{byte(ch)}, payload...) 24 | } 25 | 26 | const ( 27 | // PackData packfile content 28 | PackData Channel = 1 29 | // ProgressMessage progress messages 30 | ProgressMessage Channel = 2 31 | // ErrorMessage fatal error message just before stream aborts 32 | ErrorMessage Channel = 3 33 | ) 34 | -------------------------------------------------------------------------------- /vendor/github.com/muesli/termenv/copy.go: -------------------------------------------------------------------------------- 1 | package termenv 2 | 3 | import ( 4 | "strings" 5 | 6 | "github.com/aymanbagabas/go-osc52/v2" 7 | ) 8 | 9 | // Copy copies text to clipboard using OSC 52 escape sequence. 10 | func (o Output) Copy(str string) { 11 | s := osc52.New(str) 12 | if strings.HasPrefix(o.environ.Getenv("TERM"), "screen") { 13 | s = s.Screen() 14 | } 15 | _, _ = s.WriteTo(o) 16 | } 17 | 18 | // CopyPrimary copies text to primary clipboard (X11) using OSC 52 escape 19 | // sequence. 20 | func (o Output) CopyPrimary(str string) { 21 | s := osc52.New(str).Primary() 22 | if strings.HasPrefix(o.environ.Getenv("TERM"), "screen") { 23 | s = s.Screen() 24 | } 25 | _, _ = s.WriteTo(o) 26 | } 27 | 28 | // Copy copies text to clipboard using OSC 52 escape sequence. 29 | func Copy(str string) { 30 | output.Copy(str) 31 | } 32 | 33 | // CopyPrimary copies text to primary clipboard (X11) using OSC 52 escape 34 | // sequence. 35 | func CopyPrimary(str string) { 36 | output.CopyPrimary(str) 37 | } 38 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_gccgo_x86.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 (386 || amd64 || amd64p32) && gccgo 6 | // +build 386 amd64 amd64p32 7 | // +build gccgo 8 | 9 | package cpu 10 | 11 | //extern gccgoGetCpuidCount 12 | func gccgoGetCpuidCount(eaxArg, ecxArg uint32, eax, ebx, ecx, edx *uint32) 13 | 14 | func cpuid(eaxArg, ecxArg uint32) (eax, ebx, ecx, edx uint32) { 15 | var a, b, c, d uint32 16 | gccgoGetCpuidCount(eaxArg, ecxArg, &a, &b, &c, &d) 17 | return a, b, c, d 18 | } 19 | 20 | //extern gccgoXgetbv 21 | func gccgoXgetbv(eax, edx *uint32) 22 | 23 | func xgetbv() (eax, edx uint32) { 24 | var a, d uint32 25 | gccgoXgetbv(&a, &d) 26 | return a, d 27 | } 28 | 29 | // gccgo doesn't build on Darwin, per: 30 | // https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/gcc.rb#L76 31 | func darwinSupportsAVX512() bool { 32 | return false 33 | } 34 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/Makefile: -------------------------------------------------------------------------------- 1 | # General 2 | WORKDIR = $(PWD) 3 | 4 | # Go parameters 5 | GOCMD = go 6 | GOTEST = $(GOCMD) test 7 | 8 | # Git config 9 | GIT_VERSION ?= 10 | GIT_DIST_PATH ?= $(PWD)/.git-dist 11 | GIT_REPOSITORY = http://github.com/git/git.git 12 | 13 | # Coverage 14 | COVERAGE_REPORT = coverage.out 15 | COVERAGE_MODE = count 16 | 17 | build-git: 18 | @if [ -f $(GIT_DIST_PATH)/git ]; then \ 19 | echo "nothing to do, using cache $(GIT_DIST_PATH)"; \ 20 | else \ 21 | git clone $(GIT_REPOSITORY) -b $(GIT_VERSION) --depth 1 --single-branch $(GIT_DIST_PATH); \ 22 | cd $(GIT_DIST_PATH); \ 23 | make configure; \ 24 | ./configure; \ 25 | make all; \ 26 | fi 27 | 28 | test: 29 | @echo "running against `git version`"; \ 30 | $(GOTEST) ./... 31 | 32 | test-coverage: 33 | @echo "running against `git version`"; \ 34 | echo "" > $(COVERAGE_REPORT); \ 35 | $(GOTEST) -coverprofile=$(COVERAGE_REPORT) -coverpkg=./... -covermode=$(COVERAGE_MODE) ./... 36 | 37 | clean: 38 | rm -rf $(GIT_DIST_PATH) -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-colorable/colorable_appengine.go: -------------------------------------------------------------------------------- 1 | //go:build appengine 2 | // +build appengine 3 | 4 | package colorable 5 | 6 | import ( 7 | "io" 8 | "os" 9 | 10 | _ "github.com/mattn/go-isatty" 11 | ) 12 | 13 | // NewColorable returns new instance of Writer which handles escape sequence. 14 | func NewColorable(file *os.File) io.Writer { 15 | if file == nil { 16 | panic("nil passed instead of *os.File to NewColorable()") 17 | } 18 | 19 | return file 20 | } 21 | 22 | // NewColorableStdout returns new instance of Writer which handles escape sequence for stdout. 23 | func NewColorableStdout() io.Writer { 24 | return os.Stdout 25 | } 26 | 27 | // NewColorableStderr returns new instance of Writer which handles escape sequence for stderr. 28 | func NewColorableStderr() io.Writer { 29 | return os.Stderr 30 | } 31 | 32 | // EnableColorsStdout enable colors if possible. 33 | func EnableColorsStdout(enabled *bool) func() { 34 | if enabled != nil { 35 | *enabled = true 36 | } 37 | return func() {} 38 | } 39 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/ssh/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2011 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 | /* 6 | Package ssh implements an SSH client and server. 7 | 8 | SSH is a transport security protocol, an authentication protocol and a 9 | family of application protocols. The most typical application level 10 | protocol is a remote shell and this is specifically implemented. However, 11 | the multiplexed nature of SSH is exposed to users that wish to support 12 | others. 13 | 14 | References: 15 | 16 | [PROTOCOL.certkeys]: http://cvsweb.openbsd.org/cgi-bin/cvsweb/src/usr.bin/ssh/PROTOCOL.certkeys?rev=HEAD 17 | [SSH-PARAMETERS]: http://www.iana.org/assignments/ssh-parameters/ssh-parameters.xml#ssh-parameters-1 18 | 19 | This package does not fall under the stability promise of the Go language itself, 20 | so its API may be changed when pressing needs arise. 21 | */ 22 | package ssh // import "golang.org/x/crypto/ssh" 23 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/dev_aix_ppc64.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 && ppc64 6 | // +build aix,ppc64 7 | 8 | // Functions to access/create device major and minor numbers matching the 9 | // encoding used AIX. 10 | 11 | package unix 12 | 13 | // Major returns the major component of a Linux device number. 14 | func Major(dev uint64) uint32 { 15 | return uint32((dev & 0x3fffffff00000000) >> 32) 16 | } 17 | 18 | // Minor returns the minor component of a Linux device number. 19 | func Minor(dev uint64) uint32 { 20 | return uint32((dev & 0x00000000ffffffff) >> 0) 21 | } 22 | 23 | // Mkdev returns a Linux device number generated from the given major and minor 24 | // components. 25 | func Mkdev(major, minor uint32) uint64 { 26 | var DEVNO64 uint64 27 | DEVNO64 = 0x8000000000000000 28 | return ((uint64(major) << 32) | (uint64(minor) & 0x00000000FFFFFFFF) | DEVNO64) 29 | } 30 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-colorable/colorable_others.go: -------------------------------------------------------------------------------- 1 | //go:build !windows && !appengine 2 | // +build !windows,!appengine 3 | 4 | package colorable 5 | 6 | import ( 7 | "io" 8 | "os" 9 | 10 | _ "github.com/mattn/go-isatty" 11 | ) 12 | 13 | // NewColorable returns new instance of Writer which handles escape sequence. 14 | func NewColorable(file *os.File) io.Writer { 15 | if file == nil { 16 | panic("nil passed instead of *os.File to NewColorable()") 17 | } 18 | 19 | return file 20 | } 21 | 22 | // NewColorableStdout returns new instance of Writer which handles escape sequence for stdout. 23 | func NewColorableStdout() io.Writer { 24 | return os.Stdout 25 | } 26 | 27 | // NewColorableStderr returns new instance of Writer which handles escape sequence for stderr. 28 | func NewColorableStderr() io.Writer { 29 | return os.Stderr 30 | } 31 | 32 | // EnableColorsStdout enable colors if possible. 33 | func EnableColorsStdout(enabled *bool) func() { 34 | if enabled != nil { 35 | *enabled = true 36 | } 37 | return func() {} 38 | } 39 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_netbsd_386.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 386 && netbsd 6 | // +build 386,netbsd 7 | 8 | package unix 9 | 10 | func setTimespec(sec, nsec int64) Timespec { 11 | return Timespec{Sec: sec, Nsec: int32(nsec)} 12 | } 13 | 14 | func setTimeval(sec, usec int64) Timeval { 15 | return Timeval{Sec: sec, Usec: int32(usec)} 16 | } 17 | 18 | func SetKevent(k *Kevent_t, fd, mode, flags int) { 19 | k.Ident = uint32(fd) 20 | k.Filter = uint32(mode) 21 | k.Flags = uint32(flags) 22 | } 23 | 24 | func (iov *Iovec) SetLen(length int) { 25 | iov.Len = uint32(length) 26 | } 27 | 28 | func (msghdr *Msghdr) SetControllen(length int) { 29 | msghdr.Controllen = uint32(length) 30 | } 31 | 32 | func (msghdr *Msghdr) SetIovlen(length int) { 33 | msghdr.Iovlen = int32(length) 34 | } 35 | 36 | func (cmsg *Cmsghdr) SetLen(length int) { 37 | cmsg.Len = uint32(length) 38 | } 39 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_netbsd_amd64.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 amd64 && netbsd 6 | // +build amd64,netbsd 7 | 8 | package unix 9 | 10 | func setTimespec(sec, nsec int64) Timespec { 11 | return Timespec{Sec: sec, Nsec: nsec} 12 | } 13 | 14 | func setTimeval(sec, usec int64) Timeval { 15 | return Timeval{Sec: sec, Usec: int32(usec)} 16 | } 17 | 18 | func SetKevent(k *Kevent_t, fd, mode, flags int) { 19 | k.Ident = uint64(fd) 20 | k.Filter = uint32(mode) 21 | k.Flags = uint32(flags) 22 | } 23 | 24 | func (iov *Iovec) SetLen(length int) { 25 | iov.Len = uint64(length) 26 | } 27 | 28 | func (msghdr *Msghdr) SetControllen(length int) { 29 | msghdr.Controllen = uint32(length) 30 | } 31 | 32 | func (msghdr *Msghdr) SetIovlen(length int) { 33 | msghdr.Iovlen = int32(length) 34 | } 35 | 36 | func (cmsg *Cmsghdr) SetLen(length int) { 37 | cmsg.Len = uint32(length) 38 | } 39 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_netbsd_arm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2013 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 && netbsd 6 | // +build arm,netbsd 7 | 8 | package unix 9 | 10 | func setTimespec(sec, nsec int64) Timespec { 11 | return Timespec{Sec: sec, Nsec: int32(nsec)} 12 | } 13 | 14 | func setTimeval(sec, usec int64) Timeval { 15 | return Timeval{Sec: sec, Usec: int32(usec)} 16 | } 17 | 18 | func SetKevent(k *Kevent_t, fd, mode, flags int) { 19 | k.Ident = uint32(fd) 20 | k.Filter = uint32(mode) 21 | k.Flags = uint32(flags) 22 | } 23 | 24 | func (iov *Iovec) SetLen(length int) { 25 | iov.Len = uint32(length) 26 | } 27 | 28 | func (msghdr *Msghdr) SetControllen(length int) { 29 | msghdr.Controllen = uint32(length) 30 | } 31 | 32 | func (msghdr *Msghdr) SetIovlen(length int) { 33 | msghdr.Iovlen = int32(length) 34 | } 35 | 36 | func (cmsg *Cmsghdr) SetLen(length int) { 37 | cmsg.Len = uint32(length) 38 | } 39 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_netbsd_arm64.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 arm64 && netbsd 6 | // +build arm64,netbsd 7 | 8 | package unix 9 | 10 | func setTimespec(sec, nsec int64) Timespec { 11 | return Timespec{Sec: sec, Nsec: nsec} 12 | } 13 | 14 | func setTimeval(sec, usec int64) Timeval { 15 | return Timeval{Sec: sec, Usec: int32(usec)} 16 | } 17 | 18 | func SetKevent(k *Kevent_t, fd, mode, flags int) { 19 | k.Ident = uint64(fd) 20 | k.Filter = uint32(mode) 21 | k.Flags = uint32(flags) 22 | } 23 | 24 | func (iov *Iovec) SetLen(length int) { 25 | iov.Len = uint64(length) 26 | } 27 | 28 | func (msghdr *Msghdr) SetControllen(length int) { 29 | msghdr.Controllen = uint32(length) 30 | } 31 | 32 | func (msghdr *Msghdr) SetIovlen(length int) { 33 | msghdr.Iovlen = int32(length) 34 | } 35 | 36 | func (cmsg *Cmsghdr) SetLen(length int) { 37 | cmsg.Len = uint32(length) 38 | } 39 | -------------------------------------------------------------------------------- /vendor/golang.org/x/term/CONTRIBUTING.md: -------------------------------------------------------------------------------- 1 | # Contributing to Go 2 | 3 | Go is an open source project. 4 | 5 | It is the work of hundreds of contributors. We appreciate your help! 6 | 7 | ## Filing issues 8 | 9 | When [filing an issue](https://golang.org/issue/new), make sure to answer these five questions: 10 | 11 | 1. What version of Go are you using (`go version`)? 12 | 2. What operating system and processor architecture are you using? 13 | 3. What did you do? 14 | 4. What did you expect to see? 15 | 5. What did you see instead? 16 | 17 | General questions should go to the [golang-nuts mailing list](https://groups.google.com/group/golang-nuts) instead of the issue tracker. 18 | The gophers there will answer or ask you to file an issue if you've tripped over a bug. 19 | 20 | ## Contributing code 21 | 22 | Please read the [Contribution Guidelines](https://golang.org/doc/contribute.html) 23 | before sending patches. 24 | 25 | Unless otherwise noted, the Go source files are distributed under 26 | the BSD-style license found in the LICENSE file. 27 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/go-git/v5/storage/storer.go: -------------------------------------------------------------------------------- 1 | package storage 2 | 3 | import ( 4 | "errors" 5 | 6 | "github.com/go-git/go-git/v5/config" 7 | "github.com/go-git/go-git/v5/plumbing/storer" 8 | ) 9 | 10 | var ErrReferenceHasChanged = errors.New("reference has changed concurrently") 11 | 12 | // Storer is a generic storage of objects, references and any information 13 | // related to a particular repository. The package github.com/go-git/go-git/v5/storage 14 | // contains two implementation a filesystem base implementation (such as `.git`) 15 | // and a memory implementations being ephemeral 16 | type Storer interface { 17 | storer.EncodedObjectStorer 18 | storer.ReferenceStorer 19 | storer.ShallowStorer 20 | storer.IndexStorer 21 | config.ConfigStorer 22 | ModuleStorer 23 | } 24 | 25 | // ModuleStorer allows interact with the modules' Storers 26 | type ModuleStorer interface { 27 | // Module returns a Storer representing a submodule, if not exists returns a 28 | // new empty Storer is returned 29 | Module(name string) (Storer, error) 30 | } 31 | -------------------------------------------------------------------------------- /vendor/github.com/pjbgf/sha1cd/Makefile: -------------------------------------------------------------------------------- 1 | FUZZ_TIME ?= 1m 2 | 3 | export CGO_ENABLED := 1 4 | 5 | .PHONY: test 6 | test: 7 | go test ./... 8 | 9 | .PHONY: bench 10 | bench: 11 | go test -benchmem -run=^$$ -bench ^Benchmark ./... 12 | 13 | .PHONY: fuzz 14 | fuzz: 15 | go test -tags gofuzz -fuzz=. -fuzztime=$(FUZZ_TIME) ./test/ 16 | 17 | # Cross build project in arm/v7. 18 | build-arm: 19 | docker build -t sha1cd-arm -f Dockerfile.arm . 20 | docker run --rm sha1cd-arm 21 | 22 | # Cross build project in arm64. 23 | build-arm64: 24 | docker build -t sha1cd-arm64 -f Dockerfile.arm64 . 25 | docker run --rm sha1cd-arm64 26 | 27 | # Build with cgo disabled. 28 | build-nocgo: 29 | CGO_ENABLED=0 go build ./cgo 30 | 31 | # Run cross-compilation to assure supported architectures. 32 | cross-build: build-arm build-arm64 build-nocgo 33 | 34 | generate: 35 | go run sha1cdblock_amd64_asm.go -out sha1cdblock_amd64.s 36 | sed -i 's;&\samd64;&\n// +build !noasm,gc,amd64;g' sha1cdblock_amd64.s 37 | 38 | verify: generate 39 | git diff --exit-code 40 | go vet ./... 41 | -------------------------------------------------------------------------------- /vendor/github.com/thlib/go-timezone-local/tzlocal/tz.go: -------------------------------------------------------------------------------- 1 | package tzlocal 2 | 3 | import ( 4 | "fmt" 5 | "os" 6 | "time" 7 | ) 8 | 9 | // EnvTZ will return the TZ env value if it is set, go will revert any invalid timezone to UTC 10 | func EnvTZ() (string, bool) { 11 | if name, ok := os.LookupEnv("TZ"); ok { 12 | // Go treats blank as UTC 13 | if name == "" { 14 | return "UTC", true 15 | } 16 | _, err := time.LoadLocation(name) 17 | // Go treats invalid as UTC 18 | if err != nil { 19 | return "UTC", true 20 | } 21 | return name, true 22 | } 23 | return "", false 24 | } 25 | 26 | // RuntimeTZ get the full timezone name of the local machine 27 | func RuntimeTZ() (string, error) { 28 | 29 | // Get the timezone from the TZ env variable 30 | if name, ok := EnvTZ(); ok { 31 | return name, nil 32 | } 33 | 34 | // Get the timezone from the system file 35 | name, err := LocalTZ() 36 | if err != nil { 37 | err = fmt.Errorf("failed to get local machine timezone: %w", err) 38 | return "", err 39 | } 40 | 41 | return name, err 42 | } 43 | -------------------------------------------------------------------------------- /vendor/golang.org/x/tools/internal/pkgbits/reloc.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 | package pkgbits 6 | 7 | // A RelocKind indicates a particular section within a unified IR export. 8 | type RelocKind int32 9 | 10 | // An Index represents a bitstream element index within a particular 11 | // section. 12 | type Index int32 13 | 14 | // A relocEnt (relocation entry) is an entry in an element's local 15 | // reference table. 16 | // 17 | // TODO(mdempsky): Rename this too. 18 | type RelocEnt struct { 19 | Kind RelocKind 20 | Idx Index 21 | } 22 | 23 | // Reserved indices within the meta relocation section. 24 | const ( 25 | PublicRootIdx Index = 0 26 | PrivateRootIdx Index = 1 27 | ) 28 | 29 | const ( 30 | RelocString RelocKind = iota 31 | RelocMeta 32 | RelocPosBase 33 | RelocPkg 34 | RelocName 35 | RelocType 36 | RelocObj 37 | RelocObjExt 38 | RelocObjDict 39 | RelocBody 40 | 41 | numRelocs = iota 42 | ) 43 | -------------------------------------------------------------------------------- /main.go: -------------------------------------------------------------------------------- 1 | // cspell:ignore kongplete 2 | 3 | package main 4 | 5 | import ( 6 | "os" 7 | "reflect" 8 | "regexp" 9 | 10 | "github.com/alecthomas/kong" 11 | ) 12 | 13 | var cmd struct { 14 | Clean clean `cmd:"" help:"Remove cache."` 15 | Run run `cmd:"" help:"Execute a command."` 16 | } 17 | 18 | type regexpMapper bool 19 | 20 | func (m regexpMapper) Decode(ctx *kong.DecodeContext, target reflect.Value) error { 21 | var regexString string 22 | if err := ctx.Scan.PopValueInto("regex", ®exString); err != nil { 23 | return err 24 | } 25 | r, err := regexp.CompilePOSIX(regexString) 26 | if err != nil { 27 | return err 28 | } 29 | target.Set(reflect.ValueOf(r)) 30 | return nil 31 | } 32 | 33 | func main() { 34 | parser := kong.Must(&cmd, 35 | kong.Description("Automatically clone and execute commands across multiple GitHub repositories."), 36 | kong.TypeMapper(reflect.TypeOf(®exp.Regexp{}), regexpMapper(false))) 37 | ctx, err := parser.Parse(os.Args[1:]) 38 | parser.FatalIfErrorf(err) 39 | err = ctx.Run() 40 | ctx.FatalIfErrorf(err) 41 | } 42 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/dev_netbsd.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 NetBSD's sys/types.h header. 7 | 8 | package unix 9 | 10 | // Major returns the major component of a NetBSD device number. 11 | func Major(dev uint64) uint32 { 12 | return uint32((dev & 0x000fff00) >> 8) 13 | } 14 | 15 | // Minor returns the minor component of a NetBSD device number. 16 | func Minor(dev uint64) uint32 { 17 | minor := uint32((dev & 0x000000ff) >> 0) 18 | minor |= uint32((dev & 0xfff00000) >> 12) 19 | return minor 20 | } 21 | 22 | // Mkdev returns a NetBSD device number generated from the given major and minor 23 | // components. 24 | func Mkdev(major, minor uint32) uint64 { 25 | dev := (uint64(major) << 8) & 0x000fff00 26 | dev |= (uint64(minor) << 12) & 0xfff00000 27 | dev |= (uint64(minor) << 0) & 0x000000ff 28 | return dev 29 | } 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/types_windows_386.go: -------------------------------------------------------------------------------- 1 | // Copyright 2011 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 windows 6 | 7 | type WSAData struct { 8 | Version uint16 9 | HighVersion uint16 10 | Description [WSADESCRIPTION_LEN + 1]byte 11 | SystemStatus [WSASYS_STATUS_LEN + 1]byte 12 | MaxSockets uint16 13 | MaxUdpDg uint16 14 | VendorInfo *byte 15 | } 16 | 17 | type Servent struct { 18 | Name *byte 19 | Aliases **byte 20 | Port uint16 21 | Proto *byte 22 | } 23 | 24 | type JOBOBJECT_BASIC_LIMIT_INFORMATION struct { 25 | PerProcessUserTimeLimit int64 26 | PerJobUserTimeLimit int64 27 | LimitFlags uint32 28 | MinimumWorkingSetSize uintptr 29 | MaximumWorkingSetSize uintptr 30 | ActiveProcessLimit uint32 31 | Affinity uintptr 32 | PriorityClass uint32 33 | SchedulingClass uint32 34 | _ uint32 // pad to 8 byte boundary 35 | } 36 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/types_windows_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 | package windows 6 | 7 | type WSAData struct { 8 | Version uint16 9 | HighVersion uint16 10 | Description [WSADESCRIPTION_LEN + 1]byte 11 | SystemStatus [WSASYS_STATUS_LEN + 1]byte 12 | MaxSockets uint16 13 | MaxUdpDg uint16 14 | VendorInfo *byte 15 | } 16 | 17 | type Servent struct { 18 | Name *byte 19 | Aliases **byte 20 | Port uint16 21 | Proto *byte 22 | } 23 | 24 | type JOBOBJECT_BASIC_LIMIT_INFORMATION struct { 25 | PerProcessUserTimeLimit int64 26 | PerJobUserTimeLimit int64 27 | LimitFlags uint32 28 | MinimumWorkingSetSize uintptr 29 | MaximumWorkingSetSize uintptr 30 | ActiveProcessLimit uint32 31 | Affinity uintptr 32 | PriorityClass uint32 33 | SchedulingClass uint32 34 | _ uint32 // pad to 8 byte boundary 35 | } 36 | -------------------------------------------------------------------------------- /vendor/github.com/go-git/gcfg/errors.go: -------------------------------------------------------------------------------- 1 | package gcfg 2 | 3 | import ( 4 | "gopkg.in/warnings.v0" 5 | ) 6 | 7 | // FatalOnly filters the results of a Read*Into invocation and returns only 8 | // fatal errors. That is, errors (warnings) indicating data for unknown 9 | // sections / variables is ignored. Example invocation: 10 | // 11 | // err := gcfg.FatalOnly(gcfg.ReadFileInto(&cfg, configFile)) 12 | // if err != nil { 13 | // ... 14 | // 15 | func FatalOnly(err error) error { 16 | return warnings.FatalOnly(err) 17 | } 18 | 19 | func isFatal(err error) bool { 20 | _, ok := err.(extraData) 21 | return !ok 22 | } 23 | 24 | type extraData struct { 25 | section string 26 | subsection *string 27 | variable *string 28 | } 29 | 30 | func (e extraData) Error() string { 31 | s := "can't store data at section \"" + e.section + "\"" 32 | if e.subsection != nil { 33 | s += ", subsection \"" + *e.subsection + "\"" 34 | } 35 | if e.variable != nil { 36 | s += ", variable \"" + *e.variable + "\"" 37 | } 38 | return s 39 | } 40 | 41 | var _ error = extraData{} 42 | --------------------------------------------------------------------------------