@jsenv/node-esm-resolution 0.1.1 → 1.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/node-esm-resolution",
-  "version": "0.1.1",
+  "version": "1.0.0",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/determine_module_system.js

@@ -29,11 +29,11 @@ export const determineModuleSystem = (
     return "url"
   }
   if (ambiguousExtensions.includes(extension)) {
-    const packageUrl = defaultLookupPackageScope(url)
-    if (!packageUrl) {
+    const packageDirectoryUrl = defaultLookupPackageScope(url)
+    if (!packageDirectoryUrl) {
       return "commonjs"
     }
-    const packageJson = defaultReadPackageJson(packageUrl)
+    const packageJson = defaultReadPackageJson(packageDirectoryUrl)
     if (packageJson.type === "module") {
       return "module"
     }

package/src/errors.js

@@ -1,11 +1,11 @@
 // https://github.com/nodejs/node/blob/0367b5c35ea0f98b323175a4aaa8e651af7a91e7/tools/node_modules/eslint/node_modules/%40babel/core/lib/vendor/import-meta-resolve.js#L2473
 import { fileURLToPath } from "node:url"
 
-export const createInvalidModuleSpecifierError = ({
-  specifier,
-  parentUrl,
+export const createInvalidModuleSpecifierError = (
   reason,
-}) => {
+  specifier,
+  { parentUrl },
+) => {
   const error = new Error(
     `Invalid module "${specifier}" ${reason} imported from ${fileURLToPath(
       parentUrl,
@@ -15,24 +15,21 @@ export const createInvalidModuleSpecifierError = ({
   return error
 }
 
-export const createInvalidPackageTargetError = ({
-  parentUrl,
-  packageUrl,
-  target,
-  key,
-  isImport,
+export const createInvalidPackageTargetError = (
   reason,
-}) => {
+  target,
+  { parentUrl, packageDirectoryUrl, key, isImport },
+) => {
   let message
   if (key === ".") {
     message = `Invalid "exports" main target defined in ${fileURLToPath(
-      packageUrl,
+      packageDirectoryUrl,
     )}package.json imported from ${fileURLToPath(parentUrl)}; ${reason}`
   } else {
     message = `Invalid "${
       isImport ? "imports" : "exports"
     }" target ${JSON.stringify(target)} defined for "${key}" in ${fileURLToPath(
-      packageUrl,
+      packageDirectoryUrl,
     )}package.json imported from ${fileURLToPath(parentUrl)}; ${reason}`
   }
   const error = new Error(message)
@@ -40,19 +37,18 @@ export const createInvalidPackageTargetError = ({
   return error
 }
 
-export const createPackagePathNotExportedError = ({
+export const createPackagePathNotExportedError = (
   subpath,
-  parentUrl,
-  packageUrl,
-}) => {
+  { parentUrl, packageDirectoryUrl },
+) => {
   let message
   if (subpath === ".") {
     message = `No "exports" main defined in ${fileURLToPath(
-      packageUrl,
+      packageDirectoryUrl,
     )}package.json imported from ${fileURLToPath(parentUrl)}`
   } else {
     message = `Package subpath "${subpath}" is not defined by "exports" in ${fileURLToPath(
-      packageUrl,
+      packageDirectoryUrl,
     )}package.json imported from ${fileURLToPath(parentUrl)}`
   }
   const error = new Error(message)
@@ -60,7 +56,7 @@ export const createPackagePathNotExportedError = ({
   return error
 }
 
-export const createModuleNotFoundError = ({ specifier, parentUrl }) => {
+export const createModuleNotFoundError = (specifier, { parentUrl }) => {
   const error = new Error(
     `Cannot find "${specifier}" imported from ${fileURLToPath(parentUrl)}`,
   )
@@ -68,14 +64,13 @@ export const createModuleNotFoundError = ({ specifier, parentUrl }) => {
   return error
 }
 
-export const createPackageImportNotDefinedError = ({
+export const createPackageImportNotDefinedError = (
   specifier,
-  packageUrl,
-  parentUrl,
-}) => {
+  { parentUrl, packageDirectoryUrl },
+) => {
   const error = new Error(
     `Package import specifier "${specifier}" is not defined in ${fileURLToPath(
-      packageUrl,
+      packageDirectoryUrl,
     )}package.json imported from ${fileURLToPath(parentUrl)}`,
   )
   error.code = "PACKAGE_IMPORT_NOT_DEFINED"

package/src/node_esm_resolution.js

@@ -9,7 +9,8 @@
  *   maintain symlink as facade url when it's outside project directory
  *   or use the real path when inside
  */
-import { existsSync, readFileSync } from "node:fs"
+import { pathToFileURL } from "node:url"
+import { existsSync, readFileSync, realpathSync } from "node:fs"
 
 import { isSpecifierForNodeBuiltin } from "./node_builtin_specifiers.js"
 import { defaultLookupPackageScope } from "./default_lookup_package_scope.js"
@@ -25,40 +26,38 @@ import {
 import { readCustomConditionsFromProcessArgs } from "./custom_conditions.js"
 
 export const applyNodeEsmResolution = ({
-  conditions = [...readCustomConditionsFromProcessArgs(), "node", "import"],
-  parentUrl,
   specifier,
+  parentUrl,
+  conditions = [...readCustomConditionsFromProcessArgs(), "node", "import"],
   lookupPackageScope = defaultLookupPackageScope,
   readPackageJson = defaultReadPackageJson,
+  preservesSymlink = false,
 }) => {
-  const resolution = applyPackageSpecifierResolution({
-    conditions,
+  const resolution = applyPackageSpecifierResolution(specifier, {
     parentUrl: String(parentUrl),
-    specifier,
+    conditions,
     lookupPackageScope,
     readPackageJson,
+    preservesSymlink,
   })
   const { url } = resolution
   if (url.startsWith("file:")) {
     if (url.includes("%2F") || url.includes("%5C")) {
-      throw createInvalidModuleSpecifierError({
+      throw createInvalidModuleSpecifierError(
+        `must not include encoded "/" or "\\" characters`,
         specifier,
-        parentUrl,
-        reason: `must not include encoded "/" or "\\" characters`,
-      })
+        {
+          parentUrl,
+        },
+      )
     }
     return resolution
   }
   return resolution
 }
 
-const applyPackageSpecifierResolution = ({
-  conditions,
-  parentUrl,
-  specifier,
-  lookupPackageScope,
-  readPackageJson,
-}) => {
+const applyPackageSpecifierResolution = (specifier, resolutionContext) => {
+  const { parentUrl } = resolutionContext
   // relative specifier
   if (
     specifier[0] === "/" ||
@@ -66,13 +65,10 @@ const applyPackageSpecifierResolution = ({
     specifier.startsWith("../")
   ) {
     if (specifier[0] !== "/") {
-      const browserFieldResolution = applyBrowserFieldResolution({
-        conditions,
-        parentUrl,
+      const browserFieldResolution = applyBrowserFieldResolution(
         specifier,
-        lookupPackageScope,
-        readPackageJson,
-      })
+        resolutionContext,
+      )
       if (browserFieldResolution) {
         return browserFieldResolution
       }
@@ -83,13 +79,7 @@ const applyPackageSpecifierResolution = ({
     }
   }
   if (specifier[0] === "#") {
-    return applyPackageImportsResolution({
-      conditions,
-      parentUrl,
-      specifier,
-      lookupPackageScope,
-      readPackageJson,
-    })
+    return applyPackageImportsResolution(specifier, resolutionContext)
   }
   try {
     const urlObject = new URL(specifier)
@@ -105,42 +95,34 @@ const applyPackageSpecifierResolution = ({
     }
   } catch (e) {
     // bare specifier
-    const browserFieldResolution = applyBrowserFieldResolution({
-      conditions,
-      parentUrl,
-      packageSpecifier: specifier,
-      lookupPackageScope,
-      readPackageJson,
-    })
+    const browserFieldResolution = applyBrowserFieldResolution(
+      specifier,
+      resolutionContext,
+    )
     if (browserFieldResolution) {
       return browserFieldResolution
     }
-    return applyPackageResolve({
-      conditions,
-      parentUrl,
-      packageSpecifier: specifier,
-      lookupPackageScope,
-      readPackageJson,
-    })
+    const packageResolution = applyPackageResolve(specifier, resolutionContext)
+    const search = new URL(specifier, "file://").search
+    if (search) {
+      packageResolution.url = `${packageResolution.url}${search}`
+    }
+    return packageResolution
   }
 }
 
-const applyBrowserFieldResolution = ({
-  conditions,
-  parentUrl,
-  packageSpecifier,
-  lookupPackageScope,
-  readPackageJson,
-}) => {
+const applyBrowserFieldResolution = (specifier, resolutionContext) => {
+  const { parentUrl, conditions, lookupPackageScope, readPackageJson } =
+    resolutionContext
   const browserCondition = conditions.includes("browser")
   if (!browserCondition) {
     return null
   }
-  const packageUrl = lookupPackageScope(parentUrl)
-  if (!packageUrl) {
+  const packageDirectoryUrl = lookupPackageScope(parentUrl)
+  if (!packageDirectoryUrl) {
     return null
   }
-  const packageJson = readPackageJson(packageUrl)
+  const packageJson = readPackageJson(packageDirectoryUrl)
   if (!packageJson) {
     return null
   }
@@ -152,30 +134,28 @@ const applyBrowserFieldResolution = ({
     return null
   }
   let url
-  if (packageSpecifier.startsWith(".")) {
-    const packageSpecifierUrl = new URL(packageSpecifier, parentUrl).href
-    const packageSpecifierRelativeUrl = packageSpecifierUrl.slice(
-      packageUrl.length,
-    )
-    const packageSpecifierRelativeNotation = `./${packageSpecifierRelativeUrl}`
-    const browserMapping = browser[packageSpecifierRelativeNotation]
+  if (specifier.startsWith(".")) {
+    const specifierUrl = new URL(specifier, parentUrl).href
+    const specifierRelativeUrl = specifierUrl.slice(packageDirectoryUrl.length)
+    const secifierRelativeNotation = `./${specifierRelativeUrl}`
+    const browserMapping = browser[secifierRelativeNotation]
     if (typeof browserMapping === "string") {
-      url = new URL(browserMapping, packageUrl).href
+      url = new URL(browserMapping, packageDirectoryUrl).href
     } else if (browserMapping === false) {
-      url = `file:///@ignore/${packageSpecifierUrl.slice("file:///")}`
+      url = `file:///@ignore/${specifierUrl.slice("file:///")}`
     }
   } else {
-    const browserMapping = browser[packageSpecifier]
+    const browserMapping = browser[specifier]
     if (typeof browserMapping === "string") {
-      url = new URL(browserMapping, packageUrl).href
+      url = new URL(browserMapping, packageDirectoryUrl).href
     } else if (browserMapping === false) {
-      url = `file:///@ignore/${packageSpecifier}`
+      url = `file:///@ignore/${specifier}`
     }
   }
   if (url) {
     return {
       type: "field:browser",
-      packageUrl,
+      packageDirectoryUrl,
       packageJson,
       url,
     }
@@ -183,62 +163,43 @@ const applyBrowserFieldResolution = ({
   return null
 }
 
-const applyPackageImportsResolution = ({
-  conditions,
-  parentUrl,
-  specifier,
-  lookupPackageScope,
-  readPackageJson,
-}) => {
-  if (!specifier.startsWith("#")) {
-    throw createInvalidModuleSpecifierError({
-      specifier,
-      parentUrl,
-      reason: "internal imports must start with #",
-    })
-  }
-  if (specifier === "#" || specifier.startsWith("#/")) {
-    throw createInvalidModuleSpecifierError({
-      specifier,
-      parentUrl,
-      reason: "not a valid internal imports specifier name",
-    })
+const applyPackageImportsResolution = (
+  internalSpecifier,
+  resolutionContext,
+) => {
+  const { parentUrl, lookupPackageScope, readPackageJson } = resolutionContext
+  if (internalSpecifier === "#" || internalSpecifier.startsWith("#/")) {
+    throw createInvalidModuleSpecifierError(
+      "not a valid internal imports specifier name",
+      internalSpecifier,
+      resolutionContext,
+    )
   }
-  const packageUrl = lookupPackageScope(parentUrl)
-  if (packageUrl !== null) {
-    const packageJson = readPackageJson(packageUrl)
+  const packageDirectoryUrl = lookupPackageScope(parentUrl)
+  if (packageDirectoryUrl !== null) {
+    const packageJson = readPackageJson(packageDirectoryUrl)
     const { imports } = packageJson
     if (imports !== null && typeof imports === "object") {
-      const resolved = applyPackageImportsExportsResolution({
-        conditions,
-        parentUrl,
-        packageUrl,
+      const resolved = applyPackageImportsExportsResolution(internalSpecifier, {
+        ...resolutionContext,
+        packageDirectoryUrl,
         packageJson,
-        matchObject: imports,
-        matchKey: specifier,
-        isImports: true,
-        lookupPackageScope,
-        readPackageJson,
+        isImport: true,
       })
       if (resolved) {
         return resolved
       }
     }
   }
-  throw createPackageImportNotDefinedError({
-    specifier,
-    packageUrl,
-    parentUrl,
+  throw createPackageImportNotDefinedError(internalSpecifier, {
+    ...resolutionContext,
+    packageDirectoryUrl,
   })
 }
 
-const applyPackageResolve = ({
-  conditions,
-  parentUrl,
-  packageSpecifier,
-  lookupPackageScope,
-  readPackageJson,
-}) => {
+const applyPackageResolve = (packageSpecifier, resolutionContext) => {
+  const { parentUrl, conditions, readPackageJson, preservesSymlink } =
+    resolutionContext
   if (packageSpecifier === "") {
     throw new Error("invalid module specifier")
   }
@@ -258,78 +219,64 @@ const applyPackageResolve = ({
     packageName.includes("\\") ||
     packageName.includes("%")
   ) {
-    throw createInvalidModuleSpecifierError({
-      specifier: packageName,
-      parentUrl,
-      reason: `is not a valid package name`,
-    })
+    throw createInvalidModuleSpecifierError(
+      `is not a valid package name`,
+      packageName,
+      resolutionContext,
+    )
   }
   if (packageSubpath.endsWith("/")) {
     throw new Error("invalid module specifier")
   }
-  const selfResolution = applyPackageSelfResolution({
-    conditions,
-    parentUrl,
+  const selfResolution = applyPackageSelfResolution(packageSubpath, {
+    ...resolutionContext,
     packageName,
-    packageSubpath,
-    lookupPackageScope,
-    readPackageJson,
   })
   if (selfResolution) {
     return selfResolution
   }
   let currentUrl = parentUrl
   while (currentUrl !== "file:///") {
-    const packageUrl = new URL(`node_modules/${packageName}/`, currentUrl).href
-    if (!existsSync(new URL(packageUrl))) {
+    const packageDirectoryFacadeUrl = new URL(
+      `node_modules/${packageName}/`,
+      currentUrl,
+    ).href
+    if (!existsSync(new URL(packageDirectoryFacadeUrl))) {
       currentUrl = getParentUrl(currentUrl)
       continue
     }
-    const packageJson = readPackageJson(packageUrl)
+    const packageDirectoryUrl = preservesSymlink
+      ? packageDirectoryFacadeUrl
+      : resolvePackageSymlink(packageDirectoryFacadeUrl)
+    const packageJson = readPackageJson(packageDirectoryUrl)
     if (packageJson !== null) {
       const { exports } = packageJson
       if (exports !== null && exports !== undefined) {
-        return applyPackageExportsResolution({
-          conditions,
-          parentUrl,
-          packageUrl,
+        return applyPackageExportsResolution(packageSubpath, {
+          ...resolutionContext,
+          packageDirectoryUrl,
           packageJson,
-          packageSubpath,
           exports,
-          lookupPackageScope,
-          readPackageJson,
         })
       }
     }
-    return applyLegacySubpathResolution({
-      conditions,
-      parentUrl,
-      packageUrl,
+    return applyLegacySubpathResolution(packageSubpath, {
+      ...resolutionContext,
+      packageDirectoryUrl,
       packageJson,
-      packageSubpath,
-      lookupPackageScope,
-      readPackageJson,
     })
   }
-  throw createModuleNotFoundError({
-    specifier: packageName,
-    parentUrl,
-  })
+  throw createModuleNotFoundError(packageName, resolutionContext)
 }
 
-const applyPackageSelfResolution = ({
-  conditions,
-  parentUrl,
-  packageName,
-  packageSubpath,
-  lookupPackageScope,
-  readPackageJson,
-}) => {
-  const packageUrl = lookupPackageScope(parentUrl)
-  if (!packageUrl) {
+const applyPackageSelfResolution = (packageSubpath, resolutionContext) => {
+  const { parentUrl, packageName, lookupPackageScope, readPackageJson } =
+    resolutionContext
+  const packageDirectoryUrl = lookupPackageScope(parentUrl)
+  if (!packageDirectoryUrl) {
     return undefined
   }
-  const packageJson = readPackageJson(packageUrl)
+  const packageJson = readPackageJson(packageDirectoryUrl)
   if (!packageJson) {
     return undefined
   }
@@ -338,118 +285,65 @@ const applyPackageSelfResolution = ({
   }
   const { exports } = packageJson
   if (!exports) {
-    const subpathResolution = applyLegacySubpathResolution({
-      conditions,
-      parentUrl,
-      packageUrl,
+    const subpathResolution = applyLegacySubpathResolution(packageSubpath, {
+      ...resolutionContext,
+      packageDirectoryUrl,
       packageJson,
-      packageSubpath,
-      lookupPackageScope,
-      readPackageJson,
     })
     if (subpathResolution && subpathResolution.type !== "subpath") {
       return subpathResolution
     }
     return undefined
   }
-  return applyPackageExportsResolution({
-    conditions,
-    parentUrl,
-    packageUrl,
+  return applyPackageExportsResolution(packageSubpath, {
+    ...resolutionContext,
+    packageDirectoryUrl,
     packageJson,
-    packageSubpath,
-    exports,
-    lookupPackageScope,
-    readPackageJson,
   })
 }
 
 // https://github.com/nodejs/node/blob/0367b5c35ea0f98b323175a4aaa8e651af7a91e7/lib/internal/modules/esm/resolve.js#L642
-const applyPackageExportsResolution = ({
-  conditions,
-  parentUrl,
-  packageUrl,
-  packageJson,
-  packageSubpath,
-  exports,
-  lookupPackageScope,
-  readPackageJson,
-}) => {
-  const exportsInfo = readExports({ exports, packageUrl })
+const applyPackageExportsResolution = (packageSubpath, resolutionContext) => {
   if (packageSubpath === ".") {
-    const mainExport = applyMainExportResolution({ exports, exportsInfo })
+    const mainExport = applyMainExportResolution(resolutionContext)
     if (!mainExport) {
-      throw createPackagePathNotExportedError({
-        subpath: packageSubpath,
-        parentUrl,
-        packageUrl,
-      })
+      throw createPackagePathNotExportedError(packageSubpath, resolutionContext)
     }
-    const resolved = applyPackageTargetResolution({
-      conditions,
-      parentUrl,
-      packageUrl,
-      packageJson,
+    const resolved = applyPackageTargetResolution(mainExport, {
+      ...resolutionContext,
       key: ".",
-      target: mainExport,
-      lookupPackageScope,
-      readPackageJson,
     })
     if (resolved) {
       return resolved
     }
-    throw createPackagePathNotExportedError({
-      subpath: packageSubpath,
-      parentUrl,
-      packageUrl,
-    })
+    throw createPackagePathNotExportedError(packageSubpath, resolutionContext)
   }
-  if (exportsInfo.type === "object" && exportsInfo.allKeysAreRelative) {
-    const resolved = applyPackageImportsExportsResolution({
-      conditions,
-      parentUrl,
-      packageUrl,
-      packageJson,
-      matchObject: exports,
-      matchKey: packageSubpath,
-      isImports: false,
-      lookupPackageScope,
-      readPackageJson,
+  const packageExportsInfo = readExports(resolutionContext)
+  if (
+    packageExportsInfo.type === "object" &&
+    packageExportsInfo.allKeysAreRelative
+  ) {
+    const resolved = applyPackageImportsExportsResolution(packageSubpath, {
+      ...resolutionContext,
+      isImport: false,
     })
     if (resolved) {
       return resolved
     }
   }
-  throw createPackagePathNotExportedError({
-    subpath: packageSubpath,
-    parentUrl,
-    packageUrl,
-  })
+  throw createPackagePathNotExportedError(packageSubpath, resolutionContext)
 }
 
-const applyPackageImportsExportsResolution = ({
-  conditions,
-  parentUrl,
-  packageUrl,
-  packageJson,
-  matchObject,
-  matchKey,
-  isImports,
-  lookupPackageScope,
-  readPackageJson,
-}) => {
+const applyPackageImportsExportsResolution = (matchKey, resolutionContext) => {
+  const { packageJson, isImport } = resolutionContext
+  const matchObject = isImport ? packageJson.imports : packageJson.exports
+
   if (!matchKey.includes("*") && matchObject.hasOwnProperty(matchKey)) {
     const target = matchObject[matchKey]
-    return applyPackageTargetResolution({
-      conditions,
-      parentUrl,
-      packageUrl,
-      packageJson,
+    return applyPackageTargetResolution(target, {
+      ...resolutionContext,
       key: matchKey,
-      target,
-      internal: isImports,
-      lookupPackageScope,
-      readPackageJson,
+      isImport,
     })
   }
   const expansionKeys = Object.keys(matchObject)
@@ -468,80 +362,64 @@ const applyPackageImportsExportsResolution = ({
       patternBase.length,
       matchKey.length - patternTrailer.length,
     )
-    return applyPackageTargetResolution({
-      conditions,
-      parentUrl,
-      packageUrl,
-      packageJson,
+    return applyPackageTargetResolution(target, {
+      ...resolutionContext,
       key: matchKey,
-      target,
       subpath,
       pattern: true,
-      internal: isImports,
-      lookupPackageScope,
-      readPackageJson,
+      isImport,
     })
   }
   return null
 }
 
-const applyPackageTargetResolution = ({
-  conditions,
-  parentUrl,
-  packageUrl,
-  packageJson,
-  key,
-  target,
-  subpath = "",
-  pattern = false,
-  internal = false,
-  lookupPackageScope,
-  readPackageJson,
-}) => {
+const applyPackageTargetResolution = (target, resolutionContext) => {
+  const {
+    conditions,
+    packageDirectoryUrl,
+    packageJson,
+    key,
+    subpath = "",
+    pattern = false,
+    isImport = false,
+  } = resolutionContext
+
   if (typeof target === "string") {
     if (pattern === false && subpath !== "" && !target.endsWith("/")) {
       throw new Error("invalid module specifier")
     }
     if (target.startsWith("./")) {
-      const targetUrl = new URL(target, packageUrl).href
-      if (!targetUrl.startsWith(packageUrl)) {
-        throw createInvalidPackageTargetError({
-          parentUrl,
-          packageUrl,
+      const targetUrl = new URL(target, packageDirectoryUrl).href
+      if (!targetUrl.startsWith(packageDirectoryUrl)) {
+        throw createInvalidPackageTargetError(
+          `target must be inside package`,
           target,
-          key,
-          isImport: internal,
-          reason: `target must be inside package`,
-        })
+          resolutionContext,
+        )
       }
       return {
-        type: internal ? "field:imports" : "field:exports",
-        packageUrl,
+        type: isImport ? "field:imports" : "field:exports",
+        packageDirectoryUrl,
         packageJson,
         url: pattern
           ? targetUrl.replaceAll("*", subpath)
           : new URL(subpath, targetUrl).href,
       }
     }
-    if (!internal || target.startsWith("../") || isValidUrl(target)) {
-      throw createInvalidPackageTargetError({
-        parentUrl,
-        packageUrl,
+    if (!isImport || target.startsWith("../") || isValidUrl(target)) {
+      throw createInvalidPackageTargetError(
+        `target must starst with "./"`,
         target,
-        key,
-        isImport: internal,
-        reason: `target must starst with "./"`,
-      })
+        resolutionContext,
+      )
     }
-    return applyPackageResolve({
-      conditions,
-      parentUrl: packageUrl,
-      packageSpecifier: pattern
-        ? target.replaceAll("*", subpath)
-        : `${target}${subpath}`,
-      lookupPackageScope,
-      readPackageJson,
-    })
+    return applyPackageResolve(
+      pattern ? target.replaceAll("*", subpath) : `${target}${subpath}`,
+      {
+        ...resolutionContext,
+        parentUrl: packageDirectoryUrl,
+      },
+    )
   }
   if (Array.isArray(target)) {
     if (target.length === 0) {
@@ -553,18 +431,12 @@ const applyPackageTargetResolution = ({
       const targetValue = target[i]
       i++
       try {
-        const resolved = applyPackageTargetResolution({
-          conditions,
-          parentUrl,
-          packageUrl,
-          packageJson,
+        const resolved = applyPackageTargetResolution(targetValue, {
+          ...resolutionContext,
           key: `${key}[${i}]`,
-          target: targetValue,
           subpath,
           pattern,
-          internal,
-          lookupPackageScope,
-          readPackageJson,
+          isImport,
         })
         if (resolved) {
           return resolved
@@ -593,18 +465,12 @@ const applyPackageTargetResolution = ({
       }
       if (key === "default" || conditions.includes(key)) {
         const targetValue = target[key]
-        const resolved = applyPackageTargetResolution({
-          conditions,
-          parentUrl,
-          packageUrl,
-          packageJson,
+        const resolved = applyPackageTargetResolution(targetValue, {
+          ...resolutionContext,
           key,
-          target: targetValue,
           subpath,
           pattern,
-          internal,
-          lookupPackageScope,
-          readPackageJson,
+          isImport,
         })
         if (resolved) {
           return resolved
@@ -613,27 +479,25 @@ const applyPackageTargetResolution = ({
     }
     return null
   }
-  throw createInvalidPackageTargetError({
-    parentUrl,
-    packageUrl,
+  throw createInvalidPackageTargetError(
+    `target must be a string, array, object or null`,
     target,
-    key,
-    isImport: internal,
-    reason: `target must be a string, array, object or null`,
-  })
+    resolutionContext,
+  )
 }
 
-const readExports = ({ exports, packageUrl }) => {
-  if (Array.isArray(exports)) {
+const readExports = ({ packageDirectoryUrl, packageJson }) => {
+  const packageExports = packageJson.exports
+  if (Array.isArray(packageExports)) {
     return {
       type: "array",
     }
   }
-  if (exports === null) {
+  if (packageExports === null) {
     return {}
   }
-  if (typeof exports === "object") {
-    const keys = Object.keys(exports)
+  if (typeof packageExports === "object") {
+    const keys = Object.keys(packageExports)
     const relativeKeys = []
     const conditionalKeys = []
     keys.forEach((availableKey) => {
@@ -649,8 +513,8 @@ const readExports = ({ exports, packageUrl }) => {
         `Invalid package configuration: cannot mix relative and conditional keys in package.exports
 --- unexpected keys ---
 ${conditionalKeys.map((key) => `"${key}"`).join("\n")}
---- package.json ---
-${packageUrl}`,
+--- package directory url ---
+${packageDirectoryUrl}`,
       )
     }
     return {
@@ -659,7 +523,7 @@ ${packageUrl}`,
       allKeysAreRelative: relativeKeys.length === keys.length,
     }
   }
-  if (typeof exports === "string") {
+  if (typeof packageExports === "string") {
     return { type: "string" }
   }
   return {}
@@ -704,78 +568,71 @@ const parsePackageSpecifier = (packageSpecifier) => {
   }
 }
 
-const applyMainExportResolution = ({ exports, exportsInfo }) => {
-  if (exportsInfo.type === "array" || exportsInfo.type === "string") {
-    return exports
+const applyMainExportResolution = (resolutionContext) => {
+  const { packageJson } = resolutionContext
+  const packageExportsInfo = readExports(resolutionContext)
+  if (
+    packageExportsInfo.type === "array" ||
+    packageExportsInfo.type === "string"
+  ) {
+    return packageJson.exports
   }
-  if (exportsInfo.type === "object") {
-    if (exportsInfo.hasRelativeKey) {
-      return exports["."]
+  if (packageExportsInfo.type === "object") {
+    if (packageExportsInfo.hasRelativeKey) {
+      return packageJson.exports["."]
     }
-    return exports
+    return packageJson.exports
   }
   return undefined
 }
 
-const applyLegacySubpathResolution = ({
-  conditions,
-  parentUrl,
-  packageUrl,
-  packageJson,
-  packageSubpath,
-  lookupPackageScope,
-  readPackageJson,
-}) => {
+const applyLegacySubpathResolution = (packageSubpath, resolutionContext) => {
+  const { packageDirectoryUrl, packageJson } = resolutionContext
+
   if (packageSubpath === ".") {
-    return applyLegacyMainResolution({
-      conditions,
-      packageUrl,
-      packageJson,
-    })
+    return applyLegacyMainResolution(packageSubpath, resolutionContext)
   }
-  const browserFieldResolution = applyBrowserFieldResolution({
-    conditions,
-    parentUrl,
-    specifier: packageSubpath,
-    lookupPackageScope,
-    readPackageJson,
-  })
+  const browserFieldResolution = applyBrowserFieldResolution(
+    packageSubpath,
+    resolutionContext,
+  )
   if (browserFieldResolution) {
     return browserFieldResolution
   }
   return {
     type: "subpath",
-    packageUrl,
+    packageDirectoryUrl,
     packageJson,
-    url: new URL(packageSubpath, packageUrl).href,
+    url: new URL(packageSubpath, packageDirectoryUrl).href,
   }
 }
 
-const applyLegacyMainResolution = ({ conditions, packageUrl, packageJson }) => {
+const applyLegacyMainResolution = (packageSubpath, resolutionContext) => {
+  const { conditions, packageDirectoryUrl, packageJson } = resolutionContext
   for (const condition of conditions) {
     const conditionResolver = mainLegacyResolvers[condition]
     if (!conditionResolver) {
       continue
     }
-    const resolved = conditionResolver(packageJson, packageUrl)
+    const resolved = conditionResolver(resolutionContext)
     if (resolved) {
       return {
         type: resolved.type,
-        packageUrl,
+        packageDirectoryUrl,
         packageJson,
-        url: new URL(resolved.path, packageUrl).href,
+        url: new URL(resolved.path, packageDirectoryUrl).href,
       }
     }
   }
   return {
     type: "field:main", // the absence of "main" field
-    packageUrl,
+    packageDirectoryUrl,
     packageJson,
-    url: new URL("index.js", packageUrl).href,
+    url: new URL("index.js", packageDirectoryUrl).href,
   }
 }
 const mainLegacyResolvers = {
-  import: (packageJson) => {
+  import: ({ packageJson }) => {
     if (typeof packageJson.module === "string") {
       return { type: "field:module", path: packageJson.module }
     }
@@ -787,7 +644,7 @@ const mainLegacyResolvers = {
     }
     return null
   },
-  browser: (packageJson, packageUrl) => {
+  browser: ({ packageDirectoryUrl, packageJson }) => {
     const browserMain = (() => {
       if (typeof packageJson.browser === "string") {
         return packageJson.browser
@@ -819,7 +676,7 @@ const mainLegacyResolvers = {
         path: browserMain,
       }
     }
-    const browserMainUrlObject = new URL(browserMain, packageUrl)
+    const browserMainUrlObject = new URL(browserMain, packageDirectoryUrl)
     const content = readFileSync(browserMainUrlObject, "utf-8")
     if (
       (/typeof exports\s*==/.test(content) &&
@@ -836,7 +693,7 @@ const mainLegacyResolvers = {
       path: browserMain,
     }
   },
-  node: (packageJson) => {
+  node: ({ packageJson }) => {
     if (typeof packageJson.main === "string") {
       return {
         type: "field:main",
@@ -878,3 +735,9 @@ const comparePatternKeys = (keyA, keyB) => {
   }
   return 0
 }
+
+const resolvePackageSymlink = (packageDirectoryUrl) => {
+  const packageDirectoryPath = realpathSync(new URL(packageDirectoryUrl))
+  const packageDirectoryResolvedUrl = pathToFileURL(packageDirectoryPath).href
+  return `${packageDirectoryResolvedUrl}/`
+}