@jsenv/core 27.0.0-alpha.2 → 27.0.0-alpha.20

package/src/omega/kitchen.js

@@ -4,51 +4,52 @@ import {
   isFileSystemPath,
   fileSystemPathToUrl,
   moveUrl,
-  fileSystemRootUrl,
 } from "@jsenv/filesystem"
+import { createDetailedMessage } from "@jsenv/logger"
 
 import { stringifyUrlSite } from "@jsenv/utils/urls/url_trace.js"
+import { CONTENT_TYPE } from "@jsenv/utils/content_type/content_type.js"
+import { setUrlFilename } from "@jsenv/utils/urls/url_utils.js"
 
+import { createPluginController } from "../plugins/plugin_controller.js"
+import { jsenvPluginUrlReferences } from "../plugins/url_references/jsenv_plugin_url_references.js"
 import { createUrlInfoTransformer } from "./url_graph/url_info_transformations.js"
-import { featuresCompatMap } from "./runtime_support/features_compatibility.js"
-import { isFeatureSupportedOnRuntimes } from "./runtime_support/runtime_support.js"
-import { fileUrlConverter } from "./file_url_converter.js"
-import { parseUrlMentions } from "./url_mentions/parse_url_mentions.js"
+import { RUNTIME_COMPAT } from "./compat/runtime_compat.js"
+import { defaultRuntimeCompat } from "./compat/default_runtime_compat.js"
 import {
-  createResolveError,
-  createLoadError,
-  createParseError,
-  createTransformError,
+  createResolveUrlError,
+  createFetchUrlContentError,
+  createTransformUrlContentError,
+  createFinalizeUrlContentError,
 } from "./errors.js"
