@jsenv/core 35.0.2 → 35.0.4

package/src/plugins/import_meta_scenarios/jsenv_plugin_import_meta_scenarios.js

@@ -8,8 +8,8 @@
  * - replaced by undefined (import.meta.dev but it's build; the goal is to ensure it's tree-shaked)
  */
 
-import { createMagicSource } from "@jsenv/sourcemap"
-import { applyBabelPlugins } from "@jsenv/ast"
+import { createMagicSource } from "@jsenv/sourcemap";
+import { applyBabelPlugins } from "@jsenv/ast";
 
 export const jsenvPluginImportMetaScenarios = () => {
   return {
@@ -22,80 +22,80 @@ export const jsenvPluginImportMetaScenarios = () => {
           !urlInfo.content.includes("import.meta.test") &&
           !urlInfo.content.includes("import.meta.build")
         ) {
-          return null
+          return null;
         }
         const { metadata } = await applyBabelPlugins({
           babelPlugins: [babelPluginMetadataImportMetaScenarios],
           urlInfo,
-        })
-        const { dev = [], build = [] } = metadata.importMetaScenarios
-        const replacements = []
+        });
+        const { dev = [], build = [] } = metadata.importMetaScenarios;
+        const replacements = [];
         const replace = (path, value) => {
-          replacements.push({ path, value })
-        }
+          replacements.push({ path, value });
+        };
         if (context.build) {
           // during build ensure replacement for tree-shaking
           dev.forEach((path) => {
-            replace(path, "undefined")
-          })
+            replace(path, "undefined");
+          });
           build.forEach((path) => {
-            replace(path, "true")
-          })
+            replace(path, "true");
+          });
         } else {
           // during dev we can let "import.meta.build" untouched
           // it will be evaluated to undefined.
           // Moreover it can be surprising to see some "undefined"
           // when source file contains "import.meta.build"
           dev.forEach((path) => {
-            replace(path, "true")
-          })
+            replace(path, "true");
+          });
         }
-        const magicSource = createMagicSource(urlInfo.content)
+        const magicSource = createMagicSource(urlInfo.content);
         replacements.forEach(({ path, value }) => {
           magicSource.replace({
             start: path.node.start,
             end: path.node.end,
             replacement: value,
-          })
-        })
-        return magicSource.toContentAndSourcemap()
+          });
+        });
+        return magicSource.toContentAndSourcemap();
       },
     },
-  }
-}
+  };
+};
 
 const babelPluginMetadataImportMetaScenarios = () => {
   return {
     name: "metadata-import-meta-scenarios",
     visitor: {
       Program(programPath, state) {
-        const importMetas = {}
+        const importMetas = {};
         programPath.traverse({
           MemberExpression(path) {
-            const { node } = path
-            const { object } = node
+            const { node } = path;
+            const { object } = node;
             if (object.type !== "MetaProperty") {
-              return
+              return;
             }
-            const { property: objectProperty } = object
+            const { property: objectProperty } = object;
             if (objectProperty.name !== "meta") {
-              return
+              return;
             }
-            const { property } = node
-            const { name } = property
-            const importMetaPaths = importMetas[name]
+            const { property } = node;
+            const { name } = property;
+            const importMetaPaths = importMetas[name];
             if (importMetaPaths) {
-              importMetaPaths.push(path)
+              importMetaPaths.push(path);
             } else {
-              importMetas[name] = [path]
+              importMetas[name] = [path];
             }
           },
-        })
+        });
         state.file.metadata.importMetaScenarios = {
           dev: importMetas.dev,
           build: importMetas.build,
-        }
+        };
       },
     },
-  }
-}
+  };
+};

package/src/plugins/import_meta_url/client/import_meta_url_browser.js

