@jsenv/core 26.0.1 → 27.0.0-alpha.2

package/src/internal/building/ressource_builder.js

@@ -1,1098 +0,0 @@
-import { resolveUrl, urlToRelativeUrl } from "@jsenv/filesystem"
-import { createLogger, loggerToLevels } from "@jsenv/logger"
-
-import { setJavaScriptSourceMappingUrl } from "@jsenv/core/src/internal/sourcemap_utils.js"
-import { DataUrl } from "@jsenv/core/src/internal/data_url.js"
-
-import { racePromises } from "../promise_race.js"
-
-import {
-  getRessourceAsBase64Url,
-  memoize,
-  getCallerLocation,
-  formatFoundReference,
-  // formatDependenciesCollectedMessage,
-  checkContentType,
-} from "./ressource_builder_util.js"
-import { stringifyUrlSite } from "./url_trace.js"
-
-export const createRessourceBuilder = (
-  { urlFetcher, urlLoader, parseRessource },
-  {
-    logLevel,
-    format,
-    compileServerOrigin,
-    buildDirectoryUrl,
-
-    asOriginalServerUrl,
-    urlToHumanUrl,
-
-    onAsset,
-    onAssetSourceUpdated,
-    onJsModule,
-    resolveRessourceUrl,
-    buildUrlGenerator,
-  },
-) => {
-  const logger = createLogger({ logLevel })
-
-  const createReferenceForEntryPoint = async ({
-    entryContentType,
-    entryUrl,
-    entryBuffer,
-  }) => {
-    // The entry point is conceptually referenced by code passing "entryPoints"
-    // to buildProject. So we analyse stack trace to put this function caller
-    // as the reference to this ressource file
-    // we store this info in reference.isProgrammatic
-    const callerLocation = getCallerLocation()
-    const entryReference = createReference({
-      ressourceSpecifier: entryUrl,
-      contentTypeExpected: entryContentType,
-      referenceUrl: callerLocation.url,
-      referenceLine: callerLocation.line,
-      referenceColumn: callerLocation.column,
-
-      contentType: entryContentType,
-      bufferBeforeBuild: entryBuffer,
-      isJsModule: entryContentType === "application/javascript",
-
-      isEntryPoint: true,
-    })
-    entryReference.isProgrammatic = true
-    if (entryReference.ressource.isJsModule) {
-      // no need to call getDependenciesAvailablePromise and so on
-      // rollup is handling js entries
-      return
-    }
-
-    await entryReference.ressource.getDependenciesAvailablePromise()
-
-    // on await que les assets, pour le js rollup s'en occupe
-    await Promise.all(
-      entryReference.ressource.dependencies.map(async (dependency) => {
-        if (dependency.contentTypeExpected === "application/importmap+json") {
-          // don't await for importmap right away, it must be handled as the very last asset
-          // to be aware of build mappings.
-          // getReadyPromise() for that importmap will be called during getAllAssetEntryEmittedPromise
-          // (a simpler approach could keep importmap untouched and override it late
-          // (but that means updating html hash and importmap hash)
-          return
-        }
-        const { ressource } = dependency
-        const readyPromise = ressource.getReadyPromise()
-        if (ressource.isJsModule) {
-          // await internally for rollup to be done with this ressource js module
-          // but don't await explicitely or rollup wait for asset builder
-          // which is waiting for rollup
-          return
-        }
-        if (!ressource.firstStrongReference) {
-          // await internally for rollup to be done to see if this ressource gets referenced
-          // but don't await explicitly or rollup would wait
-          // for asset builder which is waiting for rollup
-          return
-        }
-        if (ressource.isPlaceholder) {
-          return
-        }
-        await readyPromise
-      }),
-    )
-  }
-
-  const createReferenceFoundByRollup = (params) => {
-    return createReference({
-      fromRollup: true,
-      ...params,
-    })
-  }
-
-  const createReferenceFoundInJsModule = ({
-    referenceLabel,
-    jsUrl,
-    jsLine,
-    jsColumn,
-    isImportAssertion,
-    isJsModule,
-
-    contentTypeExpected,
-    ressourceSpecifier,
-    contentType,
-    bufferBeforeBuild,
-  }) => {
-    const reference = createReference({
-      isImportAssertion,
-      ressourceSpecifier,
-      contentTypeExpected,
-      referenceLabel,
-      referenceUrl: jsUrl,
-      referenceLine: jsLine,
-      referenceColumn: jsColumn,
-
-      contentType,
-      bufferBeforeBuild,
-      isJsModule,
-    })
-    return reference
-  }
-
-  const getAllEntryPointsEmittedPromise = async () => {
-    const urlToWait = Object.keys(ressourceMap).filter(
-      (url) => ressourceMap[url].isEntryPoint,
-    )
-    await Promise.all(
-      urlToWait.map(async (url) => {
-        const ressource = ressourceMap[url]
-        await ressource.getReadyPromise()
-        return ressource
-      }),
-    )
-
-    // compute all asset fileName
-    Object.keys(ressourceMap).forEach((key) => {
-      const ressource = ressourceMap[key]
-      if (
-        ressource.isExternal ||
-        ressource.isJsModule ||
-        ressource.buildFileNameWithoutHash
-      ) {
-        return
-      }
-      if (ressource.isPlaceholder && !ressource.buildRelativeUrl) {
-        return
-      }
-      if (!ressource.buildRelativeUrl) {
-        if (ressource.isPlaceholder) {
-          // placeholder not filled, that's ok
-          return
-        }
-        if (ressource.references.every((ref) => ref.isRessourceHint)) {
-          // ressource hint never used, the ressource can be ignored
-          return
-        }
-      }
-      ressource.buildFileNameWithoutHash = asFileNameWithoutHash(
-        ressource.buildRelativeUrl,
-      )
-    })
-  }
-
-  const ressourceMap = {}
-  const ressourceRedirectionMap = {}
-  const createReference = ({
-    isRessourceHint,
-    isImportAssertion,
-    ressourceSpecifier,
-    referenceLabel,
-    referenceUrl,
-    referenceColumn,
-    referenceLine,
-    contentTypeExpected,
-    crossorigin,
-    integrity,
-
-    contentType,
-    bufferBeforeBuild,
-    isEntryPoint,
-    isJsModule,
-    isSourcemap,
-    isInline,
-    isPlaceholder,
-
-    urlVersioningDisabled,
-
-    fromRollup,
-  }) => {
-    let ressourceImporter
-    if (referenceUrl) {
-      const existingRessourceForReference = findRessourceByUrl(referenceUrl)
-      if (existingRessourceForReference) {
-        ressourceImporter = existingRessourceForReference
-      } else {
-        const referenceOriginalUrl = asOriginalServerUrl(referenceUrl)
-        if (referenceOriginalUrl) {
-          ressourceImporter = findRessourceByUrl(referenceOriginalUrl)
-        }
-      }
-    }
-    if (!ressourceImporter) {
-      // happens only for entry points?
-      // in that case the importer is theoric
-      // see "getCallerLocation()" in createReferenceForEntryPoint
-      ressourceImporter = {
-        url: referenceUrl,
-        isEntryPoint: false,
-        isJsModule: true,
-        bufferAfterBuild: "",
-      }
-    }
-
-    const shouldBeIgnoredWarning = referenceShouldBeIgnoredWarning({
-      isJsModule,
-      ressourceImporter,
-      ressourceSpecifier,
-      referenceUrl,
-      urlToHumanUrl,
-    })
-    if (shouldBeIgnoredWarning) {
-      logger.warn(shouldBeIgnoredWarning)
-      return null
-    }
-
-    const ressourceUrlResolution = resolveRessourceUrl({
-      ressourceSpecifier,
-      isJsModule,
-      isInline,
-      isRessourceHint,
-      ressourceImporter,
-    })
-
-    let ressourceUrl
-    let isExternal = false
-    let isWorker = false
-    let isServiceWorker = false
-    let isCrossOrigin = false
-    if (typeof ressourceUrlResolution === "object") {
-      ressourceUrl = ressourceUrlResolution.url
-      if (ressourceUrlResolution.isCrossOrigin) {
-        isCrossOrigin = true
-      }
-      if (ressourceUrlResolution.isExternal) {
-        isExternal = true
-      }
-      if (ressourceUrlResolution.isWorker) {
-        isWorker = true
-      }
-      if (ressourceUrlResolution.isServiceWorker) {
-        isServiceWorker = true
-      }
-      if (ressourceUrlResolution.isJsModule) {
-        isJsModule = true
-      }
-    } else {
-      ressourceUrl = ressourceUrlResolution
-    }
-
-    if (ressourceUrl.startsWith("data:")) {
-      isExternal = false
-      isInline = true
-      const { mediaType, base64Flag, data } = DataUrl.parse(ressourceUrl)
-      contentTypeExpected = mediaType
-      contentType = mediaType
-      bufferBeforeBuild = base64Flag
-        ? Buffer.from(data, "base64")
-        : decodeURI(data)
-    }
-
-    // any hash in the url would mess up with filenames
-    ressourceUrl = removePotentialUrlHash(ressourceUrl)
-
-    const existingRessource = findRessourceByUrl(ressourceUrl)
-    let ressource
-    if (existingRessource) {
-      ressource = existingRessource
-      // allow to update the bufferBeforeBuild on existingRessource
-      // this happens when rollup loads a js file and communicates to this code
-      // what was loaded
-      if (fromRollup) {
-        ressource.bufferBeforeBuild = bufferBeforeBuild
-        ressource.contentType = contentType
-      }
-    } else {
-      ressource = createRessource({
-        contentType,
-        ressourceUrl,
-        ressourceImporter,
-        bufferBeforeBuild,
-
-        isEntryPoint,
-        isJsModule,
-        isSourcemap,
-        isCrossOrigin,
-        isExternal,
-        isInline,
-        isPlaceholder,
-        isWorker,
-        isServiceWorker,
-
-        urlVersioningDisabled,
-      })
-      ressourceMap[ressourceUrl] = ressource
-    }
-
-    const reference = {
-      fromRollup,
-      isRessourceHint,
-      isImportAssertion,
-      referenceLabel,
-      referenceUrl,
-      referenceColumn,
-      referenceLine,
-      contentTypeExpected,
-      crossorigin,
-      integrity,
-
-      isInline,
-      inlinedCallback: () => {
-        reference.isInline = true
-        const allStrongReferenceAreInline = ressource.references.every(
-          (reference) => reference.isRessourceHint || reference.isInline,
-        )
-        if (allStrongReferenceAreInline) {
-          ressource.isInline = true
-          ressource.inlinedCallbacks.forEach((callback) => callback())
-        }
-      },
-    }
-
-    reference.ressource = ressource
-    if (fromRollup) {
-      if (ressourceImporter.isEntryPoint) {
-        // When HTML references JS, ressource builder has emitted the js chunk.
-        // so it already knows it exists and is part of references
-        // -> no need to push into reference (would incorrectly consider html references js twice)
-        // -> no need to log the js ressource (already logged during the HTML parsing)
-        return reference
-      }
-      if (ressource.isEntryPoint) {
-        // When rollup "loads" a js entry point, ressource builder is already aware of it
-        // because of "createReferenceForEntryPoint"
-        return reference
-      }
-    }
-
-    ressource.references.push(reference)
-    const effects = ressource.applyReferenceEffects(reference, { isJsModule })
-    if (loggerToLevels(logger).debug) {
-      logger.debug(
-        formatFoundReference({
-          reference,
-          referenceEffects: effects,
-          showReferenceSourceLocation,
-          urlToHumanUrl,
-        }),
-      )
-    }
-    return reference
-  }
-
-  const ressourceTransformMap = {}
-
-  const createRessource = ({
-    contentType,
-    ressourceUrl,
-    ressourceImporter,
-    bufferBeforeBuild,
-
-    isEntryPoint = false,
-    isJsModule = false,
-    isSourcemap = false,
-    isCrossOrigin = false,
-    isExternal = false,
-    isInline = false,
-    isPlaceholder = false,
-    isWorker = false,
-    isServiceWorker = false,
-
-    urlVersioningDisabled,
-  }) => {
-    const ressource = {
-      contentType,
-      url: ressourceUrl,
-      importer: ressourceImporter,
-      bufferBeforeBuild,
-      bufferAfterBuild: undefined,
-      firstStrongReference: null,
-      references: [],
-
-      isEntryPoint,
-      isJsModule,
-      isSourcemap,
-      isInline,
-      isCrossOrigin,
-      isExternal,
-      isPlaceholder,
-      isWorker,
-      isServiceWorker,
-
-      urlVersioningDisabled,
-
-      relativeUrl: ressourceUrl.startsWith(compileServerOrigin)
-        ? urlToRelativeUrl(ressourceUrl, compileServerOrigin)
-        : urlToRelativeUrl(ressourceUrl, buildDirectoryUrl),
-    }
-
-    const { buildRelativeUrlPattern, buildRelativeUrlWithoutHash } =
-      buildUrlGenerator.prepareBuildUrlForRessource(ressource)
-    ressource.buildRelativeUrlWithoutHash = buildRelativeUrlWithoutHash
-    ressource.buildRelativeUrlPattern = buildRelativeUrlPattern
-
-    ressource.usedPromise = new Promise((resolve) => {
-      ressource.usedCallback = resolve
-    })
-    ressource.inlinedCallbacks = []
-    ressource.buildEndCalledCallbacks = []
-    ressource.buildEndCalledPromise = new Promise((resolve) => {
-      ressource.buildEndCalledCallbacks.push(resolve)
-    })
-    ressource.rollupBuildDoneCallbacks = []
-    ressource.rollupBuildDonePromise = new Promise((resolve) => {
-      ressource.rollupBuildDoneCallbacks.push(resolve)
-    })
-
-    const getBufferAvailablePromise = memoize(async () => {
-      if (ressource.isJsModule) {
-        await ressource.rollupBuildDonePromise
-        return
-      }
-      // sourcemap placeholder buffer is ready once buildEnd is called on it
-      if (ressource.isPlaceholder) {
-        await ressource.buildEndCalledPromise
-        return
-      }
-      if (!ressource.firstStrongReference) {
-        // for preload/prefetch links, we don't want to start the prefetching right away.
-        // Instead we wait for something else to reference the same ressource
-        // This is by choice so that:
-        // 1. The warning about "preload but never used" is prio fetch errors like "preload not found"
-        // 2. We don't start fetching a ressource found in HTML while rollup
-        //    could do the same later. It means we should synchronize rollup
-        //    and this asset builder fetching to avoid fetching twice.
-        //    This scenario would be reproduced for every js module preloaded
-        const { usedPromise, rollupBuildDonePromise } = ressource
-        const winner = await racePromises([usedPromise, rollupBuildDonePromise])
-        if (winner.promise === rollupBuildDonePromise) {
-          return
-        }
-      }
-      const ressourceUrl = ressource.url
-      const response = await urlFetcher.fetchUrl(ressourceUrl, {
-        contentTypeExpected: ressource.firstStrongReference.contentTypeExpected,
-        crossorigin: ressource.firstStrongReference.crossorigin,
-        integrity: ressource.firstStrongReference.integrity,
-        urlTrace: () => {
-          return createRessourceTrace({
-            ressource,
-            createUrlSiteFromReference,
-            findRessourceByUrl,
-          })
-        },
-      })
-      if (response.url !== ressourceUrl) {
-        const urlBeforeRedirection = ressourceUrl
-        const urlAfterRedirection = response.url
-        ressourceRedirectionMap[urlBeforeRedirection] = urlAfterRedirection
-        ressource.url = urlAfterRedirection
-      }
-      const responseContentTypeHeader = response.headers["content-type"]
-      ressource.contentType = responseContentTypeHeader
-      const responseBodyAsArrayBuffer = await response.arrayBuffer()
-      ressource.bufferBeforeBuild = Buffer.from(responseBodyAsArrayBuffer)
-      // TODO here: integrity check
-    })
-
-    const setBufferBeforeBuild = (bufferBeforeBuild) => {
-      ressource.bufferBeforeBuild = bufferBeforeBuild
-      getBufferAvailablePromise.forceMemoization(Promise.resolve())
-    }
-
-    const getDependenciesAvailablePromise = memoize(async () => {
-      await getBufferAvailablePromise()
-
-      if (ressource.isJsModule) {
-        ressource.dependencies = []
-        return
-      }
-
-      const dependencies = []
-
-      let parsingDone = false
-      const notifyReferenceFound = ({
-        isRessourceHint,
-        contentTypeExpected,
-        crossorigin,
-        integrity,
-        ressourceSpecifier,
-        referenceLabel,
-        referenceLine,
-        referenceColumn,
-
-        contentType,
-        bufferBeforeBuild,
-        isJsModule = false,
-        isInline = false,
-        isSourcemap = false,
-        isPlaceholder = false,
-        urlVersioningDisabled,
-      }) => {
-        if (parsingDone) {
-          throw new Error(
-            `notifyReferenceFound cannot be called once ${ressource.url} parsing is done.`,
-          )
-        }
-
-        const dependencyReference = createReference({
-          ressourceSpecifier,
-          referenceLabel,
-          referenceUrl: ressource.url,
-          referenceLine,
-          referenceColumn,
-          isRessourceHint,
-          contentTypeExpected,
-          crossorigin,
-          integrity,
-
-          contentType,
-          bufferBeforeBuild,
-          isJsModule,
-          isInline,
-          isSourcemap,
-          isPlaceholder,
-
-          urlVersioningDisabled,
-        })
-
-        if (dependencyReference) {
-          dependencies.push(dependencyReference)
-        }
-        return dependencyReference
-      }
-
-      if (!ressource.isEntryPoint) {
-        logger.debug(`parse ${urlToHumanUrl(ressource.url)}`)
-      }
-
-      const parseReturnValue = await parseRessource(ressource, {
-        format,
-        notifyReferenceFound,
-      })
-      parsingDone = true
-
-      if (dependencies.length > 0 && typeof parseReturnValue !== "function") {
-        throw new Error(
-          `parse notified some dependencies, it must return a function but received ${parseReturnValue}`,
-        )
-      }
-      if (typeof parseReturnValue === "function") {
-        ressourceTransformMap[ressource.url] = parseReturnValue
-      }
-      ressource.dependencies = dependencies
-      // if (dependencies.length > 0) {
-      //   logger.debug(formatDependenciesCollectedMessage({ ressource, shortenUrl }))
-      // }
-    })
-
-    const getReadyPromise = memoize(async () => {
-      if (ressource.isExternal) {
-        // external urls are immediatly available and not modified
-        return
-      }
-
-      // la transformation d'un asset c'est avant tout la transformation de ses dépendances
-      await getDependenciesAvailablePromise()
-      const dependencies = ressource.dependencies
-      await Promise.all(
-        dependencies.map(async (dependencyReference) => {
-          const dependencyRessource = dependencyReference.ressource
-          if (dependencyRessource.isPlaceholder) {
-            return
-          }
-          // don't keep waiting for ever in case ressource hint is never used
-          if (dependencyReference.isRessourceHint) {
-            return
-          }
-          await dependencyRessource.getReadyPromise()
-        }),
-      )
-
-      const transform = ressourceTransformMap[ressource.url]
-      if (typeof transform !== "function") {
-        if (ressource.isPlaceholder) {
-          return
-        }
-        // sourcemap content depends on their source file
-        // sourcemap.buildEnd() will be called by the source file
-        if (ressource.isSourcemap) {
-          return
-        }
-        ressource.buildEnd(
-          ressource.bufferAfterBuild || ressource.bufferBeforeBuild,
-          ressource.buildRelativeUrl,
-        )
-        return
-      }
-
-      // assetDependenciesMapping contains all dependencies for an asset
-      // each key is the absolute url to the dependency file
-      // each value is an url relative to the asset importing this dependency
-      // it looks like this:
-      // {
-      //   "file:///project/coin.png": "./coin-45eiopri.png"
-      // }
-      // we don't yet know the exact importerBuildRelativeUrl but we can generate a fake one
-      // to ensure we resolve dependency against where the importer file will be
-      const importer = ressource
-      await transform({
-        buildDirectoryUrl,
-        getUrlRelativeToImporter: (referencedRessource) => {
-          const referenceBuildRelativeUrl = importer.isJsModule
-            ? // js can reference an url without versionning
-              // and actually fetch the versioned url thanks to importmap
-              referencedRessource.buildRelativeUrlWithoutHash
-            : // other ressource must use the exact url
-              referencedRessource.buildRelativeUrl
-          const referenceBuildUrl = resolveUrl(
-            referenceBuildRelativeUrl,
-            "file:///",
-          )
-          const importerBuildUrl = resolveUrl(
-            importer.buildRelativeUrlWithoutHash,
-            "file:///",
-          )
-          return urlToRelativeUrl(referenceBuildUrl, importerBuildUrl)
-        },
-        getOriginalRessource: (ressource) => {
-          const originalServerUrl = asOriginalServerUrl(ressource.url)
-          return ressourceMap[originalServerUrl]
-        },
-      })
-      if (typeof ressource.bufferAfterBuild === "undefined") {
-        throw new Error(
-          `transform must call ressource.buildEnd() for ${ressource.url}`,
-        )
-      }
-    })
-
-    // was used to remove sourcemap files that are renamed after they are emitted
-    // could be useful one day in case an asset is finally discarded
-    const remove = () => {
-      ressource.shouldBeIgnored = true
-    }
-
-    const buildEnd = (bufferAfterBuild, buildRelativeUrl) => {
-      if (bufferAfterBuild !== undefined) {
-        ressource.bufferAfterBuild = bufferAfterBuild
-        if (buildRelativeUrl === undefined) {
-          ressource.buildRelativeUrl =
-            buildUrlGenerator.computeBuildRelativeUrl(ressource)
-        }
-      }
-
-      if (buildRelativeUrl !== undefined) {
-        ressource.buildRelativeUrl = buildRelativeUrl
-      }
-
-      if (
-        // ressource.bufferAfterBuild can be undefined when ressource is only preloaded
-        // and never used
-        ressource.bufferAfterBuild &&
-        !ressource.isInline &&
-        !ressource.isJsModule
-      ) {
-        onAssetSourceUpdated({ ressource })
-      }
-    }
-
-    const applyReferenceEffects = (reference, infoFromReference) => {
-      const effects = []
-      if (reference.fromRollup && ressource.isJsModule && ressource.isInline) {
-        return effects
-      }
-      if (ressource.isEntryPoint) {
-        if (ressource.contentType === "text/html") {
-          effects.push(`parse html to find references`)
-        }
-      }
-      if (reference.isRessourceHint) {
-        // do not try to load or fetch this file
-        // we'll wait for something to reference it
-        // if nothing references it a warning will be logged
-        return effects
-      }
-      ressource.getBufferAvailablePromise().then(
-        () => {
-          if (ressource.firstStrongReference) {
-            checkContentType(reference, { logger, showReferenceSourceLocation })
-          }
-        },
-        () => {},
-      )
-      if (ressource.firstStrongReference) {
-        // this ressource was already strongly referenced by something
-        // don't try to load it twice
-        return effects
-      }
-      ressource.firstStrongReference = reference
-      // the first strong reference is allowed to transform a reference where we did not know if it was
-      // a js module to a js module
-      // This happen for preload link following by a script type module
-      // <link rel="preload" href="file.js" />
-      // <script type="module" src="file.js"></script>
-      if (!ressource.isJsModule && infoFromReference.isJsModule) {
-        effects.push(`mark ${urlToHumanUrl(ressource.url)} as js module`)
-        ressource.isJsModule = infoFromReference.isJsModule
-      }
-      ressource.usedCallback()
-      if (ressource.isExternal) {
-        // nothing to do
-        return effects
-      }
-      if (ressource.isJsModule) {
-        const jsModuleUrl = ressource.url
-        const rollupChunk = onJsModule({
-          ressource,
-          jsModuleUrl,
-          jsModuleIsInline: ressource.isInline,
-          jsModuleSource: String(bufferBeforeBuild),
-          line: reference.referenceLine,
-          column: reference.referenceColumn,
-        })
-        if (rollupChunk) {
-          ressource.rollupReferenceId = rollupChunk.rollupReferenceId
-          effects.push(
-            `emit rollup chunk "${rollupChunk.fileName}" (${rollupChunk.rollupReferenceId})`,
-          )
-        }
-        return effects
-      }
-      if (ressource.isInline) {
-        // nothing to do
-        return effects
-      }
-      const rollupAsset = onAsset({
-        ressource,
-      })
-      ressource.rollupReferenceId = rollupAsset.rollupReferenceId
-      effects.push(
-        `emit rollup asset "${rollupAsset.fileName}" (${rollupAsset.rollupReferenceId})`,
-      )
-      return effects
-    }
-
-    if (bufferBeforeBuild !== undefined) {
-      setBufferBeforeBuild(bufferBeforeBuild)
-    }
-    Object.assign(ressource, {
-      applyReferenceEffects,
-      getBufferAvailablePromise,
-      getDependenciesAvailablePromise,
-      getReadyPromise,
-      remove,
-      setBufferBeforeBuild,
-      buildEnd,
-    })
-    return ressource
-  }
-
-  const rollupBuildEnd = ({
-    rollupResult,
-    useImportMapToMaximizeCacheReuse,
-  }) => {
-    const jsRessources = {}
-    Object.keys(ressourceMap).forEach((ressourceUrl) => {
-      const ressource = ressourceMap[ressourceUrl]
-      const rollupFileName = Object.keys(rollupResult).find((key) => {
-        const rollupFileInfo = rollupResult[key]
-        return (
-          rollupFileInfo.url === ressourceUrl ||
-          // asset
-          ressource.buildFileNameWithoutHash === key ||
-          ressource.relativeUrl === key
-        )
-      })
-      if (rollupFileName) {
-        const rollupFileInfo = rollupResult[rollupFileName]
-        if (rollupFileInfo.type === "asset") {
-          ressource.buildFileNameWithoutHash = rollupFileName
-          return
-        }
-        if (rollupFileInfo.type === "chunk") {
-          applyBuildEndEffects(ressource, {
-            rollupFileInfo,
-            rollupResult,
-            useImportMapToMaximizeCacheReuse,
-          })
-          const { rollupBuildDoneCallbacks } = ressource
-          rollupBuildDoneCallbacks.forEach((rollupBuildDoneCallback) => {
-            rollupBuildDoneCallback()
-          })
-          if (rollupFileInfo.type === "chunk") {
-            jsRessources[ressourceUrl] = ressource
-          }
-          return
-        }
-      }
-    })
-    return { jsRessources }
-  }
-
-  const applyBuildEndEffects = (
-    ressource,
-    { rollupFileInfo, rollupResult, useImportMapToMaximizeCacheReuse },
-  ) => {
-    const fileName = rollupFileInfo.fileName
-    let code = rollupFileInfo.code
-    ressource.contentType = "application/javascript"
-    if (useImportMapToMaximizeCacheReuse) {
-      ressource.buildFileNameWithoutHash = fileName
-      ressource.buildEnd(code)
-    } else {
-      ressource.buildFileNameWithoutHash = asFileNameWithoutHash(fileName)
-      ressource.buildEnd(code, fileName)
-    }
-    const map = rollupFileInfo.map
-    if (map) {
-      const sourcemapBuildRelativeUrl = `${ressource.buildRelativeUrl}.map`
-      const sourcemapRollupFileInfo = rollupResult[sourcemapBuildRelativeUrl]
-      if (!sourcemapRollupFileInfo) {
-        const ressourceBuildUrl = resolveUrl(
-          ressource.buildRelativeUrl,
-          buildDirectoryUrl,
-        )
-        const sourcemapBuildUrl = resolveUrl(
-          sourcemapBuildRelativeUrl,
-          buildDirectoryUrl,
-        )
-        const sourcemapAsString = JSON.stringify(rollupFileInfo.map, null, "  ")
-        const sourcemapBuildUrlRelativeToFileBuildUrl = urlToRelativeUrl(
-          sourcemapBuildUrl,
-          ressourceBuildUrl,
-        )
-        const codeWithSourcemapComment = setJavaScriptSourceMappingUrl(
-          rollupFileInfo.code,
-          sourcemapBuildUrlRelativeToFileBuildUrl,
-        )
-        ressource.bufferAfterBuild = codeWithSourcemapComment
-        rollupFileInfo.code = codeWithSourcemapComment
-        const sourcemapReference = createReference({
-          referenceLabel: "js sourcemapping comment",
-          contentType: "application/octet-stream",
-          ressourceSpecifier: sourcemapBuildUrlRelativeToFileBuildUrl,
-          referenceUrl: ressourceBuildUrl,
-          referenceLine: codeWithSourcemapComment.split(/\r?\n/).length,
-          // ${"//#"} is to avoid a parser thinking there is a sourceMappingUrl for this file
-          referenceColumn: `${"//#"} sourceMappingURL=`.length + 1,
-          isSourcemap: true,
-          isPlaceholder: true,
-        })
-        sourcemapReference.ressource.buildEnd(
-          sourcemapAsString,
-          sourcemapBuildUrlRelativeToFileBuildUrl,
-        )
-      }
-    }
-  }
-
-  const findRessourceByUrl = (url) => {
-    if (url in ressourceMap) {
-      return ressourceMap[url]
-    }
-    if (url in ressourceRedirectionMap) {
-      return findRessourceByUrl(ressourceRedirectionMap[url])
-    }
-    return null
-  }
-
-  const findRessource = (predicate) => {
-    let ressourceFound = null
-    Object.keys(ressourceMap).find((url) => {
-      const ressourceCandidate = ressourceMap[url]
-      if (predicate(ressourceCandidate)) {
-        ressourceFound = ressourceCandidate
-        return true
-      }
-      return false
-    })
-    return ressourceFound
-  }
-
-  const createUrlSiteFromReference = (reference) => {
-    const { referenceUrl, referenceLine, referenceColumn } = reference
-    const referenceRessource = findRessourceByUrl(referenceUrl)
-    const referenceSource = referenceRessource
-      ? referenceRessource.bufferBeforeBuild
-      : urlLoader.getUrlResponseTextFromMemory(referenceUrl)
-    const referenceSourceAsString = referenceSource
-      ? String(referenceSource)
-      : ""
-
-    const urlSite = {
-      type:
-        referenceRessource && referenceRessource.isJsModule
-          ? "import"
-          : "reference",
-      url: urlToHumanUrl(referenceUrl),
-      line: referenceLine,
-      column: referenceColumn,
-      source: referenceSourceAsString,
-    }
-
-    if (!referenceRessource) {
-      return urlSite
-    }
-    if (!referenceRessource.isInline) {
-      return urlSite
-    }
-    const { firstStrongReference } = referenceRessource
-    if (!firstStrongReference) {
-      return urlSite
-    }
-    const htmlUrlSite = createUrlSiteFromReference(firstStrongReference)
-    // when the html node is injected there is no line in the source file to target
-    if (htmlUrlSite.line === undefined) {
-      return urlSite
-    }
-    const importerRessource = findRessourceByUrl(
-      firstStrongReference.referenceUrl,
-    )
-    if (!importerRessource || importerRessource.contentType !== "text/html") {
-      return urlSite
-    }
-    return {
-      ...htmlUrlSite,
-      line:
-        typeof urlSite.line === "number"
-          ? htmlUrlSite.line + urlSite.line
-          : htmlUrlSite.line,
-      column:
-        typeof urlSite.column === "number"
-          ? htmlUrlSite.column + urlSite.column
-          : htmlUrlSite.column,
-    }
-  }
-
-  const showReferenceSourceLocation = (reference) => {
-    return stringifyUrlSite(createUrlSiteFromReference(reference))
-  }
-
-  return {
-    createReferenceForEntryPoint,
-    createReferenceFoundByRollup,
-    createReferenceFoundInJsModule,
-
-    rollupBuildEnd,
-    getAllEntryPointsEmittedPromise,
-    findRessource,
-
-    inspect: () => {
-      return {
-        ressourceMap,
-        ressourceRedirectionMap,
-      }
-    },
-  }
-}
-
-const asFileNameWithoutHash = (fileName) => {
-  return fileName.replace(/_[a-z0-9]{8,}(\..*?)?$/, (_, afterHash = "") => {
-    return afterHash
-  })
-}
-
-// const preredirectUrlFromRessource = (ressource, ressourceRedirectionMap) => {
-//   const ressourceUrlPreRedirect = Object.keys(ressourceRedirectionMap).find(
-//     (urlPreRedirect) =>
-//       ressourceRedirectionMap[urlPreRedirect] === ressource.url,
-//   )
-//   return ressourceUrlPreRedirect
-// }
-
-export const referenceToCodeForRollup = (reference) => {
-  const ressource = reference.ressource
-  if (ressource.isInline) {
-    return getRessourceAsBase64Url(ressource)
-  }
-
-  return `import.meta.ROLLUP_FILE_URL_${ressource.rollupReferenceId}`
-}
-
-// const targetFileNameFromBuildManifest = (buildManifest, buildRelativeUrl) => {
-//   const key = Object.keys(buildManifest).find((keyCandidate) => {
-//     return buildManifest[keyCandidate] === buildRelativeUrl
-//   })
-//   return buildManifest[key]
-// }
-
-const createRessourceTrace = ({
-  ressource,
-  createUrlSiteFromReference,
-  findRessourceByUrl,
-}) => {
-  // we could pass a way to build the import trace
-  // it can be deduced by starting with the firstStrongReference
-  // and trying to get a ressource for that reference
-  // to get an other firstStrongReference
-  // everytime we could build the sourcelocation
-  // but for importer after the first once just line and column are enough
-  // the source code would be too much
-
-  const { firstStrongReference } = ressource
-  const trace = [createUrlSiteFromReference(firstStrongReference)]
-
-  const next = (reference) => {
-    const referenceRessource = findRessourceByUrl(reference.referenceUrl)
-    if (!referenceRessource) {
-      return
-    }
-    const { firstStrongReference } = referenceRessource
-    if (!firstStrongReference) {
-      return
-    }
-    // ignore the programmatic reference
-    if (firstStrongReference.isProgrammatic) {
-      return
-    }
-    trace.push(createUrlSiteFromReference(firstStrongReference))
-    next(firstStrongReference)
-  }
-  next(firstStrongReference)
-
-  return trace
-}
-
-const removePotentialUrlHash = (url) => {
-  const urlObject = new URL(url)
-  urlObject.hash = ""
-  return String(urlObject)
-}
-
-/*
- * We cannot reference js from asset (svg for example)
- * that is because rollup awaits for html to be ready which waits
- * fetch and parse its dependencies (let's say an svg)
- * which waits for js to be fetched and parsed
- * but the fetching + parsing of js happens in rollup
- * so rollup would end up waiting forever
- *
- * see also:
- * - https://rollupjs.org/guide/en/#thisemitfileemittedfile-emittedchunk--emittedasset--string
- * - https://github.com/rollup/rollup/issues/2872
- */
-const referenceShouldBeIgnoredWarning = ({
-  isJsModule,
-  ressourceImporter,
-  ressourceSpecifier,
-  referenceUrl,
-  urlToHumanUrl,
-}) => {
-  if (!isJsModule) {
-    return false
-  }
-
-  // js can reference js
-  if (ressourceImporter.isJsModule) {
-    return false
-  }
-
-  // entry point can reference js (html)
-  if (ressourceImporter.isEntryPoint) {
-    return false
-  }
-
-  return `
-WARNING: Ignoring reference to ${urlToHumanUrl(
-    ressourceSpecifier,
-  )} found inside ${urlToHumanUrl(referenceUrl)}.
-`
-}