@templmf/temp-solf-lmf 0.0.128 → 0.0.129

package/esm.sh/server/build_resolver.go

@@ -0,0 +1,1447 @@
+package server
+
+import (
+	"crypto/sha1"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"os"
+	"path"
+	"slices"
+	"sort"
+	"strings"
+
+	"github.com/esm-dev/esm.sh/internal/npm"
+	esbuild "github.com/ije/esbuild-internal/api"
+	esbuild_config "github.com/ije/esbuild-internal/config"
+	"github.com/ije/esbuild-internal/js_ast"
+	"github.com/ije/esbuild-internal/js_parser"
+	"github.com/ije/esbuild-internal/logger"
+	"github.com/ije/gox/utils"
+)
+
+var moduleExts = []string{".js", ".ts", ".mjs", ".mts", ".jsx", ".tsx", ".cjs", ".cts"}
+
+// BuildEntry represents the build entrypoints of a module
+type BuildEntry struct {
+	main   string
+	module bool
+	types  string
+}
+
+func (entry *BuildEntry) isEmpty() bool {
+	return entry.main == "" && entry.types == ""
+}
+
+func (entry *BuildEntry) isTypesOnly() bool {
+	return entry.main == "" && entry.types != ""
+}
+
+func (entry *BuildEntry) update(main string, module bool) {
+	entry.main = main
+	entry.module = module || strings.HasSuffix(main, ".mjs")
+}
+
+func (ctx *BuildContext) resolveEntry(esm EsmPath) (entry BuildEntry) {
+	pkgJson := ctx.pkgJson
+
+	if subPath := esm.SubPath; subPath != "" {
+		if endsWith(subPath, ".d.ts", ".d.mts", ".d.cts") {
+			entry.types = normalizeEntryPath(subPath)
+			return
+		}
+
+		switch ext := path.Ext(subPath); ext {
+		case ".mts", ".ts", ".tsx", ".cts", ".json", ".jsx", ".svelte", ".vue", ".css":
+			if ctx.existsPkgFile(subPath) {
+				switch ext {
+				case ".mts", ".ts", ".tsx", ".cts":
+					// todo: create dts from the ts file
+					entry.update(subPath, true)
+					// lookup jsr built dts
+					if strings.HasPrefix(esm.PkgName, "@jsr/") {
+						for _, v := range pkgJson.Exports.Values() {
+							if obj, ok := v.(npm.JSONObject); ok {
+								if v, ok := obj.Get("default"); ok {
+									if s, ok := v.(string); ok && s == "./"+stripModuleExt(subPath)+".js" {
+										if v, ok := obj.Get("types"); ok {
+											if s, ok := v.(string); ok {
+												entry.types = normalizeEntryPath(s)
+											}
+										}
+										break
+									}
+								}
+							}
+						}
+					}
+					return
+				case ".json", ".jsx", ".svelte", ".vue":
+					entry.update(subPath, true)
+					return
+				case ".css":
+					// check if CSS file is defined in exports
+					if pkgJson.Exports.Len() > 0 {
+						if v, ok := pkgJson.Exports.Get("./" + subPath); ok {
+							if s, ok := v.(string); ok {
+								entry.update(s, true)
+								return
+							}
+							if obj, ok := v.(npm.JSONObject); ok {
+								// handle conditional exports like {"types": "...", "default": "..."}
+								if defaultPath, ok := obj.Get("default"); ok {
+									if s, ok := defaultPath.(string); ok {
+										entry.update(s, true)
+										return
+									}
+								}
+							}
+						}
+					}
+					// if not found in exports, use the subPath as-is
+					entry.update(subPath, true)
+					return
+				}
+			}
+		}
+
+		// reslove sub-module using `exports` conditions if exists
+		// see https://nodejs.org/api/packages.html#package-entry-points
+		if pkgJson.Exports.Len() > 0 {
+			var exportEntry BuildEntry
+			conditions, ok := pkgJson.Exports.Get("./" + subPath)
+			if ok {
+				if s, ok := conditions.(string); ok {
+					/**
+					exports: {
+						"./lib/foo": "./lib/foo.js"
+					}
+					*/
+					exportEntry.update(s, pkgJson.Type == "module")
+				} else if obj, ok := conditions.(npm.JSONObject); ok {
+					/**
+					exports: {
+						"./lib/foo": {
+							"require": "./lib/foo.js",
+							"import": "./esm/foo.js",
+							"types": "./types/foo.d.ts"
+						}
+					}
+					*/
+					exportEntry = ctx.resolveConditionExportEntry(obj, pkgJson.Type)
+				}
+			} else {
+				for _, name := range pkgJson.Exports.Keys() {
+					conditions, _ := pkgJson.Exports.Get(name)
+					if stripEntryModuleExt(name) == "./"+subPath {
+						if s, ok := conditions.(string); ok {
+							/**
+							exports: {
+								"./lib/foo.js": "./lib/foo.js"
+							}
+							*/
+							exportEntry.update(s, pkgJson.Type == "module")
+						} else if obj, ok := conditions.(npm.JSONObject); ok {
+							/**
+							exports: {
+								"./lib/foo.js": {
+									"require": "./lib/foo.js",
+									"import": "./esm/foo.js",
+									"types": "./types/foo.d.ts"
+								}
+							}
+							*/
+							exportEntry = ctx.resolveConditionExportEntry(obj, pkgJson.Type)
+						}
+						break
+					} else if diff, ok := matchAsteriskExport(name, subPath); ok {
+						if s, ok := conditions.(string); ok {
+							/**
+							exports: {
+								"./lib/*": "./dist/lib/*.js",
+							}
+							*/
+							path := strings.ReplaceAll(s, "*", diff)
+							if endsWith(path, ".mjs", ".js", ".cjs") {
+								if ctx.existsPkgFile(path) {
+									exportEntry.update(path, pkgJson.Type == "module")
+									break
+								}
+							} else if p := path + ".mjs"; ctx.existsPkgFile(p) {
+								exportEntry.update(p, true)
+								break
+							} else if p := path + ".js"; ctx.existsPkgFile(p) {
+								exportEntry.update(p, pkgJson.Type == "module")
+								break
+							} else if p := path + ".cjs"; ctx.existsPkgFile(p) {
+								exportEntry.update(p, false)
+								break
+							} else if p := path + "/index.mjs"; ctx.existsPkgFile(p) {
+								exportEntry.update(p, true)
+								break
+							} else if p := path + "/index.js"; ctx.existsPkgFile(p) {
+								exportEntry.update(p, pkgJson.Type == "module")
+								break
+							} else if p := path + "/index.cjs"; ctx.existsPkgFile(p) {
+								exportEntry.update(p, false)
+								break
+							}
+						} else if obj, ok := conditions.(npm.JSONObject); ok {
+							/**
+							exports: {
+								"./lib/*": {
+									"require": ".dist/lib/dist/*.js",
+									"import": ".dist/lib/esm/*.js",
+									"types": ".dist/lib/types/*.d.ts"
+								},
+							}
+							*/
+							exportEntry = ctx.resolveConditionExportEntry(resloveAsteriskPathMapping(obj, diff), pkgJson.Type)
+							ctx.finalizeBuildEntry(&exportEntry)
+							if !exportEntry.isEmpty() {
+								break
+							}
+						}
+					}
+				}
+			}
+			if mainJs, ok := ctx.resloveSubModule(exportEntry.main); ok {
+				entry.update(mainJs, exportEntry.module)
+			}
+			if exportEntry.types != "" && ctx.existsPkgFile(exportEntry.types) {
+				entry.types = exportEntry.types
+			}
+		}
+
+		// check if the sub-module is a directory and has a package.json
+		var rawInfo npm.PackageJSONRaw
+		if utils.ParseJSONFile(path.Join(ctx.wd, "node_modules", ctx.esmPath.PkgName, subPath, "package.json"), &rawInfo) == nil {
+			p := rawInfo.ToNpmPackage()
+			if entry.main == "" {
+				if p.Module != "" && ctx.existsPkgFile(subPath, p.Module) {
+					entry.update("./"+path.Join(subPath, p.Module), true)
+				} else if p.Main != "" && ctx.existsPkgFile(subPath, p.Main) {
+					entry.update("./"+path.Join(subPath, p.Main), p.Type == "module")
+				}
+			}
+			if entry.types == "" {
+				if p.Types != "" && ctx.existsPkgFile(subPath, p.Types) {
+					entry.types = "./" + path.Join(subPath, p.Types)
+				}
+			}
+		}
+
+		// lookup entry from the sub-module directory if it's not defined in `package.json`
+		if entry.main == "" {
+			for _, ext := range []string{"mjs", "js", "cjs", "mts", "ts", "tsx", "cts"} {
+				isModule := ext == "mjs" || ext == "mts" || ext == "ts" || (ext == "js" && pkgJson.Type == "module")
+				if filename := "./" + subPath + "." + ext; ctx.existsPkgFile(filename) {
+					entry.update(filename, isModule)
+					break
+				} else if filename := "./" + subPath + "/index." + ext; ctx.existsPkgFile(filename) {
+					entry.update(filename, isModule)
+					break
+				}
+			}
+		}
+
+		if entry.main == "" && len(ctx.pkgJson.Imports) > 0 {
+			if v, ok := ctx.pkgJson.Imports[ctx.pkgJson.PkgName+"/*"]; ok {
+				if s, ok := v.(string); ok && strings.HasSuffix(s, "/*") {
+					for _, ext := range []string{"mjs", "js", "cjs", "mts", "ts", "tsx", "cts"} {
+						isModule := ext == "mjs" || ext == "mts" || ext == "ts" || (ext == "js" && pkgJson.Type == "module")
+						if filename := strings.TrimSuffix(s, "*") + subPath + "." + ext; ctx.existsPkgFile(filename) {
+							entry.update(filename, isModule)
+							break
+						} else if filename := strings.TrimSuffix(s, "*") + subPath + "/index." + ext; ctx.existsPkgFile(filename) {
+							entry.update(filename, isModule)
+							break
+						}
+					}
+				}
+			}
+		}
+
+		// lookup entry main from `src` directory
+		if entry.main == "" && esm.GhPrefix {
+			for _, ext := range []string{"mts", "ts", "mjs", "js", "tsx", "cts", "cjs"} {
+				isModule := ext != "cjs" && ext != "cts"
+				if filename := "./src/" + subPath + "/index." + ext; ctx.existsPkgFile(filename) {
+					entry.update(filename, isModule)
+					break
+				} else if filename := "./" + subPath + "/src/index." + ext; ctx.existsPkgFile(filename) {
+					entry.update(filename, isModule)
+					break
+				}
+			}
+		}
+
+		if entry.types == "" {
+			if entry.main != "" && ctx.existsPkgFile(stripModuleExt(entry.main)+".d.mts") {
+				entry.types = stripModuleExt(entry.main) + ".d.mts"
+			} else if entry.main != "" && ctx.existsPkgFile(stripModuleExt(entry.main)+".d.ts") {
+				entry.types = stripModuleExt(entry.main) + ".d.ts"
+			} else if entry.main != "" && ctx.existsPkgFile(stripModuleExt(entry.main)+".d.cts") {
+				entry.types = stripModuleExt(entry.main) + ".d.cts"
+			} else if ctx.existsPkgFile(subPath + ".d.mts") {
+				entry.types = "./" + subPath + ".d.mts"
+			} else if ctx.existsPkgFile(subPath + ".d.ts") {
+				entry.types = "./" + subPath + ".d.ts"
+			} else if ctx.existsPkgFile(subPath + ".d.cts") {
+				entry.types = "./" + subPath + ".d.cts"
+			} else if ctx.existsPkgFile(subPath, "index.d.mts") {
+				entry.types = "./" + subPath + "/index.d.mts"
+			} else if ctx.existsPkgFile(subPath, "index.d.ts") {
+				entry.types = "./" + subPath + "/index.d.ts"
+			} else if ctx.existsPkgFile(subPath, "index.d.cts") {
+				entry.types = "./" + subPath + "/index.d.cts"
+			}
+		}
+	} else {
+		if pkgJson.Module != "" && ctx.existsPkgFile(pkgJson.Module) {
+			entry.update(pkgJson.Module, true)
+		} else if pkgJson.Main != "" {
+			entry.update(pkgJson.Main, pkgJson.Type == "module")
+		}
+		if pkgJson.Types != "" {
+			entry.types = normalizeEntryPath(pkgJson.Types)
+		}
+		if len(pkgJson.Browser) > 0 && ctx.isBrowserTarget() {
+			if path, ok := pkgJson.Browser["."]; ok && ctx.existsPkgFile(path) {
+				entry.update(path, pkgJson.Type == "module")
+			}
+		}
+
+		if exports := pkgJson.Exports; exports.Len() > 0 {
+			exportEntry := BuildEntry{}
+			v, ok := exports.Get(".")
+			if ok {
+				if s, ok := v.(string); ok {
+					/**
+					exports: {
+						".": "./index.js"
+					}
+					*/
+					exportEntry.update(s, pkgJson.Type == "module")
+				} else if obj, ok := v.(npm.JSONObject); ok {
+					/**
+					exports: {
+						".": {
+							"require": "./cjs/index.js",
+							"import": "./esm/index.js"
+						}
+					}
+					*/
+					exportEntry = ctx.resolveConditionExportEntry(obj, pkgJson.Type)
+				} else if arr, ok := v.([]any); ok {
+					/**
+					exports: {
+						".": ["./cjs/index.js", "./esm/index.js"]
+					}
+					*/
+					a0 := arr[0]
+					if s, ok := a0.(string); ok {
+						exportEntry.update(s, pkgJson.Type == "module")
+					} else if obj, ok := a0.(npm.JSONObject); ok {
+						exportEntry = ctx.resolveConditionExportEntry(obj, pkgJson.Type)
+					}
+				}
+			} else {
+				/**
+				exports: {
+					"require": "./cjs/index.js",
+					"import": "./esm/index.js"
+				}
+				*/
+				exportEntry = ctx.resolveConditionExportEntry(exports, pkgJson.Type)
+			}
+			if exportEntry.main != "" && ctx.existsPkgFile(exportEntry.main) {
+				entry.update(exportEntry.main, exportEntry.module)
+			}
+			if exportEntry.types != "" && ctx.existsPkgFile(exportEntry.types) {
+				entry.types = exportEntry.types
+			}
+		}
+
+		// lookup entry from the package directory if it's not defined in `package.json`
+		if entry.main == "" {
+			if ctx.existsPkgFile("index.mjs") {
+				entry.update("./index.mjs", true)
+			} else if ctx.existsPkgFile("index.js") {
+				entry.update("./index.js", pkgJson.Type == "module")
+			} else if ctx.existsPkgFile("index.cjs") {
+				entry.update("./index.cjs", false)
+			}
+		}
+
+		// lookup entry main from `src` directory
+		if entry.main == "" && esm.GhPrefix {
+			for _, ext := range []string{"mts", "ts", "mjs", "js", "tsx", "cts", "cjs"} {
+				filename := "./src/index." + ext
+				if ctx.existsPkgFile(filename) {
+					entry.update(filename, ext != "cjs" && ext != "cts")
+					break
+				}
+			}
+		}
+
+		if entry.types == "" {
+			if ctx.existsPkgFile("index.d.mts") {
+				entry.types = "./index.d.mts"
+			} else if ctx.existsPkgFile("index.d.ts") {
+				entry.types = "./index.d.ts"
+			} else if ctx.existsPkgFile("index.d.cts") {
+				entry.types = "./index.d.cts"
+			}
+		}
+
+		if entry.types == "" && entry.main != "" {
+			if ctx.existsPkgFile(stripModuleExt(entry.main) + ".d.mts") {
+				entry.types = stripModuleExt(entry.main) + ".d.mts"
+			} else if ctx.existsPkgFile(stripModuleExt(entry.main) + ".d.ts") {
+				entry.types = stripModuleExt(entry.main) + ".d.ts"
+			} else if ctx.existsPkgFile(stripModuleExt(entry.main) + ".d.cts") {
+				entry.types = stripModuleExt(entry.main) + ".d.cts"
+			} else if stripModuleExt(path.Base(entry.main)) == "index" {
+				dir, _ := utils.SplitByLastByte(entry.main, '/')
+				if ctx.existsPkgFile(dir, "index.d.mts") {
+					entry.types = dir + "/index.d.mts"
+				} else if ctx.existsPkgFile(dir, "index.d.ts") {
+					entry.types = dir + "/index.d.ts"
+				} else if ctx.existsPkgFile(dir, "index.d.cts") {
+					entry.types = dir + "/index.d.cts"
+				}
+			}
+		}
+	}
+
+	// resolve entry main from `browser` field if it's defined
+	if len(pkgJson.Browser) > 0 && ctx.isBrowserTarget() {
+		if entry.main != "" {
+			if path, ok := pkgJson.Browser[entry.main]; ok && ctx.existsPkgFile(path) {
+				entry.update(path, pkgJson.Type == "module")
+			}
+		}
+	}
+
+	// resolve types from `typesVersions` field if it's defined
+	// see https://www.typescriptlang.org/docs/handbook/declaration-files/publishing.html#version-selection-with-typesversions
+	if typesVersions := pkgJson.TypesVersions; len(typesVersions) > 0 && entry.types != "" {
+		versions := make(sort.StringSlice, len(typesVersions))
+		i := 0
+		for c := range typesVersions {
+			if strings.HasPrefix(c, ">") {
+				versions[i] = c
+				i++
+			}
+		}
+		versions = versions[:i]
+		if versions.Len() > 0 {
+			versions.Sort()
+			latestVersion := typesVersions[versions[versions.Len()-1]]
+			if mapping, ok := latestVersion.(map[string]any); ok {
+				var paths any
+				var matched bool
+				var exact bool
+				var suffix string
+				types := entry.types
+				paths, matched = mapping[entry.types]
+				if !matched {
+					// try to match the dts wihout leading "./"
+					paths, matched = mapping[strings.TrimPrefix(types, "./")]
+				}
+				if matched {
+					exact = true
+				}
+				if !matched {
+					for key, value := range mapping {
+						if strings.HasSuffix(key, "/*") {
+							key = normalizeEntryPath(key)
+							if strings.HasPrefix(types, strings.TrimSuffix(key, "/*")) {
+								paths = value
+								matched = true
+								suffix = strings.TrimPrefix(types, strings.TrimSuffix(key, "*"))
+								break
+							}
+						}
+					}
+				}
+				if !matched {
+					paths, matched = mapping["*"]
+				}
+				if matched {
+					if a, ok := paths.([]any); ok && len(a) > 0 {
+						if path, ok := a[0].(string); ok {
+							path = normalizeEntryPath(path)
+							if exact {
+								entry.types = path
+							} else {
+								prefix, _ := utils.SplitByLastByte(path, '*')
+								if suffix != "" {
+									entry.types = prefix + suffix
+								} else if after, ok0 := strings.CutPrefix(types, prefix); ok0 {
+									diff := after
+									entry.types = strings.ReplaceAll(path, "*", diff)
+								} else {
+									entry.types = prefix + types[2:]
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	ctx.finalizeBuildEntry(&entry)
+	return
+}
+
+// normalizes the build entry
+func (ctx *BuildContext) finalizeBuildEntry(entry *BuildEntry) {
+	if entry.main != "" {
+		entry.main = normalizeEntryPath(entry.main)
+		if !ctx.existsPkgFile(entry.main) {
+			preferedExt := ".cjs"
+			if entry.module {
+				preferedExt = ".mjs"
+			}
+			if ctx.existsPkgFile(entry.main + preferedExt) {
+				entry.main = entry.main + preferedExt
+			} else if ctx.existsPkgFile(entry.main + ".js") {
+				entry.main = entry.main + ".js"
+			} else if ctx.existsPkgFile(entry.main, "index"+preferedExt) {
+				entry.main = entry.main + "/index" + preferedExt
+			} else if ctx.existsPkgFile(entry.main, "index.js") {
+				entry.main = entry.main + "/index.js"
+			} else {
+				entry.main = ""
+			}
+		} else if !entry.module && endsWith(entry.main, ".js", ".ts") {
+			// check if the cjs entry is an ESM
+			isESM, _, err := validateJSFile(path.Join(ctx.wd, "node_modules", ctx.esmPath.PkgName, entry.main))
+			if err == nil {
+				entry.module = isESM
+			}
+		}
+	}
+
+	if entry.types != "" {
+		entry.types = normalizeEntryPath(entry.types)
+		if endsWith(entry.types, ".js", ".mjs", ".cjs") {
+			bearName := stripModuleExt(entry.types)
+			if ctx.existsPkgFile(bearName + ".d.mts") {
+				entry.types = bearName + ".d.mts"
+			} else if ctx.existsPkgFile(bearName + ".d.ts") {
+				entry.types = bearName + ".d.ts"
+			} else if ctx.existsPkgFile(bearName + ".d.cts") {
+				entry.types = bearName + ".d.cts"
+			} else {
+				entry.types = ""
+			}
+		} else if strings.HasSuffix(entry.types, ".d") {
+			if ctx.existsPkgFile(entry.types + ".mts") {
+				entry.types += ".mts"
+			} else if ctx.existsPkgFile(entry.types + ".ts") {
+				entry.types += ".ts"
+			} else if ctx.existsPkgFile(entry.types + ".cts") {
+				entry.types += ".cts"
+			} else {
+				entry.types = ""
+			}
+		} else if !endsWith(entry.types, ".d.ts", ".d.mts", ".d.cts") {
+			if ctx.existsPkgFile(entry.types + ".d.mts") {
+				entry.types = entry.types + ".d.mts"
+			} else if ctx.existsPkgFile(entry.types + ".d.ts") {
+				entry.types = entry.types + ".d.ts"
+			} else if ctx.existsPkgFile(entry.types + ".d.cts") {
+				entry.types = entry.types + ".d.cts"
+			} else if ctx.existsPkgFile(entry.types, "index.d.mts") {
+				entry.types = entry.types + "/index.d.mts"
+			} else if ctx.existsPkgFile(entry.types, "index.d.ts") {
+				entry.types = entry.types + "/index.d.ts"
+			} else if ctx.existsPkgFile(entry.types, "index.d.cts") {
+				entry.types = entry.types + "/index.d.cts"
+			} else {
+				entry.types = ""
+			}
+		} else if !ctx.existsPkgFile(entry.types) {
+			entry.types = ""
+		}
+	} else if ext := path.Ext(entry.main); ext == ".mts" || ext == ".ts" || ext == ".tsx" || ext == ".cts" {
+		// entry.types = strings.TrimSuffix(entry.main, ext) + ".d" + strings.TrimSuffix(ext,"x")
+	}
+}
+
+// see https://nodejs.org/api/packages.html#nested-conditions
+func (ctx *BuildContext) resolveConditionExportEntry(conditions npm.JSONObject, preferedModuleType string) (entry BuildEntry) {
+	if preferedModuleType == "types" {
+		for _, conditionName := range []string{"module", "import", "es2015", "default", "require"} {
+			condition, ok := conditions.Get(conditionName)
+			if ok {
+				if s, ok := condition.(string); ok {
+					if entry.types == "" || endsWith(s, ".d.ts", ".d.mts", ".d.cts", ".d") {
+						entry.types = s
+					}
+				} else if obj, ok := condition.(npm.JSONObject); ok {
+					entry = ctx.resolveConditionExportEntry(obj, "types")
+				}
+				break
+			}
+		}
+		return
+	}
+
+	applyCondition := func(conditionName string) bool {
+		condition, ok := conditions.Get(conditionName)
+		if ok {
+			if s, ok := condition.(string); ok {
+				entry.update(s, preferedModuleType == "module")
+				return true
+			} else if obj, ok := condition.(npm.JSONObject); ok {
+				entry = ctx.resolveConditionExportEntry(obj, preferedModuleType)
+				return entry.main != ""
+			}
+		}
+		return false
+	}
+
+	var conditionFound bool
+
+	if ctx.isBrowserTarget() {
+		conditionName := "browser"
+		// [workaround] fix astring entry in browser
+		if ctx.esmPath.PkgName == "astring" {
+			conditionName = "import"
+		}
+		conditionFound = applyCondition(conditionName)
+	} else if ctx.isDenoTarget() {
+		conditionName := "deno"
+		// [workaround] to support solid-js/ssr in Deno, use `node` condition for < 1.6.0
+		if ctx.esmPath.PkgName == "solid-js" && semverLessThan(ctx.esmPath.PkgVersion, "1.6.0") {
+			conditionName = "node"
+		}
+		conditionFound = applyCondition(conditionName)
+	} else if ctx.target == "node" {
+		conditionFound = applyCondition("node")
+	}
+
+	if len(ctx.args.Conditions) > 0 {
+		for _, conditionName := range ctx.args.Conditions {
+			conditionFound = applyCondition(conditionName)
+			if conditionFound {
+				break
+			}
+		}
+	} else if ctx.dev {
+		conditionFound = applyCondition("development")
+	}
+
+LOOP:
+	for _, conditionName := range conditions.Keys() {
+		condition, _ := conditions.Get(conditionName)
+		module := false
+		prefered := ""
+		switch conditionName {
+		case "import", "module", "es2015":
+			module = true
+			prefered = "module"
+		case "require":
+			module = false
+			prefered = "commonjs"
+		case "default":
+			prefered = preferedModuleType
+			if prefered != "module" {
+				if s, ok := condition.(string); ok && strings.HasSuffix(s, ".mjs") {
+					prefered = "module"
+				} else if _, ok := conditions.Get("require"); ok {
+					prefered = "module"
+				}
+			}
+			module = prefered == "module"
+		case "types", "typings":
+			if s, ok := condition.(string); ok {
+				if entry.types == "" || (!strings.HasSuffix(entry.types, ".d.mts") && strings.HasSuffix(s, ".d.mts")) {
+					entry.types = s
+				}
+			} else if obj, ok := condition.(npm.JSONObject); ok {
+				e := ctx.resolveConditionExportEntry(obj, "types")
+				if e.types != "" {
+					if entry.types == "" || (!strings.HasSuffix(entry.types, ".d.mts") && strings.HasSuffix(e.types, ".d.mts")) {
+						entry.types = e.types
+					}
+				}
+			}
+			continue LOOP
+		default:
+			// skip unknown condition
+			continue LOOP
+		}
+		if entry.main == "" || (!entry.module && module && !conditionFound) {
+			if s, ok := condition.(string); ok {
+				entry.update(s, module)
+			} else if obj, ok := condition.(npm.JSONObject); ok {
+				e := ctx.resolveConditionExportEntry(obj, prefered)
+				if e.main != "" {
+					entry.update(e.main, e.module)
+				}
+				if e.types != "" {
+					entry.types = e.types
+				}
+			}
+		}
+	}
+
+	return
+}
+
+func (ctx *BuildContext) resolveExternalModule(specifier string, kind esbuild.ResolveKind, withTypeJSON bool, analyzeMode bool) (resolvedPath string, sideEffects esbuild.SideEffects, err error) {
+	if strings.HasPrefix(specifier, "file:") {
+		err = errors.New("file: protocol is not supported: " + specifier)
+		return
+	}
+
+	// return the specifier directly in analyze mode
+	if analyzeMode {
+		resolvedPath = specifier
+		return
+	}
+
+	defer func() {
+		if err == nil && !withTypeJSON {
+			resolvedPathFull := resolvedPath
+			// use relative path for sub-module of current package
+			if pkgJson := ctx.pkgJson; specifier == pkgJson.Name || strings.HasPrefix(specifier, pkgJson.Name+"/") {
+				rp, err := relPath(path.Dir(ctx.Path()), resolvedPath)
+				if err == nil {
+					resolvedPath = rp
+				}
+			}
+			if kind == esbuild.ResolveJSRequireCall {
+				ctx.cjsRequires = append(ctx.cjsRequires, [3]string{specifier, resolvedPathFull, resolvedPath})
+				resolvedPath = specifier
+			} else if kind == esbuild.ResolveJSImportStatement && !withTypeJSON {
+				ctx.esmImports = append(ctx.esmImports, [2]string{resolvedPathFull, resolvedPath})
+			}
+		}
+	}()
+
+	// if it's a http module
+	if isHttpSpecifier(specifier) {
+		resolvedPath = specifier
+		return
+	}
+
+	// check `?external`
+	packageName := toPackageName(specifier)
+	if ctx.externalAll || ctx.args.External.Has(packageName) || isPackageInExternalNamespace(packageName, ctx.args.External) {
+		resolvedPath = specifier
+		return
+	}
+
+	// if it's a node builtin module
+	if isNodeBuiltinSpecifier(specifier) {
+		if ctx.externalAll || ctx.target == "node" || ctx.target == "denonext" || ctx.args.External.Has(specifier) {
+			resolvedPath = specifier
+		} else if ctx.target == "deno" {
+			resolvedPath = fmt.Sprintf("https://deno.land/std@0.177.1/node/%s.ts", specifier[5:])
+		} else {
+			resolvedPath = fmt.Sprintf("/node/%s.mjs", specifier[5:])
+		}
+		return
+	}
+
+	// if it's `main` entry of current package
+	// Also handles scoped fork self-reference: e.g. `@scope/three` source importing `three`
+	// when `three` is not declared as a dependency — treat as self-reference.
+	pkgJson := ctx.pkgJson
+	isSelfRef := specifier == pkgJson.Name || specifier == pkgJson.PkgName
+	if !isSelfRef && strings.HasPrefix(pkgJson.Name, "@") {
+		_, baseName := utils.SplitByFirstByte(pkgJson.Name[1:], '/')
+		specPkgName := toPackageName(specifier)
+		if specPkgName == baseName {
+			_, inDeps := pkgJson.Dependencies[specPkgName]
+			_, inPeerDeps := pkgJson.PeerDependencies[specPkgName]
+			if !inDeps && !inPeerDeps {
+				isSelfRef = true
+			}
+		}
+	}
+	if isSelfRef {
+		esmPath := EsmPath{
+			GhPrefix:   ctx.esmPath.GhPrefix,
+			PrPrefix:   ctx.esmPath.PrPrefix,
+			PkgName:    pkgJson.Name,
+			PkgVersion: pkgJson.Version,
+		}
+		if ctx.pkgJson.SideEffectsFalse {
+			sideEffects = esbuild.SideEffectsFalse
+		} else if ctx.pkgJson.SideEffects.Len() > 0 {
+			sideEffects = esbuild.SideEffectsFalse
+			entry := ctx.resolveEntry(esmPath)
+			if entry.main != "" && !(ctx.pkgJson.SideEffects.Has(entry.main) || ctx.pkgJson.SideEffects.Has(strings.TrimPrefix(entry.main, "./"))) {
+				sideEffects = esbuild.SideEffectsTrue
+			}
+		}
+		resolvedPath = ctx.getImportPath(esmPath, ctx.getBuildArgsPrefix(false), ctx.externalAll)
+		return
+	}
+
+	// if it's a sub-module of current package
+	// Also handles scoped fork sub-paths: e.g. `@scope/three` source importing `three/tsl`
+	{
+		subPath, ok := strings.CutPrefix(specifier, ctx.pkgJson.Name+"/")
+		if !ok {
+			subPath, ok = strings.CutPrefix(specifier, ctx.pkgJson.PkgName+"/")
+		}
+		if !ok && strings.HasPrefix(ctx.pkgJson.Name, "@") {
+			_, baseName := utils.SplitByFirstByte(ctx.pkgJson.Name[1:], '/')
+			specPkgName := toPackageName(specifier)
+			if specPkgName == baseName {
+				_, inDeps := ctx.pkgJson.Dependencies[specPkgName]
+				_, inPeerDeps := ctx.pkgJson.PeerDependencies[specPkgName]
+				if !inDeps && !inPeerDeps {
+					subPath, ok = strings.CutPrefix(specifier, baseName+"/")
+				}
+			}
+		}
+		if ok {
+			subModule := EsmPath{
+				GhPrefix:   ctx.esmPath.GhPrefix,
+				PrPrefix:   ctx.esmPath.PrPrefix,
+				PkgName:    ctx.esmPath.PkgName,
+				PkgVersion: ctx.esmPath.PkgVersion,
+				SubPath:    stripEntryModuleExt(subPath),
+			}
+			if ctx.pkgJson.SideEffectsFalse {
+				sideEffects = esbuild.SideEffectsFalse
+			} else if ctx.pkgJson.SideEffects.Len() > 0 {
+				sideEffects = esbuild.SideEffectsFalse
+				entry := ctx.resolveEntry(subModule)
+				if entry.main != "" && !(ctx.pkgJson.SideEffects.Has(entry.main) || ctx.pkgJson.SideEffects.Has(strings.TrimPrefix(entry.main, "./"))) {
+					sideEffects = esbuild.SideEffectsTrue
+				}
+			}
+			if withTypeJSON {
+				resolvedPath = "/" + subModule.String()
+				if !strings.HasSuffix(subPath, ".json") {
+					entry := ctx.resolveEntry(subModule)
+					if entry.main != "" {
+						resolvedPath = "/" + subModule.PackageId() + entry.main[1:]
+					}
+				}
+				// esbuild removes the `{ type: "json" }` when it's a dynamic import
+				resolvedPath += "?module"
+			} else {
+				resolvedPath = ctx.getImportPath(subModule, ctx.getBuildArgsPrefix(false), ctx.externalAll)
+				if ctx.bundleMode == BundleFalse {
+					n, e := utils.SplitByLastByte(resolvedPath, '.')
+					resolvedPath = n + ".nobundle." + e
+				}
+			}
+			return
+		}
+	}
+
+	var pkgName string
+	var pkgVersion string
+	var subPath string
+
+	// jsr dependency
+	if strings.HasPrefix(specifier, "jsr:") {
+		pkgName, pkgVersion, subPath = splitEsmPath(specifier[4:])
+		if !strings.HasPrefix(pkgName, "@") || !strings.ContainsRune(pkgName, '/') {
+			err = errors.New("invalid `jsr:` dependency:" + specifier)
+			return
+		}
+		scope, name := utils.SplitByFirstByte(pkgName, '/')
+		pkgName = "@jsr/" + scope[1:] + "__" + name
+	} else {
+		pkgName, pkgVersion, subPath = splitEsmPath(specifier)
+	}
+
+	if pkgVersion == "" {
+		if pkgName == ctx.esmPath.PkgName {
+			pkgVersion = ctx.esmPath.PkgVersion
+		} else if pkgVerson, ok := ctx.args.Deps[pkgName]; ok {
+			pkgVersion = pkgVerson
+		} else if v, ok := ctx.pkgJson.Dependencies[pkgName]; ok {
+			pkgVersion = strings.TrimSpace(v)
+		} else if v, ok := ctx.pkgJson.PeerDependencies[pkgName]; ok {
+			pkgVersion = strings.TrimSpace(v)
+		} else {
+			pkgVersion = "latest"
+		}
+	}
+
+	dep := EsmPath{
+		PkgName:    pkgName,
+		PkgVersion: pkgVersion,
+		SubPath:    stripEntryModuleExt(subPath),
+	}
+
+	// resolve alias in dependencies
+	// e.g. "@mark/html": "npm:@jsr/mark__html@^1.0.0"
+	// e.g. "tslib": "git+https://github.com/microsoft/tslib.git#v2.3.0"
+	// e.g. "react": "github:facebook/react#v18.2.0"
+	p, err := npm.ResolveDependencyVersion(pkgVersion)
+	if err != nil {
+		resolvedPath = fmt.Sprintf("/error.js?type=%s&name=%s&importer=%s", strings.ReplaceAll(err.Error(), " ", "-"), pkgName, ctx.esmPath.String())
+		return
+	}
+	if p.Url != "" {
+		resolvedPath = p.Url
+		return
+	}
+	if p.Name != "" {
+		dep.GhPrefix = p.Github
+		dep.PrPrefix = p.PkgPrNew
+		dep.PkgName = p.Name
+		dep.PkgVersion = p.Version
+	}
+
+	// fetch the latest tag as the version of the repository
+	if dep.GhPrefix && dep.PkgVersion == "" {
+		var refs []GitRef
+		refs, err = listGhRepoRefsContext(ctx.Context(), fmt.Sprintf("https://github.com/%s", dep.PkgName))
+		if err != nil {
+			return
+		}
+		for _, ref := range refs {
+			if ref.Ref == "HEAD" {
+				dep.PkgVersion = ref.Sha[:16]
+				break
+			}
+		}
+	}
+
+	// [workaround] force the dependency version of `react` equals to react-dom
+	if ctx.esmPath.PkgName == "react-dom" && dep.PkgName == "react" {
+		dep.PkgVersion = ctx.esmPath.PkgVersion
+	}
+
+	if withTypeJSON {
+		resolvedPath = "/" + dep.String()
+		if subPath == "" || !strings.HasSuffix(subPath, ".json") {
+			b := &BuildContext{
+				npmrc:   ctx.npmrc,
+				logger:  ctx.logger,
+				esmPath: dep,
+				ctx:     ctx.ctx,
+			}
+			err = b.install()
+			if err != nil {
+				return
+			}
+			entry := b.resolveEntry(dep)
+			if entry.main != "" {
+				resolvedPath = "/" + dep.PackageId() + entry.main[1:]
+			}
+		}
+		if kind == esbuild.ResolveJSDynamicImport {
+			// esbuild removes the `{ type: "json" }` when it's a dynamic import
+			resolvedPath += "?module"
+		}
+		return
+	}
+
+	args := BuildArgs{
+		Alias:      ctx.args.Alias,
+		Deps:       ctx.args.Deps,
+		External:   ctx.args.External,
+		Conditions: ctx.args.Conditions,
+	}
+	err = resolveBuildArgs(ctx.npmrc, ctx.wd, &args, dep)
+	if err != nil {
+		return
+	}
+
+	var exactVersion bool
+	if dep.GhPrefix {
+		exactVersion = isCommitish(dep.PkgVersion) || npm.IsExactVersion(strings.TrimPrefix(dep.PkgVersion, "v"))
+	} else if dep.PrPrefix {
+		exactVersion = true
+	} else {
+		exactVersion = npm.IsExactVersion(dep.PkgVersion)
+	}
+	if exactVersion {
+		buildArgsPrefix := ""
+		if a := encodeBuildArgs(args, false); a != "" {
+			buildArgsPrefix = "X-" + a + "/"
+		}
+		resolvedPath = ctx.getImportPath(dep, buildArgsPrefix, false)
+		return
+	}
+
+	resolvedPath = "/" + dep.String()
+	// workaround for es5-ext "../#/.." path
+	if dep.PkgName == "es5-ext" {
+		resolvedPath = strings.ReplaceAll(resolvedPath, "/#/", "/%23/")
+	}
+	params := []string{}
+	if len(args.Alias) > 0 {
+		var alias []string
+		for k, v := range args.Alias {
+			alias = append(alias, fmt.Sprintf("%s:%s", k, v))
+		}
+		params = append(params, "alias="+strings.Join(alias, ","))
+	}
+	if len(args.Deps) > 0 {
+		var deps sort.StringSlice
+		for n, v := range args.Deps {
+			deps = append(deps, n+"@"+v)
+		}
+		deps.Sort()
+		params = append(params, "deps="+strings.Join(deps, ","))
+	}
+	if args.External.Len() > 0 {
+		external := make(sort.StringSlice, args.External.Len())
+		for i, e := range args.External.Values() {
+			external[i] = e
+		}
+		external.Sort()
+		params = append(params, "external="+strings.Join(external, ","))
+	}
+	if len(args.Conditions) > 0 {
+		conditions := make(sort.StringSlice, len(args.Conditions))
+		copy(conditions, args.Conditions)
+		conditions.Sort()
+		params = append(params, "conditions="+strings.Join(conditions, ","))
+	}
+	if dep.SubPath != "" && strings.HasSuffix(dep.SubPath, ".json") {
+		params = append(params, "module")
+	} else {
+		params = append(params, "target="+ctx.target)
+	}
+	if ctx.dev {
+		params = append(params, "dev")
+	}
+	resolvedPath += "?" + strings.Join(params, "&")
+	return
+}
+
+func (ctx *BuildContext) resolveDTS(entry BuildEntry) (string, error) {
+	if entry.types != "" {
+		return fmt.Sprintf(
+			"/%s/%s%s",
+			ctx.esmPath.PackageId(),
+			ctx.getBuildArgsPrefix(true),
+			strings.TrimPrefix(entry.types, "./"),
+		), nil
+	}
+
+	if ctx.esmPath.SubPath != "" && ctx.pkgJson.Types != "" {
+		return "", nil
+	}
+
+	// lookup types in @types scope
+	if pkgJson := ctx.pkgJson; pkgJson.Types == "" && !strings.HasPrefix(pkgJson.Name, "@types/") && npm.IsExactVersion(pkgJson.Version) {
+		versionParts := strings.Split(pkgJson.Version, ".")
+		versions := []string{
+			versionParts[0] + "." + versionParts[1], // major.minor
+			versionParts[0],                         // major
+		}
+		typesPkgName := npm.ToTypesPackageName(pkgJson.Name)
+		pkgVersion, ok := ctx.args.Deps[typesPkgName]
+		if ok {
+			// use the version of the `?deps` query if it exists
+			versions = append([]string{pkgVersion}, versions...)
+		}
+		for _, version := range versions {
+			p, err := ctx.npmrc.getPackageInfoContext(ctx.Context(), typesPkgName, version)
+			if err == nil {
+				dtsModule := EsmPath{
+					PkgName:    typesPkgName,
+					PkgVersion: p.Version,
+					SubPath:    ctx.esmPath.SubPath,
+				}
+				b := &BuildContext{
+					npmrc:       ctx.npmrc,
+					logger:      ctx.logger,
+					esmPath:     dtsModule,
+					args:        ctx.args,
+					externalAll: ctx.externalAll,
+					target:      "types",
+					ctx:         ctx.ctx,
+				}
+				err := b.install()
+				if err != nil {
+					if strings.Contains(err.Error(), " not found") {
+						return "", nil
+					}
+					return "", err
+				}
+				dts, err := b.resolveDTS(b.resolveEntry(dtsModule))
+				if err != nil {
+					return "", err
+				}
+				if dts != "" {
+					// use tilde semver range instead of the exact version
+					return strings.ReplaceAll(dts, fmt.Sprintf("%s@%s", typesPkgName, p.Version), fmt.Sprintf("%s@~%s", typesPkgName, p.Version)), nil
+				}
+			}
+		}
+	}
+
+	return "", nil
+}
+
+func (ctx *BuildContext) getImportPath(esm EsmPath, buildArgsPrefix string, externalAll bool) string {
+	if strings.HasSuffix(esm.SubPath, ".json") && ctx.existsPkgFile(esm.SubPath) {
+		return "/" + esm.PackageId() + "/" + esm.SubPath + "?module"
+	}
+	asteriskPrefix := ""
+	if externalAll {
+		asteriskPrefix = "*"
+	}
+	name := strings.TrimSuffix(path.Base(esm.PkgName), ".js")
+	if subPath := esm.SubPath; subPath != "" {
+		if subPath == name {
+			// if the sub-module name is same as the package name
+			name = "__" + subPath
+		} else {
+			name = subPath
+		}
+		// workaround for es5-ext "../#/.." path
+		if esm.PkgName == "es5-ext" {
+			name = strings.ReplaceAll(name, "/#/", "/%23/")
+		}
+	}
+	if ctx.dev {
+		name += ".development"
+	}
+	return fmt.Sprintf(
+		"/%s%s/%s%s/%s.mjs",
+		asteriskPrefix,
+		esm.PackageId(),
+		buildArgsPrefix,
+		ctx.target,
+		name,
+	)
+}
+
+func (ctx *BuildContext) getSavePath() string {
+	return normalizeSavePath(path.Join("modules", ctx.Path()))
+}
+
+func (ctx *BuildContext) getBuildArgsPrefix(isDts bool) string {
+	if a := encodeBuildArgs(ctx.args, isDts); a != "" {
+		return "X-" + a + "/"
+	}
+	return ""
+}
+
+func (ctx *BuildContext) getNodeEnv() string {
+	if ctx.dev {
+		return "development"
+	}
+	return "production"
+}
+
+func (ctx *BuildContext) isDenoTarget() bool {
+	return ctx.target == "deno" || ctx.target == "denonext"
+}
+
+func (ctx *BuildContext) isBrowserTarget() bool {
+	return strings.HasPrefix(ctx.target, "es")
+}
+
+func (ctx *BuildContext) getPkgFullPath(subPath string) string {
+	return path.Join(ctx.wd, "node_modules", ctx.esmPath.PkgName, subPath)
+}
+
+func (ctx *BuildContext) existsPkgFile(fp ...string) bool {
+	args := make([]string, 3+len(fp))
+	args[0] = ctx.wd
+	args[1] = "node_modules"
+	args[2] = ctx.esmPath.PkgName
+	copy(args[3:], fp)
+	return existsFile(path.Join(args...))
+}
+
+func (ctx *BuildContext) resloveSubModule(subPath string) (string, bool) {
+	if subPath != "" {
+		if ctx.existsPkgFile(subPath) {
+			return subPath, true
+		}
+		preferExt := ".mjs"
+		if ctx.pkgJson.Type == "commonjs" {
+			preferExt = ".cjs"
+		}
+		for _, ext := range []string{preferExt, "js", "mts", "ts", "cts"} {
+			if ctx.existsPkgFile(subPath + "." + ext) {
+				return subPath + "." + ext, true
+			}
+			if ctx.existsPkgFile(subPath + "/index." + ext) {
+				return subPath + "/index." + ext, true
+			}
+		}
+	}
+	return "", false
+}
+
+func (ctx *BuildContext) resolveDependency(specifier string, isDts bool) (esm EsmPath, packageJson *npm.PackageJSON, err error) {
+	pkgName, version, subPath := splitEsmPath(specifier)
+lookup:
+	if v, ok := ctx.args.Deps[pkgName]; ok {
+		packageJson, err = ctx.npmrc.getPackageInfoContext(ctx.Context(), pkgName, v)
+		if err == nil {
+			esm = EsmPath{
+				PkgName:    pkgName,
+				PkgVersion: packageJson.Version,
+				SubPath:    stripEntryModuleExt(subPath),
+			}
+		}
+		return
+	}
+
+	var raw npm.PackageJSONRaw
+	pkgJsonPath := path.Join(ctx.wd, "node_modules", pkgName, "package.json")
+	if utils.ParseJSONFile(pkgJsonPath, &raw) == nil {
+		esm = EsmPath{
+			PkgName:    pkgName,
+			PkgVersion: raw.Version,
+			SubPath:    stripEntryModuleExt(subPath),
+		}
+		packageJson = raw.ToNpmPackage()
+		return
+	}
+
+	if version == "" {
+		if v, ok := ctx.pkgJson.Dependencies[pkgName]; ok {
+			if strings.HasPrefix(v, "npm:") {
+				pkgName, version, _ = splitEsmPath(v[4:])
+			} else {
+				version = v
+			}
+		} else if v, ok = ctx.pkgJson.PeerDependencies[pkgName]; ok {
+			if strings.HasPrefix(v, "npm:") {
+				pkgName, version, _ = splitEsmPath(v[4:])
+			} else {
+				version = v
+			}
+		} else {
+			version = "latest"
+		}
+	}
+
+	packageJson, err = ctx.npmrc.getPackageInfoContext(ctx.Context(), pkgName, version)
+	if err == nil {
+		esm = EsmPath{
+			PkgName:    pkgName,
+			PkgVersion: packageJson.Version,
+			SubPath:    stripEntryModuleExt(subPath),
+		}
+	}
+	if err != nil && strings.HasSuffix(err.Error(), " not found") && isDts && !strings.HasPrefix(pkgName, "@types/") {
+		pkgName = npm.ToTypesPackageName(pkgName)
+		goto lookup
+	}
+	return
+}
+
+func (ctx *BuildContext) lexer(entry *BuildEntry) (ret *BuildMeta, cjsExports []string, cjsReexport string, err error) {
+	if entry.main != "" && entry.module {
+		if strings.HasSuffix(entry.main, ".vue") || strings.HasSuffix(entry.main, ".svelte") {
+			ret = &BuildMeta{
+				ExportDefault: true,
+			}
+			return
+		}
+
+		var isESM bool
+		var namedExports []string
+		isESM, namedExports, err = validateJSFile(path.Join(ctx.wd, "node_modules", ctx.esmPath.PkgName, entry.main))
+		if err != nil {
+			return
+		}
+		if isESM {
+			ret = &BuildMeta{
+				ExportDefault: slices.Contains(namedExports, "default"),
+			}
+			return
+		}
+
+		var cjs cjsModuleLexerResult
+		cjs, err = cjsModuleLexer(ctx, entry.main)
+		if err != nil {
+			return
+		}
+
+		if DEBUG {
+			ctx.logger.Debugf("fake ES module '%s' of '%s'", entry.main, ctx.pkgJson.Name)
+		}
+
+		ret = &BuildMeta{
+			ExportDefault: true,
+			CJS:           true,
+		}
+		cjsExports = cjs.Exports
+		cjsReexport = cjs.Reexport
+		entry.module = false
+		return
+	}
+
+	if entry.main != "" && !entry.module {
+		var cjs cjsModuleLexerResult
+		cjs, err = cjsModuleLexer(ctx, entry.main)
+		if err != nil {
+			return
+		}
+		ret = &BuildMeta{
+			ExportDefault: true,
+			CJS:           true,
+		}
+		cjsExports = cjs.Exports
+		cjsReexport = cjs.Reexport
+		return
+	}
+
+	ret = &BuildMeta{}
+	return
+}
+
+func matchAsteriskExport(exportName string, subModuleName string) (diff string, match bool) {
+	if strings.ContainsRune(exportName, '*') {
+		prefix, suffix := utils.SplitByLastByte(exportName, '*')
+		if strings.HasPrefix("./"+subModuleName, prefix) && strings.HasSuffix(subModuleName, suffix) {
+			return strings.TrimPrefix("./"+subModuleName, prefix), true
+		}
+	}
+	return "", false
+}
+
+func resloveAsteriskPathMapping(conditions npm.JSONObject, diff string) npm.JSONObject {
+	var keys []string
+	var values = map[string]any{}
+	for _, key := range conditions.Keys() {
+		value, ok := conditions.Get(key)
+		if ok {
+			if s, ok := value.(string); ok {
+				keys = append(keys, key)
+				values[key] = strings.ReplaceAll(s, "*", diff)
+			} else if c, ok := value.(npm.JSONObject); ok {
+				keys = append(keys, key)
+				values[key] = resloveAsteriskPathMapping(c, diff)
+			}
+		}
+	}
+	return npm.NewJSONObject(keys, values)
+}
+
+func getExportConditionPaths(condition npm.JSONObject) []string {
+	var values []string
+	for _, key := range condition.Keys() {
+		v, _ := condition.Get(key)
+		if s, ok := v.(string); ok {
+			values = append(values, s)
+		} else if condition, ok := v.(npm.JSONObject); ok {
+			values = append(values, getExportConditionPaths(condition)...)
+		}
+	}
+	return values
+}
+
+// stripModuleExt strips the module extension from the given string.
+func stripModuleExt(s string) string {
+	for _, ext := range moduleExts {
+		if strings.HasSuffix(s, ext) && !strings.HasSuffix(s, ".d"+ext) {
+			return s[:len(s)-len(ext)]
+		}
+	}
+	return s
+}
+
+// stripEntryModuleExt strips the entry module extension from the given string.
+func stripEntryModuleExt(s string) string {
+	if strings.HasSuffix(s, ".mjs") || strings.HasSuffix(s, ".cjs") {
+		return s[:len(s)-4]
+	}
+	if strings.HasSuffix(s, ".js") {
+		return s[:len(s)-3]
+	}
+	return s
+}
+
+func normalizeEntryPath(path string) string {
+	return "." + utils.NormalizePathname(path)
+}
+
+func normalizeSavePath(pathname string) string {
+	if strings.HasPrefix(pathname, "modules/transform/") || strings.HasPrefix(pathname, "modules/x/") {
+		return pathname
+	}
+	segments := strings.Split(pathname, "/")
+	for i, seg := range segments {
+		if strings.HasPrefix(seg, "X-") && len(seg) > 42 {
+			h := sha1.New()
+			h.Write([]byte(seg))
+			segments[i] = "x-" + hex.EncodeToString(h.Sum(nil))
+		} else if strings.HasPrefix(seg, "*") {
+			segments[i] = seg[1:] + "/ea"
+		}
+	}
+	return strings.Join(segments, "/")
+}
+
+// normalizeImportSpecifier normalizes the given specifier.
+func normalizeImportSpecifier(specifier string) string {
+	switch specifier {
+	case ".":
+		specifier = "./index"
+	case "..":
+		specifier = "../index"
+	default:
+		specifier = strings.TrimPrefix(specifier, "npm:")
+	}
+	if nodeBuiltinModules[specifier] {
+		return "node:" + specifier
+	}
+	return specifier
+}
+
+// validateJSFile validates javascript/typescript module from the given file.
+func validateJSFile(filename string) (isESM bool, namedExports []string, err error) {
+	data, err := os.ReadFile(filename)
+	if err != nil {
+		return
+	}
+	log := logger.NewDeferLog(logger.DeferLogNoVerboseOrDebug, nil)
+	parserOpts := js_parser.OptionsFromConfig(&esbuild_config.Options{
+		JSX: esbuild_config.JSXOptions{
+			Parse: endsWith(filename, ".jsx", ".tsx"),
+		},
+		TS: esbuild_config.TSOptions{
+			Parse: endsWith(filename, ".ts", ".mts", ".cts", ".tsx"),
+		},
+	})
+	ast, pass := js_parser.Parse(log, logger.Source{
+		Index:          0,
+		KeyPath:        logger.Path{Text: "<stdin>"},
+		PrettyPaths:    logger.PrettyPaths{Rel: "<stdin>"},
+		IdentifierName: "stdin",
+		Contents:       string(data),
+	}, parserOpts)
+	if !pass {
+		err = errors.New("invalid syntax, require javascript/typescript")
+		return
+	}
+	isESM = ast.ExportsKind == js_ast.ExportsESM || ast.ExportsKind == js_ast.ExportsESMWithDynamicFallback
+	// A module with no import/export/CommonJS markers (e.g. an empty file that
+	// contains only comments, as shipped by some types-only packages) is parsed
+	// as `ExportsNone`. For explicit ES module files (`.mjs`/`.mts`) such a file
+	// is still a valid—if empty—ES module and must be treated as ESM. Otherwise
+	// it would be misclassified as a "fake CommonJS module" and handed to the
+	// cjs-module-lexer, which can panic while resolving the entry's `exports`
+	// subpath under non-matching conditions (e.g. a `browser`-only build).
+	if !isESM && ast.ExportsKind == js_ast.ExportsNone && endsWith(filename, ".mjs", ".mts") {
+		isESM = true
+	}
+	namedExports = make([]string, len(ast.NamedExports))
+	i := 0
+	for name := range ast.NamedExports {
+		namedExports[i] = name
+		i++
+	}
+	return
+}