@jsenv/core 34.2.1 → 34.3.0

package/dist/jsenv.js

@@ -15,9 +15,10 @@ import { Readable, Stream, Writable } from "node:stream";
 import { Http2ServerResponse } from "node:http2";
 import { lookup } from "node:dns";
 import { SOURCEMAP, generateSourcemapFileUrl, composeTwoSourcemaps, generateSourcemapDataUrl, createMagicSource, getOriginalPosition } from "@jsenv/sourcemap";
-import { parseHtmlString, stringifyHtmlAst, getHtmlNodeAttribute, visitHtmlNodes, analyzeScriptNode, setHtmlNodeAttributes, parseSrcSet, getHtmlNodePosition, getHtmlNodeAttributePosition, parseCssUrls, parseJsUrls, getHtmlNodeText, setHtmlNodeText, removeHtmlNodeText, applyBabelPlugins, injectScriptNodeAsEarlyAsPossible, createHtmlNode, findHtmlNode, removeHtmlNode, injectJsImport, analyzeLinkNode, injectHtmlNode, insertHtmlNodeAfter } from "@jsenv/ast";
+import { parseHtmlString, stringifyHtmlAst, getHtmlNodeAttribute, visitHtmlNodes, analyzeScriptNode, setHtmlNodeAttributes, parseSrcSet, getHtmlNodePosition, getHtmlNodeAttributePosition, parseCssUrls, parseJsUrls, getHtmlNodeText, setHtmlNodeText, removeHtmlNodeText, applyBabelPlugins, injectHtmlNodeAsEarlyAsPossible, createHtmlNode, findHtmlNode, removeHtmlNode, injectJsImport, analyzeLinkNode, injectHtmlNode, insertHtmlNodeAfter } from "@jsenv/ast";
 import { createRequire } from "node:module";
 import babelParser from "@babel/parser";
+import { assertImportMap, resolveUrl as resolveUrl$1, normalizeImportMap, resolveImport } from "./js/resolveImport.js";
 import v8, { takeCoverage } from "node:v8";
 import stripAnsi from "strip-ansi";
 import { createId } from "@paralleldrive/cuid2";
@@ -77,7 +78,7 @@ const DATA_URL = {
   }
 };
 
