@jsenv/node-esm-resolution 0.0.1

package/README.md

@@ -0,0 +1,4 @@
+TODO:
+
+- add more unit tests
+- improve error messages

package/main.js

@@ -0,0 +1,5 @@
+export { applyNodeEsmResolution } from "./src/node_esm_resolution.js"
+export { determineModuleSystem } from "./src/determine_module_system.js"
+export { applyFileSystemMagicResolution } from "./src/filesystem_magic_resolution.js"
+export { lookupPackageScope } from "./src/lookup_package_scope.js"
+export { readPackageJson } from "./src/read_package_json.js"

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@jsenv/node-esm-resolution",
+  "version": "0.0.1",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jsenv/jsenv-core",
+    "directory": "packages/node-esm-resolution"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./main.js"
+    },
+    "./*": "./*"
+  },
+  "main": "./main.js",
+  "files": [
+    "/dist/",
+    "/src/",
+    "/main.js"
+  ]
+}

package/src/determine_module_system.js

@@ -0,0 +1,55 @@
+import { lookupPackageScope } from "./lookup_package_scope.js"
+import { readPackageJson } from "./read_package_json.js"
+
+// https://nodejs.org/dist/latest-v16.x/docs/api/packages.html#packages_determining_module_system)
+export const determineModuleSystem = (
+  url,
+  { ambiguousExtensions = [".js"] } = {},
+) => {
+  const inputTypeArgv = process.execArgv.find((argv) =>
+    argv.startsWith("--input-type="),
+  )
+  if (inputTypeArgv) {
+    const value = inputTypeArgv.slice("--input-type=".length)
+    if (value === "module") {
+      return "module"
+    }
+    if (value === "commonjs") {
+      return "commonjs"
+    }
+  }
+  const extension = extensionFromUrl(url)
+  if (extension === ".mjs") {
+    return "module"
+  }
+  if (extension === ".cjs") {
+    return "commonjs"
+  }
+  if (extension === ".json") {
+    return "json"
+  }
+  if (ambiguousExtensions.includes(extension)) {
+    const packageUrl = lookupPackageScope(url)
+    if (!packageUrl) {
+      return "commonjs"
+    }
+    const packageJson = readPackageJson(packageUrl)
+    if (packageJson.type === "module") {
+      return "module"
+    }
+    return "commonjs"
+  }
+  throw new Error("unsupported file extension")
+}
+
+const extensionFromUrl = (url) => {
+  const { pathname } = new URL(url)
+  const slashLastIndex = pathname.lastIndexOf("/")
+  const filename =
+    slashLastIndex === -1 ? pathname : pathname.slice(slashLastIndex + 1)
+  const dotLastIndex = filename.lastIndexOf(".")
+  if (dotLastIndex === -1) return ""
+  // if (dotLastIndex === pathname.length - 1) return ""
+  const extension = filename.slice(dotLastIndex)
+  return extension
+}

package/src/errors.js

@@ -0,0 +1,83 @@
+// 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,
+  reason,
+}) => {
+  const error = new Error(
+    `Invalid module "${specifier}" ${reason} imported from ${fileURLToPath(
+      parentUrl,
+    )}`,
+  )
+  error.code = "INVALID_MODULE_SPECIFIER"
+  return error
+}
+
+export const createInvalidPackageTargetError = ({
+  parentUrl,
+  packageUrl,
+  target,
+  key,
+  isImport,
+  reason,
+}) => {
+  let message
+  if (key === ".") {
+    message = `Invalid "exports" main target defined in ${fileURLToPath(
+      packageUrl,
+    )}package.json imported from ${fileURLToPath(parentUrl)}; ${reason}`
+  } else {
+    message = `Invalid "${
+      isImport ? "imports" : "exports"
+    }" target ${JSON.stringify(target)} defined for "${key}" in ${fileURLToPath(
+      packageUrl,
+    )}package.json imported from ${fileURLToPath(parentUrl)}; ${reason}`
+  }
+  const error = new Error(message)
+  error.code = "INVALID_PACKAGE_TARGET"
+  return error
+}
+
+export const createPackagePathNotExportedError = ({
+  subpath,
+  parentUrl,
+  packageUrl,
+}) => {
+  let message
+  if (subpath === ".") {
+    message = `No "exports" main defined in ${fileURLToPath(
+      packageUrl,
+    )}package.json imported from ${fileURLToPath(parentUrl)}`
+  } else {
+    message = `Package subpath "${subpath}" is not defined by "exports" in ${fileURLToPath(
+      packageUrl,
+    )}package.json imported from ${fileURLToPath(parentUrl)}`
+  }
+  const error = new Error(message)
+  error.code = "PACKAGE_PATH_NOT_EXPORTED"
+  return error
+}
+
+export const createModuleNotFoundError = ({ specifier, parentUrl }) => {
+  const error = new Error(
+    `Cannot find "${specifier}" imported from ${fileURLToPath(parentUrl)}`,
+  )
+  error.code = "MODULE_NOT_FOUND"
+  return error
+}
+
+export const createPackageImportNotDefinedError = ({
+  specifier,
+  packageUrl,
+  parentUrl,
+}) => {
+  const error = new Error(
+    `Package import specifier "${specifier}" is not defined in ${fileURLToPath(
+      packageUrl,
+    )}package.json imported from ${fileURLToPath(parentUrl)}`,
+  )
+  error.code = "PACKAGE_IMPORT_NOT_DEFINED"
+  return error
+}

