@templmf/temp-solf-lmf 0.0.129 → 0.0.131

package/esm.sh/server/build.go

@@ -1,1661 +0,0 @@
-package server
-
-import (
-	"bytes"
-	"context"
-	"crypto/sha512"
-	"encoding/base64"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"os"
-	"path"
-	"regexp"
-	"slices"
-	"sort"
-	"strings"
-
-	"github.com/esm-dev/esm.sh/internal/npm"
-	"github.com/esm-dev/esm.sh/internal/npm_replacements"
-	"github.com/esm-dev/esm.sh/internal/storage"
-	esbuild "github.com/ije/esbuild-internal/api"
-	"github.com/ije/gox/log"
-	"github.com/ije/gox/set"
-	"github.com/ije/gox/utils"
-)
-
-type BundleMode uint8
-
-const (
-	BundleDefault BundleMode = iota
-	BundleDeps
-	BundleFalse
-)
-
-type BuildContext struct {
-	ctx         context.Context
-	npmrc       *NpmRC
-	logger      *log.Logger
-	metaDB      *BuildMetaDB
-	storage     storage.Storage
-	esmPath     EsmPath
-	args        BuildArgs
-	bundleMode  BundleMode
-	externalAll bool
-	target      string
-	dev         bool
-	wd          string
-	pkgJson     *npm.PackageJSON
-	path        string
-	rawPath     string
-	status      string
-	splitting   *set.ReadOnlySet[string]
-	esmImports  [][2]string
-	cjsRequires [][3]string
-	smOffset    int
-}
-
-var (
-	regexpESMInternalIdent = regexp.MustCompile(`__[a-zA-Z]+\$`)
-	regexpVarDecl          = regexp.MustCompile(`var ([\w$]+)\s*=\s*[\w$]+$`)
-)
-
-var loaders = map[string]esbuild.Loader{
-	".js":     esbuild.LoaderJS,
-	".mjs":    esbuild.LoaderJS,
-	".cjs":    esbuild.LoaderJS,
-	".jsx":    esbuild.LoaderJSX,
-	".ts":     esbuild.LoaderTS,
-	".mts":    esbuild.LoaderTS,
-	".cts":    esbuild.LoaderTS,
-	".tsx":    esbuild.LoaderTSX,
-	".vue":    esbuild.LoaderJS,
-	".svelte": esbuild.LoaderJS,
-	".css":    esbuild.LoaderCSS,
-	".json":   esbuild.LoaderJSON,
-	".txt":    esbuild.LoaderText,
-	".html":   esbuild.LoaderText,
-	".md":     esbuild.LoaderText,
-	".svg":    esbuild.LoaderDataURL,
-	".png":    esbuild.LoaderDataURL,
-	".webp":   esbuild.LoaderDataURL,
-	".gif":    esbuild.LoaderDataURL,
-	".ttf":    esbuild.LoaderDataURL,
-	".eot":    esbuild.LoaderDataURL,
-	".woff":   esbuild.LoaderDataURL,
-	".woff2":  esbuild.LoaderDataURL,
-}
-
-func (ctx *BuildContext) Path() string {
-	if ctx.path != "" {
-		return ctx.path
-	}
-
-	ctx.buildPath()
-	return ctx.path
-}
-
-func (ctx *BuildContext) Exists() (meta *BuildMeta, ok bool, err error) {
-	key := ctx.Path()
-	meta, err = withLRUCache(key, func() (*BuildMeta, error) {
-		metadata, err := ctx.metaDB.Get(key)
-		if err != nil {
-			return nil, err
-		}
-		meta, err := decodeBuildMeta(metadata)
-		if err != nil {
-			// delete the invalid metadata
-			ctx.metaDB.Delete(key)
-			return nil, storage.ErrNotFound
-		}
-		return meta, nil
-	})
-	if err != nil {
-		if err == storage.ErrNotFound {
-			err = nil
-		}
-		return
-	}
-	ok = true
-	return
-}
-
-func (ctx *BuildContext) Context() context.Context {
-	if ctx.ctx != nil {
-		return ctx.ctx
-	}
-	return context.Background()
-}
-
-func (ctx *BuildContext) checkCanceled() error {
-	return ctx.Context().Err()
-}
-
-func (ctx *BuildContext) Build(buildCtx context.Context) (meta *BuildMeta, err error) {
-	if buildCtx == nil {
-		buildCtx = context.Background()
-	}
-	ctx.ctx = buildCtx
-	if err = ctx.checkCanceled(); err != nil {
-		return
-	}
-	if ctx.target == "types" {
-		return ctx.buildTypes()
-	}
-
-	// check previous build
-	meta, ok, err := ctx.Exists()
-	if err != nil || ok {
-		return
-	}
-	if err = ctx.checkCanceled(); err != nil {
-		return
-	}
-
-	// install the package
-	ctx.status = "install"
-	err = ctx.install()
-	if err != nil {
-		return
-	}
-
-	// check previous build again after installation (in case the sub-module path has been changed by the `install` function)
-	meta, ok, err = ctx.Exists()
-	if err != nil || ok {
-		return
-	}
-	if err = ctx.checkCanceled(); err != nil {
-		return
-	}
-
-	// analyze splitting modules if bundling
-	if ctx.pkgJson.Exports.Len() > 1 && ctx.shouldBundle() {
-		ctx.status = "analyze"
-		err = ctx.analyzeSplitting()
-		if err != nil {
-			return
-		}
-	}
-
-	// build the module
-	ctx.status = "build"
-	meta, _, err = ctx.buildModule(false)
-	if err != nil {
-		return
-	}
-	if err = ctx.checkCanceled(); err != nil {
-		return
-	}
-
-	// save the build result to the storage
-	key := ctx.Path()
-	err = ctx.metaDB.Put(key, encodeBuildMeta(meta))
-	if err != nil {
-		ctx.logger.Errorf("db.put(%s): %v", key, err)
-		err = errors.New("db: " + err.Error())
-	}
-	return
-}
-
-func (ctx *BuildContext) buildPath() {
-	asteriskPrefix := ""
-	if ctx.externalAll {
-		asteriskPrefix = "*"
-	}
-
-	esm := ctx.esmPath
-	if ctx.target == "types" {
-		if strings.HasSuffix(esm.SubPath, ".d.ts") {
-			ctx.path = fmt.Sprintf(
-				"/%s%s/%s%s",
-				asteriskPrefix,
-				esm.PackageId(),
-				ctx.getBuildArgsPrefix(true),
-				esm.SubPath,
-			)
-		} else {
-			ctx.path = "/" + esm.String()
-		}
-		return
-	}
-
-	name := strings.TrimSuffix(path.Base(esm.PkgName), ".js")
-	if esm.SubPath != "" {
-		if esm.SubPath == name {
-			// if the sub-module name is same as the package name
-			name = "__" + esm.SubPath
-		} else {
-			name = esm.SubPath
-		}
-		// workaround for es5-ext "../#/.." path
-		if esm.PkgName == "es5-ext" {
-			name = strings.ReplaceAll(name, "/#/", "/%23/")
-		}
-	}
-
-	if ctx.dev {
-		name += ".development"
-	}
-	switch ctx.bundleMode {
-	case BundleDeps:
-		name += ".bundle"
-	case BundleFalse:
-		name += ".nobundle"
-	}
-	ctx.path = fmt.Sprintf(
-		"/%s%s/%s%s/%s.mjs",
-		asteriskPrefix,
-		esm.PackageId(),
-		ctx.getBuildArgsPrefix(ctx.target == "types"),
-		ctx.target,
-		name,
-	)
-}
-
-func (ctx *BuildContext) buildModule(analyzeMode bool) (meta *BuildMeta, includes [][2]string, err error) {
-	if err = ctx.checkCanceled(); err != nil {
-		return
-	}
-	entry := ctx.resolveEntry(ctx.esmPath)
-	if entry.isEmpty() {
-		err = errors.New("could not resolve build entry")
-		return
-	}
-
-	if DEBUG && !analyzeMode {
-		ctx.logger.Debugf(`build(%s): Entry{main: "%s", module: %v, types: "%s"}`, ctx.esmPath.String(), entry.main, entry.module, entry.types)
-	}
-
-	isTypesOnly := strings.HasPrefix(ctx.pkgJson.Name, "@types/") || entry.isTypesOnly()
-	if isTypesOnly {
-		if analyzeMode {
-			return
-		}
-		err = ctx.transformDTS(entry.types)
-		if err != nil {
-			return
-		}
-		meta = &BuildMeta{
-			TypesOnly: true,
-			Dts:       "/" + ctx.esmPath.PackageId() + entry.types[1:],
-		}
-		return
-	}
-
-	// css entry
-	if strings.HasSuffix(entry.main, ".css") {
-		if analyzeMode {
-			return
-		}
-		meta = &BuildMeta{CSSEntry: entry.main}
-		return
-	}
-
-	// json module
-	if strings.HasSuffix(entry.main, ".json") {
-		if analyzeMode {
-			return
-		}
-		var jsonData []byte
-		jsonPath := path.Join(ctx.wd, "node_modules", ctx.esmPath.PkgName, entry.main)
-		jsonData, err = os.ReadFile(jsonPath)
-		if err != nil {
-			return
-		}
-		buffer := &bytes.Buffer{}
-		buffer.WriteString("export default ")
-		buffer.Write(jsonData)
-		err = ctx.storage.Put(ctx.getSavePath(), buffer)
-		if err != nil {
-			ctx.logger.Errorf("storage.put(%s): %v", ctx.getSavePath(), err)
-			err = errors.New("storage(put): " + err.Error())
-			return
-		}
-		meta = &BuildMeta{ExportDefault: true}
-		return
-	}
-
-	var (
-		cjsReexport string
-		cjsExports  []string
-	)
-
-	if !analyzeMode {
-		meta, cjsExports, cjsReexport, err = ctx.lexer(&entry)
-		if err != nil {
-			return
-		}
-	}
-
-	// cjs reexport
-	if cjsReexport != "" {
-		dep, _, e := ctx.resolveDependency(cjsReexport, false)
-		if e != nil {
-			err = e
-			return
-		}
-		b := &BuildContext{
-			npmrc:       ctx.npmrc,
-			logger:      ctx.logger,
-			metaDB:      ctx.metaDB,
-			storage:     ctx.storage,
-			esmPath:     dep,
-			args:        ctx.args,
-			externalAll: ctx.externalAll,
-			target:      ctx.target,
-			dev:         ctx.dev,
-			ctx:         ctx.ctx,
-		}
-		err = b.install()
-		if err != nil {
-			return
-		}
-		entry = b.resolveEntry(dep)
-		meta, _, _, err = b.lexer(&entry)
-		if err != nil {
-			return
-		}
-		importUrl := ctx.getImportPath(dep, ctx.getBuildArgsPrefix(false), ctx.externalAll)
-		buf := bytes.NewBuffer(nil)
-		fmt.Fprintf(buf, `export * from "%s";`, importUrl)
-		if meta.ExportDefault {
-			fmt.Fprintf(buf, `export { default } from "%s";`, importUrl)
-		}
-		err = ctx.storage.Put(ctx.getSavePath(), buf)
-		if err != nil {
-			ctx.logger.Errorf("storage.put(%s): %v", ctx.getSavePath(), err)
-			err = errors.New("storage(put): " + err.Error())
-			return
-		}
-		meta.Dts, err = ctx.resolveDTS(entry)
-		return
-	}
-
-	entryModuleFilename := ctx.getPkgFullPath(entry.main)
-	entrySpecifier := ctx.esmPath.PkgName
-	if ctx.esmPath.SubPath != "" {
-		entrySpecifier += "/" + ctx.esmPath.SubPath
-	}
-
-	var (
-		entryPoint string
-		stdin      esbuild.StdinOptions
-	)
-
-	if entry.module {
-		entryPoint = entryModuleFilename
-	} else {
-		buf := &bytes.Buffer{}
-		fmt.Fprintf(buf, `import * as cjsm from "%s";`, entrySpecifier)
-		if len(cjsExports) > 0 {
-			fmt.Fprintf(buf, `export const { %s } = cjsm;`, strings.Join(cjsExports, ","))
-		}
-		buf.WriteString("export default cjsm.default ?? cjsm;")
-		stdin = esbuild.StdinOptions{
-			Sourcefile: "endpoint.js",
-			Contents:   buf.String(),
-		}
-	}
-
-	browserExclude := map[string]*set.Set[string]{}
-	implicitExternal := set.New[string]()
-	noBundle := !ctx.shouldBundle()
-	esmifyPlugin := esbuild.Plugin{
-		Name: "esmify",
-		Setup: func(build esbuild.PluginBuild) {
-			// resovler
-			build.OnResolve(
-				esbuild.OnResolveOptions{Filter: ".*"},
-				func(args esbuild.OnResolveArgs) (esbuild.OnResolveResult, error) {
-					// entry point
-					if args.Path == entryPoint || args.Path == entrySpecifier {
-						path := args.Path
-						if path == entrySpecifier {
-							path = entryModuleFilename
-						}
-						if strings.HasSuffix(path, ".svelte") {
-							return esbuild.OnResolveResult{Path: path, Namespace: "svelte"}, nil
-						}
-						if strings.HasSuffix(path, ".vue") {
-							return esbuild.OnResolveResult{Path: path, Namespace: "vue"}, nil
-						}
-						return esbuild.OnResolveResult{Path: path}, nil
-					}
-
-					// ban `file:` imports
-					if after, ok := strings.CutPrefix(args.Path, "file:"); ok {
-						return esbuild.OnResolveResult{
-							Path:     fmt.Sprintf("/error.js?type=unsupported-file-dependency&name=%s&importer=%s", after, ctx.esmPath.String()),
-							External: true,
-						}, nil
-					}
-
-					// skip `data:` and `http:` imports
-					if strings.HasPrefix(args.Path, "data:") || strings.HasPrefix(args.Path, "https:") || strings.HasPrefix(args.Path, "http:") {
-						return esbuild.OnResolveResult{
-							Path:     args.Path,
-							External: true,
-						}, nil
-					}
-
-					// if `?external-require` present, ignore specifier that is a require call
-					if ctx.args.ExternalRequire && args.Kind == esbuild.ResolveJSRequireCall && entry.module {
-						return esbuild.OnResolveResult{
-							Path:     args.Path,
-							External: true,
-						}, nil
-					}
-
-					// ignore yarn PnP API
-					if args.Path == "pnpapi" {
-						return esbuild.OnResolveResult{
-							Path:      args.Path,
-							Namespace: "browser-exclude",
-						}, nil
-					}
-
-					pkgJson := ctx.pkgJson
-					specifier := normalizeImportSpecifier(args.Path)
-					withTypeJSON := len(args.With) > 0 && args.With["type"] == "json"
-
-					// it's implicit external
-					if implicitExternal.Has(args.Path) {
-						externalPath, sideEffects, err := ctx.resolveExternalModule(args.Path, args.Kind, withTypeJSON, analyzeMode)
-						if err != nil {
-							return esbuild.OnResolveResult{}, err
-						}
-						return esbuild.OnResolveResult{
-							Path:        externalPath,
-							SideEffects: sideEffects,
-							External:    true,
-						}, nil
-					}
-
-					// check `?alias` option
-					if len(ctx.args.Alias) > 0 && !isRelPathSpecifier(specifier) {
-						pkgName, _, subPath := splitEsmPath(specifier)
-						if name, ok := ctx.args.Alias[pkgName]; ok {
-							specifier = name
-							if len(subPath) > 0 {
-								specifier += "/" + subPath
-							}
-						}
-					}
-
-					// resolve specifier using the `imports` field of package.json/deno.json
-					if len(pkgJson.Imports) > 0 {
-						var v any
-						var ok bool
-						v, ok = pkgJson.Imports[specifier]
-						if !ok && !isRelPathSpecifier(specifier) {
-							// check tailing slash
-							pkgName, _, subPath := splitEsmPath(specifier)
-							v, ok = pkgJson.Imports[pkgName]
-							if !ok {
-								v, ok = pkgJson.Imports[pkgName+"/"]
-							}
-							if ok && len(subPath) > 0 {
-								if s, ok := v.(string); ok {
-									v = strings.TrimSuffix(s, "/") + "/" + subPath
-								}
-							}
-						}
-						if ok {
-							if s, ok := v.(string); ok {
-								specifier = normalizeImportSpecifier(s)
-								if isRelPathSpecifier(specifier) {
-									specifier = ctx.esmPath.PkgName + "/" + strings.TrimPrefix(specifier, "./")
-								}
-							} else if m, ok := v.(map[string]any); ok {
-								targets := []string{"browser", "module", "import", "default"}
-								if ctx.isDenoTarget() {
-									targets = []string{"deno", "module", "import", "default"}
-								} else if ctx.target == "node" {
-									targets = []string{"node", "module", "import", "default"}
-								}
-								for _, t := range targets {
-									if v, ok := m[t]; ok {
-										if s, ok := v.(string); ok {
-											specifier = s
-											break
-										}
-									}
-								}
-							}
-						}
-					}
-
-					// resolve specifier using the `browser` field of package.json
-					if !isRelPathSpecifier(specifier) && len(pkgJson.Browser) > 0 && ctx.isBrowserTarget() {
-						name, ok := pkgJson.Browser[specifier]
-						if !ok && strings.HasPrefix(specifier, "node:") {
-							name, ok = pkgJson.Browser[specifier[5:]]
-						}
-						if ok {
-							if name == "" {
-								return esbuild.OnResolveResult{
-									Path:      args.Path,
-									Namespace: "browser-exclude",
-								}, nil
-							}
-							specifier = name
-						}
-					}
-
-					// nodejs builtin module
-					if isNodeBuiltinSpecifier(specifier) {
-						externalPath, sideEffects, err := ctx.resolveExternalModule(specifier, args.Kind, withTypeJSON, analyzeMode)
-						if err != nil {
-							return esbuild.OnResolveResult{}, err
-						}
-						return esbuild.OnResolveResult{
-							Path:        externalPath,
-							SideEffects: sideEffects,
-							External:    true,
-						}, nil
-					}
-
-					var filename string
-					if strings.HasPrefix(specifier, "/") {
-						filename = specifier
-						specifier = strings.TrimPrefix(filename, path.Join(ctx.wd, "node_modules")+"/")
-					} else if isRelPathSpecifier(specifier) && args.ResolveDir != "" {
-						filename = path.Join(args.ResolveDir, specifier)
-						specifier = strings.TrimPrefix(filename, path.Join(ctx.wd, "node_modules")+"/")
-					} else {
-						filename = path.Join(ctx.wd, "node_modules", specifier)
-					}
-
-					// check if the filename is within the working directory
-					if !strings.HasPrefix(filename, ctx.wd+string(os.PathSeparator)) {
-						return esbuild.OnResolveResult{}, fmt.Errorf("could not resolve module %s", specifier)
-					}
-
-					// node native modules do not work via http import
-					if strings.HasSuffix(filename, ".node") && existsFile(filename) {
-						return esbuild.OnResolveResult{
-							Path:     fmt.Sprintf("/error.js?type=unsupported-node-native-module&name=%s&importer=%s", path.Base(args.Path), ctx.esmPath.String()),
-							External: true,
-						}, nil
-					}
-
-					// externalize top-level module
-					// e.g. "react/jsx-runtime" imports "react"
-					// Also handles scoped fork self-reference: "@scope/three" importing "three"
-					isSelfRef := specifier == ctx.esmPath.PkgName
-					if !isSelfRef && strings.HasPrefix(ctx.esmPath.PkgName, "@") {
-						_, baseName := utils.SplitByFirstByte(ctx.esmPath.PkgName[1:], '/')
-						specPkgName := toPackageName(specifier)
-						if specPkgName == baseName {
-							_, inDeps := pkgJson.Dependencies[specPkgName]
-							_, inPeerDeps := pkgJson.PeerDependencies[specPkgName]
-							if !inDeps && !inPeerDeps {
-								isSelfRef = true
-							}
-						}
-					}
-					if ctx.esmPath.SubPath != "" && isSelfRef && ctx.bundleMode != BundleDeps {
-						externalPath, sideEffects, err := ctx.resolveExternalModule(ctx.esmPath.PkgName, args.Kind, withTypeJSON, analyzeMode)
-						if err != nil {
-							return esbuild.OnResolveResult{}, err
-						}
-						if withTypeJSON {
-							externalPath += "?module"
-						}
-						return esbuild.OnResolveResult{
-							Path:        externalPath,
-							SideEffects: sideEffects,
-							External:    true,
-						}, nil
-					}
-
-					// bundles all dependencies in `bundle` mode, apart from peerDependencies and `?external` flag
-					if !isRelPathSpecifier(specifier) {
-						pkgName := toPackageName(specifier)
-						if ctx.bundleMode == BundleDeps && !ctx.args.External.Has(pkgName) && !isPackageInExternalNamespace(pkgName, ctx.args.External) && !implicitExternal.Has(specifier) {
-							_, ok := pkgJson.PeerDependencies[pkgName]
-							if !ok {
-								return esbuild.OnResolveResult{}, nil
-							}
-						}
-					}
-
-					// bundle "@babel/runtime/*"
-					if (args.Kind != esbuild.ResolveJSDynamicImport && !noBundle) && pkgJson.Name != "@babel/runtime" && pkgJson.Name != "@swc/helpers" && (strings.HasPrefix(specifier, "@babel/runtime/") || strings.Contains(args.Importer, "/@babel/runtime/") || strings.HasPrefix(specifier, "@swc/helpers/") || strings.Contains(args.Importer, "/@swc/helpers/")) {
-						return esbuild.OnResolveResult{}, nil
-					}
-
-					pkgName := ctx.esmPath.PkgName
-					isPkgModule := strings.HasPrefix(specifier, pkgName+"/")
-					if !isPkgModule && pkgJson.PkgName != "" {
-						// github packages may have different package name with the repository name
-						pkgName = pkgJson.PkgName
-						isPkgModule = strings.HasPrefix(specifier, pkgName+"/")
-					}
-					if isPkgModule {
-						// if meets scenarios of "./index.mjs" importing "./index.c?js"
-						// let esbuild to handle it
-						if stripModuleExt(filename) == stripModuleExt(args.Importer) {
-							return esbuild.OnResolveResult{}, nil
-						}
-
-						modulePath := "." + strings.TrimPrefix(specifier, pkgName)
-						if path.Ext(filename) == "" || !existsFile(filename) {
-							subPath := utils.NormalizePathname(modulePath)[1:]
-							entry := ctx.resolveEntry(EsmPath{
-								PkgName:    ctx.esmPath.PkgName,
-								PkgVersion: ctx.esmPath.PkgVersion,
-								SubPath:    stripEntryModuleExt(subPath),
-							})
-							if entry.main != "" {
-								modulePath = entry.main
-							}
-						}
-
-						// resolve specifier using the `browser` field
-						if len(pkgJson.Browser) > 0 && ctx.isBrowserTarget() {
-							if path, ok := pkgJson.Browser[modulePath]; ok {
-								if path == "" {
-									return esbuild.OnResolveResult{
-										Path:      args.Path,
-										Namespace: "browser-exclude",
-									}, nil
-								}
-								if !isRelPathSpecifier(path) {
-									externalPath, sideEffects, err := ctx.resolveExternalModule(path, args.Kind, withTypeJSON, analyzeMode)
-									if err != nil {
-										return esbuild.OnResolveResult{}, err
-									}
-									return esbuild.OnResolveResult{
-										Path:        externalPath,
-										SideEffects: sideEffects,
-										External:    true,
-									}, nil
-								}
-								modulePath = path
-							}
-						}
-
-						var exportAs string
-
-						// split modules based on the `exports` field of package.json
-						if exports := pkgJson.Exports; exports.Len() > 0 {
-							for _, exportName := range exports.Keys() {
-								v, _ := exports.Get(exportName)
-								if exportName == "." || (strings.HasPrefix(exportName, "./") && !strings.ContainsRune(exportName, '*')) {
-									match := false
-									if s, ok := v.(string); ok && stripModuleExt(s) == stripModuleExt(modulePath) {
-										// exports: "./foo": "./foo.js"
-										match = true
-									} else if m, ok := v.(npm.JSONObject); ok {
-										// exports: "./foo": { "import": "./foo.js" }
-										// exports: "./foo": { "import": { default: "./foo.js" } }
-										// ...
-										paths := getExportConditionPaths(m)
-										for _, path := range paths {
-											if stripModuleExt(path) == stripModuleExt(modulePath) {
-												match = true
-												break
-											}
-										}
-									}
-									if match {
-										exportAs = path.Join(pkgJson.Name, stripModuleExt(exportName))
-										if exportAs != entrySpecifier && exportAs != entrySpecifier+"/index" {
-											externalPath, sideEffects, err := ctx.resolveExternalModule(exportAs, args.Kind, withTypeJSON, analyzeMode)
-											if err != nil {
-												return esbuild.OnResolveResult{}, err
-											}
-											return esbuild.OnResolveResult{
-												Path:        externalPath,
-												SideEffects: sideEffects,
-												External:    true,
-											}, nil
-										}
-									}
-								}
-							}
-						}
-
-						if len(args.With) > 0 && args.With["type"] == "css" {
-							return esbuild.OnResolveResult{
-								Path:        "/" + ctx.esmPath.PackageId() + utils.NormalizePathname(modulePath) + "?module",
-								External:    true,
-								SideEffects: esbuild.SideEffectsFalse,
-							}, nil
-						}
-
-						resolvedFilename := path.Join(ctx.wd, "node_modules", ctx.esmPath.PkgName, modulePath)
-						// check if the filename is within the working directory
-						if !strings.HasPrefix(resolvedFilename, ctx.wd+string(os.PathSeparator)) {
-							return esbuild.OnResolveResult{}, fmt.Errorf("could not resolve module %s", specifier)
-						}
-
-						// externalize sideEffects modules in subpath builds so they can be shared
-						// across entries (e.g. ol/proj and ol/proj/proj4 share proj.js)
-						if ctx.esmPath.SubPath != "" && pkgJson.SideEffects.Len() > 0 {
-							shortPath := strings.TrimPrefix(modulePath, "./")
-							if pkgJson.SideEffects.Has(modulePath) || pkgJson.SideEffects.Has(shortPath) {
-								externalPath, sideEffects, err := ctx.resolveExternalModule(path.Join(pkgJson.Name, stripModuleExt(shortPath)), args.Kind, withTypeJSON, analyzeMode)
-								if err != nil {
-									return esbuild.OnResolveResult{}, err
-								}
-								return esbuild.OnResolveResult{
-									Path:        externalPath,
-									SideEffects: sideEffects,
-									External:    true,
-								}, nil
-							}
-						}
-
-						// split the module that includes `export * from "external"` statement
-						if entry.module && len(pkgJson.Dependencies)+len(pkgJson.PeerDependencies) > 0 && args.Kind == esbuild.ResolveJSImportStatement {
-							fi, err := os.Lstat(resolvedFilename)
-							if err == nil && fi.Size() < 512 {
-								data, err := os.ReadFile(resolvedFilename)
-								if err == nil {
-									var exportFrom []string
-									var moreStmt bool
-									for line := range bytes.SplitSeq(data, []byte{'\n'}) {
-										line = bytes.TrimSpace(line)
-										if len(line) == 0 || bytes.HasPrefix(line, []byte("//")) || (bytes.HasPrefix(line, []byte("/*")) && bytes.HasSuffix(line, []byte("*/"))) {
-											// skip comments
-											continue
-										} else if bytes.HasPrefix(line, []byte("export * from")) || bytes.HasPrefix(line, []byte("export*from")) || (bytes.HasPrefix(line, []byte("export")) && bytes.HasPrefix(bytes.ReplaceAll(line, []byte{' '}, []byte{}), []byte("export*from"))) {
-											a := bytes.Split(line, []byte{'"'})
-											if len(a) != 3 {
-												a = bytes.Split(line, []byte{'\''})
-											}
-											if len(a) == 3 {
-												exportFrom = append(exportFrom, string(a[1]))
-											}
-										} else {
-											moreStmt = true
-										}
-									}
-									// single `export * from "external"` statement
-									if len(exportFrom) == 1 && !moreStmt && !isRelPathSpecifier(exportFrom[0]) {
-										externalPath, sideEffects, err := ctx.resolveExternalModule(exportFrom[0], args.Kind, withTypeJSON, analyzeMode)
-										if err != nil {
-											return esbuild.OnResolveResult{}, err
-										}
-										return esbuild.OnResolveResult{
-											Path:        externalPath,
-											SideEffects: sideEffects,
-											External:    true,
-										}, nil
-									}
-									if len(exportFrom) > 0 && moreStmt {
-										externalPath, sideEffects, err := ctx.resolveExternalModule(specifier, args.Kind, withTypeJSON, false)
-										if err != nil {
-											return esbuild.OnResolveResult{}, err
-										}
-										return esbuild.OnResolveResult{
-											Path:        externalPath,
-											SideEffects: sideEffects,
-											External:    true,
-										}, nil
-									}
-								}
-							}
-						}
-
-						// bundle the sub module if:
-						// - it's the entry point
-						// - it's not a conditional export
-						// - it's not a dynamic import and the `?bundle=false` flag is not present
-						// - it's not in the `splitting` list
-						isDynamicImport := args.Kind == esbuild.ResolveJSDynamicImport
-						bundleInternalModule := exportAs == "" && !isDynamicImport && ctx.bundleMode != BundleFalse && ctx.pkgJson.Type == "module"
-						if modulePath == entry.main || exportAs == entrySpecifier || (!isDynamicImport && !noBundle) || bundleInternalModule {
-							if existsFile(resolvedFilename) {
-								pkgDir := path.Join(ctx.wd, "node_modules", pkgName)
-								short := strings.TrimPrefix(resolvedFilename, pkgDir)[1:]
-								if analyzeMode && resolvedFilename != entryModuleFilename && strings.HasPrefix(args.Importer, pkgDir) {
-									includes = append(includes, [2]string{short, strings.TrimPrefix(args.Importer, pkgDir)[1:]})
-								}
-								if !analyzeMode && ctx.splitting != nil && ctx.splitting.Has(short) {
-									specifier = pkgJson.Name + utils.NormalizePathname(stripEntryModuleExt(short))
-									externalPath, sideEffects, err := ctx.resolveExternalModule(specifier, args.Kind, withTypeJSON, false)
-									if err != nil {
-										return esbuild.OnResolveResult{}, err
-									}
-									return esbuild.OnResolveResult{
-										Path:        externalPath,
-										SideEffects: sideEffects,
-										External:    true,
-									}, nil
-								}
-								// embed wasm as WebAssembly.Module
-								if strings.HasSuffix(resolvedFilename, ".wasm") {
-									return esbuild.OnResolveResult{
-										Path:      resolvedFilename,
-										Namespace: "wasm",
-									}, nil
-								}
-								// transfrom svelte component
-								if strings.HasSuffix(resolvedFilename, ".svelte") {
-									return esbuild.OnResolveResult{
-										Path:      resolvedFilename,
-										Namespace: "svelte",
-									}, nil
-								}
-								// transfrom Vue SFC
-								if strings.HasSuffix(resolvedFilename, ".vue") {
-									return esbuild.OnResolveResult{
-										Path:      resolvedFilename,
-										Namespace: "vue",
-									}, nil
-								}
-								return esbuild.OnResolveResult{Path: resolvedFilename}, nil
-							}
-							// otherwise, let esbuild to handle it
-							return esbuild.OnResolveResult{}, nil
-						}
-					}
-
-					// use `npm:` specifier for `denonext` target if the specifier is in the `forceNpmSpecifiers` list
-					if forceNpmSpecifiers[specifier] && ctx.target == "denonext" {
-						version := ""
-						pkgName, _, subPath := splitEsmPath(specifier)
-						if pkgName == ctx.esmPath.PkgName {
-							version = ctx.esmPath.PkgVersion
-						} else if v, ok := pkgJson.Dependencies[pkgName]; ok && npm.IsExactVersion(v) {
-							version = v
-						} else if v, ok := pkgJson.PeerDependencies[pkgName]; ok && npm.IsExactVersion(v) {
-							version = v
-						}
-						p := pkgName
-						if version != "" {
-							p += "@" + version
-						}
-						if len(subPath) > 0 {
-							p += "/" + subPath
-						}
-						return esbuild.OnResolveResult{
-							Path:     fmt.Sprintf("npm:%s", p),
-							External: true,
-						}, nil
-					}
-
-					// replace some npm modules with browser native APIs
-					var replacement npm_replacements.NpmReplacement
-					var ok bool
-					query := "browser"
-					if ctx.isDenoTarget() {
-						query = "deno"
-					} else if ctx.target == "node" {
-						query = "node"
-					}
-					if ctx.dev {
-						replacement, ok = npm_replacements.Get(specifier + "_" + query + "_dev")
-						if !ok {
-							replacement, ok = npm_replacements.Get(specifier + "_dev")
-						}
-					}
-					if !ok {
-						replacement, ok = npm_replacements.Get(specifier + "_" + query)
-					}
-					if !ok {
-						replacement, ok = npm_replacements.Get(specifier)
-					}
-					if ok {
-						if args.Kind == esbuild.ResolveJSRequireCall || args.Kind == esbuild.ResolveJSRequireResolve {
-							ctx.cjsRequires = append(ctx.cjsRequires, [3]string{
-								"npm:" + specifier,
-								string(replacement.IIFE),
-								"",
-							})
-							return esbuild.OnResolveResult{
-								Path:     "npm:" + specifier,
-								External: true,
-							}, nil
-						}
-						return esbuild.OnResolveResult{
-							Path:       specifier,
-							PluginData: replacement.ESM,
-							Namespace:  "npm-replacement",
-						}, nil
-					}
-
-					// check if the specifier is in the `imports` field and is a http module
-					if ctx.externalAll && isHttpSpecifier(specifier) {
-						return esbuild.OnResolveResult{
-							Path:     args.Path,
-							External: true,
-						}, nil
-					}
-
-					// dynamic external
-					externalPath, sideEffects, err := ctx.resolveExternalModule(specifier, args.Kind, withTypeJSON, analyzeMode)
-					if err != nil {
-						return esbuild.OnResolveResult{}, err
-					}
-					return esbuild.OnResolveResult{
-						Path:        externalPath,
-						External:    true,
-						SideEffects: sideEffects,
-					}, nil
-				},
-			)
-
-			// npm replacement loader
-			build.OnLoad(
-				esbuild.OnLoadOptions{Filter: ".*", Namespace: "npm-replacement"},
-				func(args esbuild.OnLoadArgs) (ret esbuild.OnLoadResult, err error) {
-					contents := string(args.PluginData.([]byte))
-					return esbuild.OnLoadResult{Contents: &contents, Loader: esbuild.LoaderJS}, nil
-				},
-			)
-
-			// browser exclude loader
-			build.OnLoad(
-				esbuild.OnLoadOptions{Filter: ".*", Namespace: "browser-exclude"},
-				func(args esbuild.OnLoadArgs) (ret esbuild.OnLoadResult, err error) {
-					contents := "export default {};"
-					if exports, ok := browserExclude[args.Path]; ok {
-						for _, name := range exports.Values() {
-							contents = fmt.Sprintf("%sexport const %s = {};", contents, name)
-						}
-					}
-					return esbuild.OnLoadResult{Contents: &contents, Loader: esbuild.LoaderJS}, nil
-				},
-			)
-
-			// wasm module exclude loader
-			build.OnLoad(
-				esbuild.OnLoadOptions{Filter: ".*", Namespace: "wasm"},
-				func(args esbuild.OnLoadArgs) (ret esbuild.OnLoadResult, err error) {
-					wasm, err := os.ReadFile(args.Path)
-					if err != nil {
-						return
-					}
-					wasm64 := base64.StdEncoding.EncodeToString(wasm)
-					code := fmt.Sprintf("export default Uint8Array.from(atob('%s'), c => c.charCodeAt(0))", wasm64)
-					return esbuild.OnLoadResult{Contents: &code, Loader: esbuild.LoaderJS}, nil
-				},
-			)
-
-			// svelte SFC loader
-			build.OnLoad(
-				esbuild.OnLoadOptions{Filter: ".*", Namespace: "svelte"},
-				func(args esbuild.OnLoadArgs) (esbuild.OnLoadResult, error) {
-					code, err := os.ReadFile(args.Path)
-					if err != nil {
-						return esbuild.OnLoadResult{}, err
-					}
-					svelteVersion := "5"
-					if version, ok := ctx.args.Deps["svelte"]; ok {
-						svelteVersion = version
-					} else if version, ok := ctx.pkgJson.Dependencies["svelte"]; ok {
-						svelteVersion = version
-					} else if version, ok := ctx.pkgJson.PeerDependencies["svelte"]; ok {
-						svelteVersion = version
-					}
-					if !npm.IsExactVersion(svelteVersion) {
-						info, err := ctx.npmrc.getPackageInfoContext(ctx.Context(), "svelte", svelteVersion)
-						if err != nil {
-							return esbuild.OnLoadResult{}, errors.New("failed to get svelte package info")
-						}
-						svelteVersion = info.Version
-					}
-					if semverLessThan(svelteVersion, "4.0.0") {
-						return esbuild.OnLoadResult{}, errors.New("svelte version must be greater than 4.0.0")
-					}
-					out, err := transformSvelte(ctx.Context(), ctx.npmrc, svelteVersion, ctx.esmPath.String(), string(code))
-					if err != nil {
-						return esbuild.OnLoadResult{}, err
-					}
-					return esbuild.OnLoadResult{
-						Contents:   &out.Code,
-						ResolveDir: path.Join(ctx.wd, "node_modules", ctx.esmPath.PkgName),
-						Loader:     esbuild.LoaderJS,
-					}, nil
-				},
-			)
-
-			// vue SFC loader
-			build.OnLoad(
-				esbuild.OnLoadOptions{Filter: ".*", Namespace: "vue"},
-				func(args esbuild.OnLoadArgs) (esbuild.OnLoadResult, error) {
-					code, err := os.ReadFile(args.Path)
-					if err != nil {
-						return esbuild.OnLoadResult{}, err
-					}
-					vueVersion := "3"
-					if version, ok := ctx.args.Deps["vue"]; ok {
-						vueVersion = version
-					} else if version, ok := ctx.pkgJson.Dependencies["vue"]; ok {
-						vueVersion = version
-					} else if version, ok := ctx.pkgJson.PeerDependencies["vue"]; ok {
-						vueVersion = version
-					}
-					if !npm.IsExactVersion(vueVersion) {
-						info, err := ctx.npmrc.getPackageInfoContext(ctx.Context(), "vue", vueVersion)
-						if err != nil {
-							return esbuild.OnLoadResult{}, errors.New("failed to get vue package info")
-						}
-						vueVersion = info.Version
-					}
-					if semverLessThan(vueVersion, "3.0.0") {
-						return esbuild.OnLoadResult{}, errors.New("vue version must be greater than 3.0.0")
-					}
-					out, err := transformVue(ctx.Context(), ctx.npmrc, vueVersion, ctx.esmPath.String(), string(code))
-					if err != nil {
-						return esbuild.OnLoadResult{}, err
-					}
-					if out.Lang == "ts" {
-						return esbuild.OnLoadResult{
-							Contents:   &out.Code,
-							ResolveDir: path.Join(ctx.wd, "node_modules", ctx.esmPath.PkgName),
-							Loader:     esbuild.LoaderTS,
-						}, nil
-					}
-					return esbuild.OnLoadResult{
-						Contents:   &out.Code,
-						ResolveDir: path.Join(ctx.wd, "node_modules", ctx.esmPath.PkgName),
-						Loader:     esbuild.LoaderJS,
-					}, nil
-				},
-			)
-		},
-	}
-
-	if err = ctx.checkCanceled(); err != nil {
-		return
-	}
-
-	nodeFilename := ctx.Path()
-	nodeDirname, _ := utils.SplitByLastByte(nodeFilename, '/')
-	nodeEnv := ctx.getNodeEnv()
-	define := map[string]string{
-		"__filename":           fmt.Sprintf(`"%s"`, nodeFilename),
-		"__dirname":            fmt.Sprintf(`"%s"`, nodeDirname),
-		"Buffer":               "__Buffer$",
-		"process":              "__Process$",
-		"setImmediate":         "__setImmediate$",
-		"clearImmediate":       "__clearImmediate$",
-		"require.resolve":      "__rResolve$",
-		"process.env.NODE_ENV": fmt.Sprintf(`"%s"`, nodeEnv),
-	}
-	// support features that can not be polyfilled
-	supported := map[string]bool{
-		"bigint":          true,
-		"top-level-await": true,
-	}
-	if ctx.target == "node" {
-		define = map[string]string{
-			"process.env.NODE_ENV":        fmt.Sprintf(`"%s"`, nodeEnv),
-			"global.process.env.NODE_ENV": fmt.Sprintf(`"%s"`, nodeEnv),
-		}
-	} else {
-		if ctx.isBrowserTarget() && safeReserveProcessPackages[ctx.esmPath.PkgName] {
-			delete(define, "process")
-		}
-		if ctx.isDenoTarget() {
-			// deno 2 has removed the `window` global object, let's replace it with `globalThis`
-			define["window"] = "globalThis"
-		}
-		for k, v := range define {
-			define["global."+k] = v
-			define["globalThis."+k] = v
-		}
-		define["global"] = "globalThis"
-	}
-	conditions := ctx.args.Conditions
-	if ctx.dev {
-		conditions = append(conditions, "development")
-	}
-	if ctx.isDenoTarget() {
-		conditions = append(conditions, "deno")
-	} else if ctx.target == "node" {
-		conditions = append(conditions, "node")
-	}
-	minify := config.Minify
-	if ctx.dev {
-		// disable minification for development build
-		minify = false
-	}
-	keepNames := ctx.args.KeepNames
-	ignoreAnnotations := ctx.args.IgnoreAnnotations
-	if esmsh := ctx.pkgJson.Esmsh; esmsh != nil {
-		if v, ok := esmsh["keepNames"]; ok {
-			if b, ok := v.(bool); ok {
-				keepNames = b
-			}
-		}
-		if v, ok := esmsh["ignoreAnnotations"]; ok {
-			if b, ok := v.(bool); ok {
-				ignoreAnnotations = b
-			}
-		}
-	}
-	options := esbuild.BuildOptions{
-		AbsWorkingDir:     ctx.wd,
-		PreserveSymlinks:  true,
-		Format:            esbuild.FormatESModule,
-		Target:            targets[ctx.target],
-		Platform:          esbuild.PlatformBrowser,
-		Define:            define,
-		Supported:         supported,
-		JSX:               esbuild.JSXAutomatic,
-		JSXImportSource:   "react",
-		Bundle:            true,
-		MinifyWhitespace:  minify,
-		MinifyIdentifiers: minify,
-		MinifySyntax:      minify,
-		KeepNames:         keepNames,
-		IgnoreAnnotations: ignoreAnnotations,
-		Conditions:        conditions,
-		Loader:            loaders,
-		Plugins:           []esbuild.Plugin{esmifyPlugin},
-		Outdir:            "/esbuild",
-		Write:             false,
-	}
-	if entryPoint != "" {
-		options.EntryPoints = []string{entryPoint}
-	} else {
-		options.Stdin = &stdin
-	}
-	if ctx.target == "node" {
-		options.Platform = esbuild.PlatformNode
-	}
-	if config.SourceMap {
-		options.Sourcemap = esbuild.SourceMapExternal
-	}
-	for _, pkgName := range []string{"preact", "react", "solid-js", "mono-jsx", "vue", "hono"} {
-		_, ok1 := ctx.pkgJson.Dependencies[pkgName]
-		_, ok2 := ctx.pkgJson.PeerDependencies[pkgName]
-		if ok1 || ok2 {
-			options.JSXImportSource = pkgName
-			switch pkgName {
-			case "mono-jsx":
-				options.JSXImportSource += "/dom"
-			case "hono":
-				options.JSXImportSource += "/jsx"
-			}
-			break
-		}
-	}
-
-	esbCtx, ctxErr := esbuild.Context(options)
-	if ctxErr != nil {
-		err = errors.New("esbuild: " + ctxErr.Error())
-		return
-	}
-	defer esbCtx.Dispose()
-
-REBUILD:
-	res := esbCtx.Rebuild()
-	if len(res.Errors) > 0 {
-		// mark the missing module as external to exclude it from the bundle
-		msg := res.Errors[0].Text
-		if strings.HasPrefix(msg, "Could not resolve \"") {
-			// current module can not be marked as an external
-			if strings.HasPrefix(msg, fmt.Sprintf("Could not resolve \"%s\"", entrySpecifier)) {
-				err = fmt.Errorf("could not resolve \"%s\"", entrySpecifier)
-				return
-			}
-			name := strings.Split(msg, "\"")[1]
-			if !implicitExternal.Has(name) {
-				ctx.logger.Warnf("build(%s): implicit external '%s'", ctx.Path(), name)
-				implicitExternal.Add(name)
-				goto REBUILD
-			}
-		}
-		if strings.HasPrefix(msg, "No matching export in \"") {
-			a := strings.Split(msg, "\"")
-			if len(a) > 4 {
-				path, exportName := a[1], a[3]
-				if strings.HasPrefix(path, "browser-exclude:") && exportName != "default" {
-					path = strings.TrimPrefix(path, "browser-exclude:")
-					exports, ok := browserExclude[path]
-					if !ok {
-						exports = set.New[string]()
-						browserExclude[path] = exports
-					}
-					if !exports.Has(exportName) {
-						exports.Add(exportName)
-						goto REBUILD
-					}
-				}
-			}
-		}
-		err = errors.New("esbuild: " + msg)
-		return
-	}
-
-	if analyzeMode {
-		return
-	}
-
-	for _, w := range res.Warnings {
-		ctx.logger.Warnf("esbuild(%s): %s", ctx.Path(), w.Text)
-	}
-
-	imports := set.New[string]()
-
-	for _, file := range res.OutputFiles {
-		if strings.HasSuffix(file.Path, ".js") {
-			header := bytes.NewBufferString("/* esm.sh - ")
-			if ctx.esmPath.GhPrefix {
-				header.WriteString("github:")
-			} else if ctx.esmPath.PrPrefix {
-				header.WriteString("pkg.pr.new/")
-			}
-			header.WriteString(ctx.esmPath.PkgName)
-			if ctx.esmPath.GhPrefix {
-				header.WriteByte('#')
-			} else {
-				header.WriteByte('@')
-			}
-			header.WriteString(ctx.esmPath.PkgVersion)
-			if ctx.esmPath.SubPath != "" {
-				header.WriteByte('/')
-				header.WriteString(ctx.esmPath.SubPath)
-			}
-			header.WriteString(" */\n")
-
-			jsContent := file.Contents
-
-			// remove shebang
-			if bytes.HasPrefix(jsContent, []byte("#!/")) {
-				jsContent = jsContent[bytes.IndexByte(jsContent, '\n')+1:]
-				ctx.smOffset--
-			}
-
-			// add nodejs compatibility
-			if ctx.target != "node" {
-				ids := set.New[string]()
-				for _, r := range regexpESMInternalIdent.FindAll(jsContent, -1) {
-					ids.Add(string(r))
-				}
-				if ids.Has("__Process$") {
-					if ctx.args.External.Has("node:process") {
-						header.WriteString(`import __Process$ from "node:process";`)
-						header.WriteByte('\n')
-					} else if ctx.isBrowserTarget() {
-						if len(ctx.pkgJson.Browser) > 0 {
-							var excluded bool
-							if name, ok := ctx.pkgJson.Browser["process"]; ok {
-								excluded = name == ""
-							} else if name, ok := ctx.pkgJson.Browser["node:process"]; ok {
-								excluded = name == ""
-							}
-							if excluded {
-								header.WriteString(`const __Process$ = globalThis.process;`)
-								header.WriteByte('\n')
-							} else {
-								header.WriteString(`import __Process$ from "/node/process.mjs";`)
-								header.WriteByte('\n')
-								imports.Add("/node/process.mjs")
-							}
-						} else {
-							header.WriteString(`import __Process$ from "/node/process.mjs";`)
-							header.WriteByte('\n')
-							imports.Add("/node/process.mjs")
-						}
-					} else if ctx.target == "denonext" {
-						header.WriteString(`import __Process$ from "node:process";`)
-						header.WriteByte('\n')
-					} else if ctx.target == "deno" {
-						header.WriteString(`import __Process$ from "https://deno.land/std@0.177.1/node/process.ts";`)
-						header.WriteByte('\n')
-					}
-				}
-				if ids.Has("__Buffer$") {
-					if ctx.args.External.Has("node:buffer") {
-						header.WriteString(`import { Buffer as __Buffer$ } from "node:buffer";`)
-						header.WriteByte('\n')
-					} else if ctx.isBrowserTarget() {
-						var excluded bool
-						if len(ctx.pkgJson.Browser) > 0 {
-							if name, ok := ctx.pkgJson.Browser["buffer"]; ok {
-								excluded = name == ""
-							} else if name, ok := ctx.pkgJson.Browser["node:buffer"]; ok {
-								excluded = name == ""
-							}
-						}
-						if excluded {
-							header.WriteString(`const __Buffer$ = globalThis.Buffer;`)
-							header.WriteByte('\n')
-						} else {
-							header.WriteString(`import { Buffer as __Buffer$ } from "/node/buffer.mjs";`)
-							header.WriteByte('\n')
-							imports.Add("/node/buffer.mjs")
-						}
-					} else if ctx.target == "denonext" {
-						header.WriteString(`import { Buffer as __Buffer$ } from "node:buffer";`)
-						header.WriteByte('\n')
-					} else if ctx.target == "deno" {
-						header.WriteString(`import { Buffer as __Buffer$ } from "https://deno.land/std@0.177.1/node/buffer.ts";`)
-						header.WriteByte('\n')
-					}
-				}
-				if ids.Has("__setImmediate$") {
-					header.WriteString(`var __setImmediate$ = (cb, ...args) => ( { $t: setTimeout(cb, 0, ...args), [Symbol.dispose](){ clearTimeout(this.t) } });`)
-					header.WriteByte('\n')
-				}
-				if ids.Has("__clearImmediate$") {
-					header.WriteString(`var __clearImmediate$ = i => clearTimeout(i.$t);`)
-					header.WriteByte('\n')
-				}
-				if ids.Has("__rResolve$") {
-					header.WriteString(`var __rResolve$ = p => p;`)
-					header.WriteByte('\n')
-				}
-			}
-
-			// check cjs requires
-			if len(ctx.cjsRequires) > 0 {
-				requires := make([][3]string, 0, len(ctx.cjsRequires))
-				set := set.New[string]()
-				for _, r := range ctx.cjsRequires {
-					specifier := r[0]
-					if !set.Has(specifier) {
-						set.Add(specifier)
-						requires = append(requires, r)
-					}
-				}
-				isEsModule := make([]bool, len(requires))
-				for i, r := range requires {
-					specifier := r[0]
-					importUrl := r[2]
-					if strings.HasPrefix(specifier, "npm:") {
-						// npm replacements
-						fmt.Fprintf(header, `var __%x$=%s;`, i, r[1])
-					} else if isJsonModuleSpecifier(specifier) {
-						fmt.Fprintf(header, `import __%x$ from"%s";`, i, importUrl)
-						imports.Add(r[1])
-					} else {
-						fmt.Fprintf(header, `import*as __%x$ from"%s";`, i, importUrl)
-						imports.Add(r[1])
-					}
-					// if `require("module").default` found
-					if bytes.Contains(jsContent, fmt.Appendf(nil, `("%s").default`, specifier)) {
-						isEsModule[i] = true
-						continue
-					}
-					// `var mod = require("module");...;mod()` -> cjs
-					// `var mod = require("module");...;mod.default` -> es module
-					if a := bytes.SplitN(jsContent, fmt.Appendf(nil, `("%s")`, specifier), 2); len(a) >= 2 {
-						ret := regexpVarDecl.FindSubmatch(a[0])
-						if len(ret) == 2 {
-							r, e := regexp.Compile(fmt.Sprintf(`[^\w$]%s(\(|\.default[^\w$=])`, string(ret[1])))
-							if e == nil {
-								ret := r.FindSubmatch(jsContent)
-								if len(ret) == 2 {
-									isEsModule[i] = string(ret[1]) != "("
-									continue
-								}
-							}
-						}
-					}
-					if !isRelPathSpecifier(specifier) && !isNodeBuiltinSpecifier(specifier) && !strings.HasPrefix(specifier, "npm:") && !isJsonModuleSpecifier(specifier) {
-						dep, pkgJson, err := ctx.resolveDependency(specifier, false)
-						if err == nil {
-							if pkgJson.Type == "module" || pkgJson.Module != "" {
-								isEsModule[i] = true
-							} else {
-								b := &BuildContext{
-									npmrc:       ctx.npmrc,
-									logger:      ctx.logger,
-									metaDB:      ctx.metaDB,
-									storage:     ctx.storage,
-									esmPath:     dep,
-									args:        ctx.args,
-									externalAll: ctx.externalAll,
-									target:      ctx.target,
-									dev:         ctx.dev,
-									ctx:         ctx.ctx,
-								}
-								err = b.install()
-								if err == nil {
-									entry := b.resolveEntry(dep)
-									if !entry.module {
-										ret, cjsNamedExports, _, e := b.lexer(&entry)
-										if e == nil && ret.CJS && slices.Contains(cjsNamedExports, "__esModule") {
-											isEsModule[i] = true
-										}
-									}
-								}
-							}
-						}
-					}
-				}
-				header.WriteString(`var require=n=>{const e=m=>typeof m.default<"u"?m.default:m,c=m=>Object.assign({__esModule:true},m);switch(n){`)
-				for i, r := range requires {
-					specifier := r[0]
-					if isEsModule[i] {
-						fmt.Fprintf(header, `case"%s":return c(__%x$);`, specifier, i)
-					} else {
-						fmt.Fprintf(header, `case"%s":return e(__%x$);`, specifier, i)
-					}
-				}
-				header.WriteString(`default:console.error('module "'+n+'" not found');return null;}};`)
-				header.WriteByte('\n')
-			}
-
-			// check esm imports
-			for _, a := range ctx.esmImports {
-				resolvedPathFull, resolvedPath := a[0], a[1]
-				if bytes.Contains(jsContent, fmt.Appendf(nil, `"%s"`, resolvedPath)) {
-					imports.Add(resolvedPathFull)
-				}
-			}
-
-			// to fix the source map
-			ctx.smOffset += strings.Count(header.String(), "\n")
-
-			// apply rewrites
-			jsContent, dropSourceMap := ctx.rewriteJS(jsContent)
-
-			finalJS := &bytes.Buffer{}
-			io.Copy(finalJS, header)
-			finalJS.Write(jsContent)
-
-			// check if the package is deprecated
-			if !ctx.esmPath.GhPrefix && !ctx.esmPath.PrPrefix {
-				deprecated, _ := ctx.npmrc.isDeprecated(ctx.pkgJson.Name, ctx.pkgJson.Version)
-				if deprecated != "" {
-					fmt.Fprintf(finalJS, `console.warn("%%c[esm.sh]%%c %%cdeprecated%%c %s@%s: " + %s, "color:grey", "", "color:red", "");%s`, ctx.esmPath.PkgName, ctx.esmPath.PkgVersion, utils.MustEncodeJSON(deprecated), "\n")
-				}
-			}
-
-			// add sourcemap Url
-			if config.SourceMap && !dropSourceMap {
-				finalJS.WriteString("//# sourceMappingURL=")
-				finalJS.WriteString(path.Base(ctx.Path()))
-				finalJS.WriteString(".map")
-			}
-
-			var stat storage.Stat
-			stat, err = ctx.storage.Stat(ctx.getSavePath())
-			if err == nil && stat.Size() > 0 {
-				ctx.logger.Infof("build(%s): file already exists in the storage, skip it", ctx.Path())
-				continue
-			}
-			if err != storage.ErrNotFound {
-				ctx.logger.Errorf("storage.stat(%s): %v", ctx.getSavePath(), err)
-				err = errors.New("storage(stat): " + err.Error())
-				return
-			}
-			sha := sha512.New384()
-			err = ctx.storage.Put(ctx.getSavePath(), storage.TeeReader(finalJS, sha))
-			if err != nil {
-				ctx.logger.Errorf("storage.put(%s): %v", ctx.getSavePath(), err)
-				err = errors.New("storage(put): " + err.Error())
-				return
-			}
-			meta.Integrity = "sha384-" + base64.StdEncoding.EncodeToString(sha.Sum(nil))
-		}
-	}
-
-	for _, file := range res.OutputFiles {
-		if strings.HasSuffix(file.Path, ".css") {
-			savePath := ctx.getSavePath()
-			savePath = strings.TrimSuffix(savePath, path.Ext(savePath)) + ".css"
-			err = ctx.storage.Put(savePath, bytes.NewReader(file.Contents))
-			if err != nil {
-				ctx.logger.Errorf("storage.put(%s): %v", savePath, err)
-				err = errors.New("storage(put): " + err.Error())
-				return
-			}
-			meta.CSSInJS = true
-		} else if config.SourceMap && strings.HasSuffix(file.Path, ".js.map") {
-			var sourceMap map[string]any
-			if json.Unmarshal(file.Contents, &sourceMap) == nil {
-				if mapping, ok := sourceMap["mappings"].(string); ok {
-					fixedMapping := make([]byte, ctx.smOffset+len(mapping))
-					for i := 0; i < ctx.smOffset; i++ {
-						fixedMapping[i] = ';'
-					}
-					copy(fixedMapping[ctx.smOffset:], mapping)
-					sourceMap["mappings"] = string(fixedMapping)
-				}
-				buf := &bytes.Buffer{}
-				if json.NewEncoder(buf).Encode(sourceMap) == nil {
-					err = ctx.storage.Put(ctx.getSavePath()+".map", buf)
-					if err != nil {
-						ctx.logger.Errorf("storage.put(%s): %v", ctx.getSavePath()+".map", err)
-						err = errors.New("storage(put): " + err.Error())
-						return
-					}
-				}
-			}
-		}
-	}
-
-	// sort imports
-	for _, path := range imports.Values() {
-		if strings.HasPrefix(path, "/") {
-			meta.Imports = append(meta.Imports, path)
-		}
-	}
-	sort.Strings(meta.Imports)
-
-	// resolve types(dts)
-	meta.Dts, err = ctx.resolveDTS(entry)
-	return
-}
-
-func (ctx *BuildContext) buildTypes() (ret *BuildMeta, err error) {
-	// install the package
-	ctx.status = "install"
-	err = ctx.install()
-	if err != nil {
-		return
-	}
-	if err = ctx.checkCanceled(); err != nil {
-		return
-	}
-
-	var dts string
-	if endsWith(ctx.esmPath.SubPath, ".ts", ".mts", ".tsx", ".cts") {
-		dts = "./" + ctx.esmPath.SubPath
-	} else {
-		entry := ctx.resolveEntry(ctx.esmPath)
-		if entry.types == "" {
-			err = errors.New("types not found")
-			return
-		}
-		dts = entry.types
-	}
-
-	ctx.status = "build"
-	err = ctx.transformDTS(dts)
-	if err != nil {
-		return
-	}
-
-	ret = &BuildMeta{Dts: "/" + ctx.esmPath.PackageId() + dts[1:]}
-	return
-}
-
-func (ctx *BuildContext) install() (err error) {
-	if ctx.wd == "" || ctx.pkgJson == nil {
-		p, err := ctx.npmrc.installPackageContext(ctx.Context(), ctx.esmPath.Package())
-		if err != nil {
-			return err
-		}
-
-		if ctx.esmPath.GhPrefix || ctx.esmPath.PrPrefix {
-			// if the name in package.json is not the same as the repository name
-			if p.Name != ctx.esmPath.PkgName {
-				p.PkgName = p.Name
-				p.Name = ctx.esmPath.PkgName
-			}
-			p.Version = ctx.esmPath.PkgVersion
-		} else {
-			p.Version = strings.TrimPrefix(p.Version, "v")
-		}
-
-		// Check if the `SubPath` is the same as the `main` or `module` field of the package.json
-		if subPath := ctx.esmPath.SubPath; subPath != "" && ctx.target != "types" {
-			isMainModule := false
-			check := func(s string) bool {
-				return isMainModule || (s != "" && subPath == utils.NormalizePathname(stripModuleExt(s))[1:])
-			}
-			if p.Exports.Len() > 0 {
-				if v, ok := p.Exports.Get("."); ok {
-					if s, ok := v.(string); ok {
-						// exports: { ".": "./index.js" }
-						isMainModule = check(s)
-					} else if obj, ok := v.(npm.JSONObject); ok {
-						// exports: { ".": { "require": "./cjs/index.js", "import": "./esm/index.js" } }
-						// exports: { ".": { "node": { "require": "./cjs/index.js", "import": "./esm/index.js" } } }
-						// ...
-						paths := getExportConditionPaths(obj)
-						isMainModule = slices.ContainsFunc(paths, check)
-					}
-				}
-			}
-			if !isMainModule {
-				isMainModule = (p.Module != "" && check(p.Module)) || (p.Main != "" && check(p.Main))
-			}
-			if isMainModule {
-				ctx.esmPath.SubPath = ""
-				ctx.rawPath = ctx.path
-				ctx.path = ""
-			}
-		}
-
-		ctx.wd = path.Join(ctx.npmrc.StoreDir(), ctx.esmPath.PackageId())
-		ctx.pkgJson = p
-	}
-
-	// - install dependencies in `BundleDeps` mode
-	// - install '@babel/runtime' and '@swc/helpers' if they are present in the dependencies in `BundleDefault` mode
-	switch ctx.bundleMode {
-	case BundleDeps:
-		err = ctx.npmrc.installDependenciesContext(ctx.Context(), ctx.wd, ctx.pkgJson, false, nil)
-	case BundleDefault:
-		if v, ok := ctx.pkgJson.Dependencies["@babel/runtime"]; ok {
-			err = ctx.npmrc.installDependenciesContext(ctx.Context(), ctx.wd, &npm.PackageJSON{Dependencies: map[string]string{"@babel/runtime": v}}, false, nil)
-		}
-		if err == nil {
-			if v, ok := ctx.pkgJson.Dependencies["@swc/helpers"]; ok {
-				err = ctx.npmrc.installDependenciesContext(ctx.Context(), ctx.wd, &npm.PackageJSON{Dependencies: map[string]string{"@swc/helpers": v}}, false, nil)
-			}
-		}
-	}
-	if err != nil {
-		return
-	}
-	return
-}
-
-func (ctx *BuildContext) shouldBundle() bool {
-	if ctx.bundleMode == BundleFalse || ctx.pkgJson.SideEffects.Len() > 0 {
-		return false
-	}
-	if ctx.pkgJson.Esmsh != nil {
-		if v, ok := ctx.pkgJson.Esmsh["bundle"]; ok {
-			if b, ok := v.(bool); ok && !b {
-				return false
-			}
-		}
-	}
-	return true
-}