-const urlToScheme$1 = url => {
+const urlToScheme = url => {
   const urlString = String(url);
   const colonIndex = urlString.indexOf(":");
   if (colonIndex === -1) {
@@ -88,7 +89,7 @@ const urlToScheme$1 = url => {
 };
 
 const urlToResource = url => {
-  const scheme = urlToScheme$1(url);
+  const scheme = urlToScheme(url);
   if (scheme === "file") {
     const urlAsStringWithoutFileProtocol = String(url).slice("file://".length);
     return urlAsStringWithoutFileProtocol;
@@ -104,7 +105,7 @@ const urlToResource = url => {
   return urlAsStringWithoutProtocol;
 };
 
-const urlToPathname$1 = url => {
+const urlToPathname = url => {
   const resource = urlToResource(url);
   const pathname = resourceToPathname(resource);
   return pathname;
@@ -122,7 +123,7 @@ const resourceToPathname = resource => {
 };
 
 const urlToFilename$1 = url => {
-  const pathname = urlToPathname$1(url);
+  const pathname = urlToPathname(url);
   const pathnameBeforeLastSlash = pathname.endsWith("/") ? pathname.slice(0, -1) : pathname;
   const slashLastIndex = pathnameBeforeLastSlash.lastIndexOf("/");
   const filename = slashLastIndex === -1 ? pathnameBeforeLastSlash : pathnameBeforeLastSlash.slice(slashLastIndex + 1);
@@ -319,10 +320,10 @@ const lineRangeWithinLines = ({
 };
 
 const urlToExtension$1 = url => {
-  const pathname = urlToPathname$1(url);
-  return pathnameToExtension$1(pathname);
+  const pathname = urlToPathname(url);
+  return pathnameToExtension(pathname);
 };
-const pathnameToExtension$1 = pathname => {
+const pathnameToExtension = pathname => {
   const slashLastIndex = pathname.lastIndexOf("/");
   if (slashLastIndex !== -1) {
     pathname = pathname.slice(slashLastIndex + 1);
@@ -446,7 +447,7 @@ const getCallerPosition = () => {
   };
 };
 
-const resolveUrl$1 = (specifier, baseUrl) => {
+const resolveUrl = (specifier, baseUrl) => {
   if (typeof baseUrl === "undefined") {
     throw new TypeError(`baseUrl missing to resolve ${specifier}`);
   }
@@ -519,7 +520,7 @@ const urlToRelativeUrl = (url, baseUrl) => {
   const specificPathname = pathname.slice(commonPathname.length);
   const baseSpecificPathname = basePathname.slice(commonPathname.length);
   if (baseSpecificPathname.includes("/")) {
-    const baseSpecificParentPathname = pathnameToParentPathname$1(baseSpecificPathname);
+    const baseSpecificParentPathname = pathnameToParentPathname(baseSpecificPathname);
     const relativeDirectoriesNotation = baseSpecificParentPathname.replace(/.*?\//g, "../");
     const relativeUrl = `${relativeDirectoriesNotation}${specificPathname}${search}${hash}`;
     return relativeUrl;
@@ -527,7 +528,7 @@ const urlToRelativeUrl = (url, baseUrl) => {
   const relativeUrl = `${specificPathname}${search}${hash}`;
   return relativeUrl;
 };
-const pathnameToParentPathname$1 = pathname => {
+const pathnameToParentPathname = pathname => {
   const slashLastIndex = pathname.lastIndexOf("/");
   if (slashLastIndex === -1) {
     return "/";
@@ -1674,7 +1675,7 @@ const removeDirectory = async (rootDirectoryUrl, {
     removeDirectoryOperation.throwIfAborted();
     const names = await readDirectory(directoryUrl);
     await Promise.all(names.map(async name => {
-      const url = resolveUrl$1(name, directoryUrl);
+      const url = resolveUrl(name, directoryUrl);
       await visit(url);
     }));
   };
@@ -2634,7 +2635,7 @@ const UNICODE = {
   supported: canUseUnicode
 };
 
-const createDetailedMessage$1 = (message, details = {}) => {
+const createDetailedMessage = (message, details = {}) => {
   let string = `${message}`;
   Object.keys(details).forEach(key => {
     const value = details[key];
@@ -4967,7 +4968,7 @@ const startServer = async ({
     warn,
     requestWaitingMs
   }) => {
-    warn(createDetailedMessage$1(`still no response found for request after ${requestWaitingMs} ms`, {
+    warn(createDetailedMessage(`still no response found for request after ${requestWaitingMs} ms`, {
       "request url": request.url,
       "request headers": JSON.stringify(request.headers, null, "  ")
     }));
@@ -5352,7 +5353,7 @@ const startServer = async ({
         if (error.message === "aborted") {
           addRequestLog(rootRequestNode, {
             type: "debug",
-            value: createDetailedMessage$1(`request aborted by client`, {
+            value: createDetailedMessage(`request aborted by client`, {
               "error message": error.message
             })
           });
@@ -5360,7 +5361,7 @@ const startServer = async ({
           // I'm not sure this can happen but it's here in case
           addRequestLog(rootRequestNode, {
             type: "error",
-            value: createDetailedMessage$1(`"error" event emitted on request`, {
+            value: createDetailedMessage(`"error" event emitted on request`, {
               "error stack": error.stack
             })
           });
@@ -5379,7 +5380,7 @@ const startServer = async ({
         const onPushStreamError = e => {
           addRequestLog(requestNode, {
             type: "error",
-            value: createDetailedMessage$1(`An error occured while pushing a stream to the response for ${request.resource}`, {
+            value: createDetailedMessage(`An error occured while pushing a stream to the response for ${request.resource}`, {
               "error stack": e.stack
             })
           });
@@ -5610,7 +5611,7 @@ const startServer = async ({
             }
             addRequestLog(requestNode, {
               type: "error",
-              value: createDetailedMessage$1(`internal error while handling request`, {
+              value: createDetailedMessage(`internal error while handling request`, {
                 "error stack": errorWhileHandlingRequest.stack
               })
             });
@@ -5704,7 +5705,7 @@ const startServer = async ({
           onError: error => {
             addRequestLog(requestNode, {
               type: "error",
-              value: createDetailedMessage$1(`An error occured while sending response`, {
+              value: createDetailedMessage(`An error occured while sending response`, {
                 "error stack": error.stack
               })
             });
@@ -8373,7 +8374,7 @@ const createResolveUrlError = ({
     reason,
     ...details
   }) => {
-    const resolveError = new Error(createDetailedMessage$1(`Failed to resolve url reference`, {
+    const resolveError = new Error(createDetailedMessage(`Failed to resolve url reference`, {
       reason,
       ...details,
       "specifier": `"${reference.specifier}"`,
@@ -8392,7 +8393,7 @@ const createResolveUrlError = ({
     });
   }
   if (error.code === "DIRECTORY_REFERENCE_NOT_ALLOWED") {
-    error.message = createDetailedMessage$1(error.message, {
+    error.message = createDetailedMessage(error.message, {
       "reference trace": reference.trace.message
     });
     return error;
@@ -8413,7 +8414,7 @@ const createFetchUrlContentError = ({
     reason,
     ...details
   }) => {
-    const fetchError = new Error(createDetailedMessage$1(`Failed to fetch url content`, {
+    const fetchError = new Error(createDetailedMessage(`Failed to fetch url content`, {
       reason,
       ...details,
       "url": urlInfo.url,
@@ -8483,7 +8484,7 @@ const createTransformUrlContentError = ({
     reason,
     ...details
   }) => {
-    const transformError = new Error(createDetailedMessage$1(`"transformUrlContent" error on "${urlInfo.type}"`, {
+    const transformError = new Error(createDetailedMessage(`"transformUrlContent" error on "${urlInfo.type}"`, {
       reason,
       ...details,
       "url": urlInfo.url,
@@ -8536,7 +8537,7 @@ const createFinalizeUrlContentError = ({
   urlInfo,
   error
 }) => {
-  const finalizeError = new Error(createDetailedMessage$1(`"finalizeUrlContent" error on "${urlInfo.type}"`, {
+  const finalizeError = new Error(createDetailedMessage(`"finalizeUrlContent" error on "${urlInfo.type}"`, {
     ...detailsFromValueThrown(error),
     "url": urlInfo.url,
     "url reference trace": reference.trace.message,
@@ -9048,7 +9049,7 @@ ${ANSI.color(normalizedReturnValue, ANSI.YELLOW)}
     try {
       const fetchUrlContentReturnValue = await pluginController.callAsyncHooksUntil("fetchUrlContent", urlInfo, contextDuringFetch);
       if (!fetchUrlContentReturnValue) {
-        logger.warn(createDetailedMessage$1(`no plugin has handled url during "fetchUrlContent" hook -> url will be ignored`, {
+        logger.warn(createDetailedMessage(`no plugin has handled url during "fetchUrlContent" hook -> url will be ignored`, {
           "url": urlInfo.url,
           "url reference trace": reference.trace.message
         }));
@@ -9372,6 +9373,7 @@ ${ANSI.color(normalizedReturnValue, ANSI.YELLOW)}
   kitchenContext.injectReference = injectReference;
   const getWithoutSearchParam = ({
     urlInfo,
+    reference,
     context,
     searchParam,
     expectedType
@@ -9384,7 +9386,7 @@ ${ANSI.color(normalizedReturnValue, ANSI.YELLOW)}
       return [null, null];
     }
     searchParams.delete(searchParam);
-    const originalRef = context.reference.original || context.reference;
+    const originalRef = reference || context.reference.original || context.reference;
     const referenceWithoutSearchParam = {
       ...originalRef,
       original: originalRef,
@@ -9393,8 +9395,8 @@ ${ANSI.color(normalizedReturnValue, ANSI.YELLOW)}
         ...originalRef.data
       },
       expectedType,
-      specifier: context.reference.specifier.replace(`?${searchParam}`, "").replace(`&${searchParam}`, ""),
-      url: urlObject.href,
+      specifier: originalRef.specifier.replace(`?${searchParam}`, "").replace(`&${searchParam}`, ""),
+      url: normalizeUrl(urlObject.href),
       generatedSpecifier: null,
       generatedUrl: null,
       filename: null
@@ -10109,7 +10111,7 @@ const visitHtmlUrls = ({
       if (type === "text") {
         // ignore <script type="whatever" src="./file.js">
         // per HTML spec https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#attr-type
-        // this will be handled by jsenv_plugin_html_inline_content
+        // this will be handled by jsenv_plugin_html_inline_content_analysis
         return;
       }
       visitAttributeAsUrlSpecifier({
@@ -10426,12 +10428,211 @@ const findOriginalDirectoryReference = (urlInfo, context) => {
   return ref;
 };
 
+const jsenvPluginInliningAsDataUrl = () => {
+  return {
+    name: "jsenv:inlining_as_data_url",
+    appliesDuring: "*",
+    formatUrl: {
+      // if the referenced url is a worker we could use
+      // https://www.oreilly.com/library/view/web-workers/9781449322120/ch04.html
+      // but maybe we should rather use ?object_url
+      // or people could do this:
+      // import workerText from './worker.js?text'
+      // const blob = new Blob(workerText, { type: 'text/javascript' })
+      // window.URL.createObjectURL(blob)
+      // in any case the recommended way is to use an url
+      // to benefit from shared worker and reuse worker between tabs
+      "*": (reference, context) => {
+        if (!reference.original || !reference.original.searchParams.has("inline")) {
+          return null;
+        }
+        // <link rel="stylesheet"> and <script> can be inlined in the html
+        if (reference.type === "link_href" && reference.subtype === "stylesheet") {
+          return null;
+        }
+        if (reference.type === "script") {
+          return null;
+        }
+        return (async () => {
+          const urlInfo = context.urlGraph.getUrlInfo(reference.url);
+          await context.cook(urlInfo, {
+            reference
+          });
+          const specifier = DATA_URL.stringify({
+            mediaType: urlInfo.contentType,
+            base64Flag: true,
+            data: Buffer.from(urlInfo.content).toString("base64")
+          });
+          return specifier;
+        })();
+      }
+    }
+  };
+};
+
+const jsenvPluginInliningIntoHtml = () => {
+  return {
+    name: "jsenv:inlining_into_html",
+    appliesDuring: "*",
+    transformUrlContent: {
+      html: async (urlInfo, context) => {
+        const htmlAst = parseHtmlString(urlInfo.content);
+        const mutations = [];
+        const actions = [];
+        const onStyleSheet = (linkNode, {
+          href
+        }) => {
+          const linkReference = context.referenceUtils.find(ref => ref.generatedSpecifier === href && ref.type === "link_href" && ref.subtype === "stylesheet");
+          if (!linkReference.original || !linkReference.original.searchParams.has("inline")) {
+            return;
+          }
+          const linkUrlInfo = context.urlGraph.getUrlInfo(linkReference.url);
+          actions.push(async () => {
+            await context.cook(linkUrlInfo, {
+              reference: linkReference
+            });
+            const {
+              line,
+              column,
+              isOriginal
+            } = getHtmlNodePosition(linkNode, {
+              preferOriginal: true
+            });
+            context.referenceUtils.becomesInline(linkReference, {
+              line: line - 1,
+              column,
+              isOriginal,
+              specifier: linkReference.generatedSpecifier,
+              content: linkUrlInfo.content,
+              contentType: linkUrlInfo.contentType
+            });
+            mutations.push(() => {
+              setHtmlNodeAttributes(linkNode, {
+                "inlined-from-href": href,
+                "href": undefined,
+                "rel": undefined,
+                "type": undefined,
+                "as": undefined,
+                "crossorigin": undefined,
+                "integrity": undefined,
+                "jsenv-inlined-by": "jsenv:inlining_into_html"
+              });
+              linkNode.nodeName = "style";
+              linkNode.tagName = "style";
+              setHtmlNodeText(linkNode, linkUrlInfo.content, {
+                indentation: "auto"
+              });
+            });
+          });
+        };
+        const onScriptWithSrc = (scriptNode, {
+          src
+        }) => {
+          const scriptReference = context.referenceUtils.find(ref => ref.generatedSpecifier === src && ref.type === "script");
+          if (!scriptReference.original || !scriptReference.original.searchParams.has("inline")) {
+            return;
+          }
+          const scriptUrlInfo = context.urlGraph.getUrlInfo(scriptReference.url);
+          actions.push(async () => {
+            await context.cook(scriptUrlInfo, {
+              reference: scriptReference
+            });
+            const {
+              line,
+              column,
+              isOriginal
+            } = getHtmlNodePosition(scriptNode, {
+              preferOriginal: true
+            });
+            context.referenceUtils.becomesInline(scriptReference, {
+              line: line - 1,
+              column,
+              isOriginal,
+              specifier: scriptReference.generatedSpecifier,
+              content: scriptUrlInfo.content,
+              contentType: scriptUrlInfo.contentType
+            });
+            mutations.push(() => {
+              setHtmlNodeAttributes(scriptNode, {
+                "inlined-from-src": src,
+                "src": undefined,
+                "crossorigin": undefined,
+                "integrity": undefined,
+                "jsenv-inlined-by": "jsenv:inlining_into_html"
+              });
+              setHtmlNodeText(scriptNode, scriptUrlInfo.content, {
+                indentation: "auto"
+              });
+            });
+          });
+        };
+        visitHtmlNodes(htmlAst, {
+          link: linkNode => {
+            const rel = getHtmlNodeAttribute(linkNode, "rel");
+            if (rel !== "stylesheet") {
+              return;
+            }
+            const href = getHtmlNodeAttribute(linkNode, "href");
+            if (!href) {
+              return;
+            }
+            onStyleSheet(linkNode, {
+              href
+            });
+          },
+          script: scriptNode => {
+            const {
+              type
+            } = analyzeScriptNode(scriptNode);
+            const scriptNodeText = getHtmlNodeText(scriptNode);
+            if (scriptNodeText) {
+              return;
+            }
+            const src = getHtmlNodeAttribute(scriptNode, "src");
+            if (!src) {
+              return;
+            }
+            onScriptWithSrc(scriptNode, {
+              type,
+              src
+            });
+          }
+        });
+        if (actions.length > 0) {
+          await Promise.all(actions.map(action => action()));
+        }
+        mutations.forEach(mutation => mutation());
+        const htmlModified = stringifyHtmlAst(htmlAst);
+        return htmlModified;
+      }
+    }
+  };
+};
+
+const jsenvPluginInlining = () => {
+  return [{
+    name: "jsenv:inlining",
+    appliesDuring: "*",
+    redirectUrl: reference => {
+      const {
+        searchParams
+      } = reference;
+      if (searchParams.has("inline")) {
+        const urlObject = new URL(reference.url);
+        urlObject.searchParams.delete("inline");
+        return urlObject.href;
+      }
+      return null;
+    }
+  }, jsenvPluginInliningAsDataUrl(), jsenvPluginInliningIntoHtml()];
+};
+
 /*
  * This plugin ensure content inlined inside HTML is cooked (inline <script> for instance)
  * For <script hot-accept> the script content will be moved to a virtual file
  * to enable hot reloading
  */
-const jsenvPluginHtmlInlineContent = ({
+const jsenvPluginHtmlInlineContentAnalysis = ({
   analyzeConvertedScripts
 }) => {
   const cookInlineContent = async ({
@@ -10457,7 +10658,7 @@ ${e.traceMessage}`);
     }
   };
   return {
-    name: "jsenv:html_inline_content",
+    name: "jsenv:html_inline_content_analysis",
     appliesDuring: "*",
     transformUrlContent: {
       html: async (urlInfo, context) => {
@@ -10511,9 +10712,12 @@ ${e.traceMessage}`);
               });
             });
             mutations.push(() => {
-              setHtmlNodeText(styleNode, inlineStyleUrlInfo.content);
+              setHtmlNodeText(styleNode, inlineStyleUrlInfo.content, {
+                indentation: false // indentation would decrease strack trace precision
+              });
+
               setHtmlNodeAttributes(styleNode, {
-                "jsenv-cooked-by": "jsenv:html_inline_content"
+                "jsenv-cooked-by": "jsenv:html_inline_content_analysis"
               });
             });
           },
@@ -10575,7 +10779,7 @@ ${e.traceMessage}`);
               });
               mutations.push(() => {
                 const attributes = {
-                  "jsenv-cooked-by": "jsenv:html_inline_content",
+                  "jsenv-cooked-by": "jsenv:html_inline_content_analysis",
                   // 1. <script type="jsx"> becomes <script>
                   // 2. <script type="module/jsx"> becomes <script type="module">
                   ...(extension ? {
@@ -10588,7 +10792,10 @@ ${e.traceMessage}`);
                     ...attributes
                   });
                 } else {
-                  setHtmlNodeText(scriptNode, inlineScriptUrlInfo.content);
+                  setHtmlNodeText(scriptNode, inlineScriptUrlInfo.content, {
+                    indentation: false // indentation would decrease stack trace precision
+                  });
+
                   setHtmlNodeAttributes(scriptNode, {
                     ...attributes
                   });
@@ -10721,7 +10928,7 @@ const JS_QUOTE_REPLACEMENTS = {
   }
 };
 
-const jsenvPluginJsInlineContent = ({
+const jsenvPluginJsInlineContentAnalysis = ({
   allowEscapeForVersioning
 }) => {
   const parseAndTransformInlineContentCalls = async (urlInfo, context) => {
@@ -10783,7 +10990,7 @@ const jsenvPluginJsInlineContent = ({
     return magicSource.toContentAndSourcemap();
   };
   return {
-    name: "jsenv:js_inline_content",
+    name: "jsenv:js_inline_content_analysis",
     appliesDuring: "*",
     transformUrlContent: {
       js_classic: parseAndTransformInlineContentCalls,
@@ -11099,61 +11306,20 @@ const base64ToBuffer = base64String => Buffer.from(base64String, "base64");
 const base64ToString = base64String => Buffer.from(base64String, "base64").toString("utf8");
 const dataToBase64 = data => Buffer.from(data).toString("base64");
 
-const jsenvPluginInlineQueryParam = () => {
-  return {
-    name: "jsenv:inline_query_param",
-    appliesDuring: "*",
-    formatUrl: {
-      // <link> and <script> can be inlined in the html
-      // this should be done during dev and postbuild but not build
-      // so that the bundled file gets inlined and not the entry point
-      "link_href": () => null,
-      "style": () => null,
-      "script": () => null,
-      // if the referenced url is a worker we could use
-      // https://www.oreilly.com/library/view/web-workers/9781449322120/ch04.html
-      // but maybe we should rather use ?object_url
-      // or people could do this:
-      // import workerText from './worker.js?text'
-      // const blob = new Blob(workerText, { type: 'text/javascript' })
-      // window.URL.createObjectURL(blob)
-      // in any case the recommended way is to use an url
-      // to benefit from shared worker and reuse worker between tabs
-      "*": (reference, context) => {
-        if (!reference.searchParams.has("inline")) {
-          return null;
-        }
-        return (async () => {
-          const urlInfo = context.urlGraph.getUrlInfo(reference.url);
-          await context.cook(urlInfo, {
-            reference
-          });
-          const specifier = DATA_URL.stringify({
-            mediaType: urlInfo.contentType,
-            base64Flag: true,
-            data: Buffer.from(urlInfo.content).toString("base64")
-          });
-          return specifier;
-        })();
-      }
-    }
-  };
-};
-
-const jsenvPluginInline = ({
+const jsenvPluginInlineContentAnalysis = ({
   fetchInlineUrls = true,
   analyzeConvertedScripts = false,
   allowEscapeForVersioning = false
 } = {}) => {
-  return [...(fetchInlineUrls ? [jsenvPluginInlineUrls()] : []), jsenvPluginHtmlInlineContent({
+  return [...(fetchInlineUrls ? [jsenvPluginInlineContentFetcher()] : []), jsenvPluginHtmlInlineContentAnalysis({
     analyzeConvertedScripts
-  }), jsenvPluginJsInlineContent({
+  }), jsenvPluginJsInlineContentAnalysis({
     allowEscapeForVersioning
-  }), jsenvPluginDataUrls(), jsenvPluginInlineQueryParam()];
+  }), jsenvPluginDataUrls()];
 };
-const jsenvPluginInlineUrls = () => {
+const jsenvPluginInlineContentFetcher = () => {
   return {
-    name: "jsenv:inline_urls",
+    name: "jsenv:inline_content_fetcher",
     appliesDuring: "*",
     fetchUrlContent: urlInfo => {
       if (!urlInfo.isInline) {
@@ -15176,7 +15342,7 @@ const jsenvPluginJsModuleFallbackInsideHtml = ({
               await context.cook(systemJsUrlInfo, {
                 reference: systemJsReference
               });
-              injectScriptNodeAsEarlyAsPossible(htmlAst, createHtmlNode({
+              injectHtmlNodeAsEarlyAsPossible(htmlAst, createHtmlNode({
                 tagName: "script",
                 textContent: systemJsUrlInfo.content
               }), "jsenv:js_module_fallback");
@@ -15209,13 +15375,13 @@ const isExpectingJsModule = reference => {
  * when {type: "module"} cannot be used on web workers:
  * - new Worker("worker.js", { type: "module" })
  *   transformed into
- *   new Worker("worker.js?as_js_classic", { type: " lassic" })
+ *   new Worker("worker.js?js_module_fallback", { type: " lassic" })
  * - navigator.serviceWorker.register("service_worker.js", { type: "module" })
  *   transformed into
- *   navigator.serviceWorker.register("service_worker.js?as_js_classic", { type: "classic" })
+ *   navigator.serviceWorker.register("service_worker.js?js_module_fallback", { type: "classic" })
  * - new SharedWorker("shared_worker.js", { type: "module" })
  *   transformed into
- *   new SharedWorker("shared_worker.js?as_js_classic", { type: "classic" })
+ *   new SharedWorker("shared_worker.js?js_module_fallback", { type: "classic" })
  */
 const jsenvPluginJsModuleFallbackOnWorkers = () => {
   const turnIntoJsClassicProxy = reference => {
@@ -15294,306 +15460,6 @@ const splitFileExtension$2 = filename => {
   return [filename.slice(0, dotLastIndex), filename.slice(dotLastIndex)];
 };
 
-// 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);
-};
-
 // https://github.com/systemjs/systemjs/blob/89391f92dfeac33919b0223bbf834a1f4eea5750/src/common.js#L136
 const composeTwoImportMaps = (leftImportMap, rightImportMap) => {
   assertImportMap(leftImportMap);
@@ -15651,8 +15517,8 @@ const composeTwoMappings = (leftMappings, rightMappings) => {
 };
 const objectHasKey = (object, key) => Object.prototype.hasOwnProperty.call(object, key);
 const compareAddressAndSpecifier = (address, specifier) => {
-  const addressUrl = resolveUrl(address, "file:///");
-  const specifierUrl = resolveUrl(specifier, "file:///");
+  const addressUrl = resolveUrl$1(address, "file:///");
+  const specifierUrl = resolveUrl$1(specifier, "file:///");
   return addressUrl === specifierUrl;
 };
 const composeTwoScopes = (leftScopes, rightScopes, imports) => {
@@ -15684,209 +15550,6 @@ const composeTwoScopes = (leftScopes, rightScopes, imports) => {
   return scopes;
 };
 
-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;
-};
-
 /*
  * Plugin to read and apply importmap files found in html files.
  * - feeds importmap files to jsenv kitchen
@@ -16003,7 +15666,9 @@ const jsenvPluginImportmap = () => {
           await context.cook(inlineImportmapUrlInfo, {
             reference: inlineImportmapReference
           });
-          setHtmlNodeText(importmap, inlineImportmapUrlInfo.content);
+          setHtmlNodeText(importmap, inlineImportmapUrlInfo.content, {
+            indentation: "auto"
+          });
           setHtmlNodeAttributes(importmap, {
             "jsenv-cooked-by": "jsenv:importmap"
           });
@@ -16021,7 +15686,9 @@ const jsenvPluginImportmap = () => {
             reference: importmapReference
           });
           onHtmlImportmapParsed(JSON.parse(importmapUrlInfo.content), htmlUrlInfo.url);
-          setHtmlNodeText(importmap, importmapUrlInfo.content);
+          setHtmlNodeText(importmap, importmapUrlInfo.content, {
+            indentation: "auto"
+          });
           setHtmlNodeAttributes(importmap, {
             "src": undefined,
             "jsenv-inlined-by": "jsenv:importmap",
@@ -17796,7 +17463,9 @@ const injectSupervisorIntoHTML = async ({
           src: inlineScriptSrc
         });
         mutations.push(() => {
-          setHtmlNodeText(scriptNode, remoteJsSupervised);
+          setHtmlNodeText(scriptNode, remoteJsSupervised, {
+            indentation: "auto"
+          });
           setHtmlNodeAttributes(scriptNode, {
             "jsenv-cooked-by": "jsenv:supervisor",
             "src": undefined,
@@ -17819,7 +17488,9 @@ const injectSupervisorIntoHTML = async ({
               inlineSrc: inlineScriptSrc
             });
             mutations.push(() => {
-              setHtmlNodeText(scriptNode, inlineJsSupervised);
+              setHtmlNodeText(scriptNode, inlineJsSupervised, {
+                indentation: "auto"
+              });
               setHtmlNodeAttributes(scriptNode, {
                 "jsenv-cooked-by": "jsenv:supervisor"
               });
@@ -17852,7 +17523,9 @@ const injectSupervisorIntoHTML = async ({
         src
       });
       mutations.push(() => {
-        setHtmlNodeText(scriptNode, remoteJsSupervised);
+        setHtmlNodeText(scriptNode, remoteJsSupervised, {
+          indentation: "auto"
+        });
         setHtmlNodeAttributes(scriptNode, {
           "jsenv-cooked-by": "jsenv:supervisor",
           "src": undefined,
@@ -17887,6 +17560,10 @@ const injectSupervisorIntoHTML = async ({
         }
         const src = getHtmlNodeAttribute(scriptNode, "src");
         if (src) {
+          const urlObject = new URL(src, "http://example.com");
+          if (urlObject.searchParams.has("inline")) {
+            return;
+          }
           handleScriptWithSrc(scriptNode, {
             type,
             src
@@ -17903,20 +17580,15 @@ const injectSupervisorIntoHTML = async ({
       serverIsJsenvDevServer: webServer.isJsenvDevServer,
       rootDirectoryUrl: webServer.rootDirectoryUrl,
       scriptInfos
-    }, "        ");
-    injectScriptNodeAsEarlyAsPossible(htmlAst, createHtmlNode({
+    }, "  ");
+    injectHtmlNodeAsEarlyAsPossible(htmlAst, createHtmlNode({
       tagName: "script",
-      textContent: `
-      window.__supervisor__.setup({
-        ${setupParamsSource}
-      })
-      `
+      textContent: `window.__supervisor__.setup({${setupParamsSource}})`
     }), "jsenv:supervisor");
-    const supervisorScript = createHtmlNode({
+    injectHtmlNodeAsEarlyAsPossible(htmlAst, createHtmlNode({
       tagName: "script",
       src: supervisorScriptSrc
-    });
-    injectScriptNodeAsEarlyAsPossible(htmlAst, supervisorScript, "jsenv:supervisor");
+    }), "jsenv:supervisor");
   }
   // 3. Perform actions (transforming inline script content) and html mutations
   if (actions.length > 0) {
@@ -17944,14 +17616,11 @@ const generateCodeToSuperviseScriptWithSrc = ({
   type,
   src
 }) => {
+  const srcEncoded = JSON.stringify(src);
   if (type === "js_module") {
-    return `
-        window.__supervisor__.superviseScriptTypeModule(${JSON.stringify(src)}, (url) => import(url));
-    `;
+    return `window.__supervisor__.superviseScriptTypeModule(${srcEncoded}, (url) => import(url));`;
   }
-  return `
-        window.__supervisor__.superviseScript(${JSON.stringify(src)});
-    `;
+  return `window.__supervisor__.superviseScript(${srcEncoded});`;
 };
 
 /*
@@ -18556,10 +18225,23 @@ const jsenvPluginImportAssertions = ({
   };
   const turnIntoJsModuleProxy = (reference, type) => {
     reference.mutation = magicSource => {
-      magicSource.remove({
-        start: reference.assertNode.start,
-        end: reference.assertNode.end
-      });
+      const {
+        assertNode
+      } = reference;
+      if (reference.subtype === "import_dynamic") {
+        const assertPropertyNode = assertNode.properties.find(prop => prop.key.name === "assert");
+        const assertPropertyValue = assertPropertyNode.value;
+        const typePropertyNode = assertPropertyValue.properties.find(prop => prop.key.name === "type");
+        magicSource.remove({
+          start: typePropertyNode.start,
+          end: typePropertyNode.end
+        });
+      } else {
+        magicSource.remove({
+          start: assertNode.start,
+          end: assertNode.end
+        });
+      }
     };
     const newUrl = injectQueryParams(reference.url, {
       [`as_${type}_module`]: ""
@@ -20300,7 +19982,7 @@ const jsenvPluginAutoreloadClient = () => {
           expectedType: "js_module",
           specifier: autoreloadClientFileUrl
         });
-        injectScriptNodeAsEarlyAsPossible(htmlAst, createHtmlNode({
+        injectHtmlNodeAsEarlyAsPossible(htmlAst, createHtmlNode({
           tagName: "script",
           type: "module",
           src: autoreloadClientReference.generatedSpecifier
@@ -20668,16 +20350,13 @@ const jsenvPluginRibbon = ({
         const paramsJson = JSON.stringify({
           text: context.dev ? "DEV" : "BUILD"
         }, null, "  ");
-        const scriptNode = createHtmlNode({
+        injectHtmlNode(htmlAst, createHtmlNode({
           tagName: "script",
           type: "module",
-          textContent: `
-  import { injectRibbon } from "${ribbonClientFileReference.generatedSpecifier}"
-  
-  injectRibbon(${paramsJson})
-`
-        });
-        injectHtmlNode(htmlAst, scriptNode, "jsenv:ribbon");
+          textContent: `import { injectRibbon } from "${ribbonClientFileReference.generatedSpecifier}"
+
+injectRibbon(${paramsJson});`
+        }), "jsenv:ribbon");
         return stringifyHtmlAst(htmlAst);
       }
     }
@@ -20694,6 +20373,7 @@ const getCorePlugins = ({
   directoryReferenceAllowed,
   supervisor,
   transpilation = true,
+  inlining = true,
   clientAutoreload = false,
   clientFileChangeCallbackList,
   clientFilesPruneCallbackList,
@@ -20726,9 +20406,9 @@ const getCorePlugins = ({
   }), jsenvPluginTranspilation(transpilation), jsenvPluginImportmap(),
   // before node esm to handle bare specifiers
   // + before node esm to handle importmap before inline content
-  jsenvPluginInline(),
+  jsenvPluginInlineContentAnalysis(),
   // before "file urls" to resolve and load inline urls
-  ...(supervisor ? [jsenvPluginSupervisor(supervisor)] : []),
+  ...(inlining ? [jsenvPluginInlining()] : []), ...(supervisor ? [jsenvPluginSupervisor(supervisor)] : []),
   // after inline as it needs inline script to be cooked
   jsenvPluginFileUrls({
     directoryReferenceAllowed,
@@ -20983,7 +20663,7 @@ const injectors = {
     const htmlAst = parseHtmlString(urlInfo.content, {
       storeOriginalPositions: false
     });
-    injectScriptNodeAsEarlyAsPossible(htmlAst, createHtmlNode({
+    injectHtmlNodeAsEarlyAsPossible(htmlAst, createHtmlNode({
       tagName: "script",
       textContent: generateClientCodeForVersionMappings(versionMappings, {
         globalName: "window",
@@ -21002,10 +20682,11 @@ const jsInjector = (urlInfo, {
   minification
 }) => {
   const magicSource = createMagicSource(urlInfo.content);
-  magicSource.prepend(generateClientCodeForVersionMappings(versionMappings, {
+  const code = generateClientCodeForVersionMappings(versionMappings, {
     globalName: isWebWorkerUrlInfo(urlInfo) ? "self" : "window",
     minification
-  }));
+  });
+  magicSource.prepend(`${code}\n\n`);
   return magicSource.toContentAndSourcemap();
 };
 const generateClientCodeForVersionMappings = (versionMappings, {
@@ -21015,14 +20696,12 @@ const generateClientCodeForVersionMappings = (versionMappings, {
   if (minification) {
     return `;(function(){var m = ${JSON.stringify(versionMappings)}; ${globalName}.__v__ = function (s) { return m[s] || s }; })();`;
   }
-  return `
-;(function() {
+  return `;(function() {
   var __versionMappings__ = ${JSON.stringify(versionMappings, null, "  ")};
   ${globalName}.__v__ = function (specifier) {
     return __versionMappings__[specifier] || specifier
   };
-})();
-`;
+})();`;
 };
 const injectVersionMappingsAsImportmap = async ({
   urlInfo,
@@ -21035,18 +20714,15 @@ const injectVersionMappingsAsImportmap = async ({
   // jsenv_plugin_importmap.js is removing importmap during build
   // it means at this point we know HTML has no importmap in it
   // we can safely inject one
-  const importmapNode = createHtmlNode({
+  injectHtmlNodeAsEarlyAsPossible(htmlAst, createHtmlNode({
     tagName: "script",
     type: "importmap",
     textContent: kitchen.kitchenContext.minification ? JSON.stringify({
       imports: versionMappings
-    }) : `  
-      {
-        "imports": {${JSON.stringify(versionMappings, null, "          ").slice(1, -1)}        }
-      }
-    `
-  });
-  injectScriptNodeAsEarlyAsPossible(htmlAst, importmapNode, "jsenv:versioning");
+    }) : JSON.stringify({
+      imports: versionMappings
+    }, null, "  ")
+  }), "jsenv:versioning");
   kitchen.urlInfoTransformer.applyFinalTransformations(urlInfo, {
     content: stringifyHtmlAst(htmlAst)
   });
@@ -21121,7 +20797,7 @@ const defaultRuntimeCompat = {
  *        Controls if url in build file contents are versioned
  * @param {('search_param'|'filename')} [buildParameters.versioningMethod="search_param"]
  *        Controls how url are versioned
- * @param {boolean|string} [buildParameters.sourcemaps=false]
+ * @param {('none'|'inline'|'file'|'programmatic'} [buildParameters.sourcemaps="none"]
  *        Generate sourcemaps in the build directory
  * @return {Object} buildReturnValue
  * @return {Object} buildReturnValue.buildFileContents
@@ -21142,7 +20818,7 @@ const build = async ({
   runtimeCompat = defaultRuntimeCompat,
   base = runtimeCompat.node ? "./" : "/",
   plugins = [],
-  sourcemaps = false,
+  sourcemaps = "none",
   sourcemapsSourcesContent,
   urlAnalysis = {},
   urlResolution,
@@ -21305,6 +20981,7 @@ build ${entryPointKeys.length} entry points`);
           babelHelpersAsImport: !explicitJsModuleFallback,
           jsModuleFallbackOnJsClassic: false
         },
+        inlining: false,
         scenarioPlaceholders
       })],
       sourcemaps,
@@ -21343,9 +21020,9 @@ ${ANSI.color(buildUrl, ANSI.MAGENTA)}
       ...contextSharedDuringBuild,
       plugins: [urlAnalysisPlugin, ...(lineBreakNormalization ? [jsenvPluginLineBreakNormalization()] : []), jsenvPluginJsModuleFallback({
         systemJsInjection: true
-      }), jsenvPluginInline({
+      }), jsenvPluginInlineContentAnalysis({
         fetchInlineUrls: false
-      }), {
+      }), jsenvPluginInlining(), {
         name: "jsenv:build",
         appliesDuring: "build",
         resolveUrl: reference => {
@@ -21382,16 +21059,25 @@ ${ANSI.color(buildUrl, ANSI.MAGENTA)}
             return reference.url;
           }
           if (reference.isInline) {
+            const parentUrlInfo = finalGraph.getUrlInfo(reference.parentUrl);
+            const parentRawUrl = parentUrlInfo.originalUrl;
             const rawUrlInfo = GRAPH.find(rawGraph, rawUrlInfo => {
-              if (!rawUrlInfo.isInline) {
-                return false;
+              const {
+                inlineUrlSite
+              } = rawUrlInfo;
+              // not inline
+              if (!inlineUrlSite) return false;
+              if (inlineUrlSite.url === parentRawUrl && inlineUrlSite.line === reference.specifierLine && inlineUrlSite.column === reference.specifierColumn) {
+                return true;
               }
               if (rawUrlInfo.content === reference.content) {
                 return true;
               }
-              return rawUrlInfo.originalContent === reference.content;
+              if (rawUrlInfo.originalContent === reference.content) {
+                return true;
+              }
+              return false;
             });
-            const parentUrlInfo = finalGraph.getUrlInfo(reference.parentUrl);
             if (!rawUrlInfo) {
               // generated during final graph
               // (happens for JSON.parse injected for import assertions for instance)
@@ -21521,7 +21207,7 @@ ${ANSI.color(buildUrl, ANSI.MAGENTA)}
             const rawUrl = buildDirectoryRedirections.get(url) || url;
             const rawUrlInfo = rawGraph.getUrlInfo(rawUrl);
             if (!rawUrlInfo) {
-              throw new Error(createDetailedMessage$1(`Cannot find url`, {
+              throw new Error(createDetailedMessage(`Cannot find url`, {
                 url,
                 "raw urls": Array.from(buildDirectoryRedirections.values()),
                 "build urls": Array.from(buildDirectoryRedirections.keys())
@@ -21559,6 +21245,10 @@ ${ANSI.color(buildUrl, ANSI.MAGENTA)}
             return rawUrlInfo;
           }
           if (reference.isInline) {
+            if (reference.prev && !reference.prev.isInline) {
+              const urlBeforeRedirect = findKey(finalRedirections, reference.prev.url);
+              return fromBundleOrRawGraph(urlBeforeRedirect);
+            }
             return fromBundleOrRawGraph(reference.url);
           }
           // reference updated during "postbuild":
@@ -22007,7 +21697,7 @@ ${ANSI.color(buildUrl, ANSI.MAGENTA)}
             build: true,
             runtimeCompat,
             ...contextSharedDuringBuild,
-            plugins: [urlAnalysisPlugin, jsenvPluginInline({
+            plugins: [urlAnalysisPlugin, jsenvPluginInlineContentAnalysis({
               fetchInlineUrls: false,
               analyzeConvertedScripts: true,
               // to be able to version their urls
@@ -22280,7 +21970,7 @@ ${ANSI.color(buildUrl, ANSI.MAGENTA)}
                     type: getHtmlNodeAttribute(hintNode, "type"),
                     crossorigin: getHtmlNodeAttribute(hintNode, "crossorigin")
                   });
-                  insertHtmlNodeAfter(nodeToInsert, hintNode.parentNode, hintNode);
+                  insertHtmlNodeAfter(nodeToInsert, hintNode);
                 });
               }
             });
@@ -22591,7 +22281,7 @@ const jsenvPluginServerEventsClientInjection = () => {
           expectedType: "js_module",
           specifier: serverEventsClientFileUrl
         });
-        injectScriptNodeAsEarlyAsPossible(htmlAst, createHtmlNode({
+        injectHtmlNodeAsEarlyAsPossible(htmlAst, createHtmlNode({
           tagName: "script",
           type: "module",
           src: serverEventsClientFileReference.generatedSpecifier
@@ -22953,7 +22643,7 @@ const createFileService = ({
       if (code === "PARSE_ERROR") {
         // when possible let browser re-throw the syntax error
         // it's not possible to do that when url info content is not available
-        // (happens for as_js_classic for instance)
+        // (happens for js_module_fallback for instance)
         if (urlInfo.content !== undefined) {
           return {
             url: reference.url,
@@ -23523,7 +23213,7 @@ const generateFileExecutionSteps = ({
       return;
     }
     if (typeof stepConfig !== "object") {
-      throw new TypeError(createDetailedMessage$1(`found unexpected value in plan, they must be object`, {
+      throw new TypeError(createDetailedMessage(`found unexpected value in plan, they must be object`, {
         ["file relative path"]: fileRelativeUrl,
         ["execution name"]: executionName,
         ["value"]: stepConfig
@@ -23590,7 +23280,7 @@ const readNodeV8CoverageDirectory = async ({
             timeSpentTrying += 200;
             return tryReadJsonFile();
           }
-          console.warn(createDetailedMessage$1(`Error while reading coverage file`, {
+          console.warn(createDetailedMessage(`Error while reading coverage file`, {
             "error stack": e.stack,
             "file": dirEntryUrl
           }));
@@ -23751,7 +23441,7 @@ const composeV8AndIstanbul = (v8FileByFileCoverage, istanbulFileByFileCoverage,
     const v8Coverage = v8FileByFileCoverage[key];
     if (v8Coverage) {
       if (coverageV8ConflictWarning) {
-        console.warn(createDetailedMessage$1(`Coverage conflict on "${key}", found two coverage that cannot be merged together: v8 and istanbul. The istanbul coverage will be ignored.`, {
+        console.warn(createDetailedMessage(`Coverage conflict on "${key}", found two coverage that cannot be merged together: v8 and istanbul. The istanbul coverage will be ignored.`, {
           details: `This happens when a file is executed on a runtime using v8 coverage (node or chromium) and on runtime using istanbul coverage (firefox or webkit)`,
           suggestion: "You can disable this warning with coverageV8ConflictWarning: false"
         }));
@@ -23856,7 +23546,7 @@ const relativeUrlToEmptyCoverage = async (relativeUrl, {
   const operation = Abort.startOperation();
   operation.addAbortSignal(signal);
   try {
-    const fileUrl = resolveUrl$1(relativeUrl, rootDirectoryUrl);
+    const fileUrl = resolveUrl(relativeUrl, rootDirectoryUrl);
     const content = await readFile(fileUrl, {
       as: "string"
     });
@@ -25137,7 +24827,7 @@ const executeTestPlan = async ({
         });
         if (patternsMatchingCoverAndExecute.length) {
           // It would be strange, for a given file to be both covered and executed
-          throw new Error(createDetailedMessage$1(`some file will be both covered and executed`, {
+          throw new Error(createDetailedMessage(`some file will be both covered and executed`, {
             patterns: patternsMatchingCoverAndExecute
           }));
         }
@@ -25166,7 +24856,7 @@ const executeTestPlan = async ({
   const logger = createLogger({
     logLevel
   });
-  logger.debug(createDetailedMessage$1(`Prepare executing plan`, {
+  logger.debug(createDetailedMessage(`Prepare executing plan`, {
     runtimes: JSON.stringify(runtimes, null, "  ")
   }));
 
@@ -25182,7 +24872,7 @@ const executeTestPlan = async ({
           await ensureEmptyDirectory(process.env.NODE_V8_COVERAGE);
         } else {
           coverageMethodForNodeJs = "Profiler";
-          logger.warn(createDetailedMessage$1(`process.env.NODE_V8_COVERAGE is required to generate coverage for Node.js subprocesses`, {
+          logger.warn(createDetailedMessage(`process.env.NODE_V8_COVERAGE is required to generate coverage for Node.js subprocesses`, {
             "suggestion": `set process.env.NODE_V8_COVERAGE`,
             "suggestion 2": `use coverageMethodForNodeJs: "Profiler". But it means coverage for child_process and worker_thread cannot be collected`
           }));
@@ -25899,7 +25589,7 @@ const importPlaywright = async ({
     return namespace;
   } catch (e) {
     if (e.code === "ERR_MODULE_NOT_FOUND") {
-      throw new Error(createDetailedMessage$1(`"playwright" not found. You need playwright in your dependencies to use "${browserName}"`, {
+      throw new Error(createDetailedMessage(`"playwright" not found. You need playwright in your dependencies to use "${browserName}"`, {
         suggestion: `npm install --save-dev playwright`
       }), {
         cause: e
@@ -26010,7 +25700,12 @@ const ExecOptions = {
     while (i < execArgv.length) {
       const execArg = execArgv[i];
       const option = execOptionFromExecArg(execArg);
-      execOptions[option.name] = option.value;
+      const existing = execOptions[option.name];
+      if (existing) {
+        execOptions[option.name] = Array.isArray(existing) ? [...existing, option.value] : [existing, option.value];
+      } else {
+        execOptions[option.name] = option.value;
+      }
       i++;
     }
     return execOptions;
@@ -26026,7 +25721,13 @@ const ExecOptions = {
         execArgv.push(optionName);
         return;
       }
-      execArgv.push(`${optionName}=${optionValue}`);
+      if (Array.isArray(optionValue)) {
+        optionValue.forEach(subValue => {
+          execArgv.push(`${optionName}=${subValue}`);
+        });
+      } else {
+        execArgv.push(`${optionName}=${optionValue}`);
+      }
     });
     return execArgv;
   }
@@ -26057,7 +25758,7 @@ const createChildExecOptions = async ({
   debugModeInheritBreak = true
 } = {}) => {
   if (typeof debugMode === "string" && AVAILABLE_DEBUG_MODE.indexOf(debugMode) === -1) {
-    throw new TypeError(createDetailedMessage$1(`unexpected debug mode.`, {
+    throw new TypeError(createDetailedMessage(`unexpected debug mode.`, {
       ["debug mode"]: debugMode,
       ["allowed debug mode"]: AVAILABLE_DEBUG_MODE
     }));
@@ -26254,6 +25955,10 @@ const EXIT_CODES = {
   SIGTERM: 128 + SIGTERM_SIGNAL_NUMBER
 };
 
+const IMPORTMAP_NODE_LOADER_FILE_URL = new URL("./importmap_node_loader.mjs?entry_point=", import.meta.url).href;
+
+const NO_EXPERIMENTAL_WARNING_FILE_URL = new URL("./no_experimental_warnings.cjs?entry_point=", import.meta.url).href;
+
 const CONTROLLABLE_CHILD_PROCESS_URL = new URL("./controllable_child_process.mjs?entry_point=", import.meta.url).href;
 const nodeChildProcess = {
   type: "node",
@@ -26266,6 +25971,7 @@ nodeChildProcess.run = async ({
   logProcessCommand = false,
   rootDirectoryUrl,
   fileRelativeUrl,
+  importMap,
   keepRunning,
   gracefulStopAllocatedMs = 4000,
   stopSignal,
@@ -26296,6 +26002,12 @@ nodeChildProcess.run = async ({
     env.NODE_V8_COVERAGE = "";
   }
   commandLineOptions = ["--experimental-import-meta-resolve", ...commandLineOptions];
+  if (importMap) {
+    env.IMPORT_MAP = JSON.stringify(importMap);
+    env.IMPORT_MAP_BASE_URL = rootDirectoryUrl;
+    commandLineOptions.push(`--experimental-loader=${fileURLToPath(IMPORTMAP_NODE_LOADER_FILE_URL)}`);
+    commandLineOptions.push(`--require=${fileURLToPath(NO_EXPERIMENTAL_WARNING_FILE_URL)}`);
+  }
   const cleanupCallbackList = createCallbackListNotifiedOnce();
   const cleanup = async reason => {
     await cleanupCallbackList.notify({
@@ -26321,9 +26033,10 @@ nodeChildProcess.run = async ({
     execArgv,
     // silent: true
     stdio: ["pipe", "pipe", "pipe", "ipc"],
-    env: envForChildProcess
+    env: envForChildProcess,
+    cwd: new URL(rootDirectoryUrl)
   });
-  logger.debug(createDetailedMessage$1(`child process forked (pid ${childProcess.pid})`, {
+  logger.debug(createDetailedMessage(`child process forked (pid ${childProcess.pid})`, {
     "custom env": JSON.stringify(env, null, "  ")
   }));
   // if we pass stream, pipe them https://github.com/sindresorhus/execa/issues/81
@@ -26584,6 +26297,7 @@ nodeWorkerThread.run = async ({
   // logger,
   rootDirectoryUrl,
   fileRelativeUrl,
+  importMap,
   keepRunning,
   stopSignal,
   onConsole,
@@ -26610,6 +26324,12 @@ nodeWorkerThread.run = async ({
   if (coverageMethodForNodeJs !== "NODE_V8_COVERAGE") {
     env.NODE_V8_COVERAGE = "";
   }
+  if (importMap) {
+    env.IMPORT_MAP = JSON.stringify(importMap);
+    env.IMPORT_MAP_BASE_URL = rootDirectoryUrl;
+    commandLineOptions.push(`--experimental-loader=${fileURLToPath(IMPORTMAP_NODE_LOADER_FILE_URL)}`);
+    commandLineOptions.push(`--require=${fileURLToPath(NO_EXPERIMENTAL_WARNING_FILE_URL)}`);
+  }
   const workerThreadExecOptions = await createChildExecOptions({
     signal,
     debugPort,
@@ -26995,6 +26715,7 @@ const execute = async ({
   logLevel,
   rootDirectoryUrl,
   webServer,
+  importMap,
   fileRelativeUrl,
   allocatedMs,
   mirrorConsole = true,
@@ -27028,6 +26749,7 @@ const execute = async ({
     rootDirectoryUrl,
     webServer,
     fileRelativeUrl,
+    importMap,
     ...runtimeParams
   };
   let result = await run({