package/src/filesystem_magic_resolution.js

@@ -0,0 +1,71 @@
+import { statSync } from "node:fs"
+
+import { urlToFilename } from "./url_utils.js"
+
+export const applyFileSystemMagicResolution = (
+  fileUrl,
+  { magicDirectoryIndex, magicExtensions },
+) => {
+  let lastENOENTError = null
+  const fileStatOrNull = (url) => {
+    try {
+      return statSync(new URL(url))
+    } catch (e) {
+      if (e.code === "ENOENT") {
+        lastENOENTError = e
+        return null
+      }
+      throw e
+    }
+  }
+
+  const fileStat = fileStatOrNull(fileUrl)
+  if (fileStat && fileStat.isFile()) {
+    return {
+      found: true,
+      url: fileUrl,
+    }
+  }
+  if (fileStat && fileStat.isDirectory()) {
+    if (magicDirectoryIndex) {
+      const indexFileSuffix = fileUrl.endsWith("/") ? "index" : "/index"
+      const indexFileUrl = `${fileUrl}${indexFileSuffix}`
+      const result = applyFileSystemMagicResolution(indexFileUrl, {
+        magicDirectoryIndex: false,
+        magicExtensions,
+      })
+      return {
+        magicDirectoryIndex: true,
+        ...result,
+      }
+    }
+    return {
+      isDirectory: true,
+      found: true,
+      url: fileUrl,
+    }
+  }
+  if (magicExtensions && magicExtensions.length) {
+    const parentUrl = new URL("./", fileUrl).href
+    const urlFilename = urlToFilename(fileUrl)
+    const extensionLeadingToFile = magicExtensions.find((extensionToTry) => {
+      const urlCandidate = `${parentUrl}${urlFilename}${extensionToTry}`
+      const stat = fileStatOrNull(urlCandidate)
+      return stat
+    })
+    if (extensionLeadingToFile) {
+      // magic extension worked
+      return {
+        magicExtension: extensionLeadingToFile,
+        found: true,
+        url: `${fileUrl}${extensionLeadingToFile}`,
+      }
+    }
+  }
+  // magic extension not found
+  return {
+    found: false,
+    url: fileUrl,
+    lastENOENTError,
+  }
+}

package/src/lookup_package_scope.js

@@ -0,0 +1,18 @@
+import { existsSync } from "node:fs"
+
+import { filesystemRootUrl, getParentUrl, asDirectoryUrl } from "./url_utils.js"
+
+export const lookupPackageScope = (url) => {
+  let scopeUrl = asDirectoryUrl(url)
+  while (scopeUrl !== filesystemRootUrl) {
+    if (scopeUrl.endsWith("node_modules/")) {
+      return null
+    }
+    const packageJsonUrlObject = new URL("package.json", scopeUrl)
+    if (existsSync(packageJsonUrlObject)) {
+      return scopeUrl
+    }
+    scopeUrl = getParentUrl(scopeUrl)
+  }
+  return null
+}