-import { createPluginController } from "./plugin_controller.js"
+import { assertFetchedContentCompliance } from "./fetched_content_compliance.js"
+import { isWebWorkerEntryPointReference } from "./web_workers.js"
 
 export const createKitchen = ({
   signal,
   logger,
   rootDirectoryUrl,
   urlGraph,
+
   plugins,
   scenario,
-
   sourcemaps = {
     dev: "inline", // "programmatic" and "file" also allowed
     test: "inline",
     build: "none",
   }[scenario],
-  // we don't need sources in sourcemap as long as the url in the
-  // sourcemap uses file:/// (chrome will understand and read from filesystem)
-  sourcemapsSources = false,
-  loadInlineUrlInfos = (urlInfo) => {
-    return {
-      contentType: urlInfo.contentType,
-      content: urlInfo.content,
-    }
-  },
-
+  sourcemapsSources = {
+    // during dev/test, chrome is able to find the sourcemap sources
+    // as long as they use file:// protocol in the sourcemap files
+    dev: false,
+    test: false,
+    build: true,
+  }[scenario],
+  runtimeCompat = defaultRuntimeCompat,
   writeOnFileSystem = true,
 }) => {
   const pluginController = createPluginController({
-    plugins,
+    plugins: [jsenvPluginUrlReferences(), ...plugins],
     scenario,
   })
   const jsenvDirectoryUrl = new URL(".jsenv/", rootDirectoryUrl).href
@@ -59,35 +60,75 @@ export const createKitchen = ({
     sourcemaps,
     urlGraph,
     scenario,
+    runtimeCompat,
+    isSupportedOnFutureClients: (feature) => {
+      return RUNTIME_COMPAT.isSupported(runtimeCompat, feature)
+    },
   }
   const createReference = ({
     data = {},
+    node,
     trace,
     parentUrl,
     type,
     subtype,
+    expectedContentType,
+    expectedType,
+    expectedSubtype,
+    filename,
+    integrity,
+    crossorigin,
     specifier,
+    baseUrl,
+    isOriginalPosition,
+    line,
+    column,
+    external = false,
     isInline = false,
+    injected = false,
+    isRessourceHint = false,
     content,
     contentType,
   }) => {
     return {
+      original: null,
+      prev: null,
+      next: null,
       data,
+      node,
       trace,
       parentUrl,
       type,
       subtype,
+      expectedContentType,
+      expectedType,
+      expectedSubtype,
+      filename,
+      integrity,
+      crossorigin,
       specifier,
+      baseUrl,
+      isOriginalPosition,
+      line,
+      column,
+      external,
       isInline,
+      injected,
+      isRessourceHint,
       // for inline ressources the reference contains the content
       content,
       contentType,
     }
   }
+  const mutateReference = (reference, newReference) => {
+    reference.next = newReference
+    newReference.prev = reference
+    newReference.original = reference.original || reference
+  }
   const resolveReference = (reference) => {
     try {
       const resolvedUrl = pluginController.callHooksUntil(
-        "resolve",
+        "resolveUrl",
         reference,
         baseContext,
       )
@@ -95,15 +136,25 @@ export const createKitchen = ({
         throw new Error(`NO_RESOLVE`)
       }
       reference.url = resolvedUrl
+      if (reference.external) {
+        reference.generatedUrl = resolvedUrl
+        reference.generatedSpecifier = reference.specifier
+        return urlGraph.reuseOrCreateUrlInfo(reference.url)
+      }
       pluginController.callHooks(
-        "normalize",
+        "normalizeUrl",
         reference,
         baseContext,
         (returnValue) => {
+          if (returnValue === reference.url) {
+            return
+          }
+          const previousReference = { ...reference }
           reference.url = returnValue
+          mutateReference(previousReference, reference)
         },
       )
-      // force a last normalization regarding on url search params
+      // force a last normalization on url search params
       // some plugin use URLSearchParams to alter the url search params
       // which can result into "file:///file.css?css_module"
       // becoming "file:///file.css?css_module="
@@ -115,32 +166,41 @@ export const createKitchen = ({
         reference.url = reference.url.replace(/[=](?=&|$)/g, "")
       }
       const urlInfo = urlGraph.reuseOrCreateUrlInfo(reference.url)
-      Object.assign(urlInfo.data, reference.data)
+      applyReferenceEffectsOnUrlInfo(reference, urlInfo, baseContext)
 
-      // create a copy because .url will be mutated
-      const referencedCopy = {
-        ...reference,
-        data: urlInfo.data,
-      }
+      const referenceUrlObject = new URL(reference.url)
+      reference.searchParams = referenceUrlObject.searchParams
+      reference.generatedUrl = reference.url
+      // This hook must touch reference.generatedUrl, NOT reference.url
+      // And this is because this hook inject query params used to:
+      // - bypass browser cache (?v)
+      // - convey information (?hmr)
+      // But do not represent an other ressource, it is considered as
+      // the same ressource under the hood
       pluginController.callHooks(
-        "transformReferencedUrl",
-        referencedCopy,
+        "transformUrlSearchParams",
+        reference,
         baseContext,
         (returnValue) => {
-          referencedCopy.url = returnValue
+          Object.keys(returnValue).forEach((key) => {
+            referenceUrlObject.searchParams.set(key, returnValue[key])
+          })
+          reference.generatedUrl = referenceUrlObject.href.replace(
+            /[=](?=&|$)/g,
+            "",
+          )
         },
       )
-      reference.generatedUrl = referencedCopy.url
       const returnValue = pluginController.callHooksUntil(
-        "formatReferencedUrl",
-        referencedCopy,
+        "formatUrl",
+        reference,
         baseContext,
       )
       reference.generatedSpecifier = returnValue || reference.generatedUrl
-      reference.generatedSpecifier = specifierFormat.encode(reference)
+      reference.generatedSpecifier = urlSpecifierFormat.encode(reference)
       return urlInfo
     } catch (error) {
-      throw createResolveError({
+      throw createResolveUrlError({
         pluginController,
         reference,
         error,
@@ -156,8 +216,7 @@ export const createKitchen = ({
       const sourcemapReference = createReference({
         trace: `sourcemap comment placeholder for ${urlInfo.url}`,
         type: "sourcemap_comment",
-        subtype:
-          urlInfo.contentType === "application/javascript" ? "js" : "css",
+        subtype: urlInfo.contentType === "text/javascript" ? "js" : "css",
         parentUrl: urlInfo.url,
         specifier,
       })
@@ -185,69 +244,77 @@ export const createKitchen = ({
     },
   })
 
-  const isSupported = ({
-    runtimeSupport,
-    featureName,
-    featureCompat = featuresCompatMap[featureName],
-  }) => {
-    return isFeatureSupportedOnRuntimes(runtimeSupport, featureCompat)
-  }
-
-  const load = async ({ reference, urlInfo, context }) => {
+  const fetchUrlContent = async ({ reference, urlInfo, context }) => {
+    if (reference.external) {
+      urlInfo.external = true
+      return
+    }
     try {
-      const loadReturnValue = urlInfo.isInline
-        ? loadInlineUrlInfos(urlInfo)
-        : await pluginController.callAsyncHooksUntil("load", urlInfo, context)
-      if (!loadReturnValue) {
-        throw new Error("NO_LOAD")
+      const returnValue = await pluginController.callAsyncHooksUntil(
+        "fetchUrlContent",
+        urlInfo,
+        context,
+      )
+      if (!returnValue) {
+        logger.warn(
+          createDetailedMessage(
+            `no plugin has handled the url during "fetchUrlContent" hook -> consider url as external (ignore it)`,
+            {
+              "url": urlInfo.url,
+              "url reference trace": reference.trace,
+            },
+          ),
+        )
+        urlInfo.external = true
+        return
+      }
+      if (returnValue.external) {
+        urlInfo.external = true
+        return
       }
-
       const {
-        contentType = "application/octet-stream",
-        content, // can be a buffer (used for binary files) or a string
-        sourcemap,
-        // during build urls info are reused and load returns originalContent
-        // that we want to keep
-        originalContent = content,
         data,
-      } = loadReturnValue
-      Object.assign(urlInfo, {
-        contentType,
+        type,
+        subtype,
+        contentType = "application/octet-stream",
         originalContent,
         content,
         sourcemap,
-      })
+        filename,
+      } = returnValue
+      urlInfo.type =
+        type ||
+        reference.expectedType ||
+        inferUrlInfoType({
+          url: urlInfo.url,
+          contentType,
+        })
+      urlInfo.subtype =
+        subtype ||
+        reference.expectedSubtype ||
+        inferUrlInfoSubtype({
+          url: urlInfo.url,
+          type: urlInfo.type,
+          subtype: urlInfo.subtype,
+        })
+      urlInfo.contentType = contentType
+      // during build urls info are reused and load returns originalContent
+      urlInfo.originalContent =
+        originalContent === undefined ? content : originalContent
+      urlInfo.content = content
+      urlInfo.sourcemap = sourcemap
       if (data) {
         Object.assign(urlInfo.data, data)
       }
-      if (!urlInfo.type) {
-        const type = inferUrlInfoType(urlInfo)
-        if (type === "js") {
-          const urlObject = new URL(urlInfo.url)
-          if (urlObject.searchParams.has("worker_type_classic")) {
-            urlInfo.type = "js_classic"
-            urlInfo.subtype = "worker"
-          } else if (
-            urlObject.searchParams.has("service_worker_type_classic")
-          ) {
-            urlInfo.type = "js_classic"
-            urlInfo.subtype = "service_worker"
-          } else if (urlObject.searchParams.has("js_classic")) {
-            urlInfo.type = "js_classic"
-          } else {
-            urlInfo.type = "js_module"
-          }
-          if (urlObject.searchParams.has("worker")) {
-            urlInfo.subtype = "worker"
-          } else if (urlObject.searchParams.has("service_worker")) {
-            urlInfo.subtype = "service_worker"
-          }
-        } else {
-          urlInfo.type = type
-        }
+      if (filename) {
+        urlInfo.filename = filename
       }
+      assertFetchedContentCompliance({
+        reference,
+        urlInfo,
+      })
     } catch (error) {
-      throw createLoadError({
+      throw createFetchUrlContentError({
         pluginController,
         urlInfo,
         reference,
@@ -255,9 +322,8 @@ export const createKitchen = ({
       })
     }
     urlInfo.generatedUrl = determineFileUrlForOutDirectory({
-      rootDirectoryUrl,
-      outDirectoryUrl: context.outDirectoryUrl,
-      url: urlInfo.url,
+      urlInfo,
+      context,
     })
     await urlInfoTransformer.initTransformations(urlInfo, context)
   }
@@ -266,34 +332,39 @@ export const createKitchen = ({
     reference,
     urlInfo,
     outDirectoryUrl,
-    runtimeSupport,
+    // during dev/test clientRuntimeCompat is a single runtime
+    // during build clientRuntimeCompat is runtimeCompat
+    clientRuntimeCompat = runtimeCompat,
     cookDuringCook = cook,
   }) => {
     const context = {
       ...baseContext,
       reference,
       outDirectoryUrl,
-      runtimeSupport,
-      isSupportedOnRuntime: (featureName, featureCompat) => {
-        return isSupported({ runtimeSupport, featureName, featureCompat })
+      clientRuntimeCompat,
+      isSupportedOnCurrentClients: (feature) => {
+        return RUNTIME_COMPAT.isSupported(clientRuntimeCompat, feature)
       },
       cook: (params) => {
         return cookDuringCook({
           outDirectoryUrl,
-          runtimeSupport,
+          clientRuntimeCompat,
           ...params,
         })
       },
-      load: (params) => {
-        return load({
+      fetchUrlContent: (params) => {
+        return fetchUrlContent({
           context,
           ...params,
         })
       },
     }
 
-    // "load" hook
-    await load({ reference, urlInfo, context })
+    // "fetchUrlContent" hook
+    await fetchUrlContent({ reference, urlInfo, context })
+    if (urlInfo.external) {
+      return
+    }
 
     // parsing
     const references = []
@@ -303,182 +374,146 @@ export const createKitchen = ({
         ...props,
       })
       references.push(reference)
-      return [reference, resolveReference(reference)]
+      const referencedUrlInfo = resolveReference(reference)
+      return [reference, referencedUrlInfo]
     }
     const referenceUtils = {
-      inject: ({ trace, ...rest }) => {
-        if (trace === undefined) {
-          const { prepareStackTrace } = Error
-          Error.prepareStackTrace = (error, stack) => {
-            Error.prepareStackTrace = prepareStackTrace
-            return stack
-          }
-          const { stack } = new Error()
-          const callerCallsite = stack[1]
-          const fileName = callerCallsite.getFileName()
-          trace = stringifyUrlSite({
-            url:
-              fileName && isFileSystemPath(fileName)
-                ? fileSystemPathToUrl(fileName)
-                : fileName,
-            line: callerCallsite.getLineNumber(),
-            column: callerCallsite.getColumnNumber(),
+      readGeneratedSpecifier: async (reference) => {
+        // "formatReferencedUrl" can be async BUT this is an exception
+        // for most cases it will be sync. We want to favor the sync signature to keep things simpler
+        // The only case where it needs to be async is when
+        // the specifier is a `data:*` url
+        // in this case we'll wait for the promise returned by
+        // "formatReferencedUrl"
+        if (reference.generatedSpecifier.then) {
+          return reference.generatedSpecifier.then((value) => {
+            reference.generatedSpecifier = value
+            return value
           })
         }
+        return reference.generatedSpecifier
+      },
+      found: ({ line, column, ...rest }) => {
+        const trace = stringifyUrlSite(
+          adjustUrlSite(urlInfo, {
+            urlGraph,
+            url: urlInfo.url,
+            line,
+            column,
+          }),
+        )
+        // console.log(trace)
         return addReference({
           trace,
+          line,
+          column,
           ...rest,
         })
       },
-      foundInline: ({
-        type,
-        isOriginal,
-        line,
-        column,
-        specifier,
-        contentType,
-        content,
-      }) => {
-        const parentUrl = isOriginal ? urlInfo.url : urlInfo.generatedUrl
-        const parentContent = isOriginal
+      foundInline: ({ isOriginalPosition, line, column, ...rest }) => {
+        const parentUrl = isOriginalPosition
+          ? urlInfo.url
+          : urlInfo.generatedUrl
+        const parentContent = isOriginalPosition
           ? urlInfo.originalContent
           : urlInfo.content
-        const [inlineReference, inlineUrlInfo] = addReference({
+        return addReference({
           trace: stringifyUrlSite({
             url: parentUrl,
             content: parentContent,
             line,
             column,
           }),
-          type,
-          specifier,
-          isInline: true,
-          contentType,
-          content,
-        })
-        inlineUrlInfo.isInline = true
-        inlineUrlInfo.inlineUrlSite = {
-          url: urlInfo.url,
-          content: parentContent,
+          isOriginalPosition,
           line,
           column,
-        }
-        inlineUrlInfo.contentType = contentType
-        inlineUrlInfo.originalContent = inlineUrlInfo.content = content
-        return [inlineReference, inlineUrlInfo]
+          isInline: true,
+          ...rest,
+        })
       },
-      updateSpecifier: (generatedSpecifier, newSpecifier, data) => {
-        const index = references.findIndex(
-          (ref) => ref.generatedSpecifier === generatedSpecifier,
-        )
+      update: (currentReference, newReferenceParams) => {
+        const index = references.indexOf(currentReference)
         if (index === -1) {
-          throw new Error(
-            `Cannot find a reference for the following generatedSpecifier "${generatedSpecifier}"`,
-          )
+          throw new Error(`reference do not exists`)
         }
-        const referenceFound = references[index]
-        const newReference = createReference({
-          ...referenceFound,
-          specifier: newSpecifier,
-          data: {
-            ...referenceFound.data,
-            ...data,
-          },
+        const previousReference = currentReference
+        const nextReference = createReference({
+          ...previousReference,
+          ...newReferenceParams,
         })
-        references[index] = newReference
-        newReference.data.originalReference = referenceFound
-        const newUrlInfo = resolveReference(newReference)
-        return [newReference, newUrlInfo]
+        references[index] = nextReference
+        mutateReference(previousReference, nextReference)
+        const newUrlInfo = resolveReference(nextReference)
+        const currentUrlInfo = context.urlGraph.getUrlInfo(currentReference.url)
+        if (
+          currentUrlInfo &&
+          currentUrlInfo !== newUrlInfo &&
+          currentUrlInfo.dependents.size === 0
+        ) {
+          delete context.urlGraph.urlInfos[currentReference.url]
+        }
+        return [nextReference, newUrlInfo]
       },
       becomesInline: (
         reference,
-        { isOriginal, line, column, specifier, contentType, content },
+        { isOriginalPosition, line, column, specifier, contentType, content },
       ) => {
-        const parentUrl = isOriginal ? urlInfo.url : urlInfo.generatedUrl
-        const parentContent = isOriginal
+        const parentUrl = isOriginalPosition
+          ? urlInfo.url
+          : urlInfo.generatedUrl
+        const parentContent = isOriginalPosition
           ? urlInfo.originalContent
           : urlInfo.content
-        reference.trace = stringifyUrlSite({
-          url: parentUrl,
-          content: parentContent,
-          line,
-          column,
+        return referenceUtils.update(reference, {
+          trace: stringifyUrlSite({
+            url: parentUrl,
+            content: parentContent,
+            line,
+            column,
+          }),
+          isOriginalPosition,
+          isInline: true,
+          specifier,
+          contentType,
+          content,
         })
-        reference.isInline = true
-        reference.specifier = specifier
-        reference.contentType = contentType
-        reference.content = content
-        const inlineUrlInfo = resolveReference(reference)
-        inlineUrlInfo.isInline = true
-        inlineUrlInfo.inlineUrlSite = {
-          url: urlInfo.url,
-          content: parentContent,
-          line,
-          column,
-        }
-        inlineUrlInfo.contentType = contentType
-        inlineUrlInfo.content = content
-        return reference
       },
-    }
-
-    let parseResult
-    try {
-      parseResult = await parseUrlMentions({
-        type: urlInfo.type,
-        url: urlInfo.data.sourceUrl || urlInfo.url,
-        generatedUrl: urlInfo.generatedUrl,
-        content: urlInfo.content,
-      })
-    } catch (error) {
-      throw createParseError({
-        reference,
-        urlInfo,
-        error,
-      })
-    }
-    if (parseResult) {
-      Object.assign(urlInfo.data, parseResult.data)
-      const { urlMentions, replaceUrls } = parseResult
-      for (const urlMention of urlMentions) {
-        const [reference] = addReference({
-          trace: stringifyUrlSite(
-            adjustUrlSite(urlInfo, {
-              urlGraph,
-              url: urlInfo.url,
-              line: urlMention.line,
-              column: urlMention.column,
-            }),
-          ),
-          type: urlMention.type,
-          subtype: urlMention.subtype,
-          specifier: urlMention.specifier,
-        })
-        urlMention.reference = reference
-      }
-      if (references.length) {
-        // "formatReferencedUrl" can be async BUT this is an exception
-        // for most cases it will be sync. We want to favor the sync signature to keep things simpler
-        // The only case where it needs to be async is when
-        // the specifier is a `data:*` url
-        // in this case we'll wait for the promise returned by
-        // "formatReferencedUrl"
-        await Promise.all(
-          references.map(async (reference) => {
-            if (reference.generatedSpecifier.then) {
-              const value = await reference.generatedSpecifier
-              reference.generatedSpecifier = value
-            }
-          }),
-        )
-        const replaceReturnValue = await replaceUrls((urlMention) => {
-          return urlMention.reference.generatedSpecifier
+      inject: ({ trace, ...rest }) => {
+        if (trace === undefined) {
+          const { prepareStackTrace } = Error
+          Error.prepareStackTrace = (error, stack) => {
+            Error.prepareStackTrace = prepareStackTrace
+            return stack
+          }
+          const { stack } = new Error()
+          const callerCallsite = stack[1]
+          const fileName = callerCallsite.getFileName()
+          trace = stringifyUrlSite({
+            url:
+              fileName && isFileSystemPath(fileName)
+                ? fileSystemPathToUrl(fileName)
+                : fileName,
+            line: callerCallsite.getLineNumber(),
+            column: callerCallsite.getColumnNumber(),
+          })
+        }
+        return addReference({
+          trace,
+          injected: true,
+          ...rest,
         })
-        await urlInfoTransformer.applyIntermediateTransformations(
-          urlInfo,
-          replaceReturnValue,
+      },
+      findByGeneratedSpecifier: (generatedSpecifier) => {
+        const reference = references.find(
+          (ref) => ref.generatedSpecifier === generatedSpecifier,
         )
-      }
+        if (!reference) {
+          throw new Error(
+            `No reference found using the following generatedSpecifier: "${generatedSpecifier}"`,
+          )
+        }
+        return reference
+      },
     }
 
     // "transform" hook
@@ -486,7 +521,7 @@ export const createKitchen = ({
     context.referenceUtils = referenceUtils
     try {
       await pluginController.callAsyncHooks(
-        "transform",
+        "transformUrlContent",
         urlInfo,
         context,
         async (transformReturnValue) => {
@@ -497,7 +532,7 @@ export const createKitchen = ({
         },
       )
     } catch (error) {
-      throw createTransformError({
+      throw createTransformUrlContentError({
         pluginController,
         reference,
         urlInfo,
@@ -509,15 +544,24 @@ export const createKitchen = ({
     urlGraph.updateReferences(urlInfo, references)
 
     // "finalize" hook
-    const finalizeReturnValue = await pluginController.callHooksUntil(
-      "finalize",
-      urlInfo,
-      context,
-    )
-    await urlInfoTransformer.applyFinalTransformations(
-      urlInfo,
-      finalizeReturnValue,
-    )
+    try {
+      const finalizeReturnValue = await pluginController.callAsyncHooksUntil(
+        "finalizeUrlContent",
+        urlInfo,
+        context,
+      )
+      await urlInfoTransformer.applyFinalTransformations(
+        urlInfo,
+        finalizeReturnValue,
+      )
+    } catch (error) {
+      throw createFinalizeUrlContentError({
+        pluginController,
+        reference,
+        urlInfo,
+        error,
+      })
+    }
 
     // "cooked" hook
     pluginController.callHooks(
@@ -580,15 +624,58 @@ export const createKitchen = ({
 
   baseContext.cook = cook
 
+  const prepareEntryPoint = (params) => {
+    const entryReference = createReference(params)
+    const entryUrlInfo = resolveReference(entryReference)
+    return [entryReference, entryUrlInfo]
+  }
+
+  const injectReference = (params) => {
+    const ref = createReference(params)
+    const urlInfo = resolveReference(ref)
+    return [ref, urlInfo]
+  }
+
   return {
     pluginController,
     urlInfoTransformer,
     rootDirectoryUrl,
     jsenvDirectoryUrl,
-    isSupported,
-    createReference,
-    resolveReference,
+    baseContext,
     cook,
+    prepareEntryPoint,
+    injectReference,
+  }
+}
+
+const applyReferenceEffectsOnUrlInfo = (reference, urlInfo, context) => {
+  Object.assign(urlInfo.data, reference.data)
+  if (reference.injected) {
+    urlInfo.data.injected = true
+  }
+  if (reference.filename) {
+    urlInfo.filename = reference.filename
+  }
+  if (reference.isInline) {
+    urlInfo.isInline = true
+    const parentUrlInfo = context.urlGraph.getUrlInfo(reference.parentUrl)
+    urlInfo.inlineUrlSite = {
+      url: parentUrlInfo.url,
+      content: reference.isOriginalPosition
+        ? parentUrlInfo.originalContent
+        : parentUrlInfo.content,
+      line: reference.line,
+      column: reference.column,
+    }
+    urlInfo.contentType = reference.contentType
+    urlInfo.originalContent =
+      urlInfo.originalContent === undefined
+        ? reference.content
+        : urlInfo.originalContent
+    urlInfo.content = reference.content
+  }
+  if (isWebWorkerEntryPointReference(reference)) {
+    urlInfo.data.isWebWorkerEntryPoint = true
   }
 }
 
@@ -626,54 +713,85 @@ const adjustUrlSite = (urlInfo, { urlGraph, url, line, column }) => {
   )
 }
 
-const inferUrlInfoType = ({ contentType }) => {
+const inferUrlInfoType = ({ url, contentType }) => {
   if (contentType === "text/html") {
     return "html"
   }
   if (contentType === "text/css") {
     return "css"
   }
-  if (contentType === "application/javascript") {
-    return "js"
-  }
-  if (contentType === "application/json") {
-    return "json"
+  if (contentType === "text/javascript") {
+    const urlObject = new URL(url)
+    if (urlObject.searchParams.has("js_classic")) {
+      return "js_classic"
+    }
+    return "js_module"
   }
   if (contentType === "application/importmap+json") {
     return "importmap"
   }
+  if (contentType === "application/manifest+json") {
+    return "webmanifest"
+  }
+  if (contentType === "image/svg+xml") {
+    return "svg"
+  }
+  if (CONTENT_TYPE.isJson(contentType)) {
+    return "json"
+  }
+  if (CONTENT_TYPE.isTextual(contentType)) {
+    return "text"
+  }
   return "other"
 }
 
-const determineFileUrlForOutDirectory = ({
-  rootDirectoryUrl,
-  outDirectoryUrl,
-  url,
-}) => {
-  if (!outDirectoryUrl) {
-    return url
+const inferUrlInfoSubtype = ({ type, subtype, url }) => {
+  if (type === "js_classic" || type === "js_module") {
+    const urlObject = new URL(url)
+    if (urlObject.searchParams.has("worker")) {
+      return "worker"
+    }
+    if (urlObject.searchParams.has("service_worker")) {
+      return "service_worker"
+    }
+    if (urlObject.searchParams.has("shared_worker")) {
+      return "shared_worker"
+    }
+    // if we are currently inside a worker, all deps are consider inside worker too
+    return subtype
+  }
+  return ""
+}
+
+const determineFileUrlForOutDirectory = ({ urlInfo, context }) => {
+  if (!context.outDirectoryUrl) {
+    return urlInfo.url
+  }
+  if (!urlInfo.url.startsWith("file:")) {
+    return urlInfo.url
   }
-  if (!url.startsWith("file:")) {
-    return url
+  let url = urlInfo.url
+  if (!urlIsInsideOf(urlInfo.url, context.rootDirectoryUrl)) {
+    url = `${context.rootDirectoryUrl}@fs/${url.slice("file:///".length)}`
   }
-  if (!urlIsInsideOf(url, rootDirectoryUrl)) {
-    url = `${rootDirectoryUrl}@fs/${url.slice(fileSystemRootUrl.length)}`
+  if (urlInfo.filename) {
+    url = setUrlFilename(url, urlInfo.filename)
   }
   return moveUrl({
-    url: fileUrlConverter.asUrlWithoutSpecialParams(url),
-    from: rootDirectoryUrl,
-    to: outDirectoryUrl,
+    url,
+    from: context.rootDirectoryUrl,
+    to: context.outDirectoryUrl,
     preferAbsolute: true,
   })
 }
 
-const specifierFormat = {
+const urlSpecifierFormat = {
   encode: (reference) => {
     const { generatedSpecifier } = reference
     if (generatedSpecifier.then) {
       return generatedSpecifier.then((value) => {
         reference.generatedSpecifier = value
-        return specifierFormat.encode(reference)
+        return urlSpecifierFormat.encode(reference)
       })
     }
     // allow plugin to return a function to bypas default formatting
@@ -698,10 +816,11 @@ const specifierFormat = {
   },
 }
 const formatters = {
-  js_import_export: { encode: JSON.stringify, decode: JSON.parse },
-  js_import_meta_url_pattern: { encode: JSON.stringify, decode: JSON.parse },
+  "js_import_export": { encode: JSON.stringify, decode: JSON.parse },
+  "js_url_specifier": { encode: JSON.stringify, decode: JSON.parse },
+  "css_@import": { encode: JSON.stringify, code: JSON.stringify },
   // https://github.com/webpack-contrib/css-loader/pull/627/files
-  css_url: {
+  "css_url": {
     encode: (url) => {
       // If url is already wrapped in quotes, remove them
       url = formatters.css_url.decode(url)