@templmf/temp-solf-lmf 0.0.129 → 0.0.131

package/esm.sh/server/router_test.go

@@ -1,35 +0,0 @@
-package server
-
-import (
-	"testing"
-)
-
-func TestCSSEntryRedirectURL(t *testing.T) {
-	origin := "https://esm.sh"
-	esmPath := EsmPath{
-		PkgName:    "@material/web",
-		PkgVersion: "2.4.2-nightly.95dd57c.0",
-	}
-
-	tests := []struct {
-		cssEntry string
-		expected string
-	}{
-		{
-			cssEntry: "./labs/gb/components/ripple/ripple.css",
-			expected: "https://esm.sh/@material/web@2.4.2-nightly.95dd57c.0/labs/gb/components/ripple/ripple.css",
-		},
-		{
-			cssEntry: "labs/gb/components/ripple/ripple.css",
-			expected: "https://esm.sh/@material/web@2.4.2-nightly.95dd57c.0/labs/gb/components/ripple/ripple.css",
-		},
-	}
-
-	for _, test := range tests {
-		// Calling the actual helper function from router.go
-		url := getCSSEntryRedirectURL(origin, esmPath, test.cssEntry)
-		if url != test.expected {
-			t.Errorf("For CSSEntry %q, expected %q, but got %q", test.cssEntry, test.expected, url)
-		}
-	}
-}

package/esm.sh/server/server.go