package/src/node_builtin_specifiers.js

@@ -0,0 +1,84 @@
+export const isSpecifierForNodeBuiltin = (specifier) => {
+  return (
+    specifier.startsWith("node:") ||
+    NODE_BUILTIN_MODULE_SPECIFIERS.includes(specifier)
+  )
+}
+
+const NODE_BUILTIN_MODULE_SPECIFIERS = [
+  "assert",
+  "assert/strict",
+  "async_hooks",
+  "buffer_ieee754",
+  "buffer",
+  "child_process",
+  "cluster",
+  "console",
+  "constants",
+  "crypto",
+  "_debugger",
+  "dgram",
+  "dns",
+  "domain",
+  "events",
+  "freelist",
+  "fs",
+  "fs/promises",
+  "_http_agent",
+  "_http_client",
+  "_http_common",
+  "_http_incoming",
+  "_http_outgoing",
+  "_http_server",
+  "http",
+  "http2",
+  "https",
+  "inspector",
+  "_linklist",
+  "module",
+  "net",
+  "node-inspect/lib/_inspect",
+  "node-inspect/lib/internal/inspect_client",
+  "node-inspect/lib/internal/inspect_repl",
+  "os",
+  "path",
+  "perf_hooks",
+  "process",
+  "punycode",
+  "querystring",
+  "readline",
+  "repl",
+  "smalloc",
+  "_stream_duplex",
+  "_stream_transform",
+  "_stream_wrap",
+  "_stream_passthrough",
+  "_stream_readable",
+  "_stream_writable",
+  "stream",
+  "stream/promises",
+  "string_decoder",
+  "sys",
+  "timers",
+  "_tls_common",
+  "_tls_legacy",
+  "_tls_wrap",
+  "tls",
+  "trace_events",
+  "tty",
+  "url",
+  "util",
+  "v8/tools/arguments",
+  "v8/tools/codemap",
+  "v8/tools/consarray",
+  "v8/tools/csvparser",
+  "v8/tools/logreader",
+  "v8/tools/profile_view",
+  "v8/tools/splaytree",
+  "v8",
+  "vm",
+  "worker_threads",
+  "zlib",
+  // global is special
+  "global",
+]

package/src/node_esm_resolution.js