@@ -1,51 +1,51 @@
 const getCurrentScriptSrc = () => {
-  const { currentScript } = document
-  if (currentScript) return currentScript.src
+  const { currentScript } = document;
+  if (currentScript) return currentScript.src;
 
   // https://github.com/amiller-gh/currentScript-polyfill
 
   const scripts = Array.prototype.slice.call(
     document.getElementsByTagName("script"),
-  )
+  );
 
   const readyScript = scripts.find((script) => {
-    return script.readyState === "interactive"
-  })
-  if (readyScript) return readyScript
+    return script.readyState === "interactive";
+  });
+  if (readyScript) return readyScript;
 
   try {
-    throw new Error()
+    throw new Error();
   } catch (err) {
     // Find the second match for the "at" string to get file src url from stack.
     // Specifically works with the format of stack traces in IE.
-    const stackDetails = /.*at [^(]*\((.*):(.+):(.+)\)$/gi.exec(err.stack)
-    const scriptLocation = (stackDetails || [false])[1]
-    const line = (stackDetails || [false])[2]
+    const stackDetails = /.*at [^(]*\((.*):(.+):(.+)\)$/gi.exec(err.stack);
+    const scriptLocation = (stackDetails || [false])[1];
+    const line = (stackDetails || [false])[2];
     const currentLocation = document.location.href.replace(
       document.location.hash,
       "",
-    )
+    );
 
     if (scriptLocation === currentLocation) {
-      const source = document.documentElement.outerHTML
+      const source = document.documentElement.outerHTML;
       const codeRegExp = new RegExp(
         `(?:[^\\n]+?\\n){0,${
           line - 2
         }}[^<]*<script>([\\d\\D]*?)<\\/script>[\\d\\D]*`,
         "i",
-      )
-      const code = source.replace(codeRegExp, "$1").trim()
+      );
+      const code = source.replace(codeRegExp, "$1").trim();
 
       return scripts.find((script) => {
-        return script.innerHTML && script.innerHTML.trim() === code
-      })
+        return script.innerHTML && script.innerHTML.trim() === code;
+      });
     }
 
     return scripts.find((script) => {
-      return script.src === scriptLocation
-    })
+      return script.src === scriptLocation;
+    });
   }
-}
+};
 
-const url = getCurrentScriptSrc()
-export { url }
+const url = getCurrentScriptSrc();
+export { url };

package/src/plugins/import_meta_url/client/import_meta_url_commonjs.mjs

@@ -1,9 +1,9 @@
 /* global __filename */
 
-const filenameContainsBackSlashes = __filename.indexOf("\\") > -1
+const filenameContainsBackSlashes = __filename.indexOf("\\") > -1;
 
 const url = filenameContainsBackSlashes
   ? `file:///${__filename.replace(/\\/g, "/")}`
-  : `file://${__filename}`
+  : `file://${__filename}`;
 
-export { url }
+export { url };

package/src/plugins/importmap/jsenv_plugin_importmap.js