@@ -1,202 +0,0 @@
-package server
-
-import (
-	"context"
-	"flag"
-	"fmt"
-	"net/http"
-	"os"
-	"os/signal"
-	"path"
-	"strings"
-	"syscall"
-	"time"
-
-	"github.com/esm-dev/esm.sh/internal/fetch"
-	"github.com/esm-dev/esm.sh/internal/storage"
-	"github.com/ije/gox/log"
-	"github.com/ije/gox/set"
-	"github.com/ije/rex"
-)
-
-// Start starts the esm.sh server
-func Start() {
-	var cfile string
-	var err error
-
-	flag.StringVar(&cfile, "config", "config.json", "the config file path")
-	flag.Parse()
-
-	if existsFile(cfile) {
-		config, err = LoadConfig(cfile)
-		if err != nil {
-			fmt.Println(err.Error())
-			os.Exit(1)
-		}
-		if DEBUG {
-			fmt.Printf("%s [info] Config loaded from %s\n", time.Now().Format("2006-01-02 15:04:05"), cfile)
-		}
-	}
-
-	if DEBUG {
-		config.LogLevel = "debug"
-	} else {
-		// disable log color in release build
-		os.Setenv("NO_COLOR", "1")
-	}
-
-	logger, err := log.New(fmt.Sprintf("file:%s?buffer=64k&fileDateFormat=20060102&term", path.Join(config.LogDir, "server.log")))
-	if err != nil {
-		fmt.Println("failed to initialize logger:", err)
-		os.Exit(1)
-	}
-	if os.Getenv("ESMDIR") != "" {
-		logger.Term(false)
-	}
-	logger.SetLevelByName(config.LogLevel)
-
-	accessLogger, err := log.New(fmt.Sprintf("file:%s?buffer=1m&fileDateFormat=20060102", path.Join(config.LogDir, "access.log")))
-	if err != nil {
-		logger.Fatalf("failed to initialize access logger: %v", err)
-	}
-
-	// initialize storage
-	esmStorage, err := storage.New(&config.Storage)
-	if err != nil {
-		logger.Fatalf("failed to initialize storage(%s): %v", config.Storage.Type, err)
-	}
-	logger.Debugf("storage initialized, type: %s, endpoint: %s", config.Storage.Type, config.Storage.Endpoint)
-
-	// load node runtime in background
-	go getNodeRuntimeJS("fs")
-
-	// add middlewares
-	rex.Use(
-		pprofRouter(),
-		cors(config.CorsAllowOrigins),
-		rex.Header("Server", "esm.sh"),
-		rex.Logger(logger),
-		rex.Optional(rex.AccessLogger(accessLogger), config.AccessLog),
-		rex.Optional(rex.Compress(), config.Compress),
-		rex.Optional(customLandingPage(&config.CustomLandingPage), config.CustomLandingPage.Origin != ""),
-		esmLegacyRouter(esmStorage),
-		esmRouter(esmStorage, logger),
-	)
-
-	// start server
-	C := rex.Serve(context.Background(), rex.ServerConfig{
-		Port: uint16(config.Port),
-		TLS: rex.TLSConfig{
-			Port: uint16(config.TlsPort),
-			AutoTLS: rex.AutoTLSConfig{
-				AcceptTOS: config.TlsPort > 0 && !DEBUG,
-				CacheDir:  path.Join(config.WorkDir, "autotls"),
-			},
-		},
-	}, func(port, tlsPort uint16) {
-		logger.Infof("Server is ready on http://localhost:%d", port)
-		if tlsPort > 0 {
-			logger.Infof("Server is ready on https://localhost:%d", tlsPort)
-		}
-	})
-
-	c := make(chan os.Signal, 1)
-	signal.Notify(c, syscall.SIGTERM, syscall.SIGINT, syscall.SIGQUIT, syscall.SIGHUP, syscall.SIGABRT)
-	select {
-	case <-c:
-	case err = <-C:
-		logger.Error(err)
-	}
-
-	// release resources
-	logger.FlushBuffer()
-	accessLogger.FlushBuffer()
-}
-
-func cors(allowOrigins []string) rex.Handle {
-	allowList := set.NewReadOnly(allowOrigins...)
-	return func(ctx *rex.Context) any {
-		origin := ctx.R.Header.Get("Origin")
-		isOptionsMethod := ctx.R.Method == "OPTIONS"
-		h := ctx.W.Header()
-		if allowList.Len() > 0 {
-			if origin != "" {
-				if !allowList.Has(origin) {
-					return rex.Status(403, "forbidden")
-				}
-				setCorsHeaders(h, isOptionsMethod, origin)
-			} else if isOptionsMethod {
-				// not a preflight request
-				return rex.Status(405, "method not allowed")
-			}
-			appendVaryHeader(h, "Origin")
-		} else {
-			setCorsHeaders(h, isOptionsMethod, "*")
-		}
-		if isOptionsMethod {
-			return rex.NoContent()
-		}
-		return ctx.Next()
-	}
-}
-
-func setCorsHeaders(h http.Header, isOptionsMethod bool, origin string) {
-	h.Set("Access-Control-Allow-Origin", origin)
-	if isOptionsMethod {
-		h.Set("Access-Control-Allow-Headers", "*")
-		h.Set("Access-Control-Max-Age", "86400")
-	}
-}
-
-func customLandingPage(options *LandingPageOptions) rex.Handle {
-	assets := set.New[string]()
-	for _, p := range options.Assets {
-		assets.Add("/" + strings.TrimPrefix(p, "/"))
-	}
-	return func(ctx *rex.Context) any {
-		if ctx.R.URL.Path == "/" || assets.Has(ctx.R.URL.Path) {
-			query := ctx.R.URL.RawQuery
-			if query != "" {
-				query = "?" + query
-			}
-			url, err := ctx.R.URL.Parse(options.Origin + ctx.R.URL.Path + query)
-			if err != nil {
-				return rex.Err(http.StatusBadRequest, "Invalid url")
-			}
-			fetchClient := fetch.NewClient(ctx.UserAgent(), 15, false)
-			res, err := fetchClient.Fetch(url, nil)
-			if err != nil {
-				return rex.Err(http.StatusBadGateway, "Failed to fetch custom landing page")
-			}
-			etag := res.Header.Get("Etag")
-			if etag != "" {
-				if ctx.R.Header.Get("If-None-Match") == etag {
-					return rex.Status(http.StatusNotModified, nil)
-				}
-				ctx.SetHeader("Etag", etag)
-			} else {
-				lastModified := res.Header.Get("Last-Modified")
-				if lastModified != "" {
-					v := ctx.R.Header.Get("If-Modified-Since")
-					if v != "" {
-						timeIfModifiedSince, e1 := time.Parse(http.TimeFormat, v)
-						timeLastModified, e2 := time.Parse(http.TimeFormat, lastModified)
-						if e1 == nil && e2 == nil && !timeIfModifiedSince.After(timeLastModified) {
-							return rex.Status(http.StatusNotModified, nil)
-						}
-					}
-					ctx.SetHeader("Last-Modified", lastModified)
-				}
-			}
-			cacheControl := res.Header.Get("Cache-Control")
-			if cacheControl != "" {
-				ctx.SetHeader("Cache-Control", cacheControl)
-			} else {
-				ctx.SetHeader("Cache-Control", ccMustRevalidate)
-			}
-			ctx.SetHeader("Content-Type", res.Header.Get("Content-Type"))
-			return res.Body // auto closed
-		}
-		return ctx.Next()
-	}
-}

