@jsenv/core 40.5.2 → 40.6.0

package/dist/build/build.js

@@ -5594,13 +5594,32 @@ const createNodeEsmResolver = ({
       return null; // let it to jsenv_web_resolution
     }
     const { specifier } = reference;
-    const conditions = buildPackageConditions(specifier, parentUrl);
-    const { url, type, isMain, packageDirectoryUrl } = applyNodeEsmResolution({
+    // specifiers like "#something" have a special meaning for Node.js
+    // but can also be used in .css and .html files for example and should not be modified
+    // by node esm resolution
+    const webResolutionFallback =
+      ownerUrlInfo.type !== "js_module" ||
+      reference.type === "sourcemap_comment";
+    const conditions = buildPackageConditions(specifier, parentUrl, {
+      webResolutionFallback,
+    });
+    let resolution;
+    const nodeEsmResolutionParams = {
       conditions,
       parentUrl,
       specifier,
       preservesSymlink,
-    });
+    };
+    if (webResolutionFallback) {
+      try {
+        resolution = applyNodeEsmResolution(nodeEsmResolutionParams);
+      } catch {
+        return null; // delegate to web_resolution plugin
+      }
+    } else {
+      resolution = applyNodeEsmResolution(nodeEsmResolutionParams);
+    }
+    const { url, type, isMain, packageDirectoryUrl } = resolution;
     // try to give a more meaningful filename after build
     if (isMain && packageDirectoryUrl) {
       const basename = urlToBasename(url);
@@ -5669,12 +5688,26 @@ const createBuildPackageConditions = (
   const nodeRuntimeEnabled = Object.keys(runtimeCompat).includes("node");
   // https://nodejs.org/api/esm.html#resolver-algorithm-specification
   const processArgConditions = readCustomConditionsFromProcessArgs();
-  const devResolver = (specifier, importer) => {
+  const devResolver = (specifier, importer, { webResolutionFallback }) => {
     if (isBareSpecifier$1(specifier)) {
-      const { url } = applyNodeEsmResolution({
-        specifier,
-        parentUrl: importer,
-      });
+      let url;
+      if (webResolutionFallback) {
+        try {
+          const resolution = applyNodeEsmResolution({
+            specifier,
+            parentUrl: importer,
+          });
+          url = resolution.url;
+        } catch {
+          url = new URL(specifier, importer).href;
+        }
+      } else {
+        const resolution = applyNodeEsmResolution({
+          specifier,
+          parentUrl: importer,
+        });
+        url = resolution.url;
+      }
       return !url.includes("/node_modules/");
     }
     return !importer.includes("/node_modules/");
@@ -5778,12 +5811,12 @@ const createBuildPackageConditions = (
   }
 
   const conditionCandidateArray = Object.keys(conditionResolvers);
-  return (specifier, importer) => {
+  return (specifier, importer, params) => {
     const conditions = [];
     for (const conditionCandidate of conditionCandidateArray) {
       const conditionResolver = conditionResolvers[conditionCandidate];
       if (typeof conditionResolver === "function") {
-        if (conditionResolver(specifier, importer)) {
+        if (conditionResolver(specifier, importer, params)) {
           conditions.push(conditionCandidate);
         }
       } else if (conditionResolver) {
@@ -5907,8 +5940,7 @@ const jsenvPluginNodeEsmResolution = (
         if (config === true) {
           resolver = nodeEsmResolverDefault;
         } else if (config === false) {
-          // resolverMap.set(urlType, () => null);
-          continue;
+          resolver = null;
         } else if (typeof config === "object") {
           resolver = resolverFromObject(config, { kitchenContext, urlType });
         } else {
@@ -5923,6 +5955,9 @@ const jsenvPluginNodeEsmResolution = (
           resolverMap.set(urlType, resolver);
         }
       }
+      if (!anyTypeResolver) {
+        anyTypeResolver = nodeEsmResolverDefault;
+      }
 
       if (!resolverMap.has("js_module")) {
         resolverMap.set("js_module", nodeEsmResolverDefault);
@@ -5948,8 +5983,11 @@ const jsenvPluginNodeEsmResolution = (
       }
       const urlType = urlTypeFromReference(reference);
       const resolver = resolverMap.get(urlType);
-      if (resolver) {
-        return resolver(reference);
+      if (resolver !== undefined) {
+        if (typeof resolver === "function") {
+          return resolver(reference);
+        }
+        return resolver;
       }
       if (anyTypeResolver) {
         return anyTypeResolver(reference);

package/dist/build/jsenv_core_packages.js

@@ -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) => {