@@ -21,8 +21,8 @@ import {
   resolveImport,
   composeTwoImportMaps,
   normalizeImportMap,
-} from "@jsenv/importmap"
-import { generateInlineContentUrl } from "@jsenv/urls"
+} from "@jsenv/importmap";
+import { generateInlineContentUrl } from "@jsenv/urls";
 import {
   parseHtmlString,
   stringifyHtmlAst,
@@ -33,26 +33,26 @@ import {
   getHtmlNodeText,
   setHtmlNodeText,
   removeHtmlNode,
-} from "@jsenv/ast"
+} from "@jsenv/ast";
 
 export const jsenvPluginImportmap = () => {
-  let finalImportmap = null
-  const importmaps = {}
+  let finalImportmap = null;
+  const importmaps = {};
   const onHtmlImportmapParsed = (importmap, htmlUrl) => {
     importmaps[htmlUrl] = importmap
       ? normalizeImportMap(importmap, htmlUrl)
-      : null
+      : null;
     finalImportmap = Object.keys(importmaps).reduce((previous, url) => {
-      const importmap = importmaps[url]
+      const importmap = importmaps[url];
       if (!previous) {
-        return importmap
+        return importmap;
       }
       if (!importmap) {
-        return previous
+        return previous;
       }
-      return composeTwoImportMaps(previous, importmap)
-    }, null)
-  }
+      return composeTwoImportMaps(previous, importmap);
+    }, null);
+  };
 
   return {
     name: "jsenv:importmap",
@@ -60,22 +60,22 @@ export const jsenvPluginImportmap = () => {
     resolveUrl: {
       js_import: (reference) => {
         if (!finalImportmap) {
-          return null
+          return null;
         }
         try {
-          let fromMapping = false
+          let fromMapping = false;
           const result = resolveImport({
             specifier: reference.specifier,
             importer: reference.parentUrl,
             importMap: finalImportmap,
             onImportMapping: () => {
-              fromMapping = true
+              fromMapping = true;
             },
-          })
+          });
           if (fromMapping) {
-            return result
+            return result;
           }
-          return null
+          return null;
         } catch (e) {
           if (e.message.includes("bare specifier")) {
             // in theory we should throw to be compliant with web behaviour
@@ -83,34 +83,34 @@ export const jsenvPluginImportmap = () => {
             // and let a chance to other plugins to handle the bare specifier
             // (node esm resolution)
             // and we want importmap to be prio over node esm so we cannot put this plugin after
-            return null
+            return null;
           }
-          throw e
+          throw e;
         }
       },
     },
     transformUrlContent: {
       html: async (htmlUrlInfo, context) => {
-        const htmlAst = parseHtmlString(htmlUrlInfo.content)
+        const htmlAst = parseHtmlString(htmlUrlInfo.content);
         const importmap = findHtmlNode(htmlAst, (node) => {
           if (node.nodeName !== "script") {
-            return false
+            return false;
           }
-          const type = getHtmlNodeAttribute(node, "type")
+          const type = getHtmlNodeAttribute(node, "type");
           if (type === undefined || type !== "importmap") {
-            return false
+            return false;
           }
-          return true
-        })
+          return true;
+        });
         if (!importmap) {
-          onHtmlImportmapParsed(null, htmlUrlInfo.url)
-          return null
+          onHtmlImportmapParsed(null, htmlUrlInfo.url);
+          return null;
         }
         const handleInlineImportmap = async (importmap, htmlNodeText) => {
           const { line, column, lineEnd, columnEnd, isOriginal } =
             getHtmlNodePosition(importmap, {
               preferOriginal: true,
-            })
+            });
           const inlineImportmapUrl = generateInlineContentUrl({
             url: htmlUrlInfo.url,
             extension: ".importmap",
@@ -118,7 +118,7 @@ export const jsenvPluginImportmap = () => {
             column,
             lineEnd,
             columnEnd,
-          })
+          });
           const [inlineImportmapReference, inlineImportmapUrlInfo] =
             context.referenceUtils.foundInline({
               type: "script",
@@ -128,21 +128,21 @@ export const jsenvPluginImportmap = () => {
               specifier: inlineImportmapUrl,
               contentType: "application/importmap+json",
               content: htmlNodeText,
-            })
+            });
           await context.cook(inlineImportmapUrlInfo, {
             reference: inlineImportmapReference,
-          })
+          });
           setHtmlNodeText(importmap, inlineImportmapUrlInfo.content, {
             indentation: "auto",
-          })
+          });
           setHtmlNodeAttributes(importmap, {
             "jsenv-cooked-by": "jsenv:importmap",
-          })
+          });
           onHtmlImportmapParsed(
             JSON.parse(inlineImportmapUrlInfo.content),
             htmlUrlInfo.url,
-          )
-        }
+          );
+        };
         const handleImportmapWithSrc = async (importmap, src) => {
           // Browser would throw on remote importmap
           // and won't sent a request to the server for it
@@ -151,30 +151,30 @@ export const jsenvPluginImportmap = () => {
           // when parsing the HTML
           const importmapReference = context.referenceUtils.find(
             (ref) => ref.generatedSpecifier === src,
-          )
+          );
           const importmapUrlInfo = context.urlGraph.getUrlInfo(
             importmapReference.url,
-          )
+          );
           await context.cook(importmapUrlInfo, {
             reference: importmapReference,
-          })
+          });
           onHtmlImportmapParsed(
             JSON.parse(importmapUrlInfo.content),
             htmlUrlInfo.url,
-          )
+          );
           setHtmlNodeText(importmap, importmapUrlInfo.content, {
             indentation: "auto",
-          })
+          });
           setHtmlNodeAttributes(importmap, {
             "src": undefined,
             "jsenv-inlined-by": "jsenv:importmap",
             "inlined-from-src": src,
-          })
+          });
 
           const { line, column, lineEnd, columnEnd, isOriginal } =
             getHtmlNodePosition(importmap, {
               preferOriginal: true,
-            })
+            });
           const inlineImportmapUrl = generateInlineContentUrl({
             url: htmlUrlInfo.url,
             extension: ".importmap",
@@ -182,7 +182,7 @@ export const jsenvPluginImportmap = () => {
             column,
             lineEnd,
             columnEnd,
-          })
+          });
           context.referenceUtils.becomesInline(importmapReference, {
             line: line - 1,
             column,
@@ -190,16 +190,16 @@ export const jsenvPluginImportmap = () => {
             specifier: inlineImportmapUrl,
             contentType: "application/importmap+json",
             content: importmapUrlInfo.content,
-          })
-        }
+          });
+        };
 