package/esm.sh/server/transform.go

@@ -1,231 +0,0 @@
-package server
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"strings"
-
-	"github.com/esm-dev/esm.sh/internal/importmap"
-	"github.com/esm-dev/esm.sh/internal/npm"
-	esbuild "github.com/ije/esbuild-internal/api"
-	"github.com/ije/gox/utils"
-)
-
-type TransformOptions struct {
-	Filename        string          `json:"filename"`
-	Lang            string          `json:"lang"`
-	Code            string          `json:"code"`
-	ImportMapRaw    json.RawMessage `json:"importMap"`
-	JSXImportSource string          `json:"jsxImportSource"`
-	Target          string          `json:"target"`
-	SourceMap       string          `json:"sourceMap"`
-	Minify          bool            `json:"minify"`
-}
-
-type ResolvedTransformOptions struct {
-	TransformOptions
-	importMap *importmap.ImportMap
-}
-
-type TransformOutput struct {
-	Code string `json:"code"`
-	Map  string `json:"map"`
-}
-
-// transform transforms the given code with the given options.
-func transform(options *ResolvedTransformOptions) (out *TransformOutput, err error) {
-	target := esbuild.ESNext
-	if options.Target != "" {
-		if t, ok := targets[options.Target]; ok {
-			target = t
-		} else {
-			err = errors.New("invalid target")
-			return
-		}
-	}
-
-	loader := esbuild.LoaderJS
-	sourceCode := options.Code
-	jsxImportSource := options.JSXImportSource
-	importMap := options.importMap
-
-	if options.Lang == "" && options.Filename != "" {
-		filename, _ := utils.SplitByFirstByte(options.Filename, '?')
-		_, basename := utils.SplitByLastByte(filename, '/')
-		_, options.Lang = utils.SplitByLastByte(basename, '.')
-	}
-	switch options.Lang {
-	case "js":
-		loader = esbuild.LoaderJS
-	case "jsx":
-		loader = esbuild.LoaderJSX
-	case "ts":
-		loader = esbuild.LoaderTS
-	case "tsx":
-		loader = esbuild.LoaderTSX
-	case "css":
-		loader = esbuild.LoaderCSS
-	default:
-		err = errors.New("unsupported language:" + options.Lang)
-		return
-	}
-
-	if jsxImportSource == "" && (loader == esbuild.LoaderJSX || loader == esbuild.LoaderTSX) && importMap != nil {
-		for _, key := range importMap.Imports.Keys() {
-			if before, ok := strings.CutSuffix(key, "/jsx-runtime"); ok {
-				jsxImportSource = before
-				break
-			}
-		}
-		if jsxImportSource == "" {
-			for _, key := range []string{"react/", "preact/", "solid-js/", "mono-jsx/dom/", "mono-jsx/", "vue/"} {
-				if importMap.Imports.Has(key) {
-					jsxImportSource = strings.TrimSuffix(key, "/")
-					break
-				}
-			}
-		}
-		if jsxImportSource == "" {
-			jsxImportSource = "react"
-		}
-	}
-
-	sourceMap := esbuild.SourceMapNone
-	switch options.SourceMap {
-	case "external":
-		sourceMap = esbuild.SourceMapExternal
-	case "inline":
-		sourceMap = esbuild.SourceMapInline
-	}
-
-	filename := options.Filename
-	if filename == "" {
-		filename = "source." + options.Lang
-	}
-	stdin := &esbuild.StdinOptions{
-		Sourcefile: filename,
-		Contents:   sourceCode,
-		Loader:     loader,
-	}
-	opts := esbuild.BuildOptions{
-		Stdin:             stdin,
-		Platform:          esbuild.PlatformBrowser,
-		Format:            esbuild.FormatESModule,
-		Target:            target,
-		JSX:               esbuild.JSXAutomatic,
-		JSXImportSource:   strings.TrimSuffix(jsxImportSource, "/"),
-		MinifyWhitespace:  options.Minify,
-		MinifySyntax:      options.Minify,
-		MinifyIdentifiers: options.Minify,
-		Sourcemap:         sourceMap,
-		Bundle:            true,
-		TreeShaking:       esbuild.TreeShakingTrue,
-		Outdir:            "/esbuild",
-		Write:             false,
-		Plugins: []esbuild.Plugin{
-			{
-				Name: "resolver",
-				Setup: func(build esbuild.PluginBuild) {
-					build.OnResolve(esbuild.OnResolveOptions{Filter: ".*"}, func(args esbuild.OnResolveArgs) (esbuild.OnResolveResult, error) {
-						if importMap != nil {
-							path, ok := importMap.Resolve(args.Path, nil)
-							if ok && isHttpSpecifier(path) {
-								return esbuild.OnResolveResult{Path: path, External: true}, nil
-							}
-						}
-						return esbuild.OnResolveResult{Path: args.Path, External: true}, nil
-					})
-				},
-			},
-		},
-	}
-	ret := esbuild.Build(opts)
-	if len(ret.Errors) > 0 {
-		err = errors.New("failed to validate code: " + ret.Errors[0].Text)
-		return
-	}
-	if len(ret.OutputFiles) == 0 {
-		err = errors.New("failed to validate code: no output files")
-		return
-	}
-	out = &TransformOutput{}
-	for _, file := range ret.OutputFiles {
-		if strings.HasSuffix(file.Path, ".js") || strings.HasSuffix(file.Path, ".css") {
-			out.Code = string(file.Contents)
-		} else if strings.HasSuffix(file.Path, ".map") {
-			out.Map = string(file.Contents)
-		}
-	}
-	return
-}
-
-// treeShake tree-shakes the given javascript code with the given exports.
-func treeShake(npmrc *NpmRC, pkg npm.Package, code []byte, exports []string, target esbuild.Target) ([]byte, error) {
-	input := &esbuild.StdinOptions{
-		Contents: fmt.Sprintf(`export { %s } from '.';`, strings.Join(exports, ", ")),
-		Loader:   esbuild.LoaderJS,
-	}
-	plugins := []esbuild.Plugin{
-		{
-			Name: "tree-shaking",
-			Setup: func(build esbuild.PluginBuild) {
-				build.OnResolve(esbuild.OnResolveOptions{Filter: ".*"}, func(args esbuild.OnResolveArgs) (esbuild.OnResolveResult, error) {
-					if args.Path == "." {
-						return esbuild.OnResolveResult{Path: ".", Namespace: "memory", PluginData: code}, nil
-					}
-					sideEffects := esbuild.SideEffectsTrue
-					if isRelPathSpecifier(args.Path) {
-						pkgJson, err := npmrc.installPackage(pkg)
-						if err != nil {
-							return esbuild.OnResolveResult{}, err
-						}
-						if pkgJson.SideEffectsFalse {
-							sideEffects = esbuild.SideEffectsFalse
-						}
-					}
-					return esbuild.OnResolveResult{SideEffects: sideEffects, External: true}, nil
-				})
-				build.OnLoad(esbuild.OnLoadOptions{Filter: ".*", Namespace: "memory"}, func(args esbuild.OnLoadArgs) (esbuild.OnLoadResult, error) {
-					contents := string(args.PluginData.([]byte))
-					return esbuild.OnLoadResult{Contents: &contents}, nil
-				})
-			},
-		},
-	}
-	ret := esbuild.Build(esbuild.BuildOptions{
-		Stdin:             input,
-		Bundle:            true,
-		Format:            esbuild.FormatESModule,
-		Target:            target,
-		Platform:          esbuild.PlatformBrowser,
-		MinifyWhitespace:  config.Minify,
-		MinifyIdentifiers: config.Minify,
-		MinifySyntax:      config.Minify,
-		Outdir:            "/esbuild",
-		Write:             false,
-		Plugins:           plugins,
-	})
-	if len(ret.Errors) > 0 {
-		return nil, errors.New(ret.Errors[0].Text)
-	}
-	return ret.OutputFiles[0].Contents, nil
-}
-
-// minify minifies the given javascript code.
-func minify(code string, loader esbuild.Loader, target esbuild.Target) ([]byte, error) {
-	ret := esbuild.Transform(code, esbuild.TransformOptions{
-		Target:            target,
-		Format:            esbuild.FormatESModule,
-		Platform:          esbuild.PlatformBrowser,
-		MinifyWhitespace:  true,
-		MinifyIdentifiers: true,
-		MinifySyntax:      true,
-		LegalComments:     esbuild.LegalCommentsExternal,
-		Loader:            loader,
-	})
-	if len(ret.Errors) > 0 {
-		return nil, errors.New(ret.Errors[0].Text)
-	}
-	return concatBytes(ret.LegalComments, ret.Code), nil
-}

