@jsenv/core 27.0.0-alpha.21 → 27.0.0-alpha.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/core",
-  "version": "27.0.0-alpha.21",
+  "version": "27.0.0-alpha.24",
   "description": "Tool to develop, test and build js projects",
   "license": "MIT",
   "repository": {
@@ -11,8 +11,7 @@
     "node": ">=16.13.0"
   },
   "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org"
+    "access": "public"
   },
   "type": "module",
   "imports": {},
@@ -67,7 +66,7 @@
     "@jsenv/node-esm-resolution": "0.0.4",
     "@jsenv/server": "12.6.1",
     "@jsenv/uneval": "1.6.0",
-    "@jsenv/utils": "1.4.0",
+    "@jsenv/utils": "1.4.1",
     "construct-style-sheets-polyfill": "3.1.0",
     "cssnano": "5.1.7",
     "cssnano-preset-default": "5.2.7",
@@ -111,4 +110,4 @@
     "redux": "4.1.2",
     "rollup": "2.70.1"
   }
-}
+}

package/src/build/start_build_server.js

@@ -21,12 +21,11 @@ import {
   pluginCORS,
   fetchFileSystem,
 } from "@jsenv/server"
-import { Abort, raceProcessTeardownEvents } from "@jsenv/abort"
 import { createLogger } from "@jsenv/logger"
 
+import { initProcessAutorestart } from "@jsenv/utils/file_watcher/process_auto_restart.js"
 import { createTaskLog } from "@jsenv/utils/logs/task_log.js"
 import { watchFiles } from "@jsenv/utils/file_watcher/file_watcher.js"
