@jsenv/core 25.5.0 → 26.0.1

package/src/internal/{compiling → compile_server}/jsenv_directory/jsenv_directory.js

@@ -38,6 +38,7 @@ export const setupJsenvDirectory = async ({
     )
   }
 
+  const compiledFileWriteSignal = { onwrite: () => {} }
   if (compileServerCanWriteOnFilesystem) {
     if (jsenvDirectoryClean) {
       await ensureEmptyDirectory(jsenvDirectoryUrl)
@@ -46,9 +47,15 @@ export const setupJsenvDirectory = async ({
       logger,
       jsenvDirectoryUrl,
       jsenvDirectoryMetaFileUrl,
-      writeMetaFile,
       jsenvDirectoryMeta,
     })
+    // We want ".jsenv" directory to appear on the filesystem only
+    // if there is a compiled file inside (and not immediatly when compile server starts)
+    // To do this we wait for a file to be written to write "__jsenv_meta__.json" file
+    compiledFileWriteSignal.onwrite = async () => {
+      compiledFileWriteSignal.onwrite = () => {}
+      await writeMetaFile()
+    }
   }
 
   /*
@@ -88,7 +95,7 @@ export const setupJsenvDirectory = async ({
       }
       return existingCompileId
     }
-    const compileIdBase = generateCompileId({ compileProfile })
+    const compileIdBase = generateCompileId({ compileProfile, runtime })
     let compileId = compileIdBase
     let integer = 1
     while (existingCompileIds.includes(compileId)) {
@@ -106,13 +113,20 @@ export const setupJsenvDirectory = async ({
   return {
     compileDirectories,
     getOrCreateCompileId,
+    compiledFileWriteSignal,
   }
 }
 
-const generateCompileId = ({ compileProfile }) => {
+const generateCompileId = ({ compileProfile, runtime }) => {
+  if (runtime.name === "jsenv_build") {
+    return `out_build`
+  }
   if (compileProfile.missingFeatures["transform-instrument"]) {
     return `out_instrumented`
   }
+  if (compileProfile.moduleOutFormat === "systemjs") {
+    return `out_system`
+  }
   return `out`
 }
 
@@ -121,7 +135,6 @@ const applyFileSystemEffects = async ({
   jsenvDirectoryUrl,
   jsenvDirectoryMetaFileUrl,
   jsenvDirectoryMeta,
-  writeMetaFile,
 }) => {
   try {
     const source = await readFile(jsenvDirectoryMetaFileUrl)
@@ -130,7 +143,6 @@ const applyFileSystemEffects = async ({
         `${jsenvDirectoryMetaFileUrl} is empty -> clean ${jsenvDirectoryUrl} directory`,
       )
       await ensureEmptyDirectory(jsenvDirectoryUrl)
-      await writeMetaFile()
       return
     }
     const jsenvDirectoryMetaPrevious = JSON.parse(source)
@@ -144,7 +156,6 @@ const applyFileSystemEffects = async ({
         `compile context has changed -> clean ${jsenvDirectoryUrl} directory`,
       )
       await ensureEmptyDirectory(jsenvDirectoryUrl)
-      await writeMetaFile()
       return
     }
     // reuse existing compile directories
@@ -158,7 +169,6 @@ const applyFileSystemEffects = async ({
         `${jsenvDirectoryMetaFileUrl} not found -> clean ${jsenvDirectoryUrl} directory`,
       )
       await ensureEmptyDirectory(jsenvDirectoryUrl)
-      await writeMetaFile()
       return
     }
     if (e.name === "SyntaxError") {
@@ -166,7 +176,6 @@ const applyFileSystemEffects = async ({
         `${jsenvDirectoryMetaFileUrl} syntax error -> clean ${jsenvDirectoryUrl} directory`,
       )
       await ensureEmptyDirectory(jsenvDirectoryUrl)
-      await writeMetaFile()
       return
     }
     throw e

package/src/internal/{compiling/jsenv_directory/getOrGenerateCompiledFile.js → compile_server/jsenv_directory/reuse_or_create_compiled_file.js}

@@ -2,13 +2,13 @@ import { timeStart, timeFunction } from "@jsenv/server"
 import { urlToFileSystemPath, readFile } from "@jsenv/filesystem"
 import { createDetailedMessage } from "@jsenv/logger"
 
-import { validateCache } from "./validateCache.js"
+import { validateCompileCache } from "./validate_compile_cache.js"
 import { getMetaJsonFileUrl } from "./compile_asset.js"
 import { createLockRegistry } from "./file_lock_registry.js"
 
 const { lockForRessource } = createLockRegistry()
 
-export const getOrGenerateCompiledFile = async ({
+export const reuseOrCreateCompiledFile = async ({
   logger,
 
   projectDirectoryUrl,
@@ -119,7 +119,7 @@ const computeCompileReport = async ({
       //     },
       //   }
       // }
-      return validateCache({
+      return validateCompileCache({
         logger,
         compiledFileUrl,
         compileCacheStrategy,

package/src/internal/compile_server/jsenv_directory/update_compile_cache.js

@@ -0,0 +1,131 @@
+import {
+  urlToRelativeUrl,
+  urlToFileSystemPath,
+  bufferToEtag,
+} from "@jsenv/filesystem"
+import { utimesSync } from "node:fs"
+
+import { writeFileContent, testFilePresence } from "./fs_optimized_for_cache.js"
+import { getMetaJsonFileUrl } from "./compile_asset.js"
+
+export const updateCompileCache = async ({
+  logger,
+  jsenvDirectory,
+  meta,
+  compiledFileUrl,
+  compileResult,
+  compileResultStatus,
+}) => {
+  const isNew = compileResultStatus === "created"
+  const isUpdated = compileResultStatus === "updated"
+  if (!isNew && !isUpdated) {
+    return
+  }
+  const {
+    compiledSource,
+    contentType,
+    sources,
+    sourcesContent,
+    assets,
+    assetsContent,
+    dependencies,
+  } = compileResult
+  const promises = []
+  // ensure source that does not leads to concrete files are not capable to invalidate the cache
+  const sourcesToRemove = sources.filter((sourceFileUrl) => {
+    return (
+      sourceFileUrl.startsWith("file://") && !testFilePresence(sourceFileUrl)
+    )
+  })
+  const sourceNotFoundCount = sourcesToRemove.length
+  if (sourceNotFoundCount > 0) {
+    logger.warn(`SOURCE_META_NOT_FOUND: ${sourceNotFoundCount} source file(s) not found.
+--- consequence ---
+cache will be reused even if one of the source file is modified
+--- source files not found ---
+${sourcesToRemove.join(`\n`)}`)
+    sourcesToRemove.forEach((url) => {
+      const sourceIndex = sources.indexOf(url)
+      if (sourceIndex) {
+        sources.splice(sourceIndex, 1)
+        sourcesContent.splice(sourceIndex, 1)
+      }
+    })
+  }
+  const { writeCompiledSourceFile = true, writeAssetsFile = true } =
+    compileResult
+  if (writeCompiledSourceFile) {
+    logger.debug(
+      `write compiled file at ${urlToFileSystemPath(compiledFileUrl)}`,
+    )
+    promises.push(
+      writeFileContent(compiledFileUrl, compiledSource, {
+        fileLikelyNotFound: isNew,
+      }).then(() => {
+        const mtime = compileResult.compiledMtime
+        // when compileResult.compiledMtime do not exists it means
+        // the client is not interested in it so
+        // -> moment we write the file is not important
+        // -> There is no need to update mtime
+        if (mtime) {
+          utimesSync(
+            urlToFileSystemPath(compiledFileUrl),
+            new Date(mtime),
+            new Date(mtime),
+          )
+        }
+      }),
+    )
+  }
+  if (writeAssetsFile) {
+    promises.push(
+      ...assets.map((assetFileUrl, index) => {
+        logger.debug(
+          `write compiled file asset at ${urlToFileSystemPath(assetFileUrl)}`,
+        )
+        return writeFileContent(assetFileUrl, assetsContent[index], {
+          fileLikelyNotFound: isNew,
+        })
+      }),
+    )
+  }
+  const metaJsonFileUrl = getMetaJsonFileUrl(compiledFileUrl)
+  let latestMeta
+  const sourceAndAssetProps = {
+    sources: sources.map((source) => urlToRelativeUrl(source, metaJsonFileUrl)),
+    sourcesEtag: sourcesContent.map((sourceContent) =>
+      bufferToEtag(Buffer.from(sourceContent)),
+    ),
+    assets: assets.map((asset) => urlToRelativeUrl(asset, metaJsonFileUrl)),
+    assetsEtag: assetsContent.map((assetContent) =>
+      bufferToEtag(Buffer.from(assetContent)),
+    ),
+    dependencies: dependencies.filter((dep) => {
+      return !dep.startsWith("data:")
+    }),
+  }
+  if (isNew) {
+    latestMeta = {
+      contentType,
+      ...sourceAndAssetProps,
+      createdMs: Number(Date.now()),
+      lastModifiedMs: Number(Date.now()),
+    }
+  } else if (isUpdated) {
+    latestMeta = {
+      ...meta,
+      ...sourceAndAssetProps,
+      lastModifiedMs: Number(Date.now()),
+    }
+  }
+  logger.debug(
+    `write compiled file meta at ${urlToFileSystemPath(metaJsonFileUrl)}`,
+  )
+  promises.push(
+    writeFileContent(metaJsonFileUrl, JSON.stringify(latestMeta, null, "  "), {
+      fileLikelyNotFound: isNew,
+    }),
+  )
+  promises.push(jsenvDirectory.compiledFileWriteSignal.onwrite())
+  await Promise.all(promises)
+}

package/src/internal/{compiling/jsenv_directory/validateCache.js → compile_server/jsenv_directory/validate_compile_cache.js}

@@ -2,7 +2,7 @@ import { fileURLToPath } from "node:url"
 import { readFileSync, statSync } from "node:fs"
 import { resolveUrl, bufferToEtag } from "@jsenv/filesystem"
 
-export const validateCache = async ({
+export const validateCompileCache = async ({
   compiledFileUrl,
   compileCacheStrategy,
   compileCacheSourcesValidation = true,

package/src/internal/{compiling → compile_server}/sse_service/sse_service.js

@@ -9,7 +9,7 @@ import {
 import { createLogger } from "@jsenv/logger"
 import { createCallbackList } from "@jsenv/abort"
 
-import { urlIsCompilationAsset } from "@jsenv/core/src/internal/compiling/jsenv_directory/compile_asset.js"
+import { urlIsCompilationAsset } from "@jsenv/core/src/internal/compile_server/jsenv_directory/compile_asset.js"
 
 export const createSSEService = ({
   projectDirectoryUrl,

package/src/internal/{executing/coverage → coverage}/babel_plugin_instrument.js

@@ -4,7 +4,7 @@ import {
   urlToMeta,
 } from "@jsenv/filesystem"
 
-import { require } from "../../require.js"
+import { require } from "@jsenv/core/src/internal/require.js"
 
 // https://github.com/istanbuljs/babel-plugin-istanbul/blob/321740f7b25d803f881466ea819d870f7ed6a254/src/index.js
 

package/src/internal/{executing/coverage_reporter → coverage}/coverage_reporter_html_directory.js

@@ -1,8 +1,9 @@
 import { readFileSync } from "node:fs"
 import { resolveUrl, urlToFileSystemPath } from "@jsenv/filesystem"
 
-import { require } from "../../require.js"
-import { istanbulCoverageMapFromCoverage } from "./istanbulCoverageMapFromCoverage.js"
+import { require } from "@jsenv/core/src/internal/require.js"
+
+import { istanbulCoverageMapFromCoverage } from "./istanbul_coverage_map_from_coverage.js"
 
 export const generateCoverageHtmlDirectory = async (
   coverage,

package/src/internal/{executing/coverage_reporter → coverage}/coverage_reporter_json_file.js

@@ -1,6 +1,6 @@
 import { writeFile, urlToFileSystemPath } from "@jsenv/filesystem"
 
-import { byteAsFileSize } from "@jsenv/core/src/internal/logs/byteAsFileSize.js"
+import { byteAsFileSize } from "@jsenv/core/src/internal/logs/byte_as_file_size.js"
 
 export const generateCoverageJsonFile = async ({
   coverage,

package/src/internal/{executing/coverage_reporter → coverage}/coverage_reporter_text_log.js

@@ -1,5 +1,6 @@
-import { require } from "../../require.js"
-import { istanbulCoverageMapFromCoverage } from "./istanbulCoverageMapFromCoverage.js"
+import { require } from "@jsenv/core/src/internal/require.js"
+
+import { istanbulCoverageMapFromCoverage } from "./istanbul_coverage_map_from_coverage.js"
 
 export const generateCoverageTextLog = (
   coverage,

package/src/internal/{executing/coverage_missing/relativeUrlToEmptyCoverage.js → coverage/empty_coverage_factory.js}

@@ -1,12 +1,14 @@
+import { require } from "@jsenv/core/src/internal/require.js"
+
 import { resolveUrl, urlToFileSystemPath, readFile } from "@jsenv/filesystem"
 import { Abort } from "@jsenv/abort"
 
 import {
   babelPluginsFromBabelPluginMap,
   getMinimalBabelPluginMap,
-} from "@jsenv/core/src/internal/compiling/babel_plugins.js"
-import { babelPluginInstrument } from "../coverage/babel_plugin_instrument.js"
-import { createEmptyCoverage } from "./createEmptyCoverage.js"
+} from "@jsenv/core/src/internal/compile_server/js/babel_plugins.js"
+
+import { babelPluginInstrument } from "./babel_plugin_instrument.js"
 
 export const relativeUrlToEmptyCoverage = async (
   relativeUrl,
@@ -61,3 +63,8 @@ export const relativeUrlToEmptyCoverage = async (
     await operation.end()
   }
 }
+
+const createEmptyCoverage = (relativeUrl) => {
+  const { createFileCoverage } = require("istanbul-lib-coverage")
+  return createFileCoverage(relativeUrl).toJSON()
+}

package/src/internal/{executing/coverage_utils → coverage}/istanbul_coverage_composition.js

@@ -1,4 +1,4 @@
-import { require } from "../../require.js"
+import { require } from "@jsenv/core/src/internal/require.js"
 
 export const composeTwoFileByFileIstanbulCoverages = (
   firstFileByFileIstanbulCoverage,

package/src/internal/{executing/coverage_reporter/istanbulCoverageMapFromCoverage.js → coverage/istanbul_coverage_map_from_coverage.js}

@@ -1,4 +1,4 @@
-import { require } from "../../require.js"
+import { require } from "@jsenv/core/src/internal/require.js"
 
 export const istanbulCoverageMapFromCoverage = (coverage) => {
   const { createCoverageMap } = require("istanbul-lib-coverage")

package/src/internal/{executing/coverage_missing → coverage}/missing_coverage.js

@@ -1,7 +1,7 @@
 import { Abort } from "@jsenv/abort"
 
 import { listRelativeFileUrlToCover } from "./list_files_not_covered.js"
-import { relativeUrlToEmptyCoverage } from "./relativeUrlToEmptyCoverage.js"
+import { relativeUrlToEmptyCoverage } from "./empty_coverage_factory.js"
 
 export const getMissingFileByFileCoverage = async ({
   signal,

package/src/internal/{executing/coverage/reportToCoverage.js → coverage/report_to_coverage.js}

@@ -4,13 +4,13 @@ import { Abort } from "@jsenv/abort"
 import {
   visitNodeV8Directory,
   filterV8Coverage,
-} from "../coverage_utils/v8_coverage_from_directory.js"
-import { composeTwoV8Coverages } from "../coverage_utils/v8_coverage_composition.js"
-import { composeTwoFileByFileIstanbulCoverages } from "../coverage_utils/istanbul_coverage_composition.js"
-import { v8CoverageToIstanbul } from "../coverage_utils/v8_coverage_to_istanbul.js"
-import { composeV8AndIstanbul } from "../coverage_utils/v8_and_istanbul.js"
-import { normalizeFileByFileCoveragePaths } from "../coverage_utils/file_by_file_coverage.js"
-import { getMissingFileByFileCoverage } from "../coverage_missing/missing_coverage.js"
+} from "./v8_coverage_from_directory.js"
+import { composeTwoV8Coverages } from "./v8_coverage_composition.js"
+import { composeTwoFileByFileIstanbulCoverages } from "./istanbul_coverage_composition.js"
+import { v8CoverageToIstanbul } from "./v8_coverage_to_istanbul.js"
+import { composeV8AndIstanbul } from "./v8_and_istanbul.js"
+import { normalizeFileByFileCoveragePaths } from "./file_by_file_coverage.js"
+import { getMissingFileByFileCoverage } from "./missing_coverage.js"
 
 export const reportToCoverage = async (
   report,
@@ -62,6 +62,7 @@ export const reportToCoverage = async (
 
   if (!coverageForceIstanbul && process.env.NODE_V8_COVERAGE) {
     await visitNodeV8Directory({
+      logger,
       signal,
       NODE_V8_COVERAGE: process.env.NODE_V8_COVERAGE,
       onV8Coverage: (nodeV8Coverage) => {

package/src/internal/{executing/coverage_utils → coverage}/v8_coverage_from_directory.js

@@ -8,6 +8,7 @@ import { createDetailedMessage } from "@jsenv/logger"
 import { Abort } from "@jsenv/abort"
 
 export const visitNodeV8Directory = async ({
+  logger,
   signal,
   NODE_V8_COVERAGE,
   onV8Coverage,
@@ -20,7 +21,7 @@ export const visitNodeV8Directory = async ({
     if (dirContent.length > 0) {
       return dirContent
     }
-    console.warn(`v8 coverage directory is empty at ${NODE_V8_COVERAGE}`)
+    logger.warn(`v8 coverage directory is empty at ${NODE_V8_COVERAGE}`)
     return dirContent
   }
 

package/src/internal/data_url.js

@@ -0,0 +1,54 @@
+/* eslint-env browser, node */
+
+export const DataUrl = {
+  parse: (string, { as = "raw" } = {}) => {
+    const afterDataProtocol = string.slice("data:".length)
+    const commaIndex = afterDataProtocol.indexOf(",")
+    const beforeComma = afterDataProtocol.slice(0, commaIndex)
+
+    let mediaType
+    let base64Flag
+    if (beforeComma.endsWith(`;base64`)) {
+      mediaType = beforeComma.slice(0, -`;base64`.length)
+      base64Flag = true
+    } else {
+      mediaType = beforeComma
+      base64Flag = false
+    }
+
+    const afterComma = afterDataProtocol.slice(commaIndex + 1)
+    return {
+      mediaType: mediaType === "" ? "text/plain;charset=US-ASCII" : mediaType,
+      base64Flag,
+      data:
+        as === "string" && base64Flag ? base64ToString(afterComma) : afterComma,
+    }
+  },
+
+  stringify: ({ mediaType, base64Flag = true, data }) => {
+    if (!mediaType || mediaType === "text/plain;charset=US-ASCII") {
+      // can be a buffer or a string, hence check on data.length instead of !data or data === ''
+      if (data.length === 0) {
+        return `data:,`
+      }
+      if (base64Flag) {
+        return `data:,${data}`
+      }
+      return `data:,${dataToBase64(data)}`
+    }
+    if (base64Flag) {
+      return `data:${mediaType};base64,${dataToBase64(data)}`
+    }
+    return `data:${mediaType},${data}`
+  },
+}
+
+const dataToBase64 =
+  typeof window === "object"
+    ? window.atob
+    : (data) => Buffer.from(data).toString("base64")
+
+const base64ToString =
+  typeof window === "object"
+    ? window.btoa
+    : (base64String) => Buffer.from(base64String, "base64").toString("utf8")

package/src/internal/dev_server/exploring/exploring.js

@@ -1,7 +1,7 @@
 import { fetchUrl } from "../toolbar/util/fetching.js"
 import { createPreference } from "../toolbar/util/preferences.js"
 import { startJavaScriptAnimation } from "../toolbar/util/animation.js"
-import { fetchExploringJson } from "./fetchExploringJson.js"
+import { fetchExploringJson } from "./fetch_exploring_json.js"
 
 const fetchJSON = async (url, options) => {
   const response = await fetchUrl(url, options)

package/src/internal/dev_server/exploring/{fetchExploringJson.js → fetch_exploring_json.js}

@@ -1,4 +1,4 @@
-import { fetchJson } from "../../browser_utils/fetchJson.js"
+import { fetchJson } from "../../browser_utils/fetch_json.js"
 
 export const fetchExploringJson = async ({ signal } = {}) => {
   try {

package/src/internal/dev_server/toolbar/compilation/{toolbar.compilation.js → toolbar_compilation.js}

@@ -1,11 +1,12 @@
-import { scanBrowserRuntimeFeatures } from "../../../features/browser_feature_detection/browser_feature_detection.js"
+import { scanBrowserRuntimeFeatures } from "@jsenv/core/src/internal/features/browser_feature_detection/browser_feature_detection.js"
+
 import { setLinkHrefForParentWindow } from "../util/iframe_to_parent_href.js"
 import { removeForceHideElement } from "../util/dom.js"
 import { enableVariant } from "../variant/variant.js"
 import {
   enableWarningStyle,
   disableWarningStyle,
-} from "../settings/toolbar.settings.js"
+} from "../settings/toolbar_settings.js"
 
 export const renderCompilationInToolbar = ({ compileGroup }) => {
   const browserSupportRootNode = document.querySelector("#browser_support")

package/src/internal/dev_server/toolbar/execution/{toolbar.execution.js → toolbar_execution.js}

@@ -2,7 +2,7 @@ import { removeForceHideElement, activateToolbarSection } from "../util/dom.js"
 import { enableVariant } from "../variant/variant.js"
 import { createHorizontalBreakpoint } from "../util/responsive.js"
 import { toggleTooltip } from "../tooltip/tooltip.js"
-import { notifyExecutionResult } from "../notification/toolbar.notification.js"
+import { notifyExecutionResult } from "../notification/toolbar_notification.js"
 
 const WINDOW_MEDIUM_WIDTH = 570
 

package/src/internal/dev_server/toolbar/{jsenv-logo.svg → jsenv_logo.svg}

@@ -1,6 +1,6 @@
 <svg
   xmlns="http://www.w3.org/2000/svg"
-  id="jsenv-logo"
+  id="jsenv_logo"
   viewBox="0 0 430 430"
   enable-background="new 0 0 430 430"
 >

package/src/internal/dev_server/toolbar/toolbar.html

@@ -8,7 +8,7 @@
     <link
       rel="stylesheet"
       type="text/css"
-      href="./toolbar.main.css"
+      href="./toolbar_main.css"
       data-jsenv-force-inline
     />
   </head>
@@ -609,7 +609,7 @@
     </script>
     <script
       type="module"
-      src="./toolbar.main.js"
+      src="./toolbar_main.js"
       data-jsenv-force-inline
     ></script>
   </body>

package/src/internal/dev_server/toolbar/{toolbar.injector.js → toolbar_injector.js}

@@ -1,9 +1,10 @@
-import { fetchExploringJson } from "@jsenv/core/src/internal/dev_server/exploring/fetchExploringJson.js"
+import { fetchExploringJson } from "@jsenv/core/src/internal/dev_server/exploring/fetch_exploring_json.js"
+
 import { setAttributes, setStyles } from "./util/dom.js"
 
 // eslint-disable-next-line no-undef
 const TOOLBAR_BUILD_RELATIVE_URL = __TOOLBAR_BUILD_RELATIVE_URL_
-const jsenvLogoSvgUrl = new URL("./jsenv-logo.svg", import.meta.url)
+const jsenvLogoSvgUrl = new URL("./jsenv_logo.svg", import.meta.url)
 
 const injectToolbar = async () => {
   await new Promise((resolve) => {
@@ -60,7 +61,7 @@ const injectToolbar = async () => {
   div.innerHTML = `
 <div id="jsenv-toolbar-trigger">
   <svg id="jsenv-toolbar-trigger-icon">
-    <use xlink:href="${jsenvLogoSvgUrl}#jsenv-logo"></use>
+    <use xlink:href="${jsenvLogoSvgUrl}#jsenv_logo"></use>
   </svg>
   <style>
     #jsenv-toolbar-trigger {

package/src/internal/dev_server/toolbar/{toolbar.main.css → toolbar_main.css}

@@ -2,9 +2,9 @@
 @import "./compilation/compilation.css";
 @import "./focus/focus.css";
 @import "./eventsource/eventsource.css";
-@import "./responsive/overflow-menu.css";
+@import "./responsive/overflow_menu.css";
 @import "./settings/settings.css";
-@import "./theme/light-theme.css";
+@import "./theme/light_theme.css";
 @import "./tooltip/tooltip.css";
 
 html[data-animation-disabled] * {

package/src/internal/dev_server/toolbar/{toolbar.main.js → toolbar_main.js}

@@ -2,7 +2,7 @@ import { urlIsInsideOf } from "@jsenv/filesystem/src/urlIsInsideOf.js"
 import { urlToRelativeUrl } from "@jsenv/filesystem/src/urlToRelativeUrl.js"
 
 import { startJavaScriptAnimation } from "../toolbar/util/animation.js"
-import "./focus/toolbar.focus.js"
+import "./focus/toolbar_focus.js"
 import { setLinkHrefForParentWindow } from "./util/iframe_to_parent_href.js"
 import {
   getToolbarIframe,
@@ -14,14 +14,14 @@ import { hideTooltip, hideAllTooltip } from "./tooltip/tooltip.js"
 import {
   renderToolbarSettings,
   hideSettings,
-} from "./settings/toolbar.settings.js"
-import { renderToolbarNotification } from "./notification/toolbar.notification.js"
-import { renderToolbarTheme } from "./theme/toolbar.theme.js"
-import { renderToolbarAnimation } from "./animation/toolbar.animation.js"
-import { renderExecutionInToolbar } from "./execution/toolbar.execution.js"
-import { renderCompilationInToolbar } from "./compilation/toolbar.compilation.js"
-import { initToolbarEventSource } from "./eventsource/toolbar.eventsource.js"
-import { makeToolbarResponsive } from "./responsive/toolbar.responsive.js"
+} from "./settings/toolbar_settings.js"
+import { renderToolbarNotification } from "./notification/toolbar_notification.js"
+import { renderToolbarTheme } from "./theme/toolbar_theme.js"
+import { renderToolbarAnimation } from "./animation/toolbar_animation.js"
+import { renderExecutionInToolbar } from "./execution/toolbar_execution.js"
+import { renderCompilationInToolbar } from "./compilation/toolbar_compilation.js"
+import { initToolbarEventSource } from "./eventsource/toolbar_eventsource.js"
+import { makeToolbarResponsive } from "./responsive/toolbar_responsive.js"
 
 const toolbarVisibilityPreference = createPreference("toolbar")