diff --git a/internal/fetch/fetch.go b/internal/fetch/fetch.go
index d5ce057..3833379 100644
--- a/internal/fetch/fetch.go
+++ b/internal/fetch/fetch.go
@@ -6,7 +6,6 @@
 package fetch
 
 import (
-	"archive/zip"
 	"context"
 	"errors"
 	"fmt"
@@ -187,19 +186,8 @@
 
 	var contentDir fs.FS
 	if fr.ModulePath == stdlib.ModulePath {
-		var (
-			resolvedVersion string
-			zr              *zip.Reader
-		)
-		zr, resolvedVersion, commitTime, err = stdlib.Zip(fr.RequestedVersion)
-		if err != nil {
-			return fi, err
-		}
-		v := resolvedVersion
-		if stdlib.SupportedBranches[fr.RequestedVersion] {
-			v = fr.RequestedVersion
-		}
-		contentDir, err = fs.Sub(zr, fr.ModulePath+"@"+v)
+		var resolvedVersion string
+		contentDir, resolvedVersion, commitTime, err = stdlib.ContentDir(fr.RequestedVersion)
 		if err != nil {
 			return fi, err
 		}
diff --git a/internal/fetch/helper_test.go b/internal/fetch/helper_test.go
index bb9f2e1..2af4b05 100644
--- a/internal/fetch/helper_test.go
+++ b/internal/fetch/helper_test.go
@@ -5,8 +5,8 @@
 package fetch
 
 import (
-	"archive/zip"
 	"context"
+	"io/fs"
 	"net/http"
 	"os"
 	"sort"
@@ -188,16 +188,20 @@
 func licenseDetector(ctx context.Context, t *testing.T, modulePath, version string, proxyClient *proxy.Client) *licenses.Detector {
 	t.Helper()
 	var (
-		zipReader *zip.Reader
-		err       error
+		contentDir fs.FS
+		err        error
 	)
 	if modulePath == stdlib.ModulePath {
-		zipReader, _, _, err = stdlib.Zip(version)
+		contentDir, _, _, err = stdlib.ContentDir(version)
 		if err != nil {
 			t.Fatal(err)
 		}
 	} else {
-		zipReader, err = proxyClient.Zip(ctx, modulePath, version)
+		zipReader, err := proxyClient.Zip(ctx, modulePath, version)
+		if err != nil {
+			t.Fatal(err)
+		}
+		contentDir, err = fs.Sub(zipReader, modulePath+"@"+version)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -205,7 +209,7 @@
 	logf := func(format string, args ...interface{}) {
 		log.Infof(ctx, format, args...)
 	}
-	return licenses.NewDetector(modulePath, version, zipReader, logf)
+	return licenses.NewDetectorFS(modulePath, version, contentDir, logf)
 }
 
 func sortFetchResult(fr *FetchResult) {
diff --git a/internal/fetch/readme_test.go b/internal/fetch/readme_test.go
index a5b850f..428cfa7 100644
--- a/internal/fetch/readme_test.go
+++ b/internal/fetch/readme_test.go
@@ -5,7 +5,6 @@
 package fetch
 
 import (
-	"archive/zip"
 	"context"
 	"io/fs"
 	"sort"
@@ -84,11 +83,11 @@
 	} {
 		t.Run(test.name, func(t *testing.T) {
 			var (
-				reader *zip.Reader
-				err    error
+				contentDir fs.FS
+				err        error
 			)
 			if test.modulePath == stdlib.ModulePath {
-				reader, _, _, err = stdlib.Zip(test.version)
+				contentDir, _, _, err = stdlib.ContentDir(test.version)
 				if err != nil {
 					t.Fatal(err)
 				}
@@ -96,14 +95,14 @@
 				proxyClient, teardownProxy := proxytest.SetupTestClient(t, []*proxytest.Module{
 					{ModulePath: test.modulePath, Files: test.files}})
 				defer teardownProxy()
-				reader, err = proxyClient.Zip(ctx, test.modulePath, "v1.0.0")
+				reader, err := proxyClient.Zip(ctx, test.modulePath, "v1.0.0")
 				if err != nil {
 					t.Fatal(err)
 				}
-			}
-			contentDir, err := fs.Sub(reader, test.modulePath+"@"+test.version)
-			if err != nil {
-				t.Fatal(err)
+				contentDir, err = fs.Sub(reader, test.modulePath+"@v1.0.0")
+				if err != nil {
+					t.Fatal(err)
+				}
 			}
 			got, err := extractReadmes(test.modulePath, test.version, contentDir)
 			if err != nil {
diff --git a/internal/stdlib/stdlib.go b/internal/stdlib/stdlib.go
index c1f7ffe..08fc407 100644
--- a/internal/stdlib/stdlib.go
+++ b/internal/stdlib/stdlib.go
@@ -313,29 +313,6 @@
 	return resolvedVersion, nil
 }
 
-// Zip creates a module zip representing the entire Go standard library at the
-// given version (which must have been resolved with ZipInfo) and returns a
-// reader to it. It also returns the time of the commit for that version. The
-// zip file is in module form, with each path prefixed by ModuleName + "@" +
-// version.
-//
-// Normally, Zip returns the resolved version it was passed. If the resolved
-// version is version.Master, Zip returns a semantic version for the branch.
-//
-// Zip reads the standard library at the Go repository tag corresponding to to
-// the given semantic version.
-//
-// Zip ignores go.mod files in the standard library, treating it as if it were a
-// single module named "std" at the given version.
-func Zip(requestedVersion string) (_ *zip.Reader, resolvedVersion string, commitTime time.Time, err error) {
-	// This code taken, with modifications, from
-	// https://github.com/shurcooL/play/blob/master/256/moduleproxy/std/std.go.
-	defer derrors.Wrap(&err, "stdlib.Zip(%q)", requestedVersion)
-
-	zr, resolvedVersion, commitTime, _, err := zipInternal(requestedVersion)
-	return zr, resolvedVersion, commitTime, err
-}
-
 func zipInternal(requestedVersion string) (_ *zip.Reader, resolvedVersion string, commitTime time.Time, prefix string, err error) {
 	var repo *git.Repository
 	if UseTestData {
diff --git a/internal/worker/server.go b/internal/worker/server.go
index 156dfe0..64a3c4f 100644
--- a/internal/worker/server.go
+++ b/internal/worker/server.go
@@ -482,7 +482,7 @@
 func (s *Server) handleFetchStdSupportedBranches(w http.ResponseWriter, r *http.Request) (err error) {
 	defer derrors.Wrap(&err, "handleFetchStdSupportedBranches")
 	for requestedVersion := range stdlib.SupportedBranches {
-		_, resolvedVersion, _, err := stdlib.Zip(requestedVersion)
+		_, resolvedVersion, _, err := stdlib.ContentDir(requestedVersion)
 		if err != nil {
 			return err
 		}