-        const src = getHtmlNodeAttribute(importmap, "src")
+        const src = getHtmlNodeAttribute(importmap, "src");
         if (src) {
-          await handleImportmapWithSrc(importmap, src)
+          await handleImportmapWithSrc(importmap, src);
         } else {
-          const htmlNodeText = getHtmlNodeText(importmap)
+          const htmlNodeText = getHtmlNodeText(importmap);
           if (htmlNodeText) {
-            await handleInlineImportmap(importmap, htmlNodeText)
+            await handleInlineImportmap(importmap, htmlNodeText);
           }
         }
         // once this plugin knows the importmap, it will use it
@@ -208,12 +208,12 @@ export const jsenvPluginImportmap = () => {
         // In dev/test we keep importmap into the HTML to see it even if useless
         // Duing build we get rid of it
         if (context.build) {
-          removeHtmlNode(importmap)
+          removeHtmlNode(importmap);
         }
         return {
           content: stringifyHtmlAst(htmlAst),
-        }
+        };
       },
     },
-  }
-}
+  };
+};

package/src/plugins/inline_content_analysis/client/inline_content.js

@@ -1,6 +1,6 @@
 function InlineContent(content, { type = "text/plain" }) {
-  this.text = content
-  this.type = type
+  this.text = content;
+  this.type = type;
 }
 
-export { InlineContent }
+export { InlineContent };

package/src/plugins/inline_content_analysis/jsenv_plugin_data_urls.js

@@ -1,5 +1,5 @@
-import { DATA_URL } from "@jsenv/urls"
-import { CONTENT_TYPE } from "@jsenv/utils/src/content_type/content_type.js"
+import { DATA_URL } from "@jsenv/urls";
+import { CONTENT_TYPE } from "@jsenv/utils/src/content_type/content_type.js";
 
 export const jsenvPluginDataUrls = () => {
   return {
@@ -7,37 +7,37 @@ export const jsenvPluginDataUrls = () => {
     appliesDuring: "*",
     resolveUrl: (reference) => {
       if (!reference.specifier.startsWith("data:")) {
-        return null
+        return null;
       }
-      return reference.specifier
+      return reference.specifier;
     },
     fetchUrlContent: (urlInfo) => {
       if (!urlInfo.url.startsWith("data:")) {
-        return null
+        return null;
       }
       const {
         contentType,
         base64Flag,
         data: urlData,
-      } = DATA_URL.parse(urlInfo.url)
-      urlInfo.data.base64Flag = base64Flag
+      } = DATA_URL.parse(urlInfo.url);
+      urlInfo.data.base64Flag = base64Flag;
       return {
         content: contentFromUrlData({ contentType, base64Flag, urlData }),
         contentType,
-      }
+      };
     },
     formatUrl: (reference, context) => {
       if (!reference.generatedUrl.startsWith("data:")) {
-        return null
+        return null;
       }
       if (reference.type === "sourcemap_comment") {
-        return null
+        return null;
       }
       return (async () => {
-        const urlInfo = context.urlGraph.getUrlInfo(reference.url)
-        await context.cook(urlInfo, { reference })
+        const urlInfo = context.urlGraph.getUrlInfo(reference.url);
+        await context.cook(urlInfo, { reference });
         if (urlInfo.originalContent === urlInfo.content) {
-          return reference.generatedUrl
+          return reference.generatedUrl;
         }
         const specifier = DATA_URL.stringify({
           contentType: urlInfo.contentType,
@@ -45,27 +45,27 @@ export const jsenvPluginDataUrls = () => {
           data: urlInfo.data.base64Flag
             ? dataToBase64(urlInfo.content)
             : String(urlInfo.content),
-        })
-        return specifier
-      })()
+        });
+        return specifier;
+      })();
     },
-  }
-}
+  };
+};
 
 const contentFromUrlData = ({ contentType, base64Flag, urlData }) => {
   if (CONTENT_TYPE.isTextual(contentType)) {
     if (base64Flag) {
-      return base64ToString(urlData)
+      return base64ToString(urlData);
     }
-    return urlData
+    return urlData;
   }
   if (base64Flag) {
-    return base64ToBuffer(urlData)
+    return base64ToBuffer(urlData);
   }
-  return Buffer.from(urlData)
-}
+  return Buffer.from(urlData);
+};
 
-const base64ToBuffer = (base64String) => Buffer.from(base64String, "base64")
+const base64ToBuffer = (base64String) => Buffer.from(base64String, "base64");
 const base64ToString = (base64String) =>
-  Buffer.from(base64String, "base64").toString("utf8")
-const dataToBase64 = (data) => Buffer.from(data).toString("base64")
+  Buffer.from(base64String, "base64").toString("utf8");
+const dataToBase64 = (data) => Buffer.from(data).toString("base64");