-import { setupFileRestart } from "@jsenv/utils/file_watcher/file_restart.js"
 import { executeCommand } from "@jsenv/utils/command/command.js"
 
 export const startBuildServer = async ({
@@ -34,155 +33,164 @@ export const startBuildServer = async ({
   handleSIGINT = true,
   logLevel,
   buildCommandLogLevel = "warn",
-  protocol,
+  protocol = "http",
   http2,
   certificate,
   privateKey,
   listenAnyIp,
   ip,
-  port,
+  port = 9779,
 
   rootDirectoryUrl,
   buildDirectoryUrl,
   buildCommand,
+  mainBuildFile,
   watchedFilePatterns,
   cooldownBetweenFileEvents,
   autorestart,
 }) => {
-  const operation = Abort.startOperation()
-  operation.addAbortSignal(signal)
-  if (handleSIGINT) {
-    operation.addAbortSource((abort) => {
-      return raceProcessTeardownEvents(
-        {
-          SIGINT: true,
-        },
-        abort,
-      )
-    })
+  const autorestartProcess = await initProcessAutorestart({
+    signal,
+    handleSIGINT,
+    ...(autorestart
+      ? {
+          enabled: true,
+          logLevel: autorestart.logLevel,
+          urlToRestart: autorestart.url,
+          urlsToWatch: [
+            ...(autorestart.urlsToWatch || []),
+            new URL("package.json", rootDirectoryUrl),
+            new URL("jsenv.config.mjs", rootDirectoryUrl),
+          ],
+        }
+      : {
+          enabled: false,
+        }),
+  })
+  if (autorestartProcess.isPrimary) {
+    return {
+      origin: `${protocol}://127.0.0.1:${port}`,
+      stop: () => {
+        autorestartProcess.stop()
+      },
+    }
   }
-  setupFileRestart({
-    signal: operation.signal,
-    autorestart,
-    injectedUrlsToWatch: [
-      new URL("package.json", rootDirectoryUrl),
-      new URL("jsenv.config.mjs", rootDirectoryUrl),
-    ],
-    job: async () => {
-      const logger = createLogger({ logLevel })
+  signal = autorestartProcess.signal
+  const logger = createLogger({ logLevel })
 
-      let buildPromise
-      let abortController
-      const runBuild = async () => {
-        const buildTask = createTaskLog(logger, `execute build command`)
-        abortController = new AbortController()
-        operation.addAbortCallback(() => {
-          abortController.abort()
-        })
-        buildPromise = executeCommand(buildCommand, {
-          cwd: rootDirectoryUrl,
-          logLevel: buildCommandLogLevel,
-          signal: abortController.signal,
-        })
-        try {
-          await buildPromise
-          buildTask.done()
-        } catch (e) {
-          if (e.code === "ABORT_ERR") {
-            buildTask.fail(`execute build command aborted`)
-          } else {
-            buildTask.fail()
-            throw e
-          }
-        }
+  let buildPromise
+  let abortController
+  const runBuild = async () => {
+    const buildTask = createTaskLog(logger, `execute build command`)
+    buildPromise = executeCommand(buildCommand, {
+      cwd: rootDirectoryUrl,
+      logLevel: buildCommandLogLevel,
+      signal,
+    })
+    try {
+      await buildPromise
+      buildTask.done()
+    } catch (e) {
+      if (e.code === "ABORT_ERR") {
+        buildTask.fail(`execute build command aborted`)
+      } else {
+        buildTask.fail()
+        throw e
       }
+    }
+  }
 
-      const startServerTask = createTaskLog(logger, "start build server")
-      const server = await startServer({
-        signal,
-        stopOnExit: false,
-        stopOnSIGINT: false,
-        stopOnInternalError: false,
-        keepProcessAlive: true,
-        logLevel,
-        startLog: false,
-
-        protocol,
-        http2,
-        certificate,
-        privateKey,
-        listenAnyIp,
-        ip,
-        port,
-        plugins: {
-          ...pluginCORS({
-            accessControlAllowRequestOrigin: true,
-            accessControlAllowRequestMethod: true,
-            accessControlAllowRequestHeaders: true,
-            accessControlAllowedRequestHeaders: [
-              ...jsenvAccessControlAllowedHeaders,
-              "x-jsenv-execution-id",
-            ],
-            accessControlAllowCredentials: true,
-          }),
-          ...pluginServerTiming(),
-          ...pluginRequestWaitingCheck({
-            requestWaitingMs: 60 * 1000,
-          }),
-        },
-        sendErrorDetails: true,
-        requestToResponse: async (request) => {
-          await buildPromise
-          const urlIsVersioned = new URL(
-            request.ressource,
-            request.origin,
-          ).searchParams.has("v")
+  const startServerTask = createTaskLog(logger, "start build server")
+  const server = await startServer({
+    signal,
+    stopOnExit: false,
+    stopOnSIGINT: false,
+    stopOnInternalError: false,
+    keepProcessAlive: true,
+    logLevel,
+    startLog: false,
 
-          return fetchFileSystem(
-            new URL(request.ressource.slice(1), buildDirectoryUrl),
-            {
-              headers: request.headers,
-              cacheControl: urlIsVersioned
-                ? `private,max-age=${SECONDS_IN_30_DAYS},immutable`
-                : "private,max-age=0,must-revalidate",
-              etagEnabled: true,
-              compressionEnabled: !request.pathname.endsWith(".mp4"),
-              rootDirectoryUrl: buildDirectoryUrl,
-              canReadDirectory: true,
-            },
-          )
+    protocol,
+    http2,
+    certificate,
+    privateKey,
+    listenAnyIp,
+    ip,
+    port,
+    plugins: {
+      ...pluginCORS({
+        accessControlAllowRequestOrigin: true,
+        accessControlAllowRequestMethod: true,
+        accessControlAllowRequestHeaders: true,
+        accessControlAllowedRequestHeaders: [
+          ...jsenvAccessControlAllowedHeaders,
+          "x-jsenv-execution-id",
+        ],
+        accessControlAllowCredentials: true,
+      }),
+      ...pluginServerTiming(),
+      ...pluginRequestWaitingCheck({
+        requestWaitingMs: 60 * 1000,
+      }),
+    },
+    sendErrorDetails: true,
+    requestToResponse: async (request) => {
+      await buildPromise
+      const urlIsVersioned = new URL(
+        request.ressource,
+        request.origin,
+      ).searchParams.has("v")
+      if (mainBuildFile && request.ressource === "/") {
+        request = {
+          ...request,
+          ressource: `/${mainBuildFile}`,
+        }
+      }
+      return fetchFileSystem(
+        new URL(request.ressource.slice(1), buildDirectoryUrl),
+        {
+          headers: request.headers,
+          cacheControl: urlIsVersioned
+            ? `private,max-age=${SECONDS_IN_30_DAYS},immutable`
+            : "private,max-age=0,must-revalidate",
+          etagEnabled: true,
+          compressionEnabled: !request.pathname.endsWith(".mp4"),
+          rootDirectoryUrl: buildDirectoryUrl,
+          canReadDirectory: true,
         },
-      })
-      startServerTask.done()
-      logger.info(``)
-      Object.keys(server.origins).forEach((key) => {
-        logger.info(`- ${server.origins[key]}`)
-      })
-      logger.info(``)
+      )
+    },
+  })
+  startServerTask.done()
+  logger.info(``)
+  Object.keys(server.origins).forEach((key) => {
+    logger.info(`- ${server.origins[key]}`)
+  })
+  logger.info(``)
 
-      const unregisterDirectoryLifecyle = watchFiles({
-        rootDirectoryUrl,
-        watchedFilePatterns,
-        cooldownBetweenFileEvents,
-        fileChangeCallback: ({ url, event }) => {
-          abortController.abort()
-          // setTimeout is to ensure the abortController.abort() above
-          // is properly taken into account so that logs about abort comes first
-          // then logs about re-running the build happens
-          setTimeout(() => {
-            logger.info(
-              `${url.slice(rootDirectoryUrl.length)} ${event} -> rebuild`,
-            )
-            runBuild()
-          })
-        },
+  const unregisterDirectoryLifecyle = watchFiles({
+    rootDirectoryUrl,
+    watchedFilePatterns,
+    cooldownBetweenFileEvents,
+    fileChangeCallback: ({ url, event }) => {
+      abortController.abort()
+      // setTimeout is to ensure the abortController.abort() above
+      // is properly taken into account so that logs about abort comes first
+      // then logs about re-running the build happens
+      setTimeout(() => {
+        logger.info(`${url.slice(rootDirectoryUrl.length)} ${event} -> rebuild`)
+        runBuild()
       })
-      operation.addAbortCallback(() => {
-        unregisterDirectoryLifecyle()
-      })
-      runBuild()
     },
   })
+  signal.addEventListener("abort", () => {
+    unregisterDirectoryLifecyle()
+  })
+  runBuild()
+  return {
+    origin: server.origin,
+    stop: () => server.stop(),
+  }
 }
 
 const SECONDS_IN_30_DAYS = 60 * 60 * 24 * 30

package/src/dev/start_dev_server.js

@@ -1,6 +1,7 @@
 import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem"
 import { createLogger } from "@jsenv/logger"
 
+import { initProcessAutorestart } from "@jsenv/utils/file_watcher/process_auto_restart.js"
 import { createTaskLog } from "@jsenv/utils/logs/task_log.js"
 import { getCorePlugins } from "@jsenv/core/src/plugins/plugins.js"
 import { createUrlGraph } from "@jsenv/core/src/omega/url_graph.js"
@@ -12,9 +13,10 @@ import { jsenvPluginToolbar } from "./plugins/toolbar/jsenv_plugin_toolbar.js"
 
 export const startDevServer = async ({
   signal = new AbortController().signal,
+  handleSIGINT,
   logLevel,
-  port,
-  protocol,
+  port = 3456,
+  protocol = "http",
   listenAnyIp,
   // it's better to use http1 by default because it allows to get statusText in devtools
   // which gives valuable information when there is errors
@@ -30,6 +32,7 @@ export const startDevServer = async ({
   injectedGlobals,
   nodeEsmResolution,
   fileSystemMagicResolution,
+  transpilation,
   autoreload = true,
   explorerGroups = {
     source: {
@@ -41,11 +44,39 @@ export const startDevServer = async ({
     },
   },
   toolbar = false,
+  autorestart,
 }) => {
+  rootDirectoryUrl = assertAndNormalizeDirectoryUrl(rootDirectoryUrl)
+  const autorestartProcess = await initProcessAutorestart({
+    signal,
+    handleSIGINT,
+    ...(autorestart
+      ? {
+          enabled: true,
+          logLevel: autorestart.logLevel,
+          urlToRestart: autorestart.url,
+          urlsToWatch: [
+            ...(autorestart.urlsToWatch || []),
+            new URL("package.json", rootDirectoryUrl),
+            new URL("jsenv.config.mjs", rootDirectoryUrl),
+          ],
+        }
+      : {
+          enabled: false,
+        }),
+  })
+  if (autorestartProcess.isPrimary) {
+    return {
+      origin: `${protocol}://127.0.0.1:${port}`,
+      stop: () => {
+        autorestartProcess.stop()
+      },
+    }
+  }
+
   const logger = createLogger({ logLevel })
   const startServerTask = createTaskLog(logger, "start server")
 
-  rootDirectoryUrl = assertAndNormalizeDirectoryUrl(rootDirectoryUrl)
   const urlGraph = createUrlGraph()
   const kitchen = createKitchen({
     signal,
@@ -65,6 +96,7 @@ export const startDevServer = async ({
         injectedGlobals,
         nodeEsmResolution,
         fileSystemMagicResolution,
+        transpilation,
         autoreload,
       }),
       jsenvPluginExplorer({
@@ -98,5 +130,8 @@ export const startDevServer = async ({
       kitchen.pluginController.callHooks("destroy")
     }
   })
-  return server
+  return {
+    origin: server.origin,
+    stop: server.stop,
+  }
 }

package/src/execute/execute.js

@@ -23,6 +23,7 @@ export const execute = async ({
   collectConsole,
   collectCoverage,
   coverageTempDirectoryUrl,
+  collectPerformance = false,
   runtime,
   runtimeParams,
 
@@ -33,6 +34,7 @@ export const execute = async ({
   fileSystemMagicResolution,
   injectedGlobals,
   transpilation,
+  htmlSupervisor = true,
 
   port,
   protocol,
@@ -75,10 +77,14 @@ export const execute = async ({
       plugins: [
         ...plugins,
         ...getCorePlugins({
+          rootDirectoryUrl,
+          urlGraph,
           scenario,
+
+          htmlSupervisor,
+          injectedGlobals,
           nodeEsmResolution,
           fileSystemMagicResolution,
-          injectedGlobals,
           transpilation,
         }),
       ],
@@ -120,6 +126,7 @@ export const execute = async ({
     collectConsole,
     collectCoverage,
     coverageTempDirectoryUrl,
+    collectPerformance,
     runtime,
     runtimeParams,
   })

package/src/execute/run.js

@@ -11,8 +11,7 @@ export const run = async ({
   collectConsole = false,
   collectCoverage = false,
   coverageTempDirectoryUrl,
-  // measurePerformance,
-  // collectPerformance = false,
+  collectPerformance = false,
 
   runtime,
   runtimeParams,
@@ -117,6 +116,7 @@ export const run = async ({
                 signal: runOperation.signal,
                 logger,
                 ...runtimeParams,
+                collectPerformance,
                 keepRunning,
                 stopSignal,
                 onConsole: (log) => onConsoleRef.current(log),

package/src/execute/runtimes/browsers/from_playwright.js

@@ -35,7 +35,7 @@ export const createRuntimeFromPlaywright = ({
     server,
 
     // measurePerformance,
-    // collectPerformance,
+    collectPerformance,
     collectCoverage = false,
     coverageForceIstanbul,
     urlShouldBeCovered,
@@ -167,6 +167,39 @@ export const createRuntimeFromPlaywright = ({
         return result
       })
     }
+
+    if (collectPerformance) {
+      resultTransformer = composeTransformer(
+        resultTransformer,
+        async (result) => {
+          const performance = await page.evaluate(
+            /* eslint-disable no-undef */
+            /* istanbul ignore next */
+            () => {
+              const { performance } = window
+              if (!performance) {
+                return null
+              }
+              const measures = {}
+              const measurePerfEntries = performance.getEntriesByType("measure")
+              measurePerfEntries.forEach((measurePerfEntry) => {
+                measures[measurePerfEntry.name] = measurePerfEntry.duration
+              })
+              return {
+                timeOrigin: performance.timeOrigin,
+                timing: performance.timing.toJSON(),
+                navigation: performance.navigation.toJSON(),
+                measures,
+              }
+              /* eslint-enable no-undef */
+            },
+          )
+          result.performance = performance
+          return result
+        },
+      )
+    }
+
     const fileClientUrl = new URL(fileRelativeUrl, `${server.origin}/`).href
 
     // https://github.com/GoogleChrome/puppeteer/blob/v1.4.0/docs/api.md#event-console

package/src/execute/runtimes/node/controllable_file.mjs

@@ -1,17 +1,33 @@
 import v8 from "node:v8"
 import { uneval } from "@jsenv/uneval"
+import { startObservingPerformances } from "./node_execution_performance.js"
 
 const ACTIONS_AVAILABLE = {
-  "execute-using-dynamic-import": async ({ fileUrl }) => {
-    const namespace = await import(fileUrl)
-    const namespaceResolved = {}
-    await Promise.all([
-      ...Object.keys(namespace).map(async (key) => {
-        const value = await namespace[key]
-        namespaceResolved[key] = value
-      }),
-    ])
-    return namespaceResolved
+  "execute-using-dynamic-import": async ({ fileUrl, collectPerformance }) => {
+    const getNamespace = async () => {
+      const namespace = await import(fileUrl)
+      const namespaceResolved = {}
+      await Promise.all([
+        ...Object.keys(namespace).map(async (key) => {
+          const value = await namespace[key]
+          namespaceResolved[key] = value
+        }),
+      ])
+      return namespaceResolved
+    }
+    if (collectPerformance) {
+      const getPerformance = startObservingPerformances()
+      const namespace = await getNamespace()
+      const performance = await getPerformance()
+      return {
+        namespace,
+        performance,
+      }
+    }
+    const namespace = await getNamespace()
+    return {
+      namespace,
+    }
   },
   "execute-using-require": async ({ fileUrl }) => {
     const { createRequire } = await import("module")

package/src/execute/runtimes/node/node_execution_performance.js

@@ -0,0 +1,67 @@
+import { PerformanceObserver, performance } from "node:perf_hooks"
+
+export const startObservingPerformances = () => {
+  const measureEntries = []
+  // https://nodejs.org/dist/latest-v16.x/docs/api/perf_hooks.html
+  const perfObserver = new PerformanceObserver(
+    (
+      // https://nodejs.org/dist/latest-v16.x/docs/api/perf_hooks.html#perf_hooks_class_performanceobserverentrylist
+      list,
+    ) => {
+      const perfMeasureEntries = list.getEntriesByType("measure")
+      measureEntries.push(...perfMeasureEntries)
+    },
+  )
+  perfObserver.observe({
+    entryTypes: ["measure"],
+  })
+  return async () => {
+    // wait for node to call the performance observer
+    await new Promise((resolve) => {
+      setTimeout(resolve)
+    })
+    performance.clearMarks()
+    perfObserver.disconnect()
+    return {
+      ...readNodePerformance(),
+      measures: measuresFromMeasureEntries(measureEntries),
+    }
+  }
+}
+
+const readNodePerformance = () => {
+  const nodePerformance = {
+    nodeTiming: asPlainObject(performance.nodeTiming),
+    timeOrigin: performance.timeOrigin,
+    eventLoopUtilization: performance.eventLoopUtilization(),
+  }
+  return nodePerformance
+}
+
+// remove getters that cannot be stringified
+const asPlainObject = (objectWithGetters) => {
+  const objectWithoutGetters = {}
+  Object.keys(objectWithGetters).forEach((key) => {
+    objectWithoutGetters[key] = objectWithGetters[key]
+  })
+  return objectWithoutGetters
+}
+
+const measuresFromMeasureEntries = (measureEntries) => {
+  const measures = {}
+  // Sort to ensure measures order is predictable
+  // It seems to be already predictable on Node 16+ but
+  // it's not the case on Node 14.
+  measureEntries.sort((a, b) => {
+    return a.startTime - b.startTime
+  })
+  measureEntries.forEach(
+    (
+      // https://nodejs.org/dist/latest-v16.x/docs/api/perf_hooks.html#perf_hooks_class_performanceentry
+      perfMeasureEntry,
+    ) => {
+      measures[perfMeasureEntry.name] = perfMeasureEntry.duration
+    },
+  )
+  return measures
+}

package/src/execute/runtimes/node/node_process.js

@@ -35,10 +35,9 @@ nodeProcess.run = async ({
   stopSignal,
   onConsole,
 
-  measurePerformance,
-  collectPerformance,
   collectCoverage = false,
   coverageForceIstanbul,
+  collectPerformance,
 
   debugPort,
   debugMode,
@@ -191,9 +190,7 @@ nodeProcess.run = async ({
       actionType: "execute-using-dynamic-import",
       actionParams: {
         fileUrl: new URL(fileRelativeUrl, rootDirectoryUrl).href,
-        measurePerformance,
         collectPerformance,
-        collectCoverage,
       },
     })
     const winner = await winnerPromise
@@ -246,7 +243,7 @@ nodeProcess.run = async ({
     }
     return {
       status: "completed",
-      namespace: value,
+      ...value,
     }
   }
 

package/src/omega/kitchen.js

@@ -670,9 +670,11 @@ const applyReferenceEffectsOnUrlInfo = (reference, urlInfo, context) => {
     }
     urlInfo.contentType = reference.contentType
     urlInfo.originalContent =
-      urlInfo.originalContent === undefined
-        ? reference.content
-        : urlInfo.originalContent
+      context === "build"
+        ? urlInfo.originalContent === undefined
+          ? reference.content
+          : urlInfo.originalContent
+        : reference.content
     urlInfo.content = reference.content
   }
   if (isWebWorkerEntryPointReference(reference)) {

package/src/plugins/transpilation/as_js_classic/jsenv_plugin_as_js_classic.js

@@ -23,7 +23,6 @@ import { composeTwoSourcemaps } from "@jsenv/utils/sourcemap/sourcemap_compositi
 import { babelPluginTransformImportMetaUrl } from "./helpers/babel_plugin_transform_import_meta_url.js"
 import { jsenvPluginScriptTypeModuleAsClassic } from "./jsenv_plugin_script_type_module_as_classic.js"
 import { jsenvPluginWorkersTypeModuleAsClassic } from "./jsenv_plugin_workers_type_module_as_classic.js"
-import { jsenvPluginTopLevelAwait } from "./jsenv_plugin_top_level_await.js"
 
 const require = createRequire(import.meta.url)
 
@@ -40,7 +39,6 @@ export const jsenvPluginAsJsClassic = ({ systemJsInjection }) => {
     jsenvPluginWorkersTypeModuleAsClassic({
       generateJsClassicFilename,
     }),
-    jsenvPluginTopLevelAwait(),
   ]
 }
 

package/src/plugins/transpilation/babel/helpers/babel_plugin_structure.js

@@ -31,9 +31,12 @@ export const getBaseBabelPluginStructure = ({ url, isSupported }) => {
       requireBabelPlugin("@babel/plugin-proposal-unicode-property-regex")
   }
   if (isBabelPluginNeeded("transform-async-to-promises")) {
-    babelPluginStructure["transform-async-to-promises"] = requireBabelPlugin(
-      "babel-plugin-transform-async-to-promises",
-    )
+    babelPluginStructure["transform-async-to-promises"] = [
+      requireBabelPlugin("babel-plugin-transform-async-to-promises"),
+      {
+        topLevelAwait: "ignore", // will be handled by "jsenv:top_level_await" plugin
+      },
+    ]
   }
   if (isBabelPluginNeeded("transform-arrow-functions")) {
     babelPluginStructure["transform-arrow-functions"] = requireBabelPlugin(

package/src/plugins/transpilation/jsenv_plugin_transpilation.js

@@ -11,6 +11,7 @@ import { jsenvPluginCssParcel } from "./css_parcel/jsenv_plugin_css_parcel.js"
 import { jsenvPluginImportAssertions } from "./import_assertions/jsenv_plugin_import_assertions.js"
 import { jsenvPluginAsJsClassic } from "./as_js_classic/jsenv_plugin_as_js_classic.js"
 import { jsenvPluginBabel } from "./babel/jsenv_plugin_babel.js"
+import { jsenvPluginTopLevelAwait } from "./jsenv_plugin_top_level_await.js"
 
 export const jsenvPluginTranspilation = ({
   importAssertions = true,
@@ -35,6 +36,9 @@ export const jsenvPluginTranspilation = ({
     ...(jsModuleAsJsClassic
       ? [jsenvPluginAsJsClassic({ systemJsInjection })]
       : []),
+    // topLevelAwait must come after js_module_as_js_classic because it's related to the module format
+    // so we want to wait to know the module format before transforming things related to top level await
+    ...(topLevelAwait ? [jsenvPluginTopLevelAwait(topLevelAwait)] : []),
     ...(css ? [jsenvPluginCssParcel()] : []),
   ]
 }