package/esm.sh/server/unenv.go

@@ -1,221 +0,0 @@
-package server
-
-import (
-	"archive/tar"
-	"bytes"
-	"compress/gzip"
-	"errors"
-	"io"
-	"os"
-	"path"
-	"strings"
-	"time"
-
-	"github.com/esm-dev/esm.sh/internal/npm"
-	esbuild "github.com/ije/esbuild-internal/api"
-)
-
-var (
-	// https://github.com/unjs/unenv
-	unenvPkg = npm.Package{
-		Name:    "unenv",
-		Version: "2.0.0-rc.22",
-	}
-	unenvNodeRuntimeMap = map[string][]byte{
-		"sys.mjs": []byte(`export*from "/node/util.mjs";export{default}from "/node/util.mjs";`),
-	}
-)
-
-// getNodeRuntimeJS returns the unenv node runtime by the given name.
-func getNodeRuntimeJS(name string) (js []byte, ok bool) {
-	doOnce("load-node-runtime", func() (err error) {
-		return loadNodeRuntime()
-	})
-	js, ok = unenvNodeRuntimeMap[name]
-	return
-}
-
-// loadNodeRuntime loads the unenv node runtime from the embed filesystem.
-func loadNodeRuntime() (err error) {
-	data, err := embedFS.ReadFile("embed/node-runtime.tgz")
-	if err == nil {
-		tarball, err := gzip.NewReader(bytes.NewReader(data))
-		if err == nil {
-			defer tarball.Close()
-			tr := tar.NewReader(tarball)
-			for {
-				header, err := tr.Next()
-				if err != nil {
-					break
-				}
-				if header.Typeflag == tar.TypeReg {
-					name := header.Name
-					data := make([]byte, header.Size)
-					n, err := io.ReadFull(tr, data)
-					if err == nil && int64(n) == header.Size {
-						unenvNodeRuntimeMap[name] = data
-					}
-				}
-			}
-			return nil
-		}
-	}
-	return buildUnenvNodeRuntime()
-}
-
-// slow path
-func buildUnenvNodeRuntime() (err error) {
-	wd := path.Join(config.WorkDir, "npm/"+unenvPkg.String())
-	err = ensureDir(wd)
-	if err != nil {
-		return err
-	}
-
-	npmrc := &NpmRC{globalRegistry: &NpmRegistry{NpmRegistryConfig: NpmRegistryConfig{Registry: npmRegistry}}}
-	pkgJson, err := npmrc.installPackage(unenvPkg)
-	if err != nil {
-		return
-	}
-	err = npmrc.installDependencies(wd, pkgJson, false, nil)
-	if err != nil {
-		return err
-	}
-
-	endpoints := make([]esbuild.EntryPoint, 0, len(nodeBuiltinModules))
-	for name := range nodeBuiltinModules {
-		// currently the module "sys" is just a alias of "util", no need to build it
-		if name != "sys" {
-			filename := path.Join(wd, "node_modules", unenvPkg.Name+"/dist/runtime/node/"+name+".mjs")
-			if existsFile(filename) {
-				endpoints = append(endpoints, esbuild.EntryPoint{
-					InputPath:  filename,
-					OutputPath: name,
-				})
-			}
-		}
-	}
-
-	ret := esbuild.Build(esbuild.BuildOptions{
-		AbsWorkingDir:       wd,
-		EntryPointsAdvanced: endpoints,
-		Platform:            esbuild.PlatformBrowser,
-		Format:              esbuild.FormatESModule,
-		Target:              esbuild.ESNext,
-		Bundle:              true,
-		Splitting:           true,
-		MinifyWhitespace:    true,
-		MinifyIdentifiers:   true,
-		MinifySyntax:        true,
-		OutExtension:        map[string]string{".js": ".mjs"},
-		Write:               false,
-		Outdir:              "/",
-		Plugins: []esbuild.Plugin{
-			{
-				Name: "resolve-node-builtin-modules",
-				Setup: func(build esbuild.PluginBuild) {
-					// https://github.com/unjs/unenv/issues/365
-					build.OnResolve(esbuild.OnResolveOptions{Filter: `^unenv/dist/runtime/node/stream$`}, func(args esbuild.OnResolveArgs) (esbuild.OnResolveResult, error) {
-						return esbuild.OnResolveResult{Path: "/node/stream.mjs", External: true}, nil
-					})
-					build.OnResolve(esbuild.OnResolveOptions{Filter: `^node:`}, func(args esbuild.OnResolveArgs) (esbuild.OnResolveResult, error) {
-						return esbuild.OnResolveResult{Path: "/node/" + args.Path[5:] + ".mjs", External: true}, nil
-					})
-				},
-			},
-		},
-	})
-
-	if len(ret.Errors) > 0 {
-		err = errors.New(ret.Errors[0].Text)
-		return
-	}
-
-	// bundle tiny chunks that are less than 600 bytes
-	tinyChunks := make(map[string][]byte, 0)
-	for _, result := range ret.OutputFiles {
-		name := result.Path[1:]
-		if strings.HasPrefix(name, "chunk-") && len(result.Contents) < 600 {
-			tinyChunks[name] = result.Contents
-		} else {
-			unenvNodeRuntimeMap[name] = result.Contents
-		}
-	}
-
-	// write the tarball to 'server/embed/' in DEBUG mode
-	var tarball *tar.Writer
-	if DEBUG {
-		wd, err := os.Getwd()
-		if err != nil {
-			return err
-		}
-		file, err := os.OpenFile(path.Join(wd, "server/embed/node-runtime.tgz"), os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0644)
-		if err != nil {
-			return err
-		}
-		defer file.Close()
-
-		gzipWriter := gzip.NewWriter(file)
-		defer gzipWriter.Close()
-
-		tarball = tar.NewWriter(gzipWriter)
-		defer tarball.Close()
-	}
-
-	now := time.Now()
-	for name, data := range unenvNodeRuntimeMap {
-		ret := esbuild.Build(esbuild.BuildOptions{
-			Stdin: &esbuild.StdinOptions{
-				Contents:   string(data),
-				Loader:     esbuild.LoaderJS,
-				Sourcefile: "/" + name,
-			},
-			Platform:          esbuild.PlatformBrowser,
-			Format:            esbuild.FormatESModule,
-			Target:            esbuild.ES2022,
-			Bundle:            true,
-			MinifyWhitespace:  true,
-			MinifyIdentifiers: true,
-			MinifySyntax:      true,
-			Write:             false,
-			Outdir:            "/",
-			Plugins: []esbuild.Plugin{
-				{
-					Name: "bundle-tiny-chunks",
-					Setup: func(build esbuild.PluginBuild) {
-						build.OnResolve(esbuild.OnResolveOptions{Filter: ".*"}, func(args esbuild.OnResolveArgs) (esbuild.OnResolveResult, error) {
-							if isRelPathSpecifier(args.Path) {
-								fullpath := path.Join(path.Dir(args.Importer), args.Path)
-								if strings.HasPrefix(fullpath, "/chunk-") {
-									if chunk, ok := tinyChunks[fullpath[1:]]; ok {
-										return esbuild.OnResolveResult{Path: fullpath, Namespace: "chunk", PluginData: chunk}, nil
-									}
-								}
-							}
-							return esbuild.OnResolveResult{External: true}, nil
-						})
-						build.OnLoad(esbuild.OnLoadOptions{Filter: ".*", Namespace: "chunk"}, func(args esbuild.OnLoadArgs) (esbuild.OnLoadResult, error) {
-							code := string(args.PluginData.([]byte))
-							return esbuild.OnLoadResult{Contents: &code}, nil
-						})
-					},
-				},
-			},
-		})
-		if len(ret.Errors) > 0 {
-			err = errors.New(ret.Errors[0].Text)
-			return
-		}
-		js := ret.OutputFiles[0].Contents
-		if tarball != nil {
-			tarball.WriteHeader(&tar.Header{
-				Name:    name,
-				Size:    int64(len(js)),
-				Mode:    0644,
-				ModTime: now,
-			})
-			tarball.Write(js)
-		}
-		unenvNodeRuntimeMap[name] = js
-	}
-	return
-}