@jsenv/test 3.6.1 → 3.6.2

package/dist/js/importmap_hooks.mjs

@@ -1,7 +1,606 @@
-import { normalizeImportMap, resolveImport } from "./vendors.js";
 import { readFileSync } from "node:fs";
 import { pathToFileURL } from "node:url";
 
+// 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
+    }`;
+  });
+
+  return string
+};
+
+const assertImportMap = (value) => {
+  if (value === null) {
+    throw new TypeError(`an importMap must be an object, got null`)
+  }
+
+  const type = typeof value;
+  if (type !== "object") {
+    throw new TypeError(`an importMap must be an object, received ${value}`)
+  }
+
+  if (Array.isArray(value)) {
+    throw new TypeError(
+      `an importMap must be an object, received array ${value}`,
+    )
+  }
+};
+
+const hasScheme = (string) => {
+  return /^[a-zA-Z]{2,}:/.test(string)
+};
+
+const urlToScheme = (urlString) => {
+  const colonIndex = urlString.indexOf(":");
+  if (colonIndex === -1) return ""
+  return urlString.slice(0, colonIndex)
+};
+
+const urlToPathname = (urlString) => {
+  return ressourceToPathname(urlToRessource(urlString))
+};
+
+const urlToRessource = (urlString) => {
+  const scheme = urlToScheme(urlString);
+
+  if (scheme === "file") {
+    return urlString.slice("file://".length)
+  }
+
+  if (scheme === "https" || scheme === "http") {
+    // remove origin
+    const afterProtocol = urlString.slice(scheme.length + "://".length);
+    const pathnameSlashIndex = afterProtocol.indexOf("/", "://".length);
+    return afterProtocol.slice(pathnameSlashIndex)
+  }
+
+  return urlString.slice(scheme.length + 1)
+};
+
+const ressourceToPathname = (ressource) => {
+  const searchSeparatorIndex = ressource.indexOf("?");
+  return searchSeparatorIndex === -1
+    ? ressource
+    : ressource.slice(0, searchSeparatorIndex)
+};
+
+const urlToOrigin = (urlString) => {
+  const scheme = urlToScheme(urlString);
+
+  if (scheme === "file") {
+    return "file://"
+  }
+
+  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)
+  }
+
+  return urlString.slice(0, scheme.length + 1)
+};
+
+const pathnameToParentPathname = (pathname) => {
+  const slashLastIndex = pathname.lastIndexOf("/");
+  if (slashLastIndex === -1) {
+    return "/"
+  }
+
+  return pathname.slice(0, slashLastIndex + 1)
+};
+
+// could be useful: https://url.spec.whatwg.org/#url-miscellaneous
+
+
+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 }))
+    }
+  }
+
+  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();
+      }
+    }
+
+    const resolvedPathname = `${importerFolders.join(
+      "/",
+    )}/${unresolvedPathname}`;
+    return `${baseOrigin}${resolvedPathname}`
+  }
+
+  // bare
+  if (basePathname === "") {
+    return `${baseOrigin}/${specifier}`
+  }
+  if (basePathname[basePathname.length] === "/") {
+    return `${baseOrigin}${basePathname}${specifier}`
+  }
+  return `${baseOrigin}${pathnameToParentPathname(basePathname)}${specifier}`
+};
+
+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 resolveSpecifier = (specifier, importer) => {
+  if (
+    specifier === "." ||
+    specifier[0] === "/" ||
+    specifier.startsWith("./") ||
+    specifier.startsWith("../")
+  ) {
+    return resolveUrl(specifier, importer)
+  }
+
+  if (hasScheme(specifier)) {
+    return specifier
+  }
+
+  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 (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,
+        }),
+      )
+    }
+  }
+
+  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
+      }
+    }
+  }
+
+  const { imports } = importMap;
+  if (imports) {
+    const mappingFromImports = applyMappings(
+      imports,
+      specifierNormalized,
+      undefined,
+      onImportMapping,
+    );
+    if (mappingFromImports !== null) {
+      return mappingFromImports
+    }
+  }
+
+  if (specifierUrl) {
+    return specifierUrl
+  }
+
+  throw createBareSpecifierError({ specifier, importer })
+};
+
+const applyMappings = (
+  mappings,
+  specifierNormalized,
+  scope,
+  onImportMapping,
+) => {
+  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,
+      });
+      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
+    }
+  }
+
+  return null
+};
+
+const specifierIsPrefixOf = (specifierHref, href) => {
+  return (
+    specifierHref[specifierHref.length - 1] === "/" &&
+    href.startsWith(specifierHref)
+  )
+};
+
+const sortImports = (imports) => {
+  const mappingsSorted = {};
+
+  Object.keys(imports)
+    .sort(compareLengthOrLocaleCompare)
+    .forEach((name) => {
+      mappingsSorted[name] = imports[name];
+    });
+
+  return mappingsSorted
+};
+
+const sortScopes = (scopes) => {
+  const scopesSorted = {};
+
+  Object.keys(scopes)
+    .sort(compareLengthOrLocaleCompare)
+    .forEach((scopeSpecifier) => {
+      scopesSorted[scopeSpecifier] = sortImports(scopes[scopeSpecifier]);
+    });
+
+  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,
+        }),
+      );
+      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,
+    });
+  } else {
+    url = resolveUrl(specifier, importer);
+  }
+
+  if (defaultExtension) {
+    url = applyDefaultExtension({ url, importer, defaultExtension });
+  }
+
+  return url
+};
+
+const applyDefaultExtension = ({ url, importer, defaultExtension }) => {
+  if (urlToPathname(url).endsWith("/")) {
+    return url
+  }
+
+  if (typeof defaultExtension === "string") {
+    const extension = pathnameToExtension(url);
+    if (extension === "") {
+      return `${url}${defaultExtension}`
+    }
+    return url
+  }
+
+  if (defaultExtension === true) {
+    const extension = pathnameToExtension(url);
+    if (extension === "" && importer) {
+      const importerPathname = urlToPathname(importer);
+      const importerExtension = pathnameToExtension(importerPathname);
+      return `${url}${importerExtension}`
+    }
+  }
+
+  return url
+};
+
 let importMap;
 
 const cwdUrl = `${String(pathToFileURL(process.cwd()))}/`;

package/dist/jsenv_test.js

@@ -1,19 +1,19 @@
+import { readGitHubWorkflowEnv, startGithubCheckRun } from "@jsenv/github-check-run";
 import process$1, { cpuUsage, memoryUsage } from "node:process";
-import os, { cpus, release, totalmem, availableParallelism, freemem } from "node:os";
+import os, { cpus, totalmem, release, availableParallelism, freemem } from "node:os";
 import tty from "node:tty";
 import stringWidth from "string-width";
-import { pathToFileURL, fileURLToPath } from "node:url";
-import { readdir, chmod, stat, lstat, chmodSync, statSync, lstatSync, promises, readFile as readFile$1, unlinkSync, openSync, closeSync, readdirSync, rmdirSync, mkdirSync, readFileSync, writeFileSync as writeFileSync$1, unlink, rmdir, existsSync } from "node:fs";
-import { URL_META, filterV8Coverage } from "./js/v8_coverage.js";
-import { dirname } from "node:path";
-import crypto from "node:crypto";
-import { readGitHubWorkflowEnv, startGithubCheckRun } from "@jsenv/github-check-run";
 import { applyNodeEsmResolution } from "@jsenv/node-esm-resolution";
+import { URL_META, filterV8Coverage } from "./js/v8_coverage.js";
+import { readdir, chmod, stat, lstat, chmodSync, statSync, lstatSync, promises, readFile as readFile$1, readdirSync, openSync, closeSync, unlinkSync, rmdirSync, mkdirSync, readFileSync, writeFileSync as writeFileSync$1, unlink, rmdir, existsSync } from "node:fs";
 import { takeCoverage } from "node:v8";
 import stripAnsi from "strip-ansi";
+import { pathToFileURL, fileURLToPath } from "node:url";
 import { createRequire } from "node:module";
 import { applyBabelPlugins } from "@jsenv/ast";
 import { createException } from "@jsenv/exception";
+import crypto from "node:crypto";
+import { dirname } from "node:path";
 import { createServer } from "node:net";
 import { spawn, spawnSync, fork } from "node:child_process";
 import { SOURCEMAP, generateSourcemapDataUrl } from "@jsenv/sourcemap";
@@ -3165,10 +3165,6 @@ const removeDirectoryNaive = (
   });
 };
 
-process.platform === "win32";
-
-process.platform === "win32";
-
 const ensureEmptyDirectorySync = (source) => {
   const stat = readEntryStatSync(source, {
     nullIfNotFound: true,
@@ -3223,14 +3219,6 @@ const ensureEmptyDirectory = async (source) => {
   );
 };
 
-process.platform === "win32";
-
-process.platform === "linux";
-
-process.platform === "darwin";
-process.platform === "linux";
-process.platform === "freebsd";
-
 const normalizeFileByFileCoveragePaths = (
   fileByFileCoverage,
   rootDirectoryUrl,
@@ -5976,7 +5964,6 @@ const ensureWebServerIsStarted = async (
   }
   if (webServer.command) {
     await startServerUsingCommand(webServer, {
-      ignoreProcessExecArgv,
       signal,
       allocatedMs,
       teardownCallbackSet,
@@ -7368,8 +7355,6 @@ const initJsSupervisorMiddleware = async (
     const url = request.url();
     if (url === fileServerUrl && urlToExtension(url) === ".html") {
       interceptHtmlToExecute({
-        url,
-        request,
         route,
       });
       return;
@@ -7377,14 +7362,13 @@ const initJsSupervisorMiddleware = async (
     if (inlineScriptContents.has(url)) {
       interceptInlineScript({
         url,
-        request,
         route,
       });
       return;
     }
     const fsServerUrl = new URL("/@fs/", webServer.origin);
     if (url.startsWith(fsServerUrl)) {
-      interceptFileSystemUrl({ url, request, route });
+      interceptFileSystemUrl({ url, route });
       return;
     }
     route.fallback();
@@ -9868,7 +9852,6 @@ const execute = async ({
     measureMemoryUsage,
     onMeasureMemoryAvailable,
     collectPerformance,
-    collectCoverage,
     coverageTempDirectoryUrl,
     runtime,
     runtimeParams,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/test",
-  "version": "3.6.1",
+  "version": "3.6.2",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -27,6 +27,10 @@
     "/dist/",
     "/src/"
   ],
+  "sideEffects": [
+    "./src/runtime_node/node_child_process_controlled.mjs",
+    "./src/runtime_node/node_worker_thread_controlled.mjs"
+  ],
   "scripts": {
     "build": "node --conditions=development ./scripts/build.mjs",
     "prepublishOnly": "npm run build"
@@ -37,17 +41,17 @@
   "dependencies": {
     "@c88/v8-coverage": "0.1.1",
     "@jsenv/abort": "4.3.1",
-    "@jsenv/ast": "6.6.0",
+    "@jsenv/ast": "6.6.1",
     "@jsenv/exception": "1.1.5",
-    "@jsenv/filesystem": "4.14.0",
-    "@jsenv/github-check-run": "0.2.14",
+    "@jsenv/filesystem": "4.14.1",
+    "@jsenv/github-check-run": "0.2.15",
     "@jsenv/node-esm-resolution": "1.1.0",
-    "@jsenv/humanize": "1.3.0",
-    "@jsenv/plugin-supervisor": "1.6.7",
-    "@jsenv/sourcemap": "1.3.0",
+    "@jsenv/humanize": "1.3.1",
+    "@jsenv/plugin-supervisor": "1.6.8",
+    "@jsenv/sourcemap": "1.3.1",
     "@jsenv/url-meta": "8.5.4",
-    "@jsenv/urls": "2.6.1",
-    "@jsenv/utils": "2.2.0",
+    "@jsenv/urls": "2.6.2",
+    "@jsenv/utils": "2.2.1",
     "he": "1.2.0",
     "istanbul-lib-coverage": "3.2.2",
     "istanbul-lib-instrument": "6.0.3",

package/dist/js/vendors.js

@@ -1,602 +0,0 @@
-// 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
-    }`;
-  });
-
-  return string
-};
-
-const assertImportMap = (value) => {
-  if (value === null) {
-    throw new TypeError(`an importMap must be an object, got null`)
-  }
-
-  const type = typeof value;
-  if (type !== "object") {
-    throw new TypeError(`an importMap must be an object, received ${value}`)
-  }
-
-  if (Array.isArray(value)) {
-    throw new TypeError(
-      `an importMap must be an object, received array ${value}`,
-    )
-  }
-};
-
-const hasScheme = (string) => {
-  return /^[a-zA-Z]{2,}:/.test(string)
-};
-
-const urlToScheme = (urlString) => {
-  const colonIndex = urlString.indexOf(":");
-  if (colonIndex === -1) return ""
-  return urlString.slice(0, colonIndex)
-};
-
-const urlToPathname = (urlString) => {
-  return ressourceToPathname(urlToRessource(urlString))
-};
-
-const urlToRessource = (urlString) => {
-  const scheme = urlToScheme(urlString);
-
-  if (scheme === "file") {
-    return urlString.slice("file://".length)
-  }
-
-  if (scheme === "https" || scheme === "http") {
-    // remove origin
-    const afterProtocol = urlString.slice(scheme.length + "://".length);
-    const pathnameSlashIndex = afterProtocol.indexOf("/", "://".length);
-    return afterProtocol.slice(pathnameSlashIndex)
-  }
-
-  return urlString.slice(scheme.length + 1)
-};
-
-const ressourceToPathname = (ressource) => {
-  const searchSeparatorIndex = ressource.indexOf("?");
-  return searchSeparatorIndex === -1
-    ? ressource
-    : ressource.slice(0, searchSeparatorIndex)
-};
-
-const urlToOrigin = (urlString) => {
-  const scheme = urlToScheme(urlString);
-
-  if (scheme === "file") {
-    return "file://"
-  }
-
-  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)
-  }
-
-  return urlString.slice(0, scheme.length + 1)
-};
-
-const pathnameToParentPathname = (pathname) => {
-  const slashLastIndex = pathname.lastIndexOf("/");
-  if (slashLastIndex === -1) {
-    return "/"
-  }
-
-  return pathname.slice(0, slashLastIndex + 1)
-};
-
-// could be useful: https://url.spec.whatwg.org/#url-miscellaneous
-
-
-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 }))
-    }
-  }
-
-  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();
-      }
-    }
-
-    const resolvedPathname = `${importerFolders.join(
-      "/",
-    )}/${unresolvedPathname}`;
-    return `${baseOrigin}${resolvedPathname}`
-  }
-
-  // bare
-  if (basePathname === "") {
-    return `${baseOrigin}/${specifier}`
-  }
-  if (basePathname[basePathname.length] === "/") {
-    return `${baseOrigin}${basePathname}${specifier}`
-  }
-  return `${baseOrigin}${pathnameToParentPathname(basePathname)}${specifier}`
-};
-
-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 resolveSpecifier = (specifier, importer) => {
-  if (
-    specifier === "." ||
-    specifier[0] === "/" ||
-    specifier.startsWith("./") ||
-    specifier.startsWith("../")
-  ) {
-    return resolveUrl(specifier, importer)
-  }
-
-  if (hasScheme(specifier)) {
-    return specifier
-  }
-
-  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 (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,
-        }),
-      )
-    }
-  }
-
-  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
-      }
-    }
-  }
-
-  const { imports } = importMap;
-  if (imports) {
-    const mappingFromImports = applyMappings(
-      imports,
-      specifierNormalized,
-      undefined,
-      onImportMapping,
-    );
-    if (mappingFromImports !== null) {
-      return mappingFromImports
-    }
-  }
-
-  if (specifierUrl) {
-    return specifierUrl
-  }
-
-  throw createBareSpecifierError({ specifier, importer })
-};
-
-const applyMappings = (
-  mappings,
-  specifierNormalized,
-  scope,
-  onImportMapping,
-) => {
-  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,
-      });
-      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
-    }
-  }
-
-  return null
-};
-
-const specifierIsPrefixOf = (specifierHref, href) => {
-  return (
-    specifierHref[specifierHref.length - 1] === "/" &&
-    href.startsWith(specifierHref)
-  )
-};
-
-const sortImports = (imports) => {
-  const mappingsSorted = {};
-
-  Object.keys(imports)
-    .sort(compareLengthOrLocaleCompare)
-    .forEach((name) => {
-      mappingsSorted[name] = imports[name];
-    });
-
-  return mappingsSorted
-};
-
-const sortScopes = (scopes) => {
-  const scopesSorted = {};
-
-  Object.keys(scopes)
-    .sort(compareLengthOrLocaleCompare)
-    .forEach((scopeSpecifier) => {
-      scopesSorted[scopeSpecifier] = sortImports(scopes[scopeSpecifier]);
-    });
-
-  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({
-          addressUrl,
-          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,
-        }),
-      );
-      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,
-    });
-  } else {
-    url = resolveUrl(specifier, importer);
-  }
-
-  if (defaultExtension) {
-    url = applyDefaultExtension({ url, importer, defaultExtension });
-  }
-
-  return url
-};
-
-const applyDefaultExtension = ({ url, importer, defaultExtension }) => {
-  if (urlToPathname(url).endsWith("/")) {
-    return url
-  }
-
-  if (typeof defaultExtension === "string") {
-    const extension = pathnameToExtension(url);
-    if (extension === "") {
-      return `${url}${defaultExtension}`
-    }
-    return url
-  }
-
-  if (defaultExtension === true) {
-    const extension = pathnameToExtension(url);
-    if (extension === "" && importer) {
-      const importerPathname = urlToPathname(importer);
-      const importerExtension = pathnameToExtension(importerPathname);
-      return `${url}${importerExtension}`
-    }
-  }
-
-  return url
-};
-
-export { normalizeImportMap, resolveImport };