@jsenv/core 41.0.3 → 41.0.4

package/dist/start_dev_server/jsenv_core_packages.js

@@ -3809,2481 +3809,2481 @@ const bufferToEtag = (buffer) => {
   return `"${length.toString(16)}-${hashBase64StringSubset}"`;
 };
 
-// https://nodejs.org/api/packages.html#resolving-user-conditions
-const readCustomConditionsFromProcessArgs = () => {
-  if (process.env.IGNORE_PACKAGE_CONDITIONS) {
-    return [];
+const assertImportMap = (value) => {
+  if (value === null) {
+    throw new TypeError(`an importMap must be an object, got null`);
   }
-  const packageConditions = [];
-  for (const arg of process.execArgv) {
-    if (arg.includes("-C=")) {
-      const packageCondition = arg.slice(0, "-C=".length);
-      packageConditions.push(packageCondition);
-    }
-    if (arg.includes("--conditions=")) {
-      const packageCondition = arg.slice("--conditions=".length);
-      packageConditions.push(packageCondition);
-    }
+
+  const type = typeof value;
+  if (type !== "object") {
+    throw new TypeError(`an importMap must be an object, received ${value}`);
   }
-  return packageConditions;
-};
 
-const asDirectoryUrl = (url) => {
-  const { pathname } = new URL(url);
-  if (pathname.endsWith("/")) {
-    return url;
+  if (Array.isArray(value)) {
+    throw new TypeError(
+      `an importMap must be an object, received array ${value}`,
+    );
   }
-  return new URL("./", url).href;
 };
 
-const getParentUrl = (url) => {
-  if (url.startsWith("file://")) {
-    // With node.js new URL('../', 'file:///C:/').href
-    // returns "file:///C:/" instead of "file:///"
-    const resource = url.slice("file://".length);
-    const slashLastIndex = resource.lastIndexOf("/");
-    if (slashLastIndex === -1) {
-      return url;
-    }
-    const lastCharIndex = resource.length - 1;
-    if (slashLastIndex === lastCharIndex) {
-      const slashBeforeLastIndex = resource.lastIndexOf(
-        "/",
-        slashLastIndex - 1,
-      );
-      if (slashBeforeLastIndex === -1) {
-        return url;
-      }
-      return `file://${resource.slice(0, slashBeforeLastIndex + 1)}`;
-    }
+// duplicated from @jsenv/log to avoid the dependency
+const createDetailedMessage = (message, details = {}) => {
+  let string = `${message}`;
 
-    return `file://${resource.slice(0, slashLastIndex + 1)}`;
-  }
-  return new URL(url.endsWith("/") ? "../" : "./", url).href;
-};
+  Object.keys(details).forEach((key) => {
+    const value = details[key];
+    string += `
+    --- ${key} ---
+    ${
+      Array.isArray(value)
+        ? value.join(`
+    `)
+        : value
+    }`;
+  });
 
-const isValidUrl = (url) => {
-  try {
-    // eslint-disable-next-line no-new
-    new URL(url);
-    return true;
-  } catch {
-    return false;
-  }
+  return string;
 };
 
-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;
+const hasScheme = (string) => {
+  return /^[a-zA-Z]{2,}:/.test(string);
 };
 
-const urlToExtension = (url) => {
-  const filename = urlToFilename(url);
-  const dotLastIndex = filename.lastIndexOf(".");
-  if (dotLastIndex === -1) return "";
-  // if (dotLastIndex === pathname.length - 1) return ""
-  const extension = filename.slice(dotLastIndex);
-  return extension;
+const pathnameToParentPathname = (pathname) => {
+  const slashLastIndex = pathname.lastIndexOf("/");
+  if (slashLastIndex === -1) {
+    return "/";
+  }
+
+  return pathname.slice(0, slashLastIndex + 1);
 };
 
-const defaultLookupPackageScope = (url) => {
-  let scopeUrl = asDirectoryUrl(url);
-  while (scopeUrl !== "file:///") {
-    if (scopeUrl.endsWith("node_modules/")) {
-      return null;
-    }
-    const packageJsonUrlObject = new URL("package.json", scopeUrl);
-    if (existsSync(packageJsonUrlObject)) {
-      return scopeUrl;
-    }
-    scopeUrl = getParentUrl(scopeUrl);
-  }
-  return null;
+const urlToScheme = (urlString) => {
+  const colonIndex = urlString.indexOf(":");
+  if (colonIndex === -1) return "";
+  return urlString.slice(0, colonIndex);
 };
 
-const defaultReadPackageJson = (packageUrl) => {
-  const packageJsonFileUrl = new URL("./package.json", packageUrl);
-  let packageJsonFileContentBuffer;
-  try {
-    packageJsonFileContentBuffer = readFileSync(packageJsonFileUrl, "utf8");
-  } catch (e) {
-    if (e.code === "ENOENT") {
-      return null;
-    }
-    throw e;
+const urlToOrigin = (urlString) => {
+  const scheme = urlToScheme(urlString);
+
+  if (scheme === "file") {
+    return "file://";
   }
-  const packageJsonFileContentString = String(packageJsonFileContentBuffer);
-  try {
-    const packageJsonFileContentObject = JSON.parse(
-      packageJsonFileContentString,
-    );
-    return packageJsonFileContentObject;
-  } catch {
-    throw new Error(`Invalid package configuration at ${packageJsonFileUrl}`);
+
+  if (scheme === "http" || scheme === "https") {
+    const secondProtocolSlashIndex = scheme.length + "://".length;
+    const pathnameSlashIndex = urlString.indexOf("/", secondProtocolSlashIndex);
+
+    if (pathnameSlashIndex === -1) return urlString;
+    return urlString.slice(0, pathnameSlashIndex);
   }
-};
 
-// https://github.com/nodejs/node/blob/0367b5c35ea0f98b323175a4aaa8e651af7a91e7/tools/node_modules/eslint/node_modules/%40babel/core/lib/vendor/import-meta-resolve.js#L2473
+  return urlString.slice(0, scheme.length + 1);
+};
 
-const createInvalidModuleSpecifierError = (
-  reason,
-  specifier,
-  { parentUrl },
-) => {
-  const error = new Error(
-    `Invalid module "${specifier}" ${reason} imported from ${fileURLToPath(
-      parentUrl,
-    )}`,
-  );
-  error.code = "INVALID_MODULE_SPECIFIER";
-  return error;
+const urlToPathname = (urlString) => {
+  return ressourceToPathname(urlToRessource(urlString));
 };
 
-const createInvalidPackageTargetError = (
-  reason,
-  target,
-  { parentUrl, packageDirectoryUrl, key, isImport },
-) => {
-  let message;
-  if (key === ".") {
-    message = `Invalid "exports" main target defined in ${fileURLToPath(
-      packageDirectoryUrl,
-    )}package.json imported from ${fileURLToPath(parentUrl)}; ${reason}`;
-  } else {
-    message = `Invalid "${
-      isImport ? "imports" : "exports"
-    }" target ${JSON.stringify(target)} defined for "${key}" in ${fileURLToPath(
-      packageDirectoryUrl,
-    )}package.json imported from ${fileURLToPath(parentUrl)}; ${reason}`;
+const urlToRessource = (urlString) => {
+  const scheme = urlToScheme(urlString);
+
+  if (scheme === "file") {
+    return urlString.slice("file://".length);
   }
-  const error = new Error(message);
-  error.code = "INVALID_PACKAGE_TARGET";
-  return error;
-};
 
-const createPackagePathNotExportedError = (
-  subpath,
-  { parentUrl, packageDirectoryUrl },
-) => {
-  let message;
-  if (subpath === ".") {
-    message = `No "exports" main defined in ${fileURLToPath(
-      packageDirectoryUrl,
-    )}package.json imported from ${fileURLToPath(parentUrl)}`;
-  } else {
-    message = `Package subpath "${subpath}" is not defined by "exports" in ${fileURLToPath(
-      packageDirectoryUrl,
-    )}package.json imported from ${fileURLToPath(parentUrl)}`;
+  if (scheme === "https" || scheme === "http") {
+    // remove origin
+    const afterProtocol = urlString.slice(scheme.length + "://".length);
+    const pathnameSlashIndex = afterProtocol.indexOf("/", "://".length);
+    return afterProtocol.slice(pathnameSlashIndex);
   }
-  const error = new Error(message);
-  error.code = "PACKAGE_PATH_NOT_EXPORTED";
-  return error;
-};
 
-const createModuleNotFoundError = (specifier, { parentUrl }) => {
-  const error = new Error(
-    `Cannot find "${specifier}" imported from ${fileURLToPath(parentUrl)}`,
-  );
-  error.code = "MODULE_NOT_FOUND";
-  return error;
+  return urlString.slice(scheme.length + 1);
 };
 
-const createPackageImportNotDefinedError = (
-  specifier,
-  { parentUrl, packageDirectoryUrl },
-) => {
-  const error = new Error(
-    `Package import specifier "${specifier}" is not defined in ${fileURLToPath(
-      packageDirectoryUrl,
-    )}package.json imported from ${fileURLToPath(parentUrl)}`,
-  );
-  error.code = "PACKAGE_IMPORT_NOT_DEFINED";
-  return error;
+const ressourceToPathname = (ressource) => {
+  const searchSeparatorIndex = ressource.indexOf("?");
+  return searchSeparatorIndex === -1
+    ? ressource
+    : ressource.slice(0, searchSeparatorIndex);
 };
 
-const isSpecifierForNodeBuiltin = (specifier) => {
-  return (
-    specifier.startsWith("node:") ||
-    NODE_BUILTIN_MODULE_SPECIFIERS.includes(specifier)
-  );
-};
+// could be useful: https://url.spec.whatwg.org/#url-miscellaneous
 
-const NODE_BUILTIN_MODULE_SPECIFIERS = [
-  "assert",
-  "assert/strict",
-  "async_hooks",
-  "buffer_ieee754",
-  "buffer",
-  "child_process",
-  "cluster",
-  "console",
-  "constants",
-  "crypto",
-  "_debugger",
-  "diagnostics_channel",
-  "dgram",
-  "dns",
-  "domain",
-  "events",
-  "freelist",
-  "fs",
-  "fsevents",
-  "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",
-  "sqlite",
-  "_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",
-];
 
-/*
- * 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
- */
+const resolveUrl = (specifier, baseUrl) => {
+  if (baseUrl) {
+    if (typeof baseUrl !== "string") {
+      throw new TypeError(writeBaseUrlMustBeAString({ baseUrl, specifier }));
+    }
+    if (!hasScheme(baseUrl)) {
+      throw new Error(writeBaseUrlMustBeAbsolute({ baseUrl, specifier }));
+    }
+  }
 
-const applyNodeEsmResolution = ({
-  specifier,
-  parentUrl,
-  conditions = [...readCustomConditionsFromProcessArgs(), "node", "import"],
-  lookupPackageScope = defaultLookupPackageScope,
-  readPackageJson = defaultReadPackageJson,
-  preservesSymlink = false,
-}) => {
-  const resolution = applyPackageSpecifierResolution(specifier, {
-    parentUrl: String(parentUrl),
-    conditions,
-    lookupPackageScope,
-    readPackageJson,
-    preservesSymlink,
-  });
-  const { url } = resolution;
-  if (url.startsWith("file:")) {
-    if (url.includes("%2F") || url.includes("%5C")) {
-      throw createInvalidModuleSpecifierError(
-        `must not include encoded "/" or "\\" characters`,
-        specifier,
-        {
-          parentUrl,
-        },
-      );
+  if (hasScheme(specifier)) {
+    return specifier;
+  }
+
+  if (!baseUrl) {
+    throw new Error(writeBaseUrlRequired({ baseUrl, specifier }));
+  }
+
+  // scheme relative
+  if (specifier.slice(0, 2) === "//") {
+    return `${urlToScheme(baseUrl)}:${specifier}`;
+  }
+
+  // origin relative
+  if (specifier[0] === "/") {
+    return `${urlToOrigin(baseUrl)}${specifier}`;
+  }
+
+  const baseOrigin = urlToOrigin(baseUrl);
+  const basePathname = urlToPathname(baseUrl);
+
+  if (specifier === ".") {
+    const baseDirectoryPathname = pathnameToParentPathname(basePathname);
+    return `${baseOrigin}${baseDirectoryPathname}`;
+  }
+
+  // pathname relative inside
+  if (specifier.slice(0, 2) === "./") {
+    const baseDirectoryPathname = pathnameToParentPathname(basePathname);
+    return `${baseOrigin}${baseDirectoryPathname}${specifier.slice(2)}`;
+  }
+
+  // pathname relative outside
+  if (specifier.slice(0, 3) === "../") {
+    let unresolvedPathname = specifier;
+    const importerFolders = basePathname.split("/");
+    importerFolders.pop();
+
+    while (unresolvedPathname.slice(0, 3) === "../") {
+      unresolvedPathname = unresolvedPathname.slice(3);
+      // when there is no folder left to resolved
+      // we just ignore '../'
+      if (importerFolders.length) {
+        importerFolders.pop();
+      }
     }
-    return resolution;
+
+    const resolvedPathname = `${importerFolders.join(
+      "/",
+    )}/${unresolvedPathname}`;
+    return `${baseOrigin}${resolvedPathname}`;
   }
-  return resolution;
+
+  // bare
+  if (basePathname === "") {
+    return `${baseOrigin}/${specifier}`;
+  }
+  if (basePathname[basePathname.length] === "/") {
+    return `${baseOrigin}${basePathname}${specifier}`;
+  }
+  return `${baseOrigin}${pathnameToParentPathname(basePathname)}${specifier}`;
 };
 
-const createResolutionResult = (data) => {
-  return data;
+const writeBaseUrlMustBeAString = ({
+  baseUrl,
+  specifier,
+}) => `baseUrl must be a string.
+--- base url ---
+${baseUrl}
+--- specifier ---
+${specifier}`;
+
+const writeBaseUrlMustBeAbsolute = ({
+  baseUrl,
+  specifier,
+}) => `baseUrl must be absolute.
+--- base url ---
+${baseUrl}
+--- specifier ---
+${specifier}`;
+
+const writeBaseUrlRequired = ({
+  baseUrl,
+  specifier,
+}) => `baseUrl required to resolve relative specifier.
+--- base url ---
+${baseUrl}
+--- specifier ---
+${specifier}`;
+
+const tryUrlResolution = (string, url) => {
+  const result = resolveUrl(string, url);
+  return hasScheme(result) ? result : null;
 };
 
-const applyPackageSpecifierResolution = (specifier, resolutionContext) => {
-  const { parentUrl } = resolutionContext;
-  // relative specifier
+const resolveSpecifier = (specifier, importer) => {
   if (
+    specifier === "." ||
     specifier[0] === "/" ||
     specifier.startsWith("./") ||
     specifier.startsWith("../")
   ) {
-    if (specifier[0] !== "/") {
-      const browserFieldResolution = applyBrowserFieldResolution(
-        specifier,
-        resolutionContext,
-      );
-      if (browserFieldResolution) {
-        return browserFieldResolution;
-      }
-    }
-    return createResolutionResult({
-      type: "relative_specifier",
-      url: new URL(specifier, parentUrl).href,
-    });
+    return resolveUrl(specifier, importer);
   }
-  if (specifier[0] === "#") {
-    return applyPackageImportsResolution(specifier, resolutionContext);
-  }
-  try {
-    const urlObject = new URL(specifier);
-    if (specifier.startsWith("node:")) {
-      return createResolutionResult({
-        type: "node_builtin_specifier",
-        url: specifier,
-      });
-    }
-    return createResolutionResult({
-      type: "absolute_specifier",
-      url: urlObject.href,
-    });
-  } catch {
-    // bare specifier
-    const browserFieldResolution = applyBrowserFieldResolution(
-      specifier,
-      resolutionContext,
-    );
-    if (browserFieldResolution) {
-      return browserFieldResolution;
-    }
-    const packageResolution = applyPackageResolve(specifier, resolutionContext);
-    const search = new URL(specifier, "file:///").search;
-    if (search && !new URL(packageResolution.url).search) {
-      packageResolution.url = `${packageResolution.url}${search}`;
-    }
-    return packageResolution;
+
+  if (hasScheme(specifier)) {
+    return specifier;
   }
+
+  return null;
 };
 
-const applyBrowserFieldResolution = (specifier, resolutionContext) => {
-  const { parentUrl, conditions, lookupPackageScope, readPackageJson } =
-    resolutionContext;
-  const browserCondition = conditions.includes("browser");
-  if (!browserCondition) {
-    return null;
-  }
-  const packageDirectoryUrl = lookupPackageScope(parentUrl);
-  if (!packageDirectoryUrl) {
-    return null;
-  }
-  const packageJson = readPackageJson(packageDirectoryUrl);
-  if (!packageJson) {
-    return null;
-  }
-  const { browser } = packageJson;
-  if (!browser) {
-    return null;
+const applyImportMap = ({
+  importMap,
+  specifier,
+  importer,
+  createBareSpecifierError = ({ specifier, importer }) => {
+    return new Error(
+      createDetailedMessage(`Unmapped bare specifier.`, {
+        specifier,
+        importer,
+      }),
+    );
+  },
+  onImportMapping = () => {},
+}) => {
+  assertImportMap(importMap);
+  if (typeof specifier !== "string") {
+    throw new TypeError(
+      createDetailedMessage("specifier must be a string.", {
+        specifier,
+        importer,
+      }),
+    );
   }
-  if (typeof browser !== "object") {
-    return null;
+  if (importer) {
+    if (typeof importer !== "string") {
+      throw new TypeError(
+        createDetailedMessage("importer must be a string.", {
+          importer,
+          specifier,
+        }),
+      );
+    }
+    if (!hasScheme(importer)) {
+      throw new Error(
+        createDetailedMessage(`importer must be an absolute url.`, {
+          importer,
+          specifier,
+        }),
+      );
+    }
   }
-  let url;
-  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, packageDirectoryUrl).href;
-    } else if (browserMapping === false) {
-      url = `file:///@ignore/${specifierUrl.slice("file:///")}`;
+
+  const specifierUrl = resolveSpecifier(specifier, importer);
+  const specifierNormalized = specifierUrl || specifier;
+
+  const { scopes } = importMap;
+  if (scopes && importer) {
+    const scopeSpecifierMatching = Object.keys(scopes).find(
+      (scopeSpecifier) => {
+        return (
+          scopeSpecifier === importer ||
+          specifierIsPrefixOf(scopeSpecifier, importer)
+        );
+      },
+    );
+    if (scopeSpecifierMatching) {
+      const scopeMappings = scopes[scopeSpecifierMatching];
+      const mappingFromScopes = applyMappings(
+        scopeMappings,
+        specifierNormalized,
+        scopeSpecifierMatching,
+        onImportMapping,
+      );
+      if (mappingFromScopes !== null) {
+        return mappingFromScopes;
+      }
     }
-  } else {
-    const browserMapping = browser[specifier];
-    if (typeof browserMapping === "string") {
-      url = new URL(browserMapping, packageDirectoryUrl).href;
-    } else if (browserMapping === false) {
-      url = `file:///@ignore/${specifier}`;
+  }
+
+  const { imports } = importMap;
+  if (imports) {
+    const mappingFromImports = applyMappings(
+      imports,
+      specifierNormalized,
+      undefined,
+      onImportMapping,
+    );
+    if (mappingFromImports !== null) {
+      return mappingFromImports;
     }
   }
-  if (url) {
-    return createResolutionResult({
-      type: "field:browser",
-      isMain: true,
-      packageDirectoryUrl,
-      packageJson,
-      url,
-    });
+
+  if (specifierUrl) {
+    return specifierUrl;
   }
-  return null;
+
+  throw createBareSpecifierError({ specifier, importer });
 };
 
-const applyPackageImportsResolution = (
-  internalSpecifier,
-  resolutionContext,
+const applyMappings = (
+  mappings,
+  specifierNormalized,
+  scope,
+  onImportMapping,
 ) => {
-  const { parentUrl, lookupPackageScope, readPackageJson } = resolutionContext;
-  if (internalSpecifier === "#" || internalSpecifier.startsWith("#/")) {
-    throw createInvalidModuleSpecifierError(
-      "not a valid internal imports specifier name",
-      internalSpecifier,
-      resolutionContext,
-    );
-  }
-  const packageDirectoryUrl = lookupPackageScope(parentUrl);
-  if (packageDirectoryUrl !== null) {
-    const packageJson = readPackageJson(packageDirectoryUrl);
-    const { imports } = packageJson;
-    if (imports !== null && typeof imports === "object") {
-      const resolved = applyPackageImportsExportsResolution(internalSpecifier, {
-        ...resolutionContext,
-        packageDirectoryUrl,
-        packageJson,
-        isImport: true,
+  const specifierCandidates = Object.keys(mappings);
+
+  let i = 0;
+  while (i < specifierCandidates.length) {
+    const specifierCandidate = specifierCandidates[i];
+    i++;
+    if (specifierCandidate === specifierNormalized) {
+      const address = mappings[specifierCandidate];
+      onImportMapping({
+        scope,
+        from: specifierCandidate,
+        to: address,
+        before: specifierNormalized,
+        after: address,
       });
-      if (resolved) {
-        return resolved;
-      }
+      return address;
+    }
+    if (specifierIsPrefixOf(specifierCandidate, specifierNormalized)) {
+      const address = mappings[specifierCandidate];
+      const afterSpecifier = specifierNormalized.slice(
+        specifierCandidate.length,
+      );
+      const addressFinal = tryUrlResolution(afterSpecifier, address);
+      onImportMapping({
+        scope,
+        from: specifierCandidate,
+        to: address,
+        before: specifierNormalized,
+        after: addressFinal,
+      });
+      return addressFinal;
     }
   }
-  throw createPackageImportNotDefinedError(internalSpecifier, {
-    ...resolutionContext,
-    packageDirectoryUrl,
-  });
+
+  return null;
 };
 
-const applyPackageResolve = (packageSpecifier, resolutionContext) => {
-  const { parentUrl, conditions, readPackageJson, preservesSymlink, isImport } =
-    resolutionContext;
-  if (packageSpecifier === "") {
-    throw new Error("invalid module specifier");
+const specifierIsPrefixOf = (specifierHref, href) => {
+  return (
+    specifierHref[specifierHref.length - 1] === "/" &&
+    href.startsWith(specifierHref)
+  );
+};
+
+// https://github.com/systemjs/systemjs/blob/89391f92dfeac33919b0223bbf834a1f4eea5750/src/common.js#L136
+
+const composeTwoImportMaps = (leftImportMap, rightImportMap) => {
+  assertImportMap(leftImportMap);
+  assertImportMap(rightImportMap);
+
+  const importMap = {};
+
+  const leftImports = leftImportMap.imports;
+  const rightImports = rightImportMap.imports;
+  const leftHasImports = Boolean(leftImports);
+  const rightHasImports = Boolean(rightImports);
+  if (leftHasImports && rightHasImports) {
+    importMap.imports = composeTwoMappings(leftImports, rightImports);
+  } else if (leftHasImports) {
+    importMap.imports = { ...leftImports };
+  } else if (rightHasImports) {
+    importMap.imports = { ...rightImports };
   }
-  if (
-    conditions.includes("node") &&
-    isSpecifierForNodeBuiltin(packageSpecifier)
-  ) {
-    return createResolutionResult({
-      type: "node_builtin_specifier",
-      url: `node:${packageSpecifier}`,
-    });
+
+  const leftScopes = leftImportMap.scopes;
+  const rightScopes = rightImportMap.scopes;
+  const leftHasScopes = Boolean(leftScopes);
+  const rightHasScopes = Boolean(rightScopes);
+  if (leftHasScopes && rightHasScopes) {
+    importMap.scopes = composeTwoScopes(
+      leftScopes,
+      rightScopes,
+      importMap.imports || {},
+    );
+  } else if (leftHasScopes) {
+    importMap.scopes = { ...leftScopes };
+  } else if (rightHasScopes) {
+    importMap.scopes = { ...rightScopes };
   }
-  let { packageName, packageSubpath } = parsePackageSpecifier(packageSpecifier);
-  if (
-    packageName[0] === "." ||
-    packageName.includes("\\") ||
-    packageName.includes("%")
-  ) {
-    throw createInvalidModuleSpecifierError(
-      `is not a valid package name`,
-      packageName,
-      resolutionContext,
-    );
-  }
-  if (isImport && packageSubpath.endsWith("/")) {
-    throw new Error("invalid module specifier");
-  }
-  const questionCharIndex = packageName.indexOf("?");
-  if (questionCharIndex > -1) {
-    packageName = packageName.slice(0, questionCharIndex);
-  }
-  const selfResolution = applyPackageSelfResolution(packageSubpath, {
-    ...resolutionContext,
-    packageName,
-  });
-  if (selfResolution) {
-    return selfResolution;
-  }
-  let currentUrl = parentUrl;
-  while (currentUrl !== "file:///") {
-    const packageDirectoryFacadeUrl = new URL(
-      `node_modules/${packageName}/`,
-      currentUrl,
-    ).href;
-    if (!existsSync(new URL(packageDirectoryFacadeUrl))) {
-      currentUrl = getParentUrl(currentUrl);
-      continue;
-    }
-    const packageDirectoryUrl = preservesSymlink
-      ? packageDirectoryFacadeUrl
-      : resolvePackageSymlink(packageDirectoryFacadeUrl);
-    const packageJson = readPackageJson(packageDirectoryUrl);
-    if (packageJson !== null) {
-      const { exports: exports$1 } = packageJson;
-      if (exports$1 !== null && exports$1 !== undefined) {
-        return applyPackageExportsResolution(packageSubpath, {
-          ...resolutionContext,
-          packageDirectoryUrl,
-          packageJson,
-          exports: exports$1,
-        });
-      }
-    }
-    return applyLegacySubpathResolution(packageSubpath, {
-      ...resolutionContext,
-      packageDirectoryUrl,
-      packageJson,
-    });
-  }
-  throw createModuleNotFoundError(packageName, resolutionContext);
+
+  return importMap;
 };
 
-const applyPackageSelfResolution = (packageSubpath, resolutionContext) => {
-  const { parentUrl, packageName, lookupPackageScope, readPackageJson } =
-    resolutionContext;
-  const packageDirectoryUrl = lookupPackageScope(parentUrl);
-  if (!packageDirectoryUrl) {
-    return undefined;
-  }
-  const packageJson = readPackageJson(packageDirectoryUrl);
-  if (!packageJson) {
-    return undefined;
-  }
-  if (packageJson.name !== packageName) {
-    return undefined;
-  }
-  const { exports: exports$1 } = packageJson;
-  if (!exports$1) {
-    const subpathResolution = applyLegacySubpathResolution(packageSubpath, {
-      ...resolutionContext,
-      packageDirectoryUrl,
-      packageJson,
-    });
-    if (subpathResolution && subpathResolution.type !== "subpath") {
-      return subpathResolution;
+const composeTwoMappings = (leftMappings, rightMappings) => {
+  const mappings = {};
+
+  Object.keys(leftMappings).forEach((leftSpecifier) => {
+    if (objectHasKey(rightMappings, leftSpecifier)) {
+      // will be overidden
+      return;
     }
-    return undefined;
-  }
-  return applyPackageExportsResolution(packageSubpath, {
-    ...resolutionContext,
-    packageDirectoryUrl,
-    packageJson,
+    const leftAddress = leftMappings[leftSpecifier];
+    const rightSpecifier = Object.keys(rightMappings).find((rightSpecifier) => {
+      return compareAddressAndSpecifier(leftAddress, rightSpecifier);
+    });
+    mappings[leftSpecifier] = rightSpecifier
+      ? rightMappings[rightSpecifier]
+      : leftAddress;
+  });
+
+  Object.keys(rightMappings).forEach((rightSpecifier) => {
+    mappings[rightSpecifier] = rightMappings[rightSpecifier];
   });
+
+  return mappings;
 };
 
-// https://github.com/nodejs/node/blob/0367b5c35ea0f98b323175a4aaa8e651af7a91e7/lib/internal/modules/esm/resolve.js#L642
-const applyPackageExportsResolution = (packageSubpath, resolutionContext) => {
-  if (packageSubpath === ".") {
-    const mainExport = applyMainExportResolution(resolutionContext);
-    if (!mainExport) {
-      throw createPackagePathNotExportedError(
-        packageSubpath,
-        resolutionContext,
-      );
+const objectHasKey = (object, key) =>
+  Object.prototype.hasOwnProperty.call(object, key);
+
+const compareAddressAndSpecifier = (address, specifier) => {
+  const addressUrl = resolveUrl(address, "file:///");
+  const specifierUrl = resolveUrl(specifier, "file:///");
+  return addressUrl === specifierUrl;
+};
+
+const composeTwoScopes = (leftScopes, rightScopes, imports) => {
+  const scopes = {};
+
+  Object.keys(leftScopes).forEach((leftScopeKey) => {
+    if (objectHasKey(rightScopes, leftScopeKey)) {
+      // will be merged
+      scopes[leftScopeKey] = leftScopes[leftScopeKey];
+      return;
     }
-    const resolved = applyPackageTargetResolution(mainExport, {
-      ...resolutionContext,
-      key: ".",
-    });
-    if (resolved) {
-      return resolved;
+    const topLevelSpecifier = Object.keys(imports).find(
+      (topLevelSpecifierCandidate) => {
+        return compareAddressAndSpecifier(
+          leftScopeKey,
+          topLevelSpecifierCandidate,
+        );
+      },
+    );
+    if (topLevelSpecifier) {
+      scopes[imports[topLevelSpecifier]] = leftScopes[leftScopeKey];
+    } else {
+      scopes[leftScopeKey] = leftScopes[leftScopeKey];
     }
-    throw createPackagePathNotExportedError(packageSubpath, resolutionContext);
-  }
-  const packageExportsInfo = readExports(resolutionContext);
-  if (
-    packageExportsInfo.type === "object" &&
-    packageExportsInfo.allKeysAreRelative
-  ) {
-    const resolved = applyPackageImportsExportsResolution(packageSubpath, {
-      ...resolutionContext,
-      isImport: false,
-    });
-    if (resolved) {
-      return resolved;
+  });
+
+  Object.keys(rightScopes).forEach((rightScopeKey) => {
+    if (objectHasKey(scopes, rightScopeKey)) {
+      scopes[rightScopeKey] = composeTwoMappings(
+        scopes[rightScopeKey],
+        rightScopes[rightScopeKey],
+      );
+    } else {
+      scopes[rightScopeKey] = {
+        ...rightScopes[rightScopeKey],
+      };
     }
-  }
-  throw createPackagePathNotExportedError(packageSubpath, resolutionContext);
+  });
+
+  return scopes;
 };
 
-const applyPackageImportsExportsResolution = (matchKey, resolutionContext) => {
-  const { packageJson, isImport } = resolutionContext;
-  const matchObject = isImport ? packageJson.imports : packageJson.exports;
+const sortImports = (imports) => {
+  const mappingsSorted = {};
 
-  if (!matchKey.includes("*") && matchObject.hasOwnProperty(matchKey)) {
-    const target = matchObject[matchKey];
-    return applyPackageTargetResolution(target, {
-      ...resolutionContext,
-      key: matchKey,
-      isImport,
+  Object.keys(imports)
+    .sort(compareLengthOrLocaleCompare)
+    .forEach((name) => {
+      mappingsSorted[name] = imports[name];
     });
-  }
-  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(target, {
-      ...resolutionContext,
-      key: matchKey,
-      subpath,
-      pattern: true,
-      isImport,
+
+  return mappingsSorted;
+};
+
+const sortScopes = (scopes) => {
+  const scopesSorted = {};
+
+  Object.keys(scopes)
+    .sort(compareLengthOrLocaleCompare)
+    .forEach((scopeSpecifier) => {
+      scopesSorted[scopeSpecifier] = sortImports(scopes[scopeSpecifier]);
     });
-  }
-  return null;
+
+  return scopesSorted;
 };
 
-const applyPackageTargetResolution = (target, resolutionContext) => {
-  const {
-    conditions,
-    packageDirectoryUrl,
-    packageJson,
-    key,
-    subpath = "",
-    pattern = false,
-    isImport = false,
-  } = resolutionContext;
+const compareLengthOrLocaleCompare = (a, b) => {
+  return b.length - a.length || a.localeCompare(b);
+};
 
-  if (typeof target === "string") {
-    if (pattern === false && subpath !== "" && !target.endsWith("/")) {
-      throw new Error("invalid module specifier");
-    }
-    if (target.startsWith("./")) {
-      const targetUrl = new URL(target, packageDirectoryUrl).href;
-      if (!targetUrl.startsWith(packageDirectoryUrl)) {
-        throw createInvalidPackageTargetError(
-          `target must be inside package`,
-          target,
-          resolutionContext,
-        );
-      }
-      return createResolutionResult({
-        type: isImport ? "field:imports" : "field:exports",
-        isMain: subpath === "" || subpath === ".",
-        packageDirectoryUrl,
-        packageJson,
-        url: pattern
-          ? targetUrl.replaceAll("*", subpath)
-          : new URL(subpath, targetUrl).href,
-      });
-    }
-    if (!isImport || target.startsWith("../") || isValidUrl(target)) {
-      throw createInvalidPackageTargetError(
-        `target must starst with "./"`,
-        target,
-        resolutionContext,
-      );
-    }
-    return applyPackageResolve(
-      pattern ? target.replaceAll("*", subpath) : `${target}${subpath}`,
-      {
-        ...resolutionContext,
-        parentUrl: packageDirectoryUrl,
-      },
-    );
-  }
-  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(targetValue, {
-          ...resolutionContext,
-          key: `${key}[${i}]`,
-          subpath,
-          pattern,
-          isImport,
-        });
-        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");
-      }
-      let matched;
-      if (key === "default") {
-        matched = true;
-      } else {
-        for (const conditionCandidate of conditions) {
-          if (conditionCandidate === key) {
-            matched = true;
-            break;
-          }
-          if (conditionCandidate.includes("*")) {
-            const conditionCandidateRegex = new RegExp(
-              `^${conditionCandidate.replace(/\*/g, "(.*)")}$`,
-            );
-            if (conditionCandidateRegex.test(key)) {
-              matched = true;
-              break;
-            }
-          }
-        }
-      }
-      if (matched) {
-        const targetValue = target[key];
-        const resolved = applyPackageTargetResolution(targetValue, {
-          ...resolutionContext,
-          key,
-          subpath,
-          pattern,
-          isImport,
-        });
-        if (resolved) {
-          return resolved;
-        }
-      }
-    }
-    return null;
-  }
-  throw createInvalidPackageTargetError(
-    `target must be a string, array, object or null`,
-    target,
-    resolutionContext,
-  );
-};
+const normalizeImportMap = (importMap, baseUrl) => {
+  assertImportMap(importMap);
 
-const readExports = ({ packageDirectoryUrl, packageJson }) => {
-  const packageExports = packageJson.exports;
-  if (Array.isArray(packageExports)) {
-    return {
-      type: "array",
-    };
-  }
-  if (packageExports === null) {
-    return {};
-  }
-  if (typeof packageExports === "object") {
-    const keys = Object.keys(packageExports);
-    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 directory url ---
-${packageDirectoryUrl}`,
-      );
-    }
-    return {
-      type: "object",
-      hasRelativeKey,
-      allKeysAreRelative: relativeKeys.length === keys.length,
-    };
-  }
-  if (typeof packageExports === "string") {
-    return { type: "string" };
+  if (!isStringOrUrl(baseUrl)) {
+    throw new TypeError(formulateBaseUrlMustBeStringOrUrl({ baseUrl }));
   }
-  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);
-  if (afterFirstSlash === "") {
-    return {
-      packageName,
-      packageSubpath: "/",
-    };
-  }
-  const packageSubpath = `./${afterFirstSlash}`;
+  const { imports, scopes } = importMap;
+
   return {
-    packageName,
-    packageSubpath,
+    imports: imports ? normalizeMappings(imports, baseUrl) : undefined,
+    scopes: scopes ? normalizeScopes(scopes, baseUrl) : undefined,
   };
 };
 
-const applyMainExportResolution = (resolutionContext) => {
-  const { packageJson } = resolutionContext;
-  const packageExportsInfo = readExports(resolutionContext);
-  if (
-    packageExportsInfo.type === "array" ||
-    packageExportsInfo.type === "string"
-  ) {
-    return packageJson.exports;
+const isStringOrUrl = (value) => {
+  if (typeof value === "string") {
+    return true;
   }
-  if (packageExportsInfo.type === "object") {
-    if (packageExportsInfo.hasRelativeKey) {
-      return packageJson.exports["."];
-    }
-    return packageJson.exports;
+
+  if (typeof URL === "function" && value instanceof URL) {
+    return true;
   }
-  return undefined;
+
+  return false;
 };
 
-const applyLegacySubpathResolution = (packageSubpath, resolutionContext) => {
-  const { packageDirectoryUrl, packageJson } = resolutionContext;
+const normalizeMappings = (mappings, baseUrl) => {
+  const mappingsNormalized = {};
 
-  if (packageSubpath === ".") {
-    return applyLegacyMainResolution(packageSubpath, resolutionContext);
-  }
-  const browserFieldResolution = applyBrowserFieldResolution(
-    packageSubpath,
-    resolutionContext,
-  );
-  if (browserFieldResolution) {
-    return browserFieldResolution;
-  }
-  return createResolutionResult({
-    type: "subpath",
-    isMain: packageSubpath === ".",
-    packageDirectoryUrl,
-    packageJson,
-    url: new URL(packageSubpath, packageDirectoryUrl).href,
-  });
-};
+  Object.keys(mappings).forEach((specifier) => {
+    const address = mappings[specifier];
 
-const applyLegacyMainResolution = (packageSubpath, resolutionContext) => {
-  const { conditions, packageDirectoryUrl, packageJson } = resolutionContext;
-  for (const condition of conditions) {
-    const conditionResolver = mainLegacyResolvers[condition];
-    if (!conditionResolver) {
-      continue;
-    }
-    const resolved = conditionResolver(resolutionContext);
-    if (resolved) {
-      return createResolutionResult({
-        type: resolved.type,
-        isMain: resolved.isMain,
-        packageDirectoryUrl,
-        packageJson,
-        url: new URL(resolved.path, packageDirectoryUrl).href,
-      });
-    }
-  }
-  return createResolutionResult({
-    type: "field:main", // the absence of "main" field
-    isMain: true,
-    packageDirectoryUrl,
-    packageJson,
-    url: new URL("index.js", packageDirectoryUrl).href,
-  });
-};
-const mainLegacyResolvers = {
-  import: ({ packageJson }) => {
-    if (typeof packageJson.module === "string") {
-      return { type: "field:module", isMain: true, path: packageJson.module };
-    }
-    if (typeof packageJson.jsnext === "string") {
-      return { type: "field:jsnext", isMain: true, path: packageJson.jsnext };
-    }
-    if (typeof packageJson.main === "string") {
-      return { type: "field:main", isMain: true, path: packageJson.main };
+    if (typeof address !== "string") {
+      console.warn(
+        formulateAddressMustBeAString({
+          address,
+          specifier,
+        }),
+      );
+      return;
     }
-    return null;
-  },
-  browser: ({ packageDirectoryUrl, packageJson }) => {
-    const browserMain = (() => {
-      if (typeof packageJson.browser === "string") {
-        return packageJson.browser;
-      }
-      if (
-        typeof packageJson.browser === "object" &&
-        packageJson.browser !== null
-      ) {
-        return packageJson.browser["."];
-      }
-      return "";
-    })();
 
-    if (!browserMain) {
-      if (typeof packageJson.module === "string") {
-        return {
-          type: "field:module",
-          isMain: true,
-          path: packageJson.module,
-        };
-      }
-      return null;
-    }
-    if (
-      typeof packageJson.module !== "string" ||
-      packageJson.module === browserMain
-    ) {
-      return {
-        type: "field:browser",
-        isMain: true,
-        path: browserMain,
-      };
-    }
-    const browserMainUrlObject = new URL(browserMain, packageDirectoryUrl);
-    const content = readFileSync(browserMainUrlObject, "utf-8");
-    if (
-      (/typeof exports\s*==/.test(content) &&
-        /typeof module\s*==/.test(content)) ||
-      /module\.exports\s*=/.test(content)
-    ) {
-      return {
-        type: "field:module",
-        isMain: true,
-        path: packageJson.module,
-      };
-    }
-    return {
-      type: "field:browser",
-      isMain: true,
-      path: browserMain,
-    };
-  },
-  node: ({ packageJson, conditions }) => {
-    if (conditions.includes("import") && !conditions.includes("require")) {
-      if (typeof packageJson.module === "string") {
-        return { type: "field:module", isMain: true, path: packageJson.module };
-      }
-      if (typeof packageJson.jsnext === "string") {
-        return { type: "field:jsnext", isMain: true, path: packageJson.jsnext };
-      }
-    }
-    if (typeof packageJson.main === "string") {
-      return { type: "field:main", isMain: true, path: packageJson.main };
+    const specifierResolved = resolveSpecifier(specifier, baseUrl) || specifier;
+
+    const addressUrl = tryUrlResolution(address, baseUrl);
+    if (addressUrl === null) {
+      console.warn(
+        formulateAdressResolutionFailed({
+          address,
+          baseUrl,
+          specifier,
+        }),
+      );
+      return;
     }
-    return null;
-  },
-};
-mainLegacyResolvers.require = mainLegacyResolvers.node;
 
-const comparePatternKeys = (keyA, keyB) => {
-  if (!keyA.endsWith("/") && !keyA.includes("*")) {
-    throw new Error("Invalid package configuration");
-  }
-  if (!keyB.endsWith("/") && !keyB.includes("*")) {
-    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;
-};
+    if (specifier.endsWith("/") && !addressUrl.endsWith("/")) {
+      console.warn(
+        formulateAddressUrlRequiresTrailingSlash({
+          address,
+          specifier,
+        }),
+      );
+      return;
+    }
+    mappingsNormalized[specifierResolved] = addressUrl;
+  });
 
-const resolvePackageSymlink = (packageDirectoryUrl) => {
-  const packageDirectoryPath = realpathSync(new URL(packageDirectoryUrl));
-  const packageDirectoryResolvedUrl = pathToFileURL(packageDirectoryPath).href;
-  return `${packageDirectoryResolvedUrl}/`;
+  return sortImports(mappingsNormalized);
 };
 
-const applyFileSystemMagicResolution = (
-  fileUrl,
-  { fileStat, magicDirectoryIndex, magicExtensions },
-) => {
-  const result = {
-    stat: null,
-    url: fileUrl,
-    magicExtension: "",
-    magicDirectoryIndex: false,
-    lastENOENTError: null,
-  };
-
-  if (fileStat === undefined) {
-    try {
-      fileStat = readEntryStatSync(new URL(fileUrl));
-    } catch (e) {
-      if (e.code === "ENOENT") {
-        result.lastENOENTError = e;
-        fileStat = null;
-      } else {
-        throw e;
-      }
-    }
-  }
+const normalizeScopes = (scopes, baseUrl) => {
+  const scopesNormalized = {};
 
-  if (fileStat && fileStat.isFile()) {
-    result.stat = fileStat;
-    result.url = fileUrl;
-    return result;
-  }
-  if (fileStat && fileStat.isDirectory()) {
-    if (magicDirectoryIndex) {
-      const indexFileSuffix = fileUrl.endsWith("/") ? "index" : "/index";
-      const indexFileUrl = `${fileUrl}${indexFileSuffix}`;
-      const subResult = applyFileSystemMagicResolution(indexFileUrl, {
-        magicDirectoryIndex: false,
-        magicExtensions,
-      });
-      return {
-        ...result,
-        ...subResult,
-        magicDirectoryIndex: true,
-      };
+  Object.keys(scopes).forEach((scopeSpecifier) => {
+    const scopeMappings = scopes[scopeSpecifier];
+    const scopeUrl = tryUrlResolution(scopeSpecifier, baseUrl);
+    if (scopeUrl === null) {
+      console.warn(
+        formulateScopeResolutionFailed({
+          scope: scopeSpecifier,
+          baseUrl,
+        }),
+      );
+      return;
     }
-    result.stat = fileStat;
-    result.url = fileUrl;
-    return result;
-  }
+    const scopeValueNormalized = normalizeMappings(scopeMappings, baseUrl);
+    scopesNormalized[scopeUrl] = scopeValueNormalized;
+  });
 
-  if (magicExtensions && magicExtensions.length) {
-    const parentUrl = new URL("./", fileUrl).href;
-    const urlFilename = urlToFilename(fileUrl);
-    for (const extensionToTry of magicExtensions) {
-      const urlCandidate = `${parentUrl}${urlFilename}${extensionToTry}`;
-      let stat;
-      try {
-        stat = readEntryStatSync(new URL(urlCandidate));
-      } catch (e) {
-        if (e.code === "ENOENT") {
-          stat = null;
-        } else {
-          throw e;
-        }
-      }
-      if (stat) {
-        result.stat = stat;
-        result.url = `${fileUrl}${extensionToTry}`;
-        result.magicExtension = extensionToTry;
-        return result;
-      }
-    }
-  }
-  // magic extension not found
-  return result;
+  return sortScopes(scopesNormalized);
 };
 
-const getExtensionsToTry = (magicExtensions, importer) => {
-  if (!magicExtensions) {
-    return [];
-  }
-  const extensionsSet = new Set();
-  magicExtensions.forEach((magicExtension) => {
-    if (magicExtension === "inherit") {
-      const importerExtension = urlToExtension(importer);
-      extensionsSet.add(importerExtension);
-    } else {
-      extensionsSet.add(magicExtension);
-    }
-  });
-  return Array.from(extensionsSet.values());
-};
+const formulateBaseUrlMustBeStringOrUrl = ({
+  baseUrl,
+}) => `baseUrl must be a string or an url.
+--- base url ---
+${baseUrl}`;
 
-const versionFromValue = (value) => {
-  if (typeof value === "number") {
-    return numberToVersion(value);
-  }
-  if (typeof value === "string") {
-    return stringToVersion(value);
+const formulateAddressMustBeAString = ({
+  specifier,
+  address,
+}) => `Address must be a string.
+--- address ---
+${address}
+--- specifier ---
+${specifier}`;
+
+const formulateAdressResolutionFailed = ({
+  address,
+  baseUrl,
+  specifier,
+}) => `Address url resolution failed.
+--- address ---
+${address}
+--- base url ---
+${baseUrl}
+--- specifier ---
+${specifier}`;
+
+const formulateAddressUrlRequiresTrailingSlash = ({
+  addressURL,
+  address,
+  specifier,
+}) => `Address must end with /.
+--- address url ---
+${addressURL}
+--- address ---
+${address}
+--- specifier ---
+${specifier}`;
+
+const formulateScopeResolutionFailed = ({
+  scope,
+  baseUrl,
+}) => `Scope url resolution failed.
+--- scope ---
+${scope}
+--- base url ---
+${baseUrl}`;
+
+const pathnameToExtension = (pathname) => {
+  const slashLastIndex = pathname.lastIndexOf("/");
+  if (slashLastIndex !== -1) {
+    pathname = pathname.slice(slashLastIndex + 1);
   }
-  throw new TypeError(`version must be a number or a string, got ${value}`);
-};
 
-const numberToVersion = (number) => {
-  return {
-    major: number,
-    minor: 0,
-    patch: 0,
-  };
+  const dotLastIndex = pathname.lastIndexOf(".");
+  if (dotLastIndex === -1) return "";
+  // if (dotLastIndex === pathname.length - 1) return ""
+  return pathname.slice(dotLastIndex);
 };
 
-const stringToVersion = (string) => {
-  if (string.indexOf(".") > -1) {
-    const parts = string.split(".");
-    return {
-      major: Number(parts[0]),
-      minor: parts[1] ? Number(parts[1]) : 0,
-      patch: parts[2] ? Number(parts[2]) : 0,
-    };
+const resolveImport = ({
+  specifier,
+  importer,
+  importMap,
+  defaultExtension = false,
+  createBareSpecifierError,
+  onImportMapping = () => {},
+}) => {
+  let url;
+  if (importMap) {
+    url = applyImportMap({
+      importMap,
+      specifier,
+      importer,
+      createBareSpecifierError,
+      onImportMapping,
+    });
+  } else {
+    url = resolveUrl(specifier, importer);
   }
 
-  if (isNaN(string)) {
-    return {
-      major: 0,
-      minor: 0,
-      patch: 0,
-    };
+  if (defaultExtension) {
+    url = applyDefaultExtension({ url, importer, defaultExtension });
   }
 
-  return {
-    major: Number(string),
-    minor: 0,
-    patch: 0,
-  };
+  return url;
 };
 
-const compareTwoVersions = (versionA, versionB) => {
-  const semanticVersionA = versionFromValue(versionA);
-  const semanticVersionB = versionFromValue(versionB);
-  const majorDiff = semanticVersionA.major - semanticVersionB.major;
-  if (majorDiff > 0) {
-    return majorDiff;
-  }
-  if (majorDiff < 0) {
-    return majorDiff;
-  }
-  const minorDiff = semanticVersionA.minor - semanticVersionB.minor;
-  if (minorDiff > 0) {
-    return minorDiff;
-  }
-  if (minorDiff < 0) {
-    return minorDiff;
+const applyDefaultExtension = ({ url, importer, defaultExtension }) => {
+  if (urlToPathname(url).endsWith("/")) {
+    return url;
   }
-  const patchDiff = semanticVersionA.patch - semanticVersionB.patch;
-  if (patchDiff > 0) {
-    return patchDiff;
+
+  if (typeof defaultExtension === "string") {
+    const extension = pathnameToExtension(url);
+    if (extension === "") {
+      return `${url}${defaultExtension}`;
+    }
+    return url;
   }
-  if (patchDiff < 0) {
-    return patchDiff;
+
+  if (defaultExtension === true) {
+    const extension = pathnameToExtension(url);
+    if (extension === "" && importer) {
+      const importerPathname = urlToPathname(importer);
+      const importerExtension = pathnameToExtension(importerPathname);
+      return `${url}${importerExtension}`;
+    }
   }
-  return 0;
-};
 
-const versionIsBelow = (versionSupposedBelow, versionSupposedAbove) => {
-  return compareTwoVersions(versionSupposedBelow, versionSupposedAbove) < 0;
+  return url;
 };
 
-const findHighestVersion = (...values) => {
-  if (values.length === 0) throw new Error(`missing argument`);
-  return values.reduce((highestVersion, value) => {
-    if (versionIsBelow(highestVersion, value)) {
-      return value;
+const isEscaped = (i, string) => {
+  let backslashBeforeCount = 0;
+  while (i--) {
+    const previousChar = string[i];
+    if (previousChar === "\\") {
+      backslashBeforeCount++;
     }
-    return highestVersion;
-  });
+    break;
+  }
+  const isEven = backslashBeforeCount % 2 === 0;
+  return !isEven;
 };
 
-const featuresCompatMap = {
-  script_type_module: {
-    edge: "16",
-    firefox: "60",
-    chrome: "61",
-    safari: "10.1",
-    opera: "48",
-    ios: "10.3",
-    android: "61",
-    samsung: "8.2",
-  },
-  document_current_script: {
-    edge: "12",
-    firefox: "4",
-    chrome: "29",
-    safari: "8",
-    opera: "16",
-    android: "4.4",
-    samsung: "4",
-  },
-  // https://caniuse.com/?search=import.meta
-  import_meta: {
-    android: "9",
-    chrome: "64",
-    edge: "79",
-    firefox: "62",
-    ios: "12",
-    opera: "51",
-    safari: "11.1",
-    samsung: "9.2",
-  },
-  import_meta_resolve: {
-    chrome: "107",
-    edge: "105",
-    firefox: "106",
-    node: "20.0.0",
-  },
-  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import#browser_compatibility
-  import_dynamic: {
-    android: "8",
-    chrome: "63",
-    edge: "79",
-    firefox: "67",
-    ios: "11.3",
-    opera: "50",
-    safari: "11.3",
-    samsung: "8.0",
-    node: "13.2",
+const JS_QUOTES = {
+  pickBest: (string, { canUseTemplateString, defaultQuote = DOUBLE } = {}) => {
+    // check default first, once tested do no re-test it
+    if (!string.includes(defaultQuote)) {
+      return defaultQuote;
+    }
+    if (defaultQuote !== DOUBLE && !string.includes(DOUBLE)) {
+      return DOUBLE;
+    }
+    if (defaultQuote !== SINGLE && !string.includes(SINGLE)) {
+      return SINGLE;
+    }
+    if (
+      canUseTemplateString &&
+      defaultQuote !== BACKTICK &&
+      !string.includes(BACKTICK)
+    ) {
+      return BACKTICK;
+    }
+    return defaultQuote;
   },
-  top_level_await: {
-    edge: "89",
-    chrome: "89",
-    firefox: "89",
-    opera: "75",
-    safari: "15",
-    samsung: "15",
-    ios: "15",
-    node: "14.8",
-  },
-  // https://caniuse.com/import-maps
-  importmap: {
-    edge: "89",
-    chrome: "89",
-    opera: "76",
-    samsung: "15",
-    firefox: "108",
-    safari: "16.4",
-  },
-  import_type_json: {
-    chrome: "123",
-    safari: "17.2",
-  },
-  import_type_css: {
-    chrome: "123",
-  },
-  import_type_text: {},
-  // https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleSheet#browser_compatibility
-  new_stylesheet: {
-    chrome: "73",
-    edge: "79",
-    opera: "53",
-    android: "73",
-  },
-  // https://caniuse.com/?search=worker
-  worker: {
-    ie: "10",
-    edge: "12",
-    firefox: "3.5",
-    chrome: "4",
-    opera: "11.5",
-    safari: "4",
-    ios: "5",
-    android: "4.4",
-  },
-  // https://developer.mozilla.org/en-US/docs/Web/API/Worker/Worker#browser_compatibility
-  worker_type_module: {
-    chrome: "80",
-    edge: "80",
-    opera: "67",
-    android: "80",
-  },
-  worker_importmap: {},
-  service_worker: {
-    edge: "17",
-    firefox: "44",
-    chrome: "40",
-    safari: "11.1",
-    opera: "27",
-    ios: "11.3",
-    android: "12.12",
-  },
-  service_worker_type_module: {
-    chrome: "80",
-    edge: "80",
-    opera: "67",
-    android: "80",
-  },
-  service_worker_importmap: {},
-  shared_worker: {
-    chrome: "4",
-    edge: "79",
-    firefox: "29",
-    opera: "10.6",
-  },
-  shared_worker_type_module: {
-    chrome: "80",
-    edge: "80",
-    opera: "67",
-  },
-  shared_worker_importmap: {},
-  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/globalThis#browser_compatibility
-  global_this: {
-    edge: "79",
-    firefox: "65",
-    chrome: "71",
-    safari: "12.1",
-    opera: "58",
-    ios: "12.2",
-    android: "94",
-    node: "12",
-  },
-  async_generator_function: {
-    chrome: "63",
-    opera: "50",
-    edge: "79",
-    firefox: "57",
-    safari: "12",
-    node: "10",
-    ios: "12",
-    samsung: "8",
-    electron: "3",
-  },
-  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals#browser_compatibility
-  template_literals: {
-    chrome: "41",
-    edge: "12",
-    firefox: "34",
-    opera: "28",
-    safari: "9",
-    ios: "9",
-    android: "4",
-    node: "4",
-  },
-  arrow_function: {
-    chrome: "47",
-    opera: "34",
-    edge: "13",
-    firefox: "45",
-    safari: "10",
-    node: "6",
-    ios: "10",
-    samsung: "5",
-    electron: "0.36",
-  },
-  const_bindings: {
-    chrome: "41",
-    opera: "28",
-    edge: "12",
-    firefox: "46",
-    safari: "10",
-    node: "4",
-    ie: "11",
-    ios: "10",
-    samsung: "3.4",
-    electron: "0.22",
+
+  escapeSpecialChars: (
+    string,
+    {
+      quote = "pickBest",
+      canUseTemplateString,
+      defaultQuote,
+      allowEscapeForVersioning = false,
+    },
+  ) => {
+    quote =
+      quote === "pickBest"
+        ? JS_QUOTES.pickBest(string, { canUseTemplateString, defaultQuote })
+        : quote;
+    const replacements = JS_QUOTE_REPLACEMENTS[quote];
+    let result = "";
+    let last = 0;
+    let i = 0;
+    while (i < string.length) {
+      const char = string[i];
+      i++;
+      if (isEscaped(i - 1, string)) continue;
+      const replacement = replacements[char];
+      if (replacement) {
+        if (
+          allowEscapeForVersioning &&
+          char === quote &&
+          string.slice(i, i + 6) === "+__v__"
+        ) {
+          let isVersioningConcatenation = false;
+          let j = i + 6; // start after the +
+          while (j < string.length) {
+            const lookAheadChar = string[j];
+            j++;
+            if (
+              lookAheadChar === "+" &&
+              string[j] === quote &&
+              !isEscaped(j - 1, string)
+            ) {
+              isVersioningConcatenation = true;
+              break;
+            }
+          }
+          if (isVersioningConcatenation) {
+            // it's a concatenation
+            // skip until the end of concatenation (the second +)
+            // and resume from there
+            i = j + 1;
+            continue;
+          }
+        }
+        if (last === i - 1) {
+          result += replacement;
+        } else {
+          result += `${string.slice(last, i - 1)}${replacement}`;
+        }
+        last = i;
+      }
+    }
+    if (last !== string.length) {
+      result += string.slice(last);
+    }
+    return `${quote}${result}${quote}`;
   },
-  object_properties_shorthand: {
-    chrome: "43",
-    opera: "30",
-    edge: "12",
-    firefox: "33",
-    safari: "9",
-    node: "4",
-    ios: "9",
-    samsung: "4",
-    electron: "0.28",
+};
+
+const DOUBLE = `"`;
+const SINGLE = `'`;
+const BACKTICK = "`";
+const lineEndingEscapes = {
+  "\n": "\\n",
+  "\r": "\\r",
+  "\u2028": "\\u2028",
+  "\u2029": "\\u2029",
+};
+const JS_QUOTE_REPLACEMENTS = {
+  [DOUBLE]: {
+    '"': '\\"',
+    ...lineEndingEscapes,
   },
-  reserved_words: {
-    chrome: "13",
-    opera: "10.50",
-    edge: "12",
-    firefox: "2",
-    safari: "3.1",
-    node: "0.10",
-    ie: "9",
-    android: "4.4",
-    ios: "6",
-    phantom: "2",
-    samsung: "1",
-    electron: "0.20",
+  [SINGLE]: {
+    "'": "\\'",
+    ...lineEndingEscapes,
   },
-  symbols: {
-    chrome: "38",
-    opera: "25",
-    edge: "12",
-    firefox: "36",
-    safari: "9",
-    ios: "9",
-    samsung: "4",
-    node: "0.12",
+  [BACKTICK]: {
+    "`": "\\`",
+    "$": "\\$",
   },
 };
 
-const RUNTIME_COMPAT = {
-  featuresCompatMap,
-
-  add: (originalRuntimeCompat, feature) => {
-    const featureCompat = getFeatureCompat(feature);
-    const runtimeCompat = {
-      ...originalRuntimeCompat,
-    };
-    Object.keys(originalRuntimeCompat).forEach((runtimeName) => {
-      const secondVersion = featureCompat[runtimeName]; // the version supported by the feature
-      if (secondVersion) {
-        const firstVersion = originalRuntimeCompat[runtimeName];
-        runtimeCompat[runtimeName] = findHighestVersion(
-          firstVersion,
-          secondVersion,
-        );
+// https://nodejs.org/api/packages.html#resolving-user-conditions
+const readCustomConditionsFromProcessArgs = () => {
+  if (process.env.IGNORE_PACKAGE_CONDITIONS) {
+    return [];
+  }
+  const packageConditions = [];
+  for (const arg of process.execArgv) {
+    if (arg.includes("-C=")) {
+      const packageCondition = arg.slice(0, "-C=".length);
+      packageConditions.push(packageCondition);
+    }
+    if (arg.includes("--conditions=")) {
+      const packageCondition = arg.slice("--conditions=".length);
+      packageConditions.push(packageCondition);
+    }
+  }
+  return packageConditions;
+};
+
+const asDirectoryUrl = (url) => {
+  const { pathname } = new URL(url);
+  if (pathname.endsWith("/")) {
+    return url;
+  }
+  return new URL("./", url).href;
+};
+
+const getParentUrl = (url) => {
+  if (url.startsWith("file://")) {
+    // With node.js new URL('../', 'file:///C:/').href
+    // returns "file:///C:/" instead of "file:///"
+    const resource = url.slice("file://".length);
+    const slashLastIndex = resource.lastIndexOf("/");
+    if (slashLastIndex === -1) {
+      return url;
+    }
+    const lastCharIndex = resource.length - 1;
+    if (slashLastIndex === lastCharIndex) {
+      const slashBeforeLastIndex = resource.lastIndexOf(
+        "/",
+        slashLastIndex - 1,
+      );
+      if (slashBeforeLastIndex === -1) {
+        return url;
       }
-    });
-    return runtimeCompat;
-  },
+      return `file://${resource.slice(0, slashBeforeLastIndex + 1)}`;
+    }
 
-  isSupported: (
-    runtimeCompat,
-    feature,
-    featureCompat = getFeatureCompat(feature),
-  ) => {
-    const runtimeNames = Object.keys(runtimeCompat);
-    const runtimeWithoutCompat = runtimeNames.find((runtimeName) => {
-      const runtimeVersion = runtimeCompat[runtimeName];
-      const runtimeVersionCompatible = featureCompat[runtimeName] || "Infinity";
-      const highestVersion = findHighestVersion(
-        runtimeVersion,
-        runtimeVersionCompatible,
+    return `file://${resource.slice(0, slashLastIndex + 1)}`;
+  }
+  return new URL(url.endsWith("/") ? "../" : "./", url).href;
+};
+
+const isValidUrl = (url) => {
+  try {
+    // eslint-disable-next-line no-new
+    new URL(url);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+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;
+};
+
+const urlToExtension = (url) => {
+  const filename = urlToFilename(url);
+  const dotLastIndex = filename.lastIndexOf(".");
+  if (dotLastIndex === -1) return "";
+  // if (dotLastIndex === pathname.length - 1) return ""
+  const extension = filename.slice(dotLastIndex);
+  return extension;
+};
+
+const defaultLookupPackageScope = (url) => {
+  let scopeUrl = asDirectoryUrl(url);
+  while (scopeUrl !== "file:///") {
+    if (scopeUrl.endsWith("node_modules/")) {
+      return null;
+    }
+    const packageJsonUrlObject = new URL("package.json", scopeUrl);
+    if (existsSync(packageJsonUrlObject)) {
+      return scopeUrl;
+    }
+    scopeUrl = getParentUrl(scopeUrl);
+  }
+  return null;
+};
+
+const defaultReadPackageJson = (packageUrl) => {
+  const packageJsonFileUrl = new URL("./package.json", packageUrl);
+  let packageJsonFileContentBuffer;
+  try {
+    packageJsonFileContentBuffer = readFileSync(packageJsonFileUrl, "utf8");
+  } catch (e) {
+    if (e.code === "ENOENT") {
+      return null;
+    }
+    throw e;
+  }
+  const packageJsonFileContentString = String(packageJsonFileContentBuffer);
+  try {
+    const packageJsonFileContentObject = JSON.parse(
+      packageJsonFileContentString,
+    );
+    return packageJsonFileContentObject;
+  } catch {
+    throw new Error(`Invalid package configuration at ${packageJsonFileUrl}`);
+  }
+};
+
+// https://github.com/nodejs/node/blob/0367b5c35ea0f98b323175a4aaa8e651af7a91e7/tools/node_modules/eslint/node_modules/%40babel/core/lib/vendor/import-meta-resolve.js#L2473
+
+const createInvalidModuleSpecifierError = (
+  reason,
+  specifier,
+  { parentUrl },
+) => {
+  const error = new Error(
+    `Invalid module "${specifier}" ${reason} imported from ${fileURLToPath(
+      parentUrl,
+    )}`,
+  );
+  error.code = "INVALID_MODULE_SPECIFIER";
+  return error;
+};
+
+const createInvalidPackageTargetError = (
+  reason,
+  target,
+  { parentUrl, packageDirectoryUrl, key, isImport },
+) => {
+  let message;
+  if (key === ".") {
+    message = `Invalid "exports" main target defined in ${fileURLToPath(
+      packageDirectoryUrl,
+    )}package.json imported from ${fileURLToPath(parentUrl)}; ${reason}`;
+  } else {
+    message = `Invalid "${
+      isImport ? "imports" : "exports"
+    }" target ${JSON.stringify(target)} defined for "${key}" in ${fileURLToPath(
+      packageDirectoryUrl,
+    )}package.json imported from ${fileURLToPath(parentUrl)}; ${reason}`;
+  }
+  const error = new Error(message);
+  error.code = "INVALID_PACKAGE_TARGET";
+  return error;
+};
+
+const createPackagePathNotExportedError = (
+  subpath,
+  { parentUrl, packageDirectoryUrl },
+) => {
+  let message;
+  if (subpath === ".") {
+    message = `No "exports" main defined in ${fileURLToPath(
+      packageDirectoryUrl,
+    )}package.json imported from ${fileURLToPath(parentUrl)}`;
+  } else {
+    message = `Package subpath "${subpath}" is not defined by "exports" in ${fileURLToPath(
+      packageDirectoryUrl,
+    )}package.json imported from ${fileURLToPath(parentUrl)}`;
+  }
+  const error = new Error(message);
+  error.code = "PACKAGE_PATH_NOT_EXPORTED";
+  return error;
+};
+
+const createModuleNotFoundError = (specifier, { parentUrl }) => {
+  const error = new Error(
+    `Cannot find "${specifier}" imported from ${fileURLToPath(parentUrl)}`,
+  );
+  error.code = "MODULE_NOT_FOUND";
+  return error;
+};
+
+const createPackageImportNotDefinedError = (
+  specifier,
+  { parentUrl, packageDirectoryUrl },
+) => {
+  const error = new Error(
+    `Package import specifier "${specifier}" is not defined in ${fileURLToPath(
+      packageDirectoryUrl,
+    )}package.json imported from ${fileURLToPath(parentUrl)}`,
+  );
+  error.code = "PACKAGE_IMPORT_NOT_DEFINED";
+  return error;
+};
+
+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",
+  "diagnostics_channel",
+  "dgram",
+  "dns",
+  "domain",
+  "events",
+  "freelist",
+  "fs",
+  "fsevents",
+  "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",
+  "sqlite",
+  "_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",
+];
+
+/*
+ * 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
+ */
+
+const applyNodeEsmResolution = ({
+  specifier,
+  parentUrl,
+  conditions = [...readCustomConditionsFromProcessArgs(), "node", "import"],
+  lookupPackageScope = defaultLookupPackageScope,
+  readPackageJson = defaultReadPackageJson,
+  preservesSymlink = false,
+}) => {
+  const resolution = applyPackageSpecifierResolution(specifier, {
+    parentUrl: String(parentUrl),
+    conditions,
+    lookupPackageScope,
+    readPackageJson,
+    preservesSymlink,
+  });
+  const { url } = resolution;
+  if (url.startsWith("file:")) {
+    if (url.includes("%2F") || url.includes("%5C")) {
+      throw createInvalidModuleSpecifierError(
+        `must not include encoded "/" or "\\" characters`,
+        specifier,
+        {
+          parentUrl,
+        },
       );
-      return highestVersion !== runtimeVersion;
-    });
-    return !runtimeWithoutCompat;
-  },
-};
-
-const getFeatureCompat = (feature) => {
-  if (typeof feature === "string") {
-    const compat = featuresCompatMap[feature];
-    if (!compat) {
-      throw new Error(`"${feature}" feature is unknown`);
     }
-    return compat;
-  }
-  if (typeof feature !== "object") {
-    throw new TypeError(
-      `feature must be a string or an object, got ${feature}`,
-    );
+    return resolution;
   }
-  return feature;
+  return resolution;
 };
 
-const isSupportedAlgorithm = (algo) => {
-  return SUPPORTED_ALGORITHMS.includes(algo);
+const createResolutionResult = (data) => {
+  return data;
 };
 
-// https://www.w3.org/TR/SRI/#priority
-const getPrioritizedHashFunction = (firstAlgo, secondAlgo) => {
-  const firstIndex = SUPPORTED_ALGORITHMS.indexOf(firstAlgo);
-  const secondIndex = SUPPORTED_ALGORITHMS.indexOf(secondAlgo);
-  if (firstIndex === secondIndex) {
-    return "";
+const applyPackageSpecifierResolution = (specifier, resolutionContext) => {
+  const { parentUrl } = resolutionContext;
+  // relative specifier
+  if (
+    specifier[0] === "/" ||
+    specifier.startsWith("./") ||
+    specifier.startsWith("../")
+  ) {
+    if (specifier[0] !== "/") {
+      const browserFieldResolution = applyBrowserFieldResolution(
+        specifier,
+        resolutionContext,
+      );
+      if (browserFieldResolution) {
+        return browserFieldResolution;
+      }
+    }
+    return createResolutionResult({
+      type: "relative_specifier",
+      url: new URL(specifier, parentUrl).href,
+    });
   }
-  if (firstIndex < secondIndex) {
-    return secondAlgo;
+  if (specifier[0] === "#") {
+    return applyPackageImportsResolution(specifier, resolutionContext);
   }
-  return firstAlgo;
-};
-
-const applyAlgoToRepresentationData = (algo, data) => {
-  const base64Value = crypto.createHash(algo).update(data).digest("base64");
-  return base64Value;
-};
-
-// keep this ordered by collision resistance as it is also used by "getPrioritizedHashFunction"
-const SUPPORTED_ALGORITHMS = ["sha256", "sha384", "sha512"];
-
-// see https://w3c.github.io/webappsec-subresource-integrity/#parse-metadata
-const parseIntegrity = (string) => {
-  const integrityMetadata = {};
-  string
-    .trim()
-    .split(/\s+/)
-    .forEach((token) => {
-      const { isValid, algo, base64Value, optionExpression } =
-        parseAsHashWithOptions(token);
-      if (!isValid) {
-        return;
-      }
-      if (!isSupportedAlgorithm(algo)) {
-        return;
-      }
-      const metadataList = integrityMetadata[algo];
-      const metadata = { base64Value, optionExpression };
-      integrityMetadata[algo] = metadataList
-        ? [...metadataList, metadata]
-        : [metadata];
+  try {
+    const urlObject = new URL(specifier);
+    if (specifier.startsWith("node:")) {
+      return createResolutionResult({
+        type: "node_builtin_specifier",
+        url: specifier,
+      });
+    }
+    return createResolutionResult({
+      type: "absolute_specifier",
+      url: urlObject.href,
     });
-  return integrityMetadata;
+  } catch {
+    // bare specifier
+    const browserFieldResolution = applyBrowserFieldResolution(
+      specifier,
+      resolutionContext,
+    );
+    if (browserFieldResolution) {
+      return browserFieldResolution;
+    }
+    const packageResolution = applyPackageResolve(specifier, resolutionContext);
+    const search = new URL(specifier, "file:///").search;
+    if (search && !new URL(packageResolution.url).search) {
+      packageResolution.url = `${packageResolution.url}${search}`;
+    }
+    return packageResolution;
+  }
 };
 
-// see https://w3c.github.io/webappsec-subresource-integrity/#the-integrity-attribute
-const parseAsHashWithOptions = (token) => {
-  const dashIndex = token.indexOf("-");
-  if (dashIndex === -1) {
-    return { isValid: false };
+const applyBrowserFieldResolution = (specifier, resolutionContext) => {
+  const { parentUrl, conditions, lookupPackageScope, readPackageJson } =
+    resolutionContext;
+  const browserCondition = conditions.includes("browser");
+  if (!browserCondition) {
+    return null;
   }
-  const beforeDash = token.slice(0, dashIndex);
-  const afterDash = token.slice(dashIndex + 1);
-  const questionIndex = afterDash.indexOf("?");
-  const algo = beforeDash;
-  if (questionIndex === -1) {
-    const base64Value = afterDash;
-    const isValid = BASE64_REGEX.test(afterDash);
-    return { isValid, algo, base64Value };
+  const packageDirectoryUrl = lookupPackageScope(parentUrl);
+  if (!packageDirectoryUrl) {
+    return null;
   }
-  const base64Value = afterDash.slice(0, questionIndex);
-  const optionExpression = afterDash.slice(questionIndex + 1);
-  const isValid =
-    BASE64_REGEX.test(afterDash) && VCHAR_REGEX.test(optionExpression);
-  return { isValid, algo, base64Value, optionExpression };
-};
-
-const BASE64_REGEX = /^[A-Za-z0-9+/=]+$/;
-const VCHAR_REGEX = /^[\x21-\x7E]+$/;
-
-// https://www.w3.org/TR/SRI/#does-response-match-metadatalist
-const validateResponseIntegrity = (
-  { url, type, dataRepresentation },
-  integrity,
-) => {
-  if (!isResponseEligibleForIntegrityValidation({ type })) {
-    return false;
+  const packageJson = readPackageJson(packageDirectoryUrl);
+  if (!packageJson) {
+    return null;
   }
-  const integrityMetadata = parseIntegrity(integrity);
-  const algos = Object.keys(integrityMetadata);
-  if (algos.length === 0) {
-    return true;
+  const { browser } = packageJson;
+  if (!browser) {
+    return null;
   }
-  let strongestAlgo = algos[0];
-  algos.slice(1).forEach((algoCandidate) => {
-    strongestAlgo =
-      getPrioritizedHashFunction(strongestAlgo, algoCandidate) || strongestAlgo;
-  });
-  const metadataList = integrityMetadata[strongestAlgo];
-  const actualBase64Value = applyAlgoToRepresentationData(
-    strongestAlgo,
-    dataRepresentation,
-  );
-  const acceptedBase64Values = metadataList.map(
-    (metadata) => metadata.base64Value,
-  );
-  const someIsMatching = acceptedBase64Values.includes(actualBase64Value);
-  if (someIsMatching) {
-    return true;
+  if (typeof browser !== "object") {
+    return null;
   }
-  const error = new Error(
-    `Integrity validation failed for resource "${url}". The integrity found for this resource is "${strongestAlgo}-${actualBase64Value}"`,
-  );
-  error.code = "EINTEGRITY";
-  error.algorithm = strongestAlgo;
-  error.found = actualBase64Value;
-  throw error;
+  let url;
+  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, packageDirectoryUrl).href;
+    } else if (browserMapping === false) {
+      url = `file:///@ignore/${specifierUrl.slice("file:///")}`;
+    }
+  } else {
+    const browserMapping = browser[specifier];
+    if (typeof browserMapping === "string") {
+      url = new URL(browserMapping, packageDirectoryUrl).href;
+    } else if (browserMapping === false) {
+      url = `file:///@ignore/${specifier}`;
+    }
+  }
+  if (url) {
+    return createResolutionResult({
+      type: "field:browser",
+      isMain: true,
+      packageDirectoryUrl,
+      packageJson,
+      url,
+    });
+  }
+  return null;
 };
 
-// https://www.w3.org/TR/SRI/#is-response-eligible-for-integrity-validation
-const isResponseEligibleForIntegrityValidation = (response) => {
-  return ["basic", "cors", "default"].includes(response.type);
+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 packageDirectoryUrl = lookupPackageScope(parentUrl);
+  if (packageDirectoryUrl !== null) {
+    const packageJson = readPackageJson(packageDirectoryUrl);
+    const { imports } = packageJson;
+    if (imports !== null && typeof imports === "object") {
+      const resolved = applyPackageImportsExportsResolution(internalSpecifier, {
+        ...resolutionContext,
+        packageDirectoryUrl,
+        packageJson,
+        isImport: true,
+      });
+      if (resolved) {
+        return resolved;
+      }
+    }
+  }
+  throw createPackageImportNotDefinedError(internalSpecifier, {
+    ...resolutionContext,
+    packageDirectoryUrl,
+  });
 };
 
-const assertImportMap = (value) => {
-  if (value === null) {
-    throw new TypeError(`an importMap must be an object, got null`);
+const applyPackageResolve = (packageSpecifier, resolutionContext) => {
+  const { parentUrl, conditions, readPackageJson, preservesSymlink, isImport } =
+    resolutionContext;
+  if (packageSpecifier === "") {
+    throw new Error("invalid module specifier");
   }
-
-  const type = typeof value;
-  if (type !== "object") {
-    throw new TypeError(`an importMap must be an object, received ${value}`);
+  if (
+    conditions.includes("node") &&
+    isSpecifierForNodeBuiltin(packageSpecifier)
+  ) {
+    return createResolutionResult({
+      type: "node_builtin_specifier",
+      url: `node:${packageSpecifier}`,
+    });
   }
-
-  if (Array.isArray(value)) {
-    throw new TypeError(
-      `an importMap must be an object, received array ${value}`,
+  let { packageName, packageSubpath } = parsePackageSpecifier(packageSpecifier);
+  if (
+    packageName[0] === "." ||
+    packageName.includes("\\") ||
+    packageName.includes("%")
+  ) {
+    throw createInvalidModuleSpecifierError(
+      `is not a valid package name`,
+      packageName,
+      resolutionContext,
     );
   }
-};
-
-// duplicated from @jsenv/log to avoid the dependency
-const createDetailedMessage = (message, details = {}) => {
-  let string = `${message}`;
-
-  Object.keys(details).forEach((key) => {
-    const value = details[key];
-    string += `
-    --- ${key} ---
-    ${
-      Array.isArray(value)
-        ? value.join(`
-    `)
-        : value
-    }`;
+  if (isImport && packageSubpath.endsWith("/")) {
+    throw new Error("invalid module specifier");
+  }
+  const questionCharIndex = packageName.indexOf("?");
+  if (questionCharIndex > -1) {
+    packageName = packageName.slice(0, questionCharIndex);
+  }
+  const selfResolution = applyPackageSelfResolution(packageSubpath, {
+    ...resolutionContext,
+    packageName,
   });
-
-  return string;
-};
-
-const hasScheme = (string) => {
-  return /^[a-zA-Z]{2,}:/.test(string);
-};
-
-const pathnameToParentPathname = (pathname) => {
-  const slashLastIndex = pathname.lastIndexOf("/");
-  if (slashLastIndex === -1) {
-    return "/";
+  if (selfResolution) {
+    return selfResolution;
   }
-
-  return pathname.slice(0, slashLastIndex + 1);
-};
-
-const urlToScheme = (urlString) => {
-  const colonIndex = urlString.indexOf(":");
-  if (colonIndex === -1) return "";
-  return urlString.slice(0, colonIndex);
+  let currentUrl = parentUrl;
+  while (currentUrl !== "file:///") {
+    const packageDirectoryFacadeUrl = new URL(
+      `node_modules/${packageName}/`,
+      currentUrl,
+    ).href;
+    if (!existsSync(new URL(packageDirectoryFacadeUrl))) {
+      currentUrl = getParentUrl(currentUrl);
+      continue;
+    }
+    const packageDirectoryUrl = preservesSymlink
+      ? packageDirectoryFacadeUrl
+      : resolvePackageSymlink(packageDirectoryFacadeUrl);
+    const packageJson = readPackageJson(packageDirectoryUrl);
+    if (packageJson !== null) {
+      const { exports: exports$1 } = packageJson;
+      if (exports$1 !== null && exports$1 !== undefined) {
+        return applyPackageExportsResolution(packageSubpath, {
+          ...resolutionContext,
+          packageDirectoryUrl,
+          packageJson,
+          exports: exports$1,
+        });
+      }
+    }
+    return applyLegacySubpathResolution(packageSubpath, {
+      ...resolutionContext,
+      packageDirectoryUrl,
+      packageJson,
+    });
+  }
+  throw createModuleNotFoundError(packageName, resolutionContext);
 };
 
-const urlToOrigin = (urlString) => {
-  const scheme = urlToScheme(urlString);
-
-  if (scheme === "file") {
-    return "file://";
+const applyPackageSelfResolution = (packageSubpath, resolutionContext) => {
+  const { parentUrl, packageName, lookupPackageScope, readPackageJson } =
+    resolutionContext;
+  const packageDirectoryUrl = lookupPackageScope(parentUrl);
+  if (!packageDirectoryUrl) {
+    return undefined;
   }
-
-  if (scheme === "http" || scheme === "https") {
-    const secondProtocolSlashIndex = scheme.length + "://".length;
-    const pathnameSlashIndex = urlString.indexOf("/", secondProtocolSlashIndex);
-
-    if (pathnameSlashIndex === -1) return urlString;
-    return urlString.slice(0, pathnameSlashIndex);
+  const packageJson = readPackageJson(packageDirectoryUrl);
+  if (!packageJson) {
+    return undefined;
   }
-
-  return urlString.slice(0, scheme.length + 1);
-};
-
-const urlToPathname = (urlString) => {
-  return ressourceToPathname(urlToRessource(urlString));
+  if (packageJson.name !== packageName) {
+    return undefined;
+  }
+  const { exports: exports$1 } = packageJson;
+  if (!exports$1) {
+    const subpathResolution = applyLegacySubpathResolution(packageSubpath, {
+      ...resolutionContext,
+      packageDirectoryUrl,
+      packageJson,
+    });
+    if (subpathResolution && subpathResolution.type !== "subpath") {
+      return subpathResolution;
+    }
+    return undefined;
+  }
+  return applyPackageExportsResolution(packageSubpath, {
+    ...resolutionContext,
+    packageDirectoryUrl,
+    packageJson,
+  });
 };
 
-const urlToRessource = (urlString) => {
-  const scheme = urlToScheme(urlString);
-
-  if (scheme === "file") {
-    return urlString.slice("file://".length);
+// https://github.com/nodejs/node/blob/0367b5c35ea0f98b323175a4aaa8e651af7a91e7/lib/internal/modules/esm/resolve.js#L642
+const applyPackageExportsResolution = (packageSubpath, resolutionContext) => {
+  if (packageSubpath === ".") {
+    const mainExport = applyMainExportResolution(resolutionContext);
+    if (!mainExport) {
+      throw createPackagePathNotExportedError(
+        packageSubpath,
+        resolutionContext,
+      );
+    }
+    const resolved = applyPackageTargetResolution(mainExport, {
+      ...resolutionContext,
+      key: ".",
+    });
+    if (resolved) {
+      return resolved;
+    }
+    throw createPackagePathNotExportedError(packageSubpath, resolutionContext);
   }
-
-  if (scheme === "https" || scheme === "http") {
-    // remove origin
-    const afterProtocol = urlString.slice(scheme.length + "://".length);
-    const pathnameSlashIndex = afterProtocol.indexOf("/", "://".length);
-    return afterProtocol.slice(pathnameSlashIndex);
+  const packageExportsInfo = readExports(resolutionContext);
+  if (
+    packageExportsInfo.type === "object" &&
+    packageExportsInfo.allKeysAreRelative
+  ) {
+    const resolved = applyPackageImportsExportsResolution(packageSubpath, {
+      ...resolutionContext,
+      isImport: false,
+    });
+    if (resolved) {
+      return resolved;
+    }
   }
-
-  return urlString.slice(scheme.length + 1);
+  throw createPackagePathNotExportedError(packageSubpath, resolutionContext);
 };
 
-const ressourceToPathname = (ressource) => {
-  const searchSeparatorIndex = ressource.indexOf("?");
-  return searchSeparatorIndex === -1
-    ? ressource
-    : ressource.slice(0, searchSeparatorIndex);
-};
+const applyPackageImportsExportsResolution = (matchKey, resolutionContext) => {
+  const { packageJson, isImport } = resolutionContext;
+  const matchObject = isImport ? packageJson.imports : packageJson.exports;
 
-// could be useful: https://url.spec.whatwg.org/#url-miscellaneous
+  if (!matchKey.includes("*") && matchObject.hasOwnProperty(matchKey)) {
+    const target = matchObject[matchKey];
+    return applyPackageTargetResolution(target, {
+      ...resolutionContext,
+      key: matchKey,
+      isImport,
+    });
+  }
+  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(target, {
+      ...resolutionContext,
+      key: matchKey,
+      subpath,
+      pattern: true,
+      isImport,
+    });
+  }
+  return null;
+};
 
+const applyPackageTargetResolution = (target, resolutionContext) => {
+  const {
+    conditions,
+    packageDirectoryUrl,
+    packageJson,
+    key,
+    subpath = "",
+    pattern = false,
+    isImport = false,
+  } = resolutionContext;
 
-const resolveUrl = (specifier, baseUrl) => {
-  if (baseUrl) {
-    if (typeof baseUrl !== "string") {
-      throw new TypeError(writeBaseUrlMustBeAString({ baseUrl, specifier }));
+  if (typeof target === "string") {
+    if (pattern === false && subpath !== "" && !target.endsWith("/")) {
+      throw new Error("invalid module specifier");
     }
-    if (!hasScheme(baseUrl)) {
-      throw new Error(writeBaseUrlMustBeAbsolute({ baseUrl, specifier }));
+    if (target.startsWith("./")) {
+      const targetUrl = new URL(target, packageDirectoryUrl).href;
+      if (!targetUrl.startsWith(packageDirectoryUrl)) {
+        throw createInvalidPackageTargetError(
+          `target must be inside package`,
+          target,
+          resolutionContext,
+        );
+      }
+      return createResolutionResult({
+        type: isImport ? "field:imports" : "field:exports",
+        isMain: subpath === "" || subpath === ".",
+        packageDirectoryUrl,
+        packageJson,
+        url: pattern
+          ? targetUrl.replaceAll("*", subpath)
+          : new URL(subpath, targetUrl).href,
+      });
     }
+    if (!isImport || target.startsWith("../") || isValidUrl(target)) {
+      throw createInvalidPackageTargetError(
+        `target must starst with "./"`,
+        target,
+        resolutionContext,
+      );
+    }
+    return applyPackageResolve(
+      pattern ? target.replaceAll("*", subpath) : `${target}${subpath}`,
+      {
+        ...resolutionContext,
+        parentUrl: packageDirectoryUrl,
+      },
+    );
   }
-
-  if (hasScheme(specifier)) {
-    return specifier;
-  }
-
-  if (!baseUrl) {
-    throw new Error(writeBaseUrlRequired({ baseUrl, specifier }));
+  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(targetValue, {
+          ...resolutionContext,
+          key: `${key}[${i}]`,
+          subpath,
+          pattern,
+          isImport,
+        });
+        if (resolved) {
+          return resolved;
+        }
+        lastResult = resolved;
+      } catch (e) {
+        if (e.code === "INVALID_PACKAGE_TARGET") {
+          continue;
+        }
+        lastResult = e;
+      }
+    }
+    if (lastResult) {
+      throw lastResult;
+    }
+    return null;
   }
-
-  // scheme relative
-  if (specifier.slice(0, 2) === "//") {
-    return `${urlToScheme(baseUrl)}:${specifier}`;
+  if (target === null) {
+    return null;
   }
-
-  // origin relative
-  if (specifier[0] === "/") {
-    return `${urlToOrigin(baseUrl)}${specifier}`;
+  if (typeof target === "object") {
+    const keys = Object.keys(target);
+    for (const key of keys) {
+      if (Number.isInteger(key)) {
+        throw new Error("Invalid package configuration");
+      }
+      let matched;
+      if (key === "default") {
+        matched = true;
+      } else {
+        for (const conditionCandidate of conditions) {
+          if (conditionCandidate === key) {
+            matched = true;
+            break;
+          }
+          if (conditionCandidate.includes("*")) {
+            const conditionCandidateRegex = new RegExp(
+              `^${conditionCandidate.replace(/\*/g, "(.*)")}$`,
+            );
+            if (conditionCandidateRegex.test(key)) {
+              matched = true;
+              break;
+            }
+          }
+        }
+      }
+      if (matched) {
+        const targetValue = target[key];
+        const resolved = applyPackageTargetResolution(targetValue, {
+          ...resolutionContext,
+          key,
+          subpath,
+          pattern,
+          isImport,
+        });
+        if (resolved) {
+          return resolved;
+        }
+      }
+    }
+    return null;
   }
+  throw createInvalidPackageTargetError(
+    `target must be a string, array, object or null`,
+    target,
+    resolutionContext,
+  );
+};
 
-  const baseOrigin = urlToOrigin(baseUrl);
-  const basePathname = urlToPathname(baseUrl);
-
-  if (specifier === ".") {
-    const baseDirectoryPathname = pathnameToParentPathname(basePathname);
-    return `${baseOrigin}${baseDirectoryPathname}`;
+const readExports = ({ packageDirectoryUrl, packageJson }) => {
+  const packageExports = packageJson.exports;
+  if (Array.isArray(packageExports)) {
+    return {
+      type: "array",
+    };
   }
-
-  // pathname relative inside
-  if (specifier.slice(0, 2) === "./") {
-    const baseDirectoryPathname = pathnameToParentPathname(basePathname);
-    return `${baseOrigin}${baseDirectoryPathname}${specifier.slice(2)}`;
+  if (packageExports === null) {
+    return {};
   }
-
-  // pathname relative outside
-  if (specifier.slice(0, 3) === "../") {
-    let unresolvedPathname = specifier;
-    const importerFolders = basePathname.split("/");
-    importerFolders.pop();
-
-    while (unresolvedPathname.slice(0, 3) === "../") {
-      unresolvedPathname = unresolvedPathname.slice(3);
-      // when there is no folder left to resolved
-      // we just ignore '../'
-      if (importerFolders.length) {
-        importerFolders.pop();
+  if (typeof packageExports === "object") {
+    const keys = Object.keys(packageExports);
+    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 directory url ---
+${packageDirectoryUrl}`,
+      );
     }
-
-    const resolvedPathname = `${importerFolders.join(
-      "/",
-    )}/${unresolvedPathname}`;
-    return `${baseOrigin}${resolvedPathname}`;
-  }
-
-  // bare
-  if (basePathname === "") {
-    return `${baseOrigin}/${specifier}`;
+    return {
+      type: "object",
+      hasRelativeKey,
+      allKeysAreRelative: relativeKeys.length === keys.length,
+    };
   }
-  if (basePathname[basePathname.length] === "/") {
-    return `${baseOrigin}${basePathname}${specifier}`;
+  if (typeof packageExports === "string") {
+    return { type: "string" };
   }
-  return `${baseOrigin}${pathnameToParentPathname(basePathname)}${specifier}`;
+  return {};
 };
 
-const writeBaseUrlMustBeAString = ({
-  baseUrl,
-  specifier,
-}) => `baseUrl must be a string.
---- base url ---
-${baseUrl}
---- specifier ---
-${specifier}`;
-
-const writeBaseUrlMustBeAbsolute = ({
-  baseUrl,
-  specifier,
-}) => `baseUrl must be absolute.
---- base url ---
-${baseUrl}
---- specifier ---
-${specifier}`;
-
-const writeBaseUrlRequired = ({
-  baseUrl,
-  specifier,
-}) => `baseUrl required to resolve relative specifier.
---- base url ---
-${baseUrl}
---- specifier ---
-${specifier}`;
-
-const tryUrlResolution = (string, url) => {
-  const result = resolveUrl(string, url);
-  return hasScheme(result) ? result : null;
+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);
+  if (afterFirstSlash === "") {
+    return {
+      packageName,
+      packageSubpath: "/",
+    };
+  }
+  const packageSubpath = `./${afterFirstSlash}`;
+  return {
+    packageName,
+    packageSubpath,
+  };
 };
 
-const resolveSpecifier = (specifier, importer) => {
+const applyMainExportResolution = (resolutionContext) => {
+  const { packageJson } = resolutionContext;
+  const packageExportsInfo = readExports(resolutionContext);
   if (
-    specifier === "." ||
-    specifier[0] === "/" ||
-    specifier.startsWith("./") ||
-    specifier.startsWith("../")
+    packageExportsInfo.type === "array" ||
+    packageExportsInfo.type === "string"
   ) {
-    return resolveUrl(specifier, importer);
+    return packageJson.exports;
   }
-
-  if (hasScheme(specifier)) {
-    return specifier;
+  if (packageExportsInfo.type === "object") {
+    if (packageExportsInfo.hasRelativeKey) {
+      return packageJson.exports["."];
+    }
+    return packageJson.exports;
   }
-
-  return null;
+  return undefined;
 };
 
-const applyImportMap = ({
-  importMap,
-  specifier,
-  importer,
-  createBareSpecifierError = ({ specifier, importer }) => {
-    return new Error(
-      createDetailedMessage(`Unmapped bare specifier.`, {
-        specifier,
-        importer,
-      }),
-    );
-  },
-  onImportMapping = () => {},
-}) => {
-  assertImportMap(importMap);
-  if (typeof specifier !== "string") {
-    throw new TypeError(
-      createDetailedMessage("specifier must be a string.", {
-        specifier,
-        importer,
-      }),
-    );
+const applyLegacySubpathResolution = (packageSubpath, resolutionContext) => {
+  const { packageDirectoryUrl, packageJson } = resolutionContext;
+
+  if (packageSubpath === ".") {
+    return applyLegacyMainResolution(packageSubpath, resolutionContext);
   }
-  if (importer) {
-    if (typeof importer !== "string") {
-      throw new TypeError(
-        createDetailedMessage("importer must be a string.", {
-          importer,
-          specifier,
-        }),
-      );
+  const browserFieldResolution = applyBrowserFieldResolution(
+    packageSubpath,
+    resolutionContext,
+  );
+  if (browserFieldResolution) {
+    return browserFieldResolution;
+  }
+  return createResolutionResult({
+    type: "subpath",
+    isMain: packageSubpath === ".",
+    packageDirectoryUrl,
+    packageJson,
+    url: new URL(packageSubpath, packageDirectoryUrl).href,
+  });
+};
+
+const applyLegacyMainResolution = (packageSubpath, resolutionContext) => {
+  const { conditions, packageDirectoryUrl, packageJson } = resolutionContext;
+  for (const condition of conditions) {
+    const conditionResolver = mainLegacyResolvers[condition];
+    if (!conditionResolver) {
+      continue;
     }
-    if (!hasScheme(importer)) {
-      throw new Error(
-        createDetailedMessage(`importer must be an absolute url.`, {
-          importer,
-          specifier,
-        }),
-      );
+    const resolved = conditionResolver(resolutionContext);
+    if (resolved) {
+      return createResolutionResult({
+        type: resolved.type,
+        isMain: resolved.isMain,
+        packageDirectoryUrl,
+        packageJson,
+        url: new URL(resolved.path, packageDirectoryUrl).href,
+      });
     }
   }
+  return createResolutionResult({
+    type: "field:main", // the absence of "main" field
+    isMain: true,
+    packageDirectoryUrl,
+    packageJson,
+    url: new URL("index.js", packageDirectoryUrl).href,
+  });
+};
+const mainLegacyResolvers = {
+  import: ({ packageJson }) => {
+    if (typeof packageJson.module === "string") {
+      return { type: "field:module", isMain: true, path: packageJson.module };
+    }
+    if (typeof packageJson.jsnext === "string") {
+      return { type: "field:jsnext", isMain: true, path: packageJson.jsnext };
+    }
+    if (typeof packageJson.main === "string") {
+      return { type: "field:main", isMain: true, path: packageJson.main };
+    }
+    return null;
+  },
+  browser: ({ packageDirectoryUrl, packageJson }) => {
+    const browserMain = (() => {
+      if (typeof packageJson.browser === "string") {
+        return packageJson.browser;
+      }
+      if (
+        typeof packageJson.browser === "object" &&
+        packageJson.browser !== null
+      ) {
+        return packageJson.browser["."];
+      }
+      return "";
+    })();
 
-  const specifierUrl = resolveSpecifier(specifier, importer);
-  const specifierNormalized = specifierUrl || specifier;
-
-  const { scopes } = importMap;
-  if (scopes && importer) {
-    const scopeSpecifierMatching = Object.keys(scopes).find(
-      (scopeSpecifier) => {
-        return (
-          scopeSpecifier === importer ||
-          specifierIsPrefixOf(scopeSpecifier, importer)
-        );
-      },
-    );
-    if (scopeSpecifierMatching) {
-      const scopeMappings = scopes[scopeSpecifierMatching];
-      const mappingFromScopes = applyMappings(
-        scopeMappings,
-        specifierNormalized,
-        scopeSpecifierMatching,
-        onImportMapping,
-      );
-      if (mappingFromScopes !== null) {
-        return mappingFromScopes;
+    if (!browserMain) {
+      if (typeof packageJson.module === "string") {
+        return {
+          type: "field:module",
+          isMain: true,
+          path: packageJson.module,
+        };
+      }
+      return null;
+    }
+    if (
+      typeof packageJson.module !== "string" ||
+      packageJson.module === browserMain
+    ) {
+      return {
+        type: "field:browser",
+        isMain: true,
+        path: browserMain,
+      };
+    }
+    const browserMainUrlObject = new URL(browserMain, packageDirectoryUrl);
+    const content = readFileSync(browserMainUrlObject, "utf-8");
+    if (
+      (/typeof exports\s*==/.test(content) &&
+        /typeof module\s*==/.test(content)) ||
+      /module\.exports\s*=/.test(content)
+    ) {
+      return {
+        type: "field:module",
+        isMain: true,
+        path: packageJson.module,
+      };
+    }
+    return {
+      type: "field:browser",
+      isMain: true,
+      path: browserMain,
+    };
+  },
+  node: ({ packageJson, conditions }) => {
+    if (conditions.includes("import") && !conditions.includes("require")) {
+      if (typeof packageJson.module === "string") {
+        return { type: "field:module", isMain: true, path: packageJson.module };
+      }
+      if (typeof packageJson.jsnext === "string") {
+        return { type: "field:jsnext", isMain: true, path: packageJson.jsnext };
       }
     }
+    if (typeof packageJson.main === "string") {
+      return { type: "field:main", isMain: true, path: packageJson.main };
+    }
+    return null;
+  },
+};
+mainLegacyResolvers.require = mainLegacyResolvers.node;
+
+const comparePatternKeys = (keyA, keyB) => {
+  if (!keyA.endsWith("/") && !keyA.includes("*")) {
+    throw new Error("Invalid package configuration");
+  }
+  if (!keyB.endsWith("/") && !keyB.includes("*")) {
+    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;
   }
-
-  const { imports } = importMap;
-  if (imports) {
-    const mappingFromImports = applyMappings(
-      imports,
-      specifierNormalized,
-      undefined,
-      onImportMapping,
-    );
-    if (mappingFromImports !== null) {
-      return mappingFromImports;
-    }
+  if (baseLengthB > baseLengthA) {
+    return 1;
   }
-
-  if (specifierUrl) {
-    return specifierUrl;
+  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;
+};
 
-  throw createBareSpecifierError({ specifier, importer });
+const resolvePackageSymlink = (packageDirectoryUrl) => {
+  const packageDirectoryPath = realpathSync(new URL(packageDirectoryUrl));
+  const packageDirectoryResolvedUrl = pathToFileURL(packageDirectoryPath).href;
+  return `${packageDirectoryResolvedUrl}/`;
 };
 
-const applyMappings = (
-  mappings,
-  specifierNormalized,
-  scope,
-  onImportMapping,
+const applyFileSystemMagicResolution = (
+  fileUrl,
+  { fileStat, magicDirectoryIndex, magicExtensions },
 ) => {
-  const specifierCandidates = Object.keys(mappings);
+  const result = {
+    stat: null,
+    url: fileUrl,
+    magicExtension: "",
+    magicDirectoryIndex: false,
+    lastENOENTError: null,
+  };
 
-  let i = 0;
-  while (i < specifierCandidates.length) {
-    const specifierCandidate = specifierCandidates[i];
-    i++;
-    if (specifierCandidate === specifierNormalized) {
-      const address = mappings[specifierCandidate];
-      onImportMapping({
-        scope,
-        from: specifierCandidate,
-        to: address,
-        before: specifierNormalized,
-        after: address,
-      });
-      return address;
+  if (fileStat === undefined) {
+    try {
+      fileStat = readEntryStatSync(new URL(fileUrl));
+    } catch (e) {
+      if (e.code === "ENOENT") {
+        result.lastENOENTError = e;
+        fileStat = null;
+      } else {
+        throw e;
+      }
     }
-    if (specifierIsPrefixOf(specifierCandidate, specifierNormalized)) {
-      const address = mappings[specifierCandidate];
-      const afterSpecifier = specifierNormalized.slice(
-        specifierCandidate.length,
-      );
-      const addressFinal = tryUrlResolution(afterSpecifier, address);
-      onImportMapping({
-        scope,
-        from: specifierCandidate,
-        to: address,
-        before: specifierNormalized,
-        after: addressFinal,
+  }
+
+  if (fileStat && fileStat.isFile()) {
+    result.stat = fileStat;
+    result.url = fileUrl;
+    return result;
+  }
+  if (fileStat && fileStat.isDirectory()) {
+    if (magicDirectoryIndex) {
+      const indexFileSuffix = fileUrl.endsWith("/") ? "index" : "/index";
+      const indexFileUrl = `${fileUrl}${indexFileSuffix}`;
+      const subResult = applyFileSystemMagicResolution(indexFileUrl, {
+        magicDirectoryIndex: false,
+        magicExtensions,
       });
-      return addressFinal;
+      return {
+        ...result,
+        ...subResult,
+        magicDirectoryIndex: true,
+      };
     }
+    result.stat = fileStat;
+    result.url = fileUrl;
+    return result;
   }
 
-  return null;
+  if (magicExtensions && magicExtensions.length) {
+    const parentUrl = new URL("./", fileUrl).href;
+    const urlFilename = urlToFilename(fileUrl);
+    for (const extensionToTry of magicExtensions) {
+      const urlCandidate = `${parentUrl}${urlFilename}${extensionToTry}`;
+      let stat;
+      try {
+        stat = readEntryStatSync(new URL(urlCandidate));
+      } catch (e) {
+        if (e.code === "ENOENT") {
+          stat = null;
+        } else {
+          throw e;
+        }
+      }
+      if (stat) {
+        result.stat = stat;
+        result.url = `${fileUrl}${extensionToTry}`;
+        result.magicExtension = extensionToTry;
+        return result;
+      }
+    }
+  }
+  // magic extension not found
+  return result;
 };
 
-const specifierIsPrefixOf = (specifierHref, href) => {
-  return (
-    specifierHref[specifierHref.length - 1] === "/" &&
-    href.startsWith(specifierHref)
-  );
+const getExtensionsToTry = (magicExtensions, importer) => {
+  if (!magicExtensions) {
+    return [];
+  }
+  const extensionsSet = new Set();
+  magicExtensions.forEach((magicExtension) => {
+    if (magicExtension === "inherit") {
+      const importerExtension = urlToExtension(importer);
+      extensionsSet.add(importerExtension);
+    } else {
+      extensionsSet.add(magicExtension);
+    }
+  });
+  return Array.from(extensionsSet.values());
 };
 
-// https://github.com/systemjs/systemjs/blob/89391f92dfeac33919b0223bbf834a1f4eea5750/src/common.js#L136
-
-const composeTwoImportMaps = (leftImportMap, rightImportMap) => {
-  assertImportMap(leftImportMap);
-  assertImportMap(rightImportMap);
-
-  const importMap = {};
-
-  const leftImports = leftImportMap.imports;
-  const rightImports = rightImportMap.imports;
-  const leftHasImports = Boolean(leftImports);
-  const rightHasImports = Boolean(rightImports);
-  if (leftHasImports && rightHasImports) {
-    importMap.imports = composeTwoMappings(leftImports, rightImports);
-  } else if (leftHasImports) {
-    importMap.imports = { ...leftImports };
-  } else if (rightHasImports) {
-    importMap.imports = { ...rightImports };
+const versionFromValue = (value) => {
+  if (typeof value === "number") {
+    return numberToVersion(value);
   }
-
-  const leftScopes = leftImportMap.scopes;
-  const rightScopes = rightImportMap.scopes;
-  const leftHasScopes = Boolean(leftScopes);
-  const rightHasScopes = Boolean(rightScopes);
-  if (leftHasScopes && rightHasScopes) {
-    importMap.scopes = composeTwoScopes(
-      leftScopes,
-      rightScopes,
-      importMap.imports || {},
-    );
-  } else if (leftHasScopes) {
-    importMap.scopes = { ...leftScopes };
-  } else if (rightHasScopes) {
-    importMap.scopes = { ...rightScopes };
+  if (typeof value === "string") {
+    return stringToVersion(value);
   }
+  throw new TypeError(`version must be a number or a string, got ${value}`);
+};
 
-  return importMap;
+const numberToVersion = (number) => {
+  return {
+    major: number,
+    minor: 0,
+    patch: 0,
+  };
 };
 
-const composeTwoMappings = (leftMappings, rightMappings) => {
-  const mappings = {};
+const stringToVersion = (string) => {
+  if (string.indexOf(".") > -1) {
+    const parts = string.split(".");
+    return {
+      major: Number(parts[0]),
+      minor: parts[1] ? Number(parts[1]) : 0,
+      patch: parts[2] ? Number(parts[2]) : 0,
+    };
+  }
 
-  Object.keys(leftMappings).forEach((leftSpecifier) => {
-    if (objectHasKey(rightMappings, leftSpecifier)) {
-      // will be overidden
-      return;
-    }
-    const leftAddress = leftMappings[leftSpecifier];
-    const rightSpecifier = Object.keys(rightMappings).find((rightSpecifier) => {
-      return compareAddressAndSpecifier(leftAddress, rightSpecifier);
-    });
-    mappings[leftSpecifier] = rightSpecifier
-      ? rightMappings[rightSpecifier]
-      : leftAddress;
-  });
+  if (isNaN(string)) {
+    return {
+      major: 0,
+      minor: 0,
+      patch: 0,
+    };
+  }
 
-  Object.keys(rightMappings).forEach((rightSpecifier) => {
-    mappings[rightSpecifier] = rightMappings[rightSpecifier];
-  });
+  return {
+    major: Number(string),
+    minor: 0,
+    patch: 0,
+  };
+};
 
-  return mappings;
+const compareTwoVersions = (versionA, versionB) => {
+  const semanticVersionA = versionFromValue(versionA);
+  const semanticVersionB = versionFromValue(versionB);
+  const majorDiff = semanticVersionA.major - semanticVersionB.major;
+  if (majorDiff > 0) {
+    return majorDiff;
+  }
+  if (majorDiff < 0) {
+    return majorDiff;
+  }
+  const minorDiff = semanticVersionA.minor - semanticVersionB.minor;
+  if (minorDiff > 0) {
+    return minorDiff;
+  }
+  if (minorDiff < 0) {
+    return minorDiff;
+  }
+  const patchDiff = semanticVersionA.patch - semanticVersionB.patch;
+  if (patchDiff > 0) {
+    return patchDiff;
+  }
+  if (patchDiff < 0) {
+    return patchDiff;
+  }
+  return 0;
 };
 
-const objectHasKey = (object, key) =>
-  Object.prototype.hasOwnProperty.call(object, key);
-
-const compareAddressAndSpecifier = (address, specifier) => {
-  const addressUrl = resolveUrl(address, "file:///");
-  const specifierUrl = resolveUrl(specifier, "file:///");
-  return addressUrl === specifierUrl;
+const versionIsBelow = (versionSupposedBelow, versionSupposedAbove) => {
+  return compareTwoVersions(versionSupposedBelow, versionSupposedAbove) < 0;
 };
 
-const composeTwoScopes = (leftScopes, rightScopes, imports) => {
-  const scopes = {};
-
-  Object.keys(leftScopes).forEach((leftScopeKey) => {
-    if (objectHasKey(rightScopes, leftScopeKey)) {
-      // will be merged
-      scopes[leftScopeKey] = leftScopes[leftScopeKey];
-      return;
-    }
-    const topLevelSpecifier = Object.keys(imports).find(
-      (topLevelSpecifierCandidate) => {
-        return compareAddressAndSpecifier(
-          leftScopeKey,
-          topLevelSpecifierCandidate,
-        );
-      },
-    );
-    if (topLevelSpecifier) {
-      scopes[imports[topLevelSpecifier]] = leftScopes[leftScopeKey];
-    } else {
-      scopes[leftScopeKey] = leftScopes[leftScopeKey];
-    }
-  });
-
-  Object.keys(rightScopes).forEach((rightScopeKey) => {
-    if (objectHasKey(scopes, rightScopeKey)) {
-      scopes[rightScopeKey] = composeTwoMappings(
-        scopes[rightScopeKey],
-        rightScopes[rightScopeKey],
-      );
-    } else {
-      scopes[rightScopeKey] = {
-        ...rightScopes[rightScopeKey],
-      };
+const findHighestVersion = (...values) => {
+  if (values.length === 0) throw new Error(`missing argument`);
+  return values.reduce((highestVersion, value) => {
+    if (versionIsBelow(highestVersion, value)) {
+      return value;
     }
+    return highestVersion;
   });
-
-  return scopes;
 };
 
-const sortImports = (imports) => {
-  const mappingsSorted = {};
-
-  Object.keys(imports)
-    .sort(compareLengthOrLocaleCompare)
-    .forEach((name) => {
-      mappingsSorted[name] = imports[name];
-    });
-
-  return mappingsSorted;
+const featuresCompatMap = {
+  script_type_module: {
+    edge: "16",
+    firefox: "60",
+    chrome: "61",
+    safari: "10.1",
+    opera: "48",
+    ios: "10.3",
+    android: "61",
+    samsung: "8.2",
+  },
+  document_current_script: {
+    edge: "12",
+    firefox: "4",
+    chrome: "29",
+    safari: "8",
+    opera: "16",
+    android: "4.4",
+    samsung: "4",
+  },
+  // https://caniuse.com/?search=import.meta
+  import_meta: {
+    android: "9",
+    chrome: "64",
+    edge: "79",
+    firefox: "62",
+    ios: "12",
+    opera: "51",
+    safari: "11.1",
+    samsung: "9.2",
+  },
+  import_meta_resolve: {
+    chrome: "107",
+    edge: "105",
+    firefox: "106",
+    node: "20.0.0",
+  },
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import#browser_compatibility
+  import_dynamic: {
+    android: "8",
+    chrome: "63",
+    edge: "79",
+    firefox: "67",
+    ios: "11.3",
+    opera: "50",
+    safari: "11.3",
+    samsung: "8.0",
+    node: "13.2",
+  },
+  top_level_await: {
+    edge: "89",
+    chrome: "89",
+    firefox: "89",
+    opera: "75",
+    safari: "15",
+    samsung: "15",
+    ios: "15",
+    node: "14.8",
+  },
+  // https://caniuse.com/import-maps
+  importmap: {
+    edge: "89",
+    chrome: "89",
+    opera: "76",
+    samsung: "15",
+    firefox: "108",
+    safari: "16.4",
+  },
+  import_type_json: {
+    chrome: "123",
+    safari: "17.2",
+  },
+  import_type_css: {
+    chrome: "123",
+  },
+  import_type_text: {},
+  // https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleSheet#browser_compatibility
+  new_stylesheet: {
+    chrome: "73",
+    edge: "79",
+    opera: "53",
+    android: "73",
+  },
+  // https://caniuse.com/?search=worker
+  worker: {
+    ie: "10",
+    edge: "12",
+    firefox: "3.5",
+    chrome: "4",
+    opera: "11.5",
+    safari: "4",
+    ios: "5",
+    android: "4.4",
+  },
+  // https://developer.mozilla.org/en-US/docs/Web/API/Worker/Worker#browser_compatibility
+  worker_type_module: {
+    chrome: "80",
+    edge: "80",
+    opera: "67",
+    android: "80",
+  },
+  worker_importmap: {},
+  service_worker: {
+    edge: "17",
+    firefox: "44",
+    chrome: "40",
+    safari: "11.1",
+    opera: "27",
+    ios: "11.3",
+    android: "12.12",
+  },
+  service_worker_type_module: {
+    chrome: "80",
+    edge: "80",
+    opera: "67",
+    android: "80",
+  },
+  service_worker_importmap: {},
+  shared_worker: {
+    chrome: "4",
+    edge: "79",
+    firefox: "29",
+    opera: "10.6",
+  },
+  shared_worker_type_module: {
+    chrome: "80",
+    edge: "80",
+    opera: "67",
+  },
+  shared_worker_importmap: {},
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/globalThis#browser_compatibility
+  global_this: {
+    edge: "79",
+    firefox: "65",
+    chrome: "71",
+    safari: "12.1",
+    opera: "58",
+    ios: "12.2",
+    android: "94",
+    node: "12",
+  },
+  async_generator_function: {
+    chrome: "63",
+    opera: "50",
+    edge: "79",
+    firefox: "57",
+    safari: "12",
+    node: "10",
+    ios: "12",
+    samsung: "8",
+    electron: "3",
+  },
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals#browser_compatibility
+  template_literals: {
+    chrome: "41",
+    edge: "12",
+    firefox: "34",
+    opera: "28",
+    safari: "9",
+    ios: "9",
+    android: "4",
+    node: "4",
+  },
+  arrow_function: {
+    chrome: "47",
+    opera: "34",
+    edge: "13",
+    firefox: "45",
+    safari: "10",
+    node: "6",
+    ios: "10",
+    samsung: "5",
+    electron: "0.36",
+  },
+  const_bindings: {
+    chrome: "41",
+    opera: "28",
+    edge: "12",
+    firefox: "46",
+    safari: "10",
+    node: "4",
+    ie: "11",
+    ios: "10",
+    samsung: "3.4",
+    electron: "0.22",
+  },
+  object_properties_shorthand: {
+    chrome: "43",
+    opera: "30",
+    edge: "12",
+    firefox: "33",
+    safari: "9",
+    node: "4",
+    ios: "9",
+    samsung: "4",
+    electron: "0.28",
+  },
+  reserved_words: {
+    chrome: "13",
+    opera: "10.50",
+    edge: "12",
+    firefox: "2",
+    safari: "3.1",
+    node: "0.10",
+    ie: "9",
+    android: "4.4",
+    ios: "6",
+    phantom: "2",
+    samsung: "1",
+    electron: "0.20",
+  },
+  symbols: {
+    chrome: "38",
+    opera: "25",
+    edge: "12",
+    firefox: "36",
+    safari: "9",
+    ios: "9",
+    samsung: "4",
+    node: "0.12",
+  },
 };
 
-const sortScopes = (scopes) => {
-  const scopesSorted = {};
+const RUNTIME_COMPAT = {
+  featuresCompatMap,
 
-  Object.keys(scopes)
-    .sort(compareLengthOrLocaleCompare)
-    .forEach((scopeSpecifier) => {
-      scopesSorted[scopeSpecifier] = sortImports(scopes[scopeSpecifier]);
+  add: (originalRuntimeCompat, feature) => {
+    const featureCompat = getFeatureCompat(feature);
+    const runtimeCompat = {
+      ...originalRuntimeCompat,
+    };
+    Object.keys(originalRuntimeCompat).forEach((runtimeName) => {
+      const secondVersion = featureCompat[runtimeName]; // the version supported by the feature
+      if (secondVersion) {
+        const firstVersion = originalRuntimeCompat[runtimeName];
+        runtimeCompat[runtimeName] = findHighestVersion(
+          firstVersion,
+          secondVersion,
+        );
+      }
     });
+    return runtimeCompat;
+  },
 
-  return scopesSorted;
-};
-
-const compareLengthOrLocaleCompare = (a, b) => {
-  return b.length - a.length || a.localeCompare(b);
-};
-
-const normalizeImportMap = (importMap, baseUrl) => {
-  assertImportMap(importMap);
-
-  if (!isStringOrUrl(baseUrl)) {
-    throw new TypeError(formulateBaseUrlMustBeStringOrUrl({ baseUrl }));
-  }
-
-  const { imports, scopes } = importMap;
-
-  return {
-    imports: imports ? normalizeMappings(imports, baseUrl) : undefined,
-    scopes: scopes ? normalizeScopes(scopes, baseUrl) : undefined,
-  };
-};
-
-const isStringOrUrl = (value) => {
-  if (typeof value === "string") {
-    return true;
-  }
-
-  if (typeof URL === "function" && value instanceof URL) {
-    return true;
-  }
-
-  return false;
-};
-
-const normalizeMappings = (mappings, baseUrl) => {
-  const mappingsNormalized = {};
-
-  Object.keys(mappings).forEach((specifier) => {
-    const address = mappings[specifier];
-
-    if (typeof address !== "string") {
-      console.warn(
-        formulateAddressMustBeAString({
-          address,
-          specifier,
-        }),
-      );
-      return;
-    }
-
-    const specifierResolved = resolveSpecifier(specifier, baseUrl) || specifier;
-
-    const addressUrl = tryUrlResolution(address, baseUrl);
-    if (addressUrl === null) {
-      console.warn(
-        formulateAdressResolutionFailed({
-          address,
-          baseUrl,
-          specifier,
-        }),
-      );
-      return;
-    }
-
-    if (specifier.endsWith("/") && !addressUrl.endsWith("/")) {
-      console.warn(
-        formulateAddressUrlRequiresTrailingSlash({
-          address,
-          specifier,
-        }),
-      );
-      return;
-    }
-    mappingsNormalized[specifierResolved] = addressUrl;
-  });
-
-  return sortImports(mappingsNormalized);
-};
-
-const normalizeScopes = (scopes, baseUrl) => {
-  const scopesNormalized = {};
-
-  Object.keys(scopes).forEach((scopeSpecifier) => {
-    const scopeMappings = scopes[scopeSpecifier];
-    const scopeUrl = tryUrlResolution(scopeSpecifier, baseUrl);
-    if (scopeUrl === null) {
-      console.warn(
-        formulateScopeResolutionFailed({
-          scope: scopeSpecifier,
-          baseUrl,
-        }),
+  isSupported: (
+    runtimeCompat,
+    feature,
+    featureCompat = getFeatureCompat(feature),
+  ) => {
+    const runtimeNames = Object.keys(runtimeCompat);
+    const runtimeWithoutCompat = runtimeNames.find((runtimeName) => {
+      const runtimeVersion = runtimeCompat[runtimeName];
+      const runtimeVersionCompatible = featureCompat[runtimeName] || "Infinity";
+      const highestVersion = findHighestVersion(
+        runtimeVersion,
+        runtimeVersionCompatible,
       );
-      return;
-    }
-    const scopeValueNormalized = normalizeMappings(scopeMappings, baseUrl);
-    scopesNormalized[scopeUrl] = scopeValueNormalized;
-  });
-
-  return sortScopes(scopesNormalized);
-};
-
-const formulateBaseUrlMustBeStringOrUrl = ({
-  baseUrl,
-}) => `baseUrl must be a string or an url.
---- base url ---
-${baseUrl}`;
-
-const formulateAddressMustBeAString = ({
-  specifier,
-  address,
-}) => `Address must be a string.
---- address ---
-${address}
---- specifier ---
-${specifier}`;
-
-const formulateAdressResolutionFailed = ({
-  address,
-  baseUrl,
-  specifier,
-}) => `Address url resolution failed.
---- address ---
-${address}
---- base url ---
-${baseUrl}
---- specifier ---
-${specifier}`;
-
-const formulateAddressUrlRequiresTrailingSlash = ({
-  addressURL,
-  address,
-  specifier,
-}) => `Address must end with /.
---- address url ---
-${addressURL}
---- address ---
-${address}
---- specifier ---
-${specifier}`;
-
-const formulateScopeResolutionFailed = ({
-  scope,
-  baseUrl,
-}) => `Scope url resolution failed.
---- scope ---
-${scope}
---- base url ---
-${baseUrl}`;
-
-const pathnameToExtension = (pathname) => {
-  const slashLastIndex = pathname.lastIndexOf("/");
-  if (slashLastIndex !== -1) {
-    pathname = pathname.slice(slashLastIndex + 1);
-  }
-
-  const dotLastIndex = pathname.lastIndexOf(".");
-  if (dotLastIndex === -1) return "";
-  // if (dotLastIndex === pathname.length - 1) return ""
-  return pathname.slice(dotLastIndex);
-};
-
-const resolveImport = ({
-  specifier,
-  importer,
-  importMap,
-  defaultExtension = false,
-  createBareSpecifierError,
-  onImportMapping = () => {},
-}) => {
-  let url;
-  if (importMap) {
-    url = applyImportMap({
-      importMap,
-      specifier,
-      importer,
-      createBareSpecifierError,
-      onImportMapping,
+      return highestVersion !== runtimeVersion;
     });
-  } else {
-    url = resolveUrl(specifier, importer);
-  }
+    return !runtimeWithoutCompat;
+  },
+};
 
-  if (defaultExtension) {
-    url = applyDefaultExtension({ url, importer, defaultExtension });
+const getFeatureCompat = (feature) => {
+  if (typeof feature === "string") {
+    const compat = featuresCompatMap[feature];
+    if (!compat) {
+      throw new Error(`"${feature}" feature is unknown`);
+    }
+    return compat;
+  }
+  if (typeof feature !== "object") {
+    throw new TypeError(
+      `feature must be a string or an object, got ${feature}`,
+    );
   }
+  return feature;
+};
 
-  return url;
+const isSupportedAlgorithm = (algo) => {
+  return SUPPORTED_ALGORITHMS.includes(algo);
 };
 
-const applyDefaultExtension = ({ url, importer, defaultExtension }) => {
-  if (urlToPathname(url).endsWith("/")) {
-    return url;
+// https://www.w3.org/TR/SRI/#priority
+const getPrioritizedHashFunction = (firstAlgo, secondAlgo) => {
+  const firstIndex = SUPPORTED_ALGORITHMS.indexOf(firstAlgo);
+  const secondIndex = SUPPORTED_ALGORITHMS.indexOf(secondAlgo);
+  if (firstIndex === secondIndex) {
+    return "";
   }
-
-  if (typeof defaultExtension === "string") {
-    const extension = pathnameToExtension(url);
-    if (extension === "") {
-      return `${url}${defaultExtension}`;
-    }
-    return url;
+  if (firstIndex < secondIndex) {
+    return secondAlgo;
   }
+  return firstAlgo;
+};
 
-  if (defaultExtension === true) {
-    const extension = pathnameToExtension(url);
-    if (extension === "" && importer) {
-      const importerPathname = urlToPathname(importer);
-      const importerExtension = pathnameToExtension(importerPathname);
-      return `${url}${importerExtension}`;
-    }
-  }
+const applyAlgoToRepresentationData = (algo, data) => {
+  const base64Value = crypto.createHash(algo).update(data).digest("base64");
+  return base64Value;
+};
 
-  return url;
+// keep this ordered by collision resistance as it is also used by "getPrioritizedHashFunction"
+const SUPPORTED_ALGORITHMS = ["sha256", "sha384", "sha512"];
+
+// see https://w3c.github.io/webappsec-subresource-integrity/#parse-metadata
+const parseIntegrity = (string) => {
+  const integrityMetadata = {};
+  string
+    .trim()
+    .split(/\s+/)
+    .forEach((token) => {
+      const { isValid, algo, base64Value, optionExpression } =
+        parseAsHashWithOptions(token);
+      if (!isValid) {
+        return;
+      }
+      if (!isSupportedAlgorithm(algo)) {
+        return;
+      }
+      const metadataList = integrityMetadata[algo];
+      const metadata = { base64Value, optionExpression };
+      integrityMetadata[algo] = metadataList
+        ? [...metadataList, metadata]
+        : [metadata];
+    });
+  return integrityMetadata;
 };
 
-const isEscaped = (i, string) => {
-  let backslashBeforeCount = 0;
-  while (i--) {
-    const previousChar = string[i];
-    if (previousChar === "\\") {
-      backslashBeforeCount++;
-    }
-    break;
+// see https://w3c.github.io/webappsec-subresource-integrity/#the-integrity-attribute
+const parseAsHashWithOptions = (token) => {
+  const dashIndex = token.indexOf("-");
+  if (dashIndex === -1) {
+    return { isValid: false };
   }
-  const isEven = backslashBeforeCount % 2 === 0;
-  return !isEven;
+  const beforeDash = token.slice(0, dashIndex);
+  const afterDash = token.slice(dashIndex + 1);
+  const questionIndex = afterDash.indexOf("?");
+  const algo = beforeDash;
+  if (questionIndex === -1) {
+    const base64Value = afterDash;
+    const isValid = BASE64_REGEX.test(afterDash);
+    return { isValid, algo, base64Value };
+  }
+  const base64Value = afterDash.slice(0, questionIndex);
+  const optionExpression = afterDash.slice(questionIndex + 1);
+  const isValid =
+    BASE64_REGEX.test(afterDash) && VCHAR_REGEX.test(optionExpression);
+  return { isValid, algo, base64Value, optionExpression };
 };
 
-const JS_QUOTES = {
-  pickBest: (string, { canUseTemplateString, defaultQuote = DOUBLE } = {}) => {
-    // check default first, once tested do no re-test it
-    if (!string.includes(defaultQuote)) {
-      return defaultQuote;
-    }
-    if (defaultQuote !== DOUBLE && !string.includes(DOUBLE)) {
-      return DOUBLE;
-    }
-    if (defaultQuote !== SINGLE && !string.includes(SINGLE)) {
-      return SINGLE;
-    }
-    if (
-      canUseTemplateString &&
-      defaultQuote !== BACKTICK &&
-      !string.includes(BACKTICK)
-    ) {
-      return BACKTICK;
-    }
-    return defaultQuote;
-  },
+const BASE64_REGEX = /^[A-Za-z0-9+/=]+$/;
+const VCHAR_REGEX = /^[\x21-\x7E]+$/;
 
-  escapeSpecialChars: (
-    string,
-    {
-      quote = "pickBest",
-      canUseTemplateString,
-      defaultQuote,
-      allowEscapeForVersioning = false,
-    },
-  ) => {
-    quote =
-      quote === "pickBest"
-        ? JS_QUOTES.pickBest(string, { canUseTemplateString, defaultQuote })
-        : quote;
-    const replacements = JS_QUOTE_REPLACEMENTS[quote];
-    let result = "";
-    let last = 0;
-    let i = 0;
-    while (i < string.length) {
-      const char = string[i];
-      i++;
-      if (isEscaped(i - 1, string)) continue;
-      const replacement = replacements[char];
-      if (replacement) {
-        if (
-          allowEscapeForVersioning &&
-          char === quote &&
-          string.slice(i, i + 6) === "+__v__"
-        ) {
-          let isVersioningConcatenation = false;
-          let j = i + 6; // start after the +
-          while (j < string.length) {
-            const lookAheadChar = string[j];
-            j++;
-            if (
-              lookAheadChar === "+" &&
-              string[j] === quote &&
-              !isEscaped(j - 1, string)
-            ) {
-              isVersioningConcatenation = true;
-              break;
-            }
-          }
-          if (isVersioningConcatenation) {
-            // it's a concatenation
-            // skip until the end of concatenation (the second +)
-            // and resume from there
-            i = j + 1;
-            continue;
-          }
-        }
-        if (last === i - 1) {
-          result += replacement;
-        } else {
-          result += `${string.slice(last, i - 1)}${replacement}`;
-        }
-        last = i;
-      }
-    }
-    if (last !== string.length) {
-      result += string.slice(last);
-    }
-    return `${quote}${result}${quote}`;
-  },
+// https://www.w3.org/TR/SRI/#does-response-match-metadatalist
+const validateResponseIntegrity = (
+  { url, type, dataRepresentation },
+  integrity,
+) => {
+  if (!isResponseEligibleForIntegrityValidation({ type })) {
+    return false;
+  }
+  const integrityMetadata = parseIntegrity(integrity);
+  const algos = Object.keys(integrityMetadata);
+  if (algos.length === 0) {
+    return true;
+  }
+  let strongestAlgo = algos[0];
+  algos.slice(1).forEach((algoCandidate) => {
+    strongestAlgo =
+      getPrioritizedHashFunction(strongestAlgo, algoCandidate) || strongestAlgo;
+  });
+  const metadataList = integrityMetadata[strongestAlgo];
+  const actualBase64Value = applyAlgoToRepresentationData(
+    strongestAlgo,
+    dataRepresentation,
+  );
+  const acceptedBase64Values = metadataList.map(
+    (metadata) => metadata.base64Value,
+  );
+  const someIsMatching = acceptedBase64Values.includes(actualBase64Value);
+  if (someIsMatching) {
+    return true;
+  }
+  const error = new Error(
+    `Integrity validation failed for resource "${url}". The integrity found for this resource is "${strongestAlgo}-${actualBase64Value}"`,
+  );
+  error.code = "EINTEGRITY";
+  error.algorithm = strongestAlgo;
+  error.found = actualBase64Value;
+  throw error;
 };
 
-const DOUBLE = `"`;
-const SINGLE = `'`;
-const BACKTICK = "`";
-const lineEndingEscapes = {
-  "\n": "\\n",
-  "\r": "\\r",
-  "\u2028": "\\u2028",
-  "\u2029": "\\u2029",
-};
-const JS_QUOTE_REPLACEMENTS = {
-  [DOUBLE]: {
-    '"': '\\"',
-    ...lineEndingEscapes,
-  },
-  [SINGLE]: {
-    "'": "\\'",
-    ...lineEndingEscapes,
-  },
-  [BACKTICK]: {
-    "`": "\\`",
-    "$": "\\$",
-  },
+// https://www.w3.org/TR/SRI/#is-response-eligible-for-integrity-validation
+const isResponseEligibleForIntegrityValidation = (response) => {
+  return ["basic", "cors", "default"].includes(response.type);
 };
 
 const memoizeByFirstArgument = (compute) => {