Overview

Statistics (detailed ones)
	Total 152 packages analyzed and 990 Go files
	(321568 lines of code) parsed. On average,
	* each Go source file imports 2.47 packages
	  and contains 325 lines of code.
	* each package depends on 6.02 other packages,
	  contains 6.96 source code files, and exports
	  - 9.14 type names,
	  - 2.94 variables,
	  - 22.08 constants,
	  - 11.40 functions.

All Packages (sort packages by: alphabet | imported-by count | lines of code | dependency distance)
       1. github.com/workos/workos-go/v8 - provides a Go client for the WorkOS API.
       2. bufio - implements buffered I/O. It wraps an io.Reader or io.Writer object, creating another object (Reader or Writer) that also implements the interface but provides buffering and some help for textual I/O.
       3. builtin
       4. bytes - implements functions for the manipulation of byte slices.
       5. cmp - provides types and functions related to comparing ordered values.
       6. compress/flate - implements the DEFLATE compressed data format, described in RFC 1951.
       7. compress/gzip - implements reading and writing of gzip format compressed files, as specified in RFC 1952.
       8. container/list - implements a doubly linked list.
       9. context - defines the Context type, which carries deadlines, cancellation signals, and other request-scoped values across API boundaries and between processes.
      10. crypto - collects common cryptographic constants.
      11. crypto/aes - implements AES encryption (formerly Rijndael), as defined in U.S. Federal Information Processing Standards Publication 197.
      12. crypto/cipher - implements standard block cipher modes that can be wrapped around low-level block cipher implementations.
      13. crypto/des - implements the Data Encryption Standard (DES) and the Triple Data Encryption Algorithm (TDEA) as defined in U.S. Federal Information Processing Standards Publication 46-3.
      14. crypto/dsa - implements the Digital Signature Algorithm, as defined in FIPS 186-3.
      15. crypto/ecdh - implements Elliptic Curve Diffie-Hellman over NIST curves and Curve25519.
      16. crypto/ecdsa - implements the Elliptic Curve Digital Signature Algorithm, as defined in FIPS 186-4 and SEC 1, Version 2.0.
      17. crypto/ed25519 - implements the Ed25519 signature algorithm.
      18. crypto/elliptic - implements the standard NIST P-224, P-256, P-384, and P-521 elliptic curves over prime fields.
      19. crypto/hmac - implements the Keyed-Hash Message Authentication Code (HMAC) as defined in U.S. Federal Information Processing Standards Publication 198.
      20. crypto/internal/alias - implements memory aliasing tests.
      21. crypto/internal/bigmod
      22. crypto/internal/boring - provides access to BoringCrypto implementation functions.
      23. crypto/internal/boring/bbig
      24. crypto/internal/boring/sig - holds “code signatures” that can be called and will result in certain code sequences being linked into the final binary.
      25. crypto/internal/edwards25519 - implements group logic for the twisted Edwards curve
      26. crypto/internal/edwards25519/field - implements fast arithmetic modulo 2^255-19.
      27. crypto/internal/hpke
      28. crypto/internal/mlkem768 - implements the quantum-resistant key encapsulation method ML-KEM (formerly known as Kyber).
      29. crypto/internal/nistec - implements the NIST P elliptic curves from FIPS 186-4.
      30. crypto/internal/nistec/fiat
      31. crypto/internal/randutil - contains internal randomness utilities for various crypto packages.
      32. crypto/md5 - implements the MD5 hash algorithm as defined in RFC 1321.
      33. crypto/rand - implements a cryptographically secure random number generator.
      34. crypto/rc4 - implements RC4 encryption, as defined in Bruce Schneier's Applied Cryptography.
      35. crypto/rsa - implements RSA encryption as specified in PKCS #1 and RFC 8017.
      36. crypto/sha1 - implements the SHA-1 hash algorithm as defined in RFC 3174.
      37. crypto/sha256 - implements the SHA224 and SHA256 hash algorithms as defined in FIPS 180-4.
      38. crypto/sha512 - implements the SHA-384, SHA-512, SHA-512/224, and SHA-512/256 hash algorithms as defined in FIPS 180-4.
      39. crypto/subtle - implements functions that are often useful in cryptographic code but require careful thought to use correctly.
      40. crypto/tls - partially implements TLS 1.2, as specified in RFC 5246, and TLS 1.3, as specified in RFC 8446.
      41. crypto/x509 - implements a subset of the X.509 standard.
      42. crypto/x509/pkix - contains shared, low level structures used for ASN.1 parsing and serialization of X.509 certificates, CRL and OCSP.
      43. database/sql/driver - defines interfaces to be implemented by database drivers as used by package sql.
      44. embed - provides access to files embedded in the running Go program.
      45. encoding - defines interfaces shared by other packages that convert data to and from byte-level and textual representations.
      46. encoding/asn1 - implements parsing of DER-encoded ASN.1 data structures, as defined in ITU-T Rec X.690.
      47. encoding/base64 - implements base64 encoding as specified by RFC 4648.
      48. encoding/binary - implements simple translation between numbers and byte sequences and encoding and decoding of varints.
      49. encoding/hex - implements hexadecimal encoding and decoding.
      50. encoding/json - implements encoding and decoding of JSON as defined in RFC 7159.
      51. encoding/pem - implements the PEM data encoding, which originated in Privacy Enhanced Mail.
      52. errors - implements functions to manipulate errors.
      53. fmt - implements formatted I/O with functions analogous to C's printf and scanf.
      54. github.com/google/go-querystring/query - implements encoding of structs into URL query parameters.
      55. github.com/google/uuid - generates and inspects UUIDs.
      56. hash - provides interfaces for hash functions.
      57. hash/crc32 - implements the 32-bit cyclic redundancy check, or CRC-32, checksum.
      58. internal/abi
      59. internal/asan - contains helper functions for manually instrumenting code for the address sanitizer.
      60. internal/bisect - can be used by compilers and other programs to serve as a target for the bisect debugging tool.
      61. internal/bytealg
      62. internal/byteorder - provides functions for decoding and encoding little and big endian integer types from/to byte slices.
      63. internal/chacha8rand - implements a pseudorandom generator based on ChaCha8.
      64. internal/concurrent
      65. internal/coverage/rtcov
      66. internal/cpu - implements processor feature detection used by the Go standard library.
      67. internal/filepathlite - implements a subset of path/filepath, only using packages which may be imported by "os".
      68. internal/fmtsort - provides a general stable ordering mechanism for maps, on behalf of the fmt and text/template packages.
      69. internal/goarch - package goarch contains GOARCH-specific constants.
      70. internal/godebug - makes the settings in the $GODEBUG environment variable available to other packages.
      71. internal/godebugs - provides a table of known GODEBUG settings, for use by a variety of other packages, including internal/godebug, runtime, runtime/metrics, and cmd/go/internal/load.
      72. internal/goexperiment - implements support for toolchain experiments.
      73. internal/goos - package goos contains GOOS-specific constants.
      74. internal/itoa
      75. internal/msan - contains helper functions for manually instrumenting code for the memory sanitizer.
      76. internal/nettrace - contains internal hooks for tracing activity in the net package.
      77. internal/oserror - defines errors values used in the os package.
      78. internal/poll - supports non-blocking I/O on file descriptors with polling.
      79. internal/profilerecord - holds internal types used to represent profiling records with deep stack traces.
      80. internal/race - contains helper functions for manually instrumenting code for the race detector.
      81. internal/reflectlite - implements lightweight version of reflect, not using any package except for "runtime", "unsafe", and "internal/abi"
      82. internal/runtime/atomic - provides atomic operations, independent of sync/atomic, to the runtime.
      83. internal/runtime/exithook - provides limited support for on-exit cleanup.
      84. internal/runtime/syscall - provides the syscall primitives required for the runtime.
      85. internal/singleflight - provides a duplicate function call suppression mechanism.
      86. internal/stringslite - implements a subset of strings, only using packages that may be imported by "os".
      87. internal/syscall/execenv
      88. internal/syscall/unix
      89. internal/testlog - provides a back-channel communication path between tests and package os, so that cmd/go can see which environment variables and files a test consults.
      90. internal/unsafeheader - contains header declarations for the Go runtime's slice and string implementations.
      91. internal/weak - The weak package is a package for managing weak pointers.
      92. io - provides basic interfaces to I/O primitives.
      93. io/fs - defines basic interfaces to a file system.
      94. iter - provides basic definitions and operations related to iterators over sequences.
      95. log - implements a simple logging package.
      96. log/internal - contains definitions used by both log and log/slog.
      97. maps - defines various functions useful with maps of any type.
      98. math - provides basic constants and mathematical functions.
      99. math/big - implements arbitrary-precision arithmetic (big numbers).
     100. math/bits - implements bit counting and manipulation functions for the predeclared unsigned integer types.
     101. math/rand - implements pseudo-random number generators suitable for tasks such as simulation, but it should not be used for security-sensitive work.
     102. math/rand/v2 - implements pseudo-random number generators suitable for tasks such as simulation, but it should not be used for security-sensitive work.
     103. mime - implements parts of the MIME spec.
     104. mime/multipart - implements MIME multipart parsing, as defined in RFC 2046.
     105. mime/quotedprintable - implements quoted-printable encoding as specified by RFC 2045.
     106. net - provides a portable interface for network I/O, including TCP/IP, UDP, domain name resolution, and Unix domain sockets.
     107. net/http - provides HTTP client and server implementations.
     108. net/http/httptrace - provides mechanisms to trace the events within HTTP client requests.
     109. net/http/internal - contains HTTP internals shared by net/http and net/http/httputil.
     110. net/http/internal/ascii
     111. net/netip - defines an IP address type that's a small value type.
     112. net/textproto - implements generic support for text-based request/response protocols in the style of HTTP, NNTP, and SMTP.
     113. net/url - parses URLs and implements query escaping.
     114. os - provides a platform-independent interface to operating system functionality.
     115. path - implements utility routines for manipulating slash-separated paths.
     116. path/filepath - implements utility routines for manipulating filename paths in a way compatible with the target operating system-defined file paths.
     117. reflect - implements run-time reflection, allowing a program to manipulate objects with arbitrary types.
     118. runtime - contains operations that interact with Go's runtime system, such as functions to control goroutines.
     119. runtime/cgo - contains runtime support for code generated by the cgo tool.
     120. runtime/internal/math
     121. runtime/internal/sys - package sys contains system- and configuration- and architecture-specific constants used by the runtime.
     122. slices - defines various functions useful with slices of any type.
     123. sort - provides primitives for sorting slices and user-defined collections.
     124. strconv - implements conversions to and from string representations of basic data types.
     125. strings - implements simple functions to manipulate UTF-8 encoded strings.
     126. sync - provides basic synchronization primitives such as mutual exclusion locks.
     127. sync/atomic - provides low-level atomic memory primitives useful for implementing synchronization algorithms.
     128. syscall - contains an interface to the low-level operating system primitives.
     129. time - provides functionality for measuring and displaying time.
     130. unicode - provides data and functions to test some properties of Unicode code points.
     131. unicode/utf16 - implements encoding and decoding of UTF-16 sequences.
     132. unicode/utf8 - implements functions and constants to support text encoded in UTF-8.
     133. unique - The unique package provides facilities for canonicalizing ("interning") comparable values.
     134. unsafe - contains operations that step around the type safety of Go programs.
     135. vendor/golang.org/x/crypto/chacha20 - implements the ChaCha20 and XChaCha20 encryption algorithms as specified in RFC 8439 and draft-irtf-cfrg-xchacha-01.
     136. vendor/golang.org/x/crypto/chacha20poly1305 - implements the ChaCha20-Poly1305 AEAD and its extended nonce variant XChaCha20-Poly1305, as specified in RFC 8439 and draft-irtf-cfrg-xchacha-01.
     137. vendor/golang.org/x/crypto/cryptobyte - contains types that help with parsing and constructing length-prefixed, binary messages, including ASN.1 DER.
     138. vendor/golang.org/x/crypto/cryptobyte/asn1 - contains supporting types for parsing and building ASN.1 messages with the cryptobyte package.
     139. vendor/golang.org/x/crypto/hkdf - implements the HMAC-based Extract-and-Expand Key Derivation Function (HKDF) as defined in RFC 5869.
     140. vendor/golang.org/x/crypto/internal/alias - implements memory aliasing tests.
     141. vendor/golang.org/x/crypto/internal/poly1305 - implements Poly1305 one-time message authentication code as specified in https://cr.yp.to/mac/poly1305-20050329.pdf.
     142. vendor/golang.org/x/crypto/sha3 - implements the SHA-3 fixed-output-length hash functions and the SHAKE variable-output-length hash functions defined by FIPS-202.
     143. vendor/golang.org/x/net/dns/dnsmessage - provides a mostly RFC 1035 compliant implementation of DNS message packing and unpacking.
     144. vendor/golang.org/x/net/http/httpguts - provides functions implementing various details of the HTTP specification.
     145. vendor/golang.org/x/net/http/httpproxy - provides support for HTTP proxy determination based on environment variables, as provided by net/http's ProxyFromEnvironment function.
     146. vendor/golang.org/x/net/http2/hpack - implements HPACK, a compression format for efficiently representing HTTP header fields in the context of HTTP/2.
     147. vendor/golang.org/x/net/idna - implements IDNA2008 using the compatibility processing defined by UTS (Unicode Technical Standard) #46, which defines a standard to deal with the transition from IDNA2003.
     148. vendor/golang.org/x/sys/cpu - implements processor feature detection for various CPU architectures.
     149. vendor/golang.org/x/text/secure/bidirule - implements the Bidi Rule defined by RFC 5893.
     150. vendor/golang.org/x/text/transform - provides reader and writer wrappers that transform the bytes passing through as well as various transformations.
     151. vendor/golang.org/x/text/unicode/bidi - contains functionality for bidirectional text support.
     152. vendor/golang.org/x/text/unicode/norm - contains types and functions for normalizing Unicode strings.

The pages are generated with Golds v0.8.2. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.