@@ -0,0 +1,782 @@
+/*
+ * https://nodejs.org/api/esm.html#resolver-algorithm-specification
+ * https://github.com/nodejs/node/blob/0367b5c35ea0f98b323175a4aaa8e651af7a91e7/lib/internal/modules/esm/resolve.js#L1
+ * deviations from the spec:
+ * - take into account "browser", "module" and "jsnext"
+ * - the check for isDirectory -> throw is delayed is descoped to the caller
+ * - the call to real path ->
+ *   delayed to the caller so that we can decide to
+ *   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 { isSpecifierForNodeBuiltin } from "./node_builtin_specifiers.js"
+import { lookupPackageScope } from "./lookup_package_scope.js"
+import { readPackageJson } from "./read_package_json.js"
+import { filesystemRootUrl, getParentUrl, isValidUrl } from "./url_utils.js"
+import {
+  createInvalidModuleSpecifierError,
+  createModuleNotFoundError,
+  createPackageImportNotDefinedError,
+  createPackagePathNotExportedError,
+  createInvalidPackageTargetError,
+} from "./errors.js"
+
+export const applyNodeEsmResolution = ({
+  conditions = ["node", "import"],
+  parentUrl,
+  specifier,
+}) => {
+  const resolution = applyPackageSpecifierResolution({
+    conditions,
+    parentUrl: String(parentUrl),
+    specifier,
+  })
+  const { url } = resolution
+  if (url.startsWith("file:")) {
+    if (url.includes("%2F") || url.includes("%5C")) {
+      throw createInvalidModuleSpecifierError({
+        specifier,
+        parentUrl,
+        reason: `must not include encoded "/" or "\\" characters`,
+      })
+    }
+    return resolution
+  }
+  return resolution
+}
+
+const applyPackageSpecifierResolution = ({
+  conditions,
+  parentUrl,
+  specifier,
+}) => {
+  // relative specifier
+  if (
+    specifier[0] === "/" ||
+    specifier.startsWith("./") ||
+    specifier.startsWith("../")
+  ) {
+    if (specifier[0] !== "/") {
+      const browserFieldResolution = applyBrowserFieldResolution({
+        conditions,
+        parentUrl,
+        specifier,
+      })
+      if (browserFieldResolution) {
+        return browserFieldResolution
+      }
+    }
+    return {
+      type: "relative_specifier",
+      url: new URL(specifier, parentUrl).href,
+    }
+  }
+  if (specifier[0] === "#") {
+    return applyPackageImportsResolution({
+      conditions,
+      parentUrl,
+      specifier,
+    })
+  }
+  try {
+    const urlObject = new URL(specifier)
+    return {
+      type: "absolute_specifier",
+      url: urlObject.href,
+    }
+  } catch (e) {
+    // bare specifier
+    const browserFieldResolution = applyBrowserFieldResolution({
+      conditions,
+      parentUrl,
+      packageSpecifier: specifier,
+    })
+    if (browserFieldResolution) {
+      return browserFieldResolution
+    }
+    return applyPackageResolve({
+      conditions,
+      parentUrl,
+      packageSpecifier: specifier,
+    })
+  }
+}
+
+const applyBrowserFieldResolution = ({ conditions, parentUrl, specifier }) => {
+  const browserCondition = conditions.includes("browser")
+  if (!browserCondition) {
+    return null
+  }
+  const packageUrl = lookupPackageScope(parentUrl)
+  if (!packageUrl) {
+    return null
+  }
+  const packageJson = readPackageJson(packageUrl)
+  if (!packageJson) {
+    return null
+  }
+  const { browser } = packageJson
+  if (!browser) {
+    return null
+  }
+  if (typeof browser !== "object") {
+    return null
+  }
+  let url
+  if (specifier.startsWith(".")) {
+    const specifierUrl = new URL(specifier, parentUrl).href
+    const specifierRelativeToPackage = specifierUrl.slice(packageUrl.length)
+    const specifierRelativeNotation = `./${specifierRelativeToPackage}`
+    const browserMapping = browser[specifierRelativeNotation]
+    if (typeof browserMapping === "string") {
+      url = new URL(browserMapping, packageUrl).href
+    } else if (browserMapping === false) {
+      url = `file:///@ignore/${specifierUrl.slice("file:///")}`
+    }
+  } else {
+    const browserMapping = browser[specifier]
+    if (typeof browserMapping === "string") {
+      url = new URL(browserMapping, packageUrl).href
+    } else if (browserMapping === false) {
+      url = `file:///@ignore/${specifier}`
+    }
+  }
+  if (url) {
+    return {
+      type: "browser",
+      packageUrl,
+      packageJson,
+      url,
+    }
+  }
+  return null
+}
+
+const applyPackageImportsResolution = ({
+  conditions,
+  parentUrl,
+  specifier,
+}) => {
+  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 packageUrl = lookupPackageScope(parentUrl)
+  if (packageUrl !== null) {
+    const packageJson = readPackageJson(packageUrl)
+    const { imports } = packageJson
+    if (imports !== null && typeof imports === "object") {
+      const resolved = applyPackageImportsExportsResolution({
+        conditions,
+        parentUrl,
+        packageUrl,
+        packageJson,
+        matchObject: imports,
+        matchKey: specifier,
+        isImports: true,
+      })
+      if (resolved) {
+        return resolved
+      }
+    }
+  }
+  throw createPackageImportNotDefinedError({
+    specifier,
+    packageUrl,
+    parentUrl,
+  })
+}
+
+const applyPackageResolve = ({ conditions, parentUrl, packageSpecifier }) => {
+  if (packageSpecifier === "") {
+    throw new Error("invalid module specifier")
+  }
+  if (
+    conditions.includes("node") &&
+    isSpecifierForNodeBuiltin(packageSpecifier)
+  ) {
+    return {
+      type: "node_builtin_specifier",
+      url: `node:${packageSpecifier}`,
+    }
+  }
+  const { packageName, packageSubpath } =
+    parsePackageSpecifier(packageSpecifier)
+  if (
+    packageName[0] === "." ||
+    packageName.includes("\\") ||
+    packageName.includes("%")
+  ) {
+    throw createInvalidModuleSpecifierError({
+      specifier: packageName,
+      parentUrl,
+      reason: `is not a valid package name`,
+    })
+  }
+  if (packageSubpath.endsWith("/")) {
+    throw new Error("invalid module specifier")
+  }
+  const selfResolution = applyPackageSelfResolution({
+    conditions,
+    parentUrl,
+    packageName,
+    packageSubpath,
+  })
+  if (selfResolution) {
+    return selfResolution
+  }
+  let currentUrl = parentUrl
+  while (currentUrl !== filesystemRootUrl) {
+    const packageUrl = new URL(`node_modules/${packageName}/`, currentUrl).href
+    if (!existsSync(new URL(packageUrl))) {
+      currentUrl = getParentUrl(currentUrl)
+      continue
+    }
+    const packageJson = readPackageJson(packageUrl)
+    if (packageJson !== null) {
+      const { exports } = packageJson
+      if (exports !== null && exports !== undefined) {
+        return applyPackageExportsResolution({
+          conditions,
+          parentUrl,
+          packageUrl,
+          packageJson,
+          packageSubpath,
+          exports,
+        })
+      }
+    }
+    return applyLegacySubpathResolution({
+      conditions,
+      parentUrl,
+      packageUrl,
+      packageJson,
+      packageSubpath,
+    })
+  }
+  throw createModuleNotFoundError({
+    specifier: packageName,
+    parentUrl,
+  })
+}
+
+const applyPackageSelfResolution = ({
+  conditions,
+  parentUrl,
+  packageName,
+  packageSubpath,
+}) => {
+  const packageUrl = lookupPackageScope(parentUrl)
+  if (!packageUrl) {
+    return undefined
+  }
+  const packageJson = readPackageJson(packageUrl)
+  if (!packageJson) {
+    return undefined
+  }
+  if (packageJson.name !== packageName) {
+    return undefined
+  }
+  const { exports } = packageJson
+  if (!exports) {
+    const subpathResolution = applyLegacySubpathResolution({
+      conditions,
+      parentUrl,
+      packageUrl,
+      packageJson,
+      packageSubpath,
+    })
+    if (subpathResolution && subpathResolution.type !== "subpath") {
+      return subpathResolution
+    }
+    return undefined
+  }
+  return applyPackageExportsResolution({
+    conditions,
+    parentUrl,
+    packageUrl,
+    packageJson,
+    packageSubpath,
+    exports,
+  })
+}
+
+// https://github.com/nodejs/node/blob/0367b5c35ea0f98b323175a4aaa8e651af7a91e7/lib/internal/modules/esm/resolve.js#L642
+const applyPackageExportsResolution = ({
+  conditions,
+  parentUrl,
+  packageUrl,
+  packageJson,
+  packageSubpath,
+  exports,
+}) => {
+  const exportsInfo = readExports({ exports, packageUrl })
+  if (packageSubpath === ".") {
+    const mainExport = applyMainExportResolution({ exports, exportsInfo })
+    if (!mainExport) {
+      throw createPackagePathNotExportedError({
+        subpath: packageSubpath,
+        parentUrl,
+        packageUrl,
+      })
+    }
+    const resolved = applyPackageTargetResolution({
+      conditions,
+      parentUrl,
+      packageUrl,
+      packageJson,
+      key: ".",
+      target: mainExport,
+    })
+    if (resolved) {
+      return resolved
+    }
+    throw createPackagePathNotExportedError({
+      subpath: packageSubpath,
+      parentUrl,
+      packageUrl,
+    })
+  }
+  if (exportsInfo.type === "object" && exportsInfo.allKeysAreRelative) {
+    const resolved = applyPackageImportsExportsResolution({
+      conditions,
+      parentUrl,
+      packageUrl,
+      packageJson,
+      matchObject: exports,
+      matchKey: packageSubpath,
+      isImports: false,
+    })
+    if (resolved) {
+      return resolved
+    }
+  }
+  throw createPackagePathNotExportedError({
+    subpath: packageSubpath,
+    parentUrl,
+    packageUrl,
+  })
+}
+
+const applyPackageImportsExportsResolution = ({
+  conditions,
+  parentUrl,
+  packageUrl,
+  packageJson,
+  matchObject,
+  matchKey,
+  isImports,
+}) => {
+  if (!matchKey.includes("*") && matchObject.hasOwnProperty(matchKey)) {
+    const target = matchObject[matchKey]
+    return applyPackageTargetResolution({
+      conditions,
+      parentUrl,
+      packageUrl,
+      packageJson,
+      key: matchKey,
+      target,
+      internal: isImports,
+    })
+  }
+  const expansionKeys = Object.keys(matchObject)
+    .filter((key) => key.split("*").length === 2)
+    .sort(comparePatternKeys)
+  for (const expansionKey of expansionKeys) {
+    const [patternBase, patternTrailer] = expansionKey.split("*")
+    if (matchKey === patternBase) continue
+    if (!matchKey.startsWith(patternBase)) continue
+    if (patternTrailer.length > 0) {
+      if (!matchKey.endsWith(patternTrailer)) continue
+      if (matchKey.length < expansionKey.length) continue
+    }
+    const target = matchObject[expansionKey]
+    const subpath = matchKey.slice(
+      patternBase.length,
+      matchKey.length - patternTrailer.length,
+    )
+    return applyPackageTargetResolution({
+      conditions,
+      parentUrl,
+      packageUrl,
+      packageJson,
+      key: matchKey,
+      target,
+      subpath,
+      pattern: true,
+      internal: isImports,
+    })
+  }
+  return null
+}
+
+const applyPackageTargetResolution = ({
+  conditions,
+  parentUrl,
+  packageUrl,
+  packageJson,
+  key,
+  target,
+  subpath = "",
+  pattern = false,
+  internal = false,
+}) => {
+  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,
+          target,
+          key,
+          isImport: internal,
+          reason: `target must be inside package`,
+        })
+      }
+      return {
+        type: internal ? "imports_subpath" : "exports_subpath",
+        packageUrl,
+        packageJson,
+        url: pattern
+          ? targetUrl.replaceAll("*", subpath)
+          : new URL(subpath, targetUrl).href,
+      }
+    }
+    if (!internal || target.startsWith("../") || isValidUrl(target)) {
+      throw createInvalidPackageTargetError({
+        parentUrl,
+        packageUrl,
+        target,
+        key,
+        isImport: internal,
+        reason: `target must starst with "./"`,
+      })
+    }
+    return applyPackageResolve({
+      conditions,
+      parentUrl: packageUrl,
+      packageSpecifier: pattern
+        ? target.replaceAll("*", subpath)
+        : `${target}${subpath}`,
+    })
+  }
+  if (Array.isArray(target)) {
+    if (target.length === 0) {
+      return null
+    }
+    let lastResult
+    let i = 0
+    while (i < target.length) {
+      const targetValue = target[i]
+      i++
+      try {
+        const resolved = applyPackageTargetResolution({
+          conditions,
+          parentUrl,
+          packageUrl,
+          packageJson,
+          key: `${key}[${i}]`,
+          target: targetValue,
+          subpath,
+          pattern,
+          internal,
+        })
+        if (resolved) {
+          return resolved
+        }
+        lastResult = resolved
+      } catch (e) {
+        if (e.code === "INVALID_PACKAGE_TARGET") {
+          continue
+        }
+        lastResult = e
+      }
+    }
+    if (lastResult) {
+      throw lastResult
+    }
+    return null
+  }
+  if (target === null) {
+    return null
+  }
+  if (typeof target === "object") {
+    const keys = Object.keys(target)
+    for (const key of keys) {
+      if (Number.isInteger(key)) {
+        throw new Error("Invalid package configuration")
+      }
+      if (key === "default" || conditions.includes(key)) {
+        const targetValue = target[key]
+        const resolved = applyPackageTargetResolution({
+          conditions,
+          parentUrl,
+          packageUrl,
+          packageJson,
+          key,
+          target: targetValue,
+          subpath,
+          pattern,
+          internal,
+        })
+        if (resolved) {
+          return resolved
+        }
+      }
+    }
+    return null
+  }
+  throw createInvalidPackageTargetError({
+    parentUrl,
+    packageUrl,
+    target,
+    key,
+    isImport: internal,
+    reason: `target must be a string, array, object or null`,
+  })
+}
+
+const readExports = ({ exports, packageUrl }) => {
+  if (Array.isArray(exports)) {
+    return {
+      type: "array",
+    }
+  }
+  if (exports === null) {
+    return {}
+  }
+  if (typeof exports === "object") {
+    const keys = Object.keys(exports)
+    const relativeKeys = []
+    const conditionalKeys = []
+    keys.forEach((availableKey) => {
+      if (availableKey.startsWith(".")) {
+        relativeKeys.push(availableKey)
+      } else {
+        conditionalKeys.push(availableKey)
+      }
+    })
+    const hasRelativeKey = relativeKeys.length > 0
+    if (hasRelativeKey && conditionalKeys.length > 0) {
+      throw new Error(
+        `Invalid package configuration: cannot mix relative and conditional keys in package.exports
+--- unexpected keys ---
+${conditionalKeys.map((key) => `"${key}"`).join("\n")}
+--- package.json ---
+${packageUrl}`,
+      )
+    }
+    return {
+      type: "object",
+      hasRelativeKey,
+      allKeysAreRelative: relativeKeys.length === keys.length,
+    }
+  }
+  if (typeof exports === "string") {
+    return { type: "string" }
+  }
+  return {}
+}
+
+const parsePackageSpecifier = (packageSpecifier) => {
+  if (packageSpecifier[0] === "@") {
+    const firstSlashIndex = packageSpecifier.indexOf("/")
+    if (firstSlashIndex === -1) {
+      throw new Error("invalid module specifier")
+    }
+    const secondSlashIndex = packageSpecifier.indexOf("/", firstSlashIndex + 1)
+    if (secondSlashIndex === -1) {
+      return {
+        packageName: packageSpecifier,
+        packageSubpath: ".",
+        isScoped: true,
+      }
+    }
+    const packageName = packageSpecifier.slice(0, secondSlashIndex)
+    const afterSecondSlash = packageSpecifier.slice(secondSlashIndex + 1)
+    const packageSubpath = `./${afterSecondSlash}`
+    return {
+      packageName,
+      packageSubpath,
+      isScoped: true,
+    }
+  }
+  const firstSlashIndex = packageSpecifier.indexOf("/")
+  if (firstSlashIndex === -1) {
+    return {
+      packageName: packageSpecifier,
+      packageSubpath: ".",
+    }
+  }
+  const packageName = packageSpecifier.slice(0, firstSlashIndex)
+  const afterFirstSlash = packageSpecifier.slice(firstSlashIndex + 1)
+  const packageSubpath = `./${afterFirstSlash}`
+  return {
+    packageName,
+    packageSubpath,
+  }
+}
+
+const applyMainExportResolution = ({ exports, exportsInfo }) => {
+  if (exportsInfo.type === "array" || exportsInfo.type === "string") {
+    return exports
+  }
+  if (exportsInfo.type === "object") {
+    if (exportsInfo.hasRelativeKey) {
+      return exports["."]
+    }
+    return exports
+  }
+  return undefined
+}
+
+const applyLegacySubpathResolution = ({
+  conditions,
+  parentUrl,
+  packageUrl,
+  packageJson,
+  packageSubpath,
+}) => {
+  if (packageSubpath === ".") {
+    return applyLegacyMainResolution({
+      conditions,
+      packageUrl,
+      packageJson,
+    })
+  }
+  const browserFieldResolution = applyBrowserFieldResolution({
+    conditions,
+    parentUrl,
+    specifier: packageSubpath,
+  })
+  if (browserFieldResolution) {
+    return browserFieldResolution
+  }
+  return {
+    type: "subpath",
+    packageUrl,
+    packageJson,
+    url: new URL(packageSubpath, packageUrl).href,
+  }
+}
+
+const applyLegacyMainResolution = ({ conditions, packageUrl, packageJson }) => {
+  for (const condition of conditions) {
+    const resolved = mainLegacyResolvers[condition](packageJson, packageUrl)
+    if (resolved) {
+      return {
+        type: resolved.type,
+        packageUrl,
+        packageJson,
+        url: new URL(resolved.path, packageUrl).href,
+      }
+    }
+  }
+  return {
+    type: "default",
+    packageUrl,
+    packageJson,
+    url: new URL("index.js", packageUrl).href,
+  }
+}
+const mainLegacyResolvers = {
+  import: ({ module, jsnext }) => {
+    if (typeof module === "string") {
+      return { type: "module", path: module }
+    }
+    if (typeof jsnext === "string") {
+      return { type: "jsnext", path: jsnext }
+    }
+    return null
+  },
+  browser: ({ browser, module }, packageUrl) => {
+    const browserMain =
+      typeof browser === "string"
+        ? browser
+        : typeof browser === "object" && browser !== null
+        ? browser["."]
+        : ""
+    if (!browserMain) {
+      return null
+    }
+    if (typeof module !== "string" || module === browserMain) {
+      return {
+        type: "browser",
+        path: browserMain,
+      }
+    }
+    const browserMainUrlObject = new URL(browserMain, packageUrl)
+    const content = readFileSync(browserMainUrlObject, "utf-8")
+    if (
+      (/typeof exports\s*==/.test(content) &&
+        /typeof module\s*==/.test(content)) ||
+      /module\.exports\s*=/.test(content)
+    ) {
+      return {
+        type: "module",
+        path: module,
+      }
+    }
+    return {
+      type: "browser",
+      path: browserMain,
+    }
+  },
+  node: ({ main }) => {
+    if (typeof main === "string") {
+      return {
+        type: "main",
+        path: main,
+      }
+    }
+    return null
+  },
+}
+
+const comparePatternKeys = (keyA, keyB) => {
+  if (!keyA.endsWith("/") && !keyA.contains("*")) {
+    throw new Error("Invalid package configuration")
+  }
+  if (!keyB.endsWith("/") && !keyB.contains("*")) {
+    throw new Error("Invalid package configuration")
+  }
+  const aStarIndex = keyA.indexOf("*")
+  const baseLengthA = aStarIndex > -1 ? aStarIndex + 1 : keyA.length
+  const bStarIndex = keyB.indexOf("*")
+  const baseLengthB = bStarIndex > -1 ? bStarIndex + 1 : keyB.length
+  if (baseLengthA > baseLengthB) {
+    return -1
+  }
+  if (baseLengthB > baseLengthA) {
+    return 1
+  }
+  if (aStarIndex === -1) {
+    return 1
+  }
+  if (bStarIndex === -1) {
+    return -1
+  }
+  if (keyA.length > keyB.length) {
+    return -1
+  }
+  if (keyB.length > keyA.length) {
+    return 1
+  }
+  return 0
+}

package/src/read_package_json.js

@@ -0,0 +1,12 @@
+import { readFileSync } from "node:fs"
+
+export const readPackageJson = (packageUrl) => {
+  const packageJsonUrl = new URL("package.json", packageUrl)
+  const buffer = readFileSync(packageJsonUrl)
+  const string = String(buffer)
+  try {
+    return JSON.parse(string)
+  } catch (e) {
+    throw new Error(`Invalid package configuration`)
+  }
+}

package/src/url_utils.js

@@ -0,0 +1,37 @@
+export const filesystemRootUrl =
+  process.platform === "win32" ? `file///${process.cwd()[0]}:/` : "file:///"
+
+export const asDirectoryUrl = (url) => {
+  const { pathname } = new URL(url)
+  if (pathname.endsWith("/")) {
+    return url
+  }
+  return new URL("./", url).href
+}
+
+export const getParentUrl = (url) => {
+  return new URL(url.endsWith("/") ? "../" : "./", url).href
+}
+
+export const isValidUrl = (url) => {
+  try {
+    // eslint-disable-next-line no-new
+    new URL(url)
+    return true
+  } catch (e) {
+    return false
+  }
+}
+
+export const urlToFilename = (url) => {
+  const { pathname } = new URL(url)
+  const pathnameBeforeLastSlash = pathname.endsWith("/")
+    ? pathname.slice(0, -1)
+    : pathname
+  const slashLastIndex = pathnameBeforeLastSlash.lastIndexOf("/")
+  const filename =
+    slashLastIndex === -1
+      ? pathnameBeforeLastSlash
+      : pathnameBeforeLastSlash.slice(slashLastIndex + 1)
+  return filename
+}