@jsenv/core 40.5.3 → 40.6.1

package/dist/build/jsenv_core_packages.js

@@ -516,6 +516,79 @@ const SIGINT_CALLBACK = {
   },
 };
 
+const isFileSystemPath = (value) => {
+  if (typeof value !== "string") {
+    throw new TypeError(
+      `isFileSystemPath first arg must be a string, got ${value}`,
+    );
+  }
+  if (value[0] === "/") {
+    return true;
+  }
+  return startsWithWindowsDriveLetter(value);
+};
+
+const startsWithWindowsDriveLetter = (string) => {
+  const firstChar = string[0];
+  if (!/[a-zA-Z]/.test(firstChar)) return false;
+
+  const secondChar = string[1];
+  if (secondChar !== ":") return false;
+
+  return true;
+};
+
+const fileSystemPathToUrl = (value) => {
+  if (!isFileSystemPath(value)) {
+    throw new Error(`value must be a filesystem path, got ${value}`);
+  }
+  return String(pathToFileURL(value));
+};
+
+const getCallerPosition = () => {
+  const { prepareStackTrace } = Error;
+  Error.prepareStackTrace = (error, stack) => {
+    Error.prepareStackTrace = prepareStackTrace;
+    return stack;
+  };
+  const { stack } = new Error();
+  const callerCallsite = stack[2];
+  const fileName = callerCallsite.getFileName();
+  return {
+    url:
+      fileName && isFileSystemPath(fileName)
+        ? fileSystemPathToUrl(fileName)
+        : fileName,
+    line: callerCallsite.getLineNumber(),
+    column: callerCallsite.getColumnNumber(),
+  };
+};
+
+const urlToFileSystemPath = (url) => {
+  const urlObject = new URL(url);
+  let { origin, pathname, hash } = urlObject;
+  if (urlObject.protocol === "file:") {
+    origin = "file://";
+  }
+  pathname = pathname
+    .split("/")
+    .map((part) => {
+      return part.replace(/%(?![0-9A-F][0-9A-F])/g, "%25");
+    })
+    .join("/");
+  if (hash) {
+    pathname += `%23${encodeURIComponent(hash.slice(1))}`;
+  }
+  const urlString = `${origin}${pathname}`;
+  const fileSystemPath = fileURLToPath(urlString);
+  if (fileSystemPath[fileSystemPath.length - 1] === "/") {
+    // remove trailing / so that nodejs path becomes predictable otherwise it logs
+    // the trailing slash on linux but does not on windows
+    return fileSystemPath.slice(0, -1);
+  }
+  return fileSystemPath;
+};
+
 /*
  * data:[<mediatype>][;base64],<data>
  * https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs#syntax
@@ -1947,6 +2020,75 @@ const urlToOrigin$1 = (url) => {
   return new URL(urlString).origin;
 };
 
+const setUrlExtension = (url, extension) => {
+  const origin = urlToOrigin$1(url);
+  const currentExtension = urlToExtension$1(url);
+  if (typeof extension === "function") {
+    extension = extension(currentExtension);
+  }
+  const resource = urlToResource(url);
+  const [pathname, search] = resource.split("?");
+  const pathnameWithoutExtension = currentExtension
+    ? pathname.slice(0, -currentExtension.length)
+    : pathname;
+  let newPathname;
+  if (pathnameWithoutExtension.endsWith("/")) {
+    newPathname = pathnameWithoutExtension.slice(0, -1);
+    newPathname += extension;
+    newPathname += "/";
+  } else {
+    newPathname = pathnameWithoutExtension;
+    newPathname += extension;
+  }
+  return `${origin}${newPathname}${search ? `?${search}` : ""}`;
+};
+
+const setUrlFilename = (url, filename) => {
+  const parentPathname = new URL("./", url).pathname;
+  return transformUrlPathname(url, (pathname) => {
+    if (typeof filename === "function") {
+      filename = filename(pathnameToFilename(pathname));
+    }
+    return `${parentPathname}${filename}`;
+  });
+};
+
+const setUrlBasename = (url, basename) => {
+  return setUrlFilename(url, (filename) => {
+    if (typeof basename === "function") {
+      basename = basename(filenameToBasename(filename));
+    }
+    return `${basename}${urlToExtension$1(url)}`;
+  });
+};
+
+const transformUrlPathname = (url, transformer) => {
+  if (typeof url === "string") {
+    const urlObject = new URL(url);
+    const { pathname } = urlObject;
+    const pathnameTransformed = transformer(pathname);
+    if (pathnameTransformed === pathname) {
+      return url;
+    }
+    let { origin } = urlObject;
+    // origin is "null" for "file://" urls with Node.js
+    if (origin === "null" && urlObject.href.startsWith("file:")) {
+      origin = "file://";
+    }
+    const { search, hash } = urlObject;
+    const urlWithPathnameTransformed = `${origin}${pathnameTransformed}${search}${hash}`;
+    return urlWithPathnameTransformed;
+  }
+  const pathnameTransformed = transformer(url.pathname);
+  url.pathname = pathnameTransformed;
+  return url;
+};
+const ensurePathnameTrailingSlash = (url) => {
+  return transformUrlPathname(url, (pathname) => {
+    return pathname.endsWith("/") ? pathname : `${pathname}/`;
+  });
+};
+
 const asUrlWithoutSearch = (url) => {
   url = String(url);
   if (url.includes("?")) {
@@ -2099,130 +2241,6 @@ const renderUrlOrRelativeUrlFilename = (urlOrRelativeUrl, renderer) => {
   return `${beforeFilename}${newFilename}${afterQuestion}`;
 };
 
-const setUrlExtension = (url, extension) => {
-  const origin = urlToOrigin$1(url);
-  const currentExtension = urlToExtension$1(url);
-  if (typeof extension === "function") {
-    extension = extension(currentExtension);
-  }
-  const resource = urlToResource(url);
-  const [pathname, search] = resource.split("?");
-  const pathnameWithoutExtension = currentExtension
-    ? pathname.slice(0, -currentExtension.length)
-    : pathname;
-  let newPathname;
-  if (pathnameWithoutExtension.endsWith("/")) {
-    newPathname = pathnameWithoutExtension.slice(0, -1);
-    newPathname += extension;
-    newPathname += "/";
-  } else {
-    newPathname = pathnameWithoutExtension;
-    newPathname += extension;
-  }
-  return `${origin}${newPathname}${search ? `?${search}` : ""}`;
-};
-
-const setUrlFilename = (url, filename) => {
-  const parentPathname = new URL("./", url).pathname;
-  return transformUrlPathname(url, (pathname) => {
-    if (typeof filename === "function") {
-      filename = filename(pathnameToFilename(pathname));
-    }
-    return `${parentPathname}${filename}`;
-  });
-};
-
-const setUrlBasename = (url, basename) => {
-  return setUrlFilename(url, (filename) => {
-    if (typeof basename === "function") {
-      basename = basename(filenameToBasename(filename));
-    }
-    return `${basename}${urlToExtension$1(url)}`;
-  });
-};
-
-const transformUrlPathname = (url, transformer) => {
-  if (typeof url === "string") {
-    const urlObject = new URL(url);
-    const { pathname } = urlObject;
-    const pathnameTransformed = transformer(pathname);
-    if (pathnameTransformed === pathname) {
-      return url;
-    }
-    let { origin } = urlObject;
-    // origin is "null" for "file://" urls with Node.js
-    if (origin === "null" && urlObject.href.startsWith("file:")) {
-      origin = "file://";
-    }
-    const { search, hash } = urlObject;
-    const urlWithPathnameTransformed = `${origin}${pathnameTransformed}${search}${hash}`;
-    return urlWithPathnameTransformed;
-  }
-  const pathnameTransformed = transformer(url.pathname);
-  url.pathname = pathnameTransformed;
-  return url;
-};
-const ensurePathnameTrailingSlash = (url) => {
-  return transformUrlPathname(url, (pathname) => {
-    return pathname.endsWith("/") ? pathname : `${pathname}/`;
-  });
-};
-
-const isFileSystemPath = (value) => {
-  if (typeof value !== "string") {
-    throw new TypeError(
-      `isFileSystemPath first arg must be a string, got ${value}`,
-    );
-  }
-  if (value[0] === "/") {
-    return true;
-  }
-  return startsWithWindowsDriveLetter(value);
-};
-
-const startsWithWindowsDriveLetter = (string) => {
-  const firstChar = string[0];
-  if (!/[a-zA-Z]/.test(firstChar)) return false;
-
-  const secondChar = string[1];
-  if (secondChar !== ":") return false;
-
-  return true;
-};
-
-const fileSystemPathToUrl = (value) => {
-  if (!isFileSystemPath(value)) {
-    throw new Error(`value must be a filesystem path, got ${value}`);
-  }
-  return String(pathToFileURL(value));
-};
-
-const getCallerPosition = () => {
-  const { prepareStackTrace } = Error;
-  Error.prepareStackTrace = (error, stack) => {
-    Error.prepareStackTrace = prepareStackTrace;
-    return stack;
-  };
-  const { stack } = new Error();
-  const callerCallsite = stack[2];
-  const fileName = callerCallsite.getFileName();
-  return {
-    url:
-      fileName && isFileSystemPath(fileName)
-        ? fileSystemPathToUrl(fileName)
-        : fileName,
-    line: callerCallsite.getLineNumber(),
-    column: callerCallsite.getColumnNumber(),
-  };
-};
-
-const resolveUrl$1 = (specifier, baseUrl) => {
-  if (typeof baseUrl === "undefined") {
-    throw new TypeError(`baseUrl missing to resolve ${specifier}`);
-  }
-  return String(new URL(specifier, baseUrl));
-};
-
 const getCommonPathname = (pathname, otherPathname) => {
   if (pathname === otherPathname) {
     return pathname;
@@ -2332,6 +2350,13 @@ const moveUrl = ({ url, from, to, preferRelative }) => {
   return absoluteUrl;
 };
 
+const resolveUrl$1 = (specifier, baseUrl) => {
+  if (typeof baseUrl === "undefined") {
+    throw new TypeError(`baseUrl missing to resolve ${specifier}`);
+  }
+  return String(new URL(specifier, baseUrl));
+};
+
 const urlIsInsideOf = (url, otherUrl) => {
   const urlObject = new URL(url);
   const otherUrlObject = new URL(otherUrl);
@@ -2350,31 +2375,6 @@ const urlIsInsideOf = (url, otherUrl) => {
   return isInside;
 };
 
-const urlToFileSystemPath = (url) => {
-  const urlObject = new URL(url);
-  let { origin, pathname, hash } = urlObject;
-  if (urlObject.protocol === "file:") {
-    origin = "file://";
-  }
-  pathname = pathname
-    .split("/")
-    .map((part) => {
-      return part.replace(/%(?![0-9A-F][0-9A-F])/g, "%25");
-    })
-    .join("/");
-  if (hash) {
-    pathname += `%23${encodeURIComponent(hash.slice(1))}`;
-  }
-  const urlString = `${origin}${pathname}`;
-  const fileSystemPath = fileURLToPath(urlString);
-  if (fileSystemPath[fileSystemPath.length - 1] === "/") {
-    // remove trailing / so that nodejs path becomes predictable otherwise it logs
-    // the trailing slash on linux but does not on windows
-    return fileSystemPath.slice(0, -1);
-  }
-  return fileSystemPath;
-};
-
 const validateDirectoryUrl = (value) => {
   let urlString;
 
@@ -7080,6 +7080,23 @@ const isResponseEligibleForIntegrityValidation = (response) => {
   return ["basic", "cors", "default"].includes(response.type);
 };
 
+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}`,
+    );
+  }
+};
+
 // duplicated from @jsenv/log to avoid the dependency
 const createDetailedMessage = (message, details = {}) => {
   let string = `${message}`;
@@ -7096,89 +7113,72 @@ const createDetailedMessage = (message, details = {}) => {
     }`;
   });
 
-  return string
+  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}`)
-  }
+const hasScheme = (string) => {
+  return /^[a-zA-Z]{2,}:/.test(string);
+};
 
-  if (Array.isArray(value)) {
-    throw new TypeError(
-      `an importMap must be an object, received array ${value}`,
-    )
+const pathnameToParentPathname = (pathname) => {
+  const slashLastIndex = pathname.lastIndexOf("/");
+  if (slashLastIndex === -1) {
+    return "/";
   }
-};
 
-const hasScheme = (string) => {
-  return /^[a-zA-Z]{2,}:/.test(string)
+  return pathname.slice(0, slashLastIndex + 1);
 };
 
 const urlToScheme = (urlString) => {
   const colonIndex = urlString.indexOf(":");
-  if (colonIndex === -1) return ""
-  return urlString.slice(0, colonIndex)
+  if (colonIndex === -1) return "";
+  return urlString.slice(0, colonIndex);
+};
+
+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 urlToPathname = (urlString) => {
-  return ressourceToPathname(urlToRessource(urlString))
+  return ressourceToPathname(urlToRessource(urlString));
 };
 
 const urlToRessource = (urlString) => {
   const scheme = urlToScheme(urlString);
 
   if (scheme === "file") {
-    return urlString.slice("file://".length)
+    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 afterProtocol.slice(pathnameSlashIndex);
   }
 
-  return urlString.slice(scheme.length + 1)
+  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)
+    : ressource.slice(0, searchSeparatorIndex);
 };
 
 // could be useful: https://url.spec.whatwg.org/#url-miscellaneous
@@ -7187,29 +7187,29 @@ const pathnameToParentPathname = (pathname) => {
 const resolveUrl = (specifier, baseUrl) => {
   if (baseUrl) {
     if (typeof baseUrl !== "string") {
-      throw new TypeError(writeBaseUrlMustBeAString({ baseUrl, specifier }))
+      throw new TypeError(writeBaseUrlMustBeAString({ baseUrl, specifier }));
     }
     if (!hasScheme(baseUrl)) {
-      throw new Error(writeBaseUrlMustBeAbsolute({ baseUrl, specifier }))
+      throw new Error(writeBaseUrlMustBeAbsolute({ baseUrl, specifier }));
     }
   }
 
   if (hasScheme(specifier)) {
-    return specifier
+    return specifier;
   }
 
   if (!baseUrl) {
-    throw new Error(writeBaseUrlRequired({ baseUrl, specifier }))
+    throw new Error(writeBaseUrlRequired({ baseUrl, specifier }));
   }
 
   // scheme relative
   if (specifier.slice(0, 2) === "//") {
-    return `${urlToScheme(baseUrl)}:${specifier}`
+    return `${urlToScheme(baseUrl)}:${specifier}`;
   }
 
   // origin relative
   if (specifier[0] === "/") {
-    return `${urlToOrigin(baseUrl)}${specifier}`
+    return `${urlToOrigin(baseUrl)}${specifier}`;
   }
 
   const baseOrigin = urlToOrigin(baseUrl);
@@ -7217,13 +7217,13 @@ const resolveUrl = (specifier, baseUrl) => {
 
   if (specifier === ".") {
     const baseDirectoryPathname = pathnameToParentPathname(basePathname);
-    return `${baseOrigin}${baseDirectoryPathname}`
+    return `${baseOrigin}${baseDirectoryPathname}`;
   }
 
   // pathname relative inside
   if (specifier.slice(0, 2) === "./") {
     const baseDirectoryPathname = pathnameToParentPathname(basePathname);
-    return `${baseOrigin}${baseDirectoryPathname}${specifier.slice(2)}`
+    return `${baseOrigin}${baseDirectoryPathname}${specifier.slice(2)}`;
   }
 
   // pathname relative outside
@@ -7244,17 +7244,17 @@ const resolveUrl = (specifier, baseUrl) => {
     const resolvedPathname = `${importerFolders.join(
       "/",
     )}/${unresolvedPathname}`;
-    return `${baseOrigin}${resolvedPathname}`
+    return `${baseOrigin}${resolvedPathname}`;
   }
 
   // bare
   if (basePathname === "") {
-    return `${baseOrigin}/${specifier}`
+    return `${baseOrigin}/${specifier}`;
   }
   if (basePathname[basePathname.length] === "/") {
-    return `${baseOrigin}${basePathname}${specifier}`
+    return `${baseOrigin}${basePathname}${specifier}`;
   }
-  return `${baseOrigin}${pathnameToParentPathname(basePathname)}${specifier}`
+  return `${baseOrigin}${pathnameToParentPathname(basePathname)}${specifier}`;
 };
 
 const writeBaseUrlMustBeAString = ({
@@ -7286,7 +7286,7 @@ ${specifier}`;
 
 const tryUrlResolution = (string, url) => {
   const result = resolveUrl(string, url);
-  return hasScheme(result) ? result : null
+  return hasScheme(result) ? result : null;
 };
 
 const resolveSpecifier = (specifier, importer) => {
@@ -7296,14 +7296,14 @@ const resolveSpecifier = (specifier, importer) => {
     specifier.startsWith("./") ||
     specifier.startsWith("../")
   ) {
-    return resolveUrl(specifier, importer)
+    return resolveUrl(specifier, importer);
   }
 
   if (hasScheme(specifier)) {
-    return specifier
+    return specifier;
   }
 
-  return null
+  return null;
 };
 
 const applyImportMap = ({
@@ -7316,7 +7316,7 @@ const applyImportMap = ({
         specifier,
         importer,
       }),
-    )
+    );
   },
   onImportMapping = () => {},
 }) => {
@@ -7327,7 +7327,7 @@ const applyImportMap = ({
         specifier,
         importer,
       }),
-    )
+    );
   }
   if (importer) {
     if (typeof importer !== "string") {
@@ -7336,7 +7336,7 @@ const applyImportMap = ({
           importer,
           specifier,
         }),
-      )
+      );
     }
     if (!hasScheme(importer)) {
       throw new Error(
@@ -7344,7 +7344,7 @@ const applyImportMap = ({
           importer,
           specifier,
         }),
-      )
+      );
     }
   }
 
@@ -7358,7 +7358,7 @@ const applyImportMap = ({
         return (
           scopeSpecifier === importer ||
           specifierIsPrefixOf(scopeSpecifier, importer)
-        )
+        );
       },
     );
     if (scopeSpecifierMatching) {
@@ -7370,7 +7370,7 @@ const applyImportMap = ({
         onImportMapping,
       );
       if (mappingFromScopes !== null) {
-        return mappingFromScopes
+        return mappingFromScopes;
       }
     }
   }
@@ -7384,15 +7384,15 @@ const applyImportMap = ({
       onImportMapping,
     );
     if (mappingFromImports !== null) {
-      return mappingFromImports
+      return mappingFromImports;
     }
   }
 
   if (specifierUrl) {
-    return specifierUrl
+    return specifierUrl;
   }
 
-  throw createBareSpecifierError({ specifier, importer })
+  throw createBareSpecifierError({ specifier, importer });
 };
 
 const applyMappings = (
@@ -7416,7 +7416,7 @@ const applyMappings = (
         before: specifierNormalized,
         after: address,
       });
-      return address
+      return address;
     }
     if (specifierIsPrefixOf(specifierCandidate, specifierNormalized)) {
       const address = mappings[specifierCandidate];
@@ -7431,18 +7431,18 @@ const applyMappings = (
         before: specifierNormalized,
         after: addressFinal,
       });
-      return addressFinal
+      return addressFinal;
     }
   }
 
-  return null
+  return null;
 };
 
 const specifierIsPrefixOf = (specifierHref, href) => {
   return (
     specifierHref[specifierHref.length - 1] === "/" &&
     href.startsWith(specifierHref)
-  )
+  );
 };
 
 // https://github.com/systemjs/systemjs/blob/89391f92dfeac33919b0223bbf834a1f4eea5750/src/common.js#L136
@@ -7481,7 +7481,7 @@ const composeTwoImportMaps = (leftImportMap, rightImportMap) => {
     importMap.scopes = { ...rightScopes };
   }
 
-  return importMap
+  return importMap;
 };
 
 const composeTwoMappings = (leftMappings, rightMappings) => {
@@ -7490,11 +7490,11 @@ const composeTwoMappings = (leftMappings, rightMappings) => {
   Object.keys(leftMappings).forEach((leftSpecifier) => {
     if (objectHasKey(rightMappings, leftSpecifier)) {
       // will be overidden
-      return
+      return;
     }
     const leftAddress = leftMappings[leftSpecifier];
     const rightSpecifier = Object.keys(rightMappings).find((rightSpecifier) => {
-      return compareAddressAndSpecifier(leftAddress, rightSpecifier)
+      return compareAddressAndSpecifier(leftAddress, rightSpecifier);
     });
     mappings[leftSpecifier] = rightSpecifier
       ? rightMappings[rightSpecifier]
@@ -7505,7 +7505,7 @@ const composeTwoMappings = (leftMappings, rightMappings) => {
     mappings[rightSpecifier] = rightMappings[rightSpecifier];
   });
 
-  return mappings
+  return mappings;
 };
 
 const objectHasKey = (object, key) =>
@@ -7514,7 +7514,7 @@ const objectHasKey = (object, key) =>
 const compareAddressAndSpecifier = (address, specifier) => {
   const addressUrl = resolveUrl(address, "file:///");
   const specifierUrl = resolveUrl(specifier, "file:///");
-  return addressUrl === specifierUrl
+  return addressUrl === specifierUrl;
 };
 
 const composeTwoScopes = (leftScopes, rightScopes, imports) => {
@@ -7524,14 +7524,14 @@ const composeTwoScopes = (leftScopes, rightScopes, imports) => {
     if (objectHasKey(rightScopes, leftScopeKey)) {
       // will be merged
       scopes[leftScopeKey] = leftScopes[leftScopeKey];
-      return
+      return;
     }
     const topLevelSpecifier = Object.keys(imports).find(
       (topLevelSpecifierCandidate) => {
         return compareAddressAndSpecifier(
           leftScopeKey,
           topLevelSpecifierCandidate,
-        )
+        );
       },
     );
     if (topLevelSpecifier) {
@@ -7554,7 +7554,7 @@ const composeTwoScopes = (leftScopes, rightScopes, imports) => {
     }
   });
 
-  return scopes
+  return scopes;
 };
 
 const sortImports = (imports) => {
@@ -7566,7 +7566,7 @@ const sortImports = (imports) => {
       mappingsSorted[name] = imports[name];
     });
 
-  return mappingsSorted
+  return mappingsSorted;
 };
 
 const sortScopes = (scopes) => {
@@ -7578,18 +7578,18 @@ const sortScopes = (scopes) => {
       scopesSorted[scopeSpecifier] = sortImports(scopes[scopeSpecifier]);
     });
 
-  return scopesSorted
+  return scopesSorted;
 };
 
 const compareLengthOrLocaleCompare = (a, b) => {
-  return b.length - a.length || a.localeCompare(b)
+  return b.length - a.length || a.localeCompare(b);
 };
 
 const normalizeImportMap = (importMap, baseUrl) => {
   assertImportMap(importMap);
 
   if (!isStringOrUrl(baseUrl)) {
-    throw new TypeError(formulateBaseUrlMustBeStringOrUrl({ baseUrl }))
+    throw new TypeError(formulateBaseUrlMustBeStringOrUrl({ baseUrl }));
   }
 
   const { imports, scopes } = importMap;
@@ -7597,19 +7597,19 @@ const normalizeImportMap = (importMap, baseUrl) => {
   return {
     imports: imports ? normalizeMappings(imports, baseUrl) : undefined,
     scopes: scopes ? normalizeScopes(scopes, baseUrl) : undefined,
-  }
+  };
 };
 
 const isStringOrUrl = (value) => {
   if (typeof value === "string") {
-    return true
+    return true;
   }
 
   if (typeof URL === "function" && value instanceof URL) {
-    return true
+    return true;
   }
 
-  return false
+  return false;
 };
 
 const normalizeMappings = (mappings, baseUrl) => {
@@ -7625,7 +7625,7 @@ const normalizeMappings = (mappings, baseUrl) => {
           specifier,
         }),
       );
-      return
+      return;
     }
 
     const specifierResolved = resolveSpecifier(specifier, baseUrl) || specifier;
@@ -7639,7 +7639,7 @@ const normalizeMappings = (mappings, baseUrl) => {
           specifier,
         }),
       );
-      return
+      return;
     }
 
     if (specifier.endsWith("/") && !addressUrl.endsWith("/")) {
@@ -7649,12 +7649,12 @@ const normalizeMappings = (mappings, baseUrl) => {
           specifier,
         }),
       );
-      return
+      return;
     }
     mappingsNormalized[specifierResolved] = addressUrl;
   });
 
-  return sortImports(mappingsNormalized)
+  return sortImports(mappingsNormalized);
 };
 
 const normalizeScopes = (scopes, baseUrl) => {
@@ -7670,13 +7670,13 @@ const normalizeScopes = (scopes, baseUrl) => {
           baseUrl,
         }),
       );
-      return
+      return;
     }
     const scopeValueNormalized = normalizeMappings(scopeMappings, baseUrl);
     scopesNormalized[scopeUrl] = scopeValueNormalized;
   });
 
-  return sortScopes(scopesNormalized)
+  return sortScopes(scopesNormalized);
 };
 
 const formulateBaseUrlMustBeStringOrUrl = ({
@@ -7734,9 +7734,9 @@ const pathnameToExtension = (pathname) => {
   }
 
   const dotLastIndex = pathname.lastIndexOf(".");
-  if (dotLastIndex === -1) return ""
+  if (dotLastIndex === -1) return "";
   // if (dotLastIndex === pathname.length - 1) return ""
-  return pathname.slice(dotLastIndex)
+  return pathname.slice(dotLastIndex);
 };
 
 const resolveImport = ({
@@ -7764,20 +7764,20 @@ const resolveImport = ({
     url = applyDefaultExtension({ url, importer, defaultExtension });
   }
 
-  return url
+  return url;
 };
 
 const applyDefaultExtension = ({ url, importer, defaultExtension }) => {
   if (urlToPathname(url).endsWith("/")) {
-    return url
+    return url;
   }
 
   if (typeof defaultExtension === "string") {
     const extension = pathnameToExtension(url);
     if (extension === "") {
-      return `${url}${defaultExtension}`
+      return `${url}${defaultExtension}`;
     }
-    return url
+    return url;
   }
 
   if (defaultExtension === true) {
@@ -7785,11 +7785,11 @@ const applyDefaultExtension = ({ url, importer, defaultExtension }) => {
     if (extension === "" && importer) {
       const importerPathname = urlToPathname(importer);
       const importerExtension = pathnameToExtension(importerPathname);
-      return `${url}${importerExtension}`
+      return `${url}${importerExtension}`;
     }
   }
 
-  return url
+  return url;
 };
 
 const isEscaped = (i, string) => {