@jsenv/core 19.7.2 → 20.0.2

package/src/internal/generateGroupMap/generateGroupMap.js

@@ -7,7 +7,7 @@
 { ┌──────────┴────────────┐
   "transform-block-scoping": {─┐
     "chrome": "10",            │
-    "safari": "3.0",           runTimeCompatMap
+    "safari": "3.0",           minRuntimeVersions
     "firefox": "5.1"           │
 }────┼─────────┼───────────────┘
 }    │         └─────┐
@@ -20,7 +20,7 @@
     "babelPluginRequiredNameArray" : [
       "transform-block-scoping",
     ],
-    "runtimeCompatMap": {
+    "minRuntimeVersions": {
       "chrome": "10",
       "firefox": "6"
     }
@@ -33,23 +33,16 @@ Take chars below to update legends
 */
 
 import { COMPILE_ID_OTHERWISE, COMPILE_ID_BEST } from "../CONSTANTS.js"
-import { generateAllRuntimeGroupArray } from "./generateAllRuntimeGroupArray.js"
-import { runtimeCompatMapToScore } from "./runtimeCompatMapToScore.js"
+import { jsenvBabelPluginCompatMap } from "./jsenvBabelPluginCompatMap.js"
+import { createRuntimeCompat } from "./runtime_compat.js"
 
 export const generateGroupMap = ({
   babelPluginMap,
+  runtimeSupport,
+  babelPluginCompatMap = jsenvBabelPluginCompatMap,
   // jsenv plugin are for later, for now, nothing is using them
   jsenvPluginMap = {},
-  babelPluginCompatMap,
   jsenvPluginCompatMap,
-  runtimeScoreMap,
-  groupCount = 1,
-  // pass this to true if you don't care if someone tries to run your code
-  // on a runtime which is not inside runtimeScoreMap.
-  runtimeAlwaysInsideRuntimeScoreMap = false,
-  // pass this to true if you think you will always be able to detect
-  // the runtime or that if you fail to do so you don't care.
-  runtimeWillAlwaysBeKnown = false,
 }) => {
   if (typeof babelPluginMap !== "object") {
     throw new TypeError(
@@ -61,87 +54,40 @@ export const generateGroupMap = ({
       `jsenvPluginMap must be an object, got ${jsenvPluginMap}`,
     )
   }
-  if (typeof runtimeScoreMap !== "object") {
+  if (typeof runtimeSupport !== "object") {
     throw new TypeError(
-      `runtimeScoreMap must be an object, got ${runtimeScoreMap}`,
+      `runtimeSupport must be an object, got ${runtimeSupport}`,
     )
   }
-  if (typeof groupCount < 1) {
-    throw new TypeError(`groupCount must be above 1, got ${groupCount}`)
-  }
 
+  const runtimeNames = Object.keys(runtimeSupport)
   babelPluginMap = withoutSyntaxPlugins(babelPluginMap)
 
   const groupWithoutFeature = {
     babelPluginRequiredNameArray: Object.keys(babelPluginMap),
     jsenvPluginRequiredNameArray: Object.keys(jsenvPluginMap),
-    runtimeCompatMap: {},
+    minRuntimeVersions: {},
   }
-
-  // when we create one group and we cannot ensure
-  // code will be runned on a runtime inside runtimeScoreMap
-  // then we return otherwise group to be safe
-  if (groupCount === 1 && !runtimeAlwaysInsideRuntimeScoreMap) {
+  if (runtimeNames.length === 0) {
     return {
       [COMPILE_ID_OTHERWISE]: groupWithoutFeature,
     }
   }
 
-  const allRuntimeGroupArray = generateAllRuntimeGroupArray({
+  const runtimeCompat = createRuntimeCompat({
+    runtimeSupport,
+
     babelPluginMap,
     babelPluginCompatMap,
+
     jsenvPluginMap,
     jsenvPluginCompatMap,
-    runtimeNames: arrayWithoutValue(Object.keys(runtimeScoreMap), "other"),
   })
 
-  if (allRuntimeGroupArray.length === 0) {
-    return {
-      [COMPILE_ID_OTHERWISE]: groupWithoutFeature,
-    }
+  return {
+    [COMPILE_ID_BEST]: runtimeCompat,
+    [COMPILE_ID_OTHERWISE]: groupWithoutFeature,
   }
-
-  const groupToScore = ({ runtimeCompatMap }) =>
-    runtimeCompatMapToScore(runtimeCompatMap, runtimeScoreMap)
-
-  const allRuntimeGroupArraySortedByScore = allRuntimeGroupArray.sort(
-    (a, b) => groupToScore(b) - groupToScore(a),
-  )
-
-  const length = allRuntimeGroupArraySortedByScore.length
-
-  // if we arrive here and want a single group
-  // we take the worst group and consider it's our best group
-  // because it's the lowest runtime we want to support
-  if (groupCount === 1) {
-    return {
-      [COMPILE_ID_BEST]: allRuntimeGroupArraySortedByScore[length - 1],
-    }
-  }
-
-  const addOtherwiseToBeSafe =
-    !runtimeAlwaysInsideRuntimeScoreMap || !runtimeWillAlwaysBeKnown
-
-  const lastGroupIndex = addOtherwiseToBeSafe ? groupCount - 1 : groupCount
-
-  const groupArray =
-    length + 1 > groupCount
-      ? allRuntimeGroupArraySortedByScore.slice(0, lastGroupIndex)
-      : allRuntimeGroupArraySortedByScore
-
-  const groupMap = {}
-  groupArray.forEach((group, index) => {
-    if (index === 0) {
-      groupMap[COMPILE_ID_BEST] = group
-    } else {
-      groupMap[`intermediate-${index + 1}`] = group
-    }
-  })
-  if (addOtherwiseToBeSafe) {
-    groupMap[COMPILE_ID_OTHERWISE] = groupWithoutFeature
-  }
-
-  return groupMap
 }
 
 export const withoutSyntaxPlugins = (babelPluginMap) => {
@@ -154,6 +100,3 @@ export const withoutSyntaxPlugins = (babelPluginMap) => {
   })
   return babelPluginMapWithoutSyntaxPlugins
 }
-
-const arrayWithoutValue = (array, value) =>
-  array.filter((valueCandidate) => valueCandidate !== value)

package/src/{jsenvBabelPluginCompatMap.js → internal/generateGroupMap/jsenvBabelPluginCompatMap.js}

@@ -1,6 +1,7 @@
+/* eslint-disable camelcase */
 // copied from
+// https://github.com/babel/babel/blob/e498bee10f0123bb208baa228ce6417542a2c3c4/packages/babel-compat-data/data/plugins.json#L1
 // https://github.com/babel/babel/blob/master/packages/babel-compat-data/data/plugins.json#L1
-// now moved at https://github.com/babel/babel/blob/548cb3ee89552ffc08ee5625b084bd33f8107530/packages/babel-compat-data/data/plugins.json#L1
 // Because this is an hidden implementation detail of @babel/preset-env
 // it could be deprecated or moved anytime.
 // For that reason it makes more sens to have it inlined here

package/src/internal/generateGroupMap/jsenvRuntimeSupport.js

@@ -0,0 +1,15 @@
+export const jsenvBrowserRuntimeSupport = {
+  android: "0.0.0",
+  chrome: "0.0.0",
+  edge: "0.0.0",
+  electron: "0.0.0",
+  firefox: "0.0.0",
+  ios: "0.0.0",
+  opera: "0.0.0",
+  rhino: "0.0.0",
+  safari: "0.0.0",
+}
+
+export const jsenvNodeRuntimeSupport = {
+  node: "0.0.0",
+}

package/src/internal/generateGroupMap/one_runtime_compat.js

@@ -0,0 +1,70 @@
+import { findHighestVersion } from "../semantic-versioning/index.js"
+import { jsenvBabelPluginCompatMap } from "./jsenvBabelPluginCompatMap.js"
+import { jsenvPluginCompatMap as jsenvPluginCompatMapFallback } from "./jsenvPluginCompatMap.js"
+
+export const createOneRuntimeCompat = ({
+  runtimeName,
+  runtimeVersion,
+
+  babelPluginMap,
+  babelPluginCompatMap = jsenvBabelPluginCompatMap,
+
+  jsenvPluginMap,
+  jsenvPluginCompatMap = jsenvPluginCompatMapFallback,
+}) => {
+  const babelPluginRequiredNameArray = []
+  const jsenvPluginRequiredNameArray = []
+  // will be the first runtime version compatible with all features not listed in
+  // babelPluginRequiredNameArray or jsenvPluginRequiredNameArray
+  let minRuntimeVersion
+
+  Object.keys(babelPluginMap).forEach((babelPluginName) => {
+    const babelPluginCompat = babelPluginCompatMap[babelPluginName] || {}
+    const runtimeVersionCompatible =
+      babelPluginCompat[runtimeName] || "Infinity"
+
+    const highestVersion = findHighestVersion(
+      runtimeVersion,
+      runtimeVersionCompatible,
+    )
+    const compatible = highestVersion === runtimeVersion
+    if (!compatible) {
+      babelPluginRequiredNameArray.push(babelPluginName)
+    }
+
+    if (compatible && runtimeVersionCompatible !== "Infinity") {
+      // there is a version from which runtime becomes compatible with this feature
+      minRuntimeVersion = findHighestVersion(
+        minRuntimeVersion || "0.0.0",
+        runtimeVersionCompatible,
+      )
+    }
+  })
+
+  Object.keys(jsenvPluginMap).forEach((jsenvPluginName) => {
+    const jsenvPluginCompat = jsenvPluginCompatMap[jsenvPluginName] || {}
+    const runtimeVersionCompatible =
+      jsenvPluginCompat[runtimeName] || "Infinity"
+
+    const highestVersion = findHighestVersion(
+      runtimeVersion,
+      runtimeVersionCompatible,
+    )
+    if (highestVersion === runtimeVersion) {
+      // compatible, in that case the min runtime version can be updated
+      minRuntimeVersion = findHighestVersion(
+        minRuntimeVersion || "0.0.0",
+        runtimeVersionCompatible,
+      )
+    } else {
+      // not compatible, no need to increase runtime version
+      jsenvPluginRequiredNameArray.push(jsenvPluginName)
+    }
+  })
+
+  return {
+    babelPluginRequiredNameArray,
+    jsenvPluginRequiredNameArray,
+    minRuntimeVersion: minRuntimeVersion || runtimeVersion,
+  }
+}

package/src/internal/generateGroupMap/runtime_compat.js

@@ -0,0 +1,46 @@
+import { createOneRuntimeCompat } from "./one_runtime_compat.js"
+
+export const createRuntimeCompat = ({
+  runtimeSupport,
+
+  babelPluginMap,
+  babelPluginCompatMap,
+
+  jsenvPluginMap,
+  jsenvPluginCompatMap,
+}) => {
+  const minRuntimeVersions = {}
+  const babelPluginRequiredNameArray = []
+  const jsenvPluginRequiredNameArray = []
+  Object.keys(runtimeSupport).forEach((runtimeName) => {
+    const runtimeVersion = runtimeSupport[runtimeName]
+    const oneRuntimeCompat = createOneRuntimeCompat({
+      runtimeName,
+      runtimeVersion,
+
+      babelPluginMap,
+      babelPluginCompatMap,
+
+      jsenvPluginMap,
+      jsenvPluginCompatMap,
+    })
+
+    minRuntimeVersions[runtimeName] = oneRuntimeCompat.minRuntimeVersion
+    oneRuntimeCompat.babelPluginRequiredNameArray.forEach((babelPluginName) => {
+      if (!babelPluginRequiredNameArray.includes(babelPluginName)) {
+        babelPluginRequiredNameArray.push(babelPluginName)
+      }
+    })
+    oneRuntimeCompat.jsenvPluginRequiredNameArray.forEach((jsenvPluginName) => {
+      if (!jsenvPluginRequiredNameArray.includes(jsenvPluginName)) {
+        jsenvPluginRequiredNameArray.push(jsenvPluginName)
+      }
+    })
+  })
+
+  return {
+    babelPluginRequiredNameArray,
+    jsenvPluginRequiredNameArray,
+    minRuntimeVersions,
+  }
+}

package/src/internal/generateGroupMap/runtime_compat_composition.js

@@ -0,0 +1,86 @@
+import { findHighestVersion } from "../semantic-versioning/index.js"
+
+export const composeMinRuntimeVersions = (
+  firstMinRuntimeVersions,
+  secondMinRuntimeVersions,
+) => {
+  const composed = {}
+  Object.keys(firstMinRuntimeVersions).forEach((runtimeName) => {
+    const firstRuntimeVersion = String(firstMinRuntimeVersions[runtimeName])
+    composed[runtimeName] = firstRuntimeVersion
+  })
+  Object.keys(secondMinRuntimeVersions).forEach((runtimeName) => {
+    const firstRuntimeVersion = composed[runtimeName]
+    const secondRuntimeVersion = String(secondMinRuntimeVersions[runtimeName])
+    composed[runtimeName] = firstRuntimeVersion
+      ? findHighestVersion(firstRuntimeVersion, secondRuntimeVersion)
+      : secondRuntimeVersion
+  })
+  return sortObjectKeys(composed)
+}
+
+const sortObjectKeys = (object) => {
+  const sorted = {}
+  Object.keys(object)
+    .sort()
+    .forEach((key) => {
+      sorted[key] = object[key]
+    })
+  return sorted
+}
+
+// export const composeRuntimeCompat = (...runtimeCompats) => {
+//   return runtimeCompats.reduce(runtimeCompatComposer, {
+//     babelPluginRequiredNameArray: [],
+//     jsenvPluginRequiredNameArray: [],
+//     runtimeCompatMap: {},
+//   })
+// }
+
+// const compositionMappingToStrictReducer = (compositionMapping) => {
+//   const propertyComposeStrict = (key, previous, current) => {
+//     const propertyExistInCurrent = key in current
+//     if (!propertyExistInCurrent) return previous[key]
+
+//     const propertyExistInPrevious = key in previous
+//     if (!propertyExistInPrevious) return current[key]
+
+//     const composeProperty = compositionMapping[key]
+//     return composeProperty(previous[key], current[key])
+//   }
+
+//   return (previous, current) => {
+//     if (typeof current !== "object" || current === null) return previous
+
+//     const composed = {}
+//     Object.keys(compositionMapping).forEach((key) => {
+//       composed[key] = propertyComposeStrict(key, previous, current)
+//     })
+//     return composed
+//   }
+// }
+
+// const runtimeCompatComposer = compositionMappingToStrictReducer({
+//   babelPluginRequiredNameArray: (
+//     babelPluginNamesPrevious,
+//     babelPluginNamesCurrent,
+//   ) => {
+//     return arrayWithoutDuplicate([
+//       ...babelPluginNamesPrevious,
+//       ...babelPluginNamesCurrent,
+//     ]).sort()
+//   },
+//   jsenvPluginRequiredNameArray: (
+//     jsenvPluginNamesPrevious,
+//     jsenvPluginNamesCurrent,
+//   ) => {
+//     return arrayWithoutDuplicate([
+//       ...jsenvPluginNamesPrevious,
+//       ...jsenvPluginNamesCurrent,
+//     ]).sort()
+//   },
+//   minRuntimeVersions: composeMinRuntimeVersions,
+// })
+
+// const arrayWithoutDuplicate = (array) =>
+//   array.filter((value, index) => array.indexOf(value) === index)

package/src/internal/runtime/createNodeRuntime/createNodeRuntime.js

@@ -54,6 +54,10 @@ export const createNodeRuntime = async ({
 
 const importJson = async (url) => {
   const response = await fetchSource(url)
+  const status = response.status
+  if (status !== 200) {
+    throw new Error(`unexpected response status for ${url}, got ${status}`)
+  }
   const object = await response.json()
   return object
 }

package/src/internal/runtime/resolveGroup.js

@@ -2,11 +2,11 @@ import { findHighestVersion } from "../semantic-versioning/index.js"
 
 export const resolveGroup = ({ name, version }, groupMap) => {
   return Object.keys(groupMap).find((compileIdCandidate) => {
-    const { runtimeCompatMap } = groupMap[compileIdCandidate]
-    if (name in runtimeCompatMap === false) {
+    const { minRuntimeVersions } = groupMap[compileIdCandidate]
+    if (name in minRuntimeVersions === false) {
       return false
     }
-    const versionForGroup = runtimeCompatMap[name]
+    const versionForGroup = minRuntimeVersions[name]
 
     const highestVersion = findHighestVersion(version, versionForGroup)
     return highestVersion === version

package/src/internal/semantic-versioning/index.js

@@ -1,3 +1,5 @@
 export { findLowestVersion } from "./findLowestVersion.js"
 export { findHighestVersion } from "./findHighestVersion.js"
+export { versionIsAbove } from "./versionIsAbove.js"
+export { versionIsBelow } from "./versionIsBelow.js"
 export { versionCompare } from "./versionCompare.js"

package/src/internal/semantic-versioning/valueToVersion.js

@@ -7,7 +7,7 @@ export const valueToVersion = (value) => {
     return stringToVersion(value)
   }
 
-  throw new TypeError(createValueErrorMessage({ version: value }))
+  throw new TypeError(`version must be a number or a string, got ${value}`)
 }
 
 const numberToVersion = (number) => {
@@ -42,8 +42,3 @@ const stringToVersion = (string) => {
     patch: 0,
   }
 }
-
-const createValueErrorMessage = ({
-  value,
-}) => `value must be a number or a string.
-value: ${value}`

package/src/jsenvRuntimeSupportDuringDev.js

@@ -0,0 +1,12 @@
+import {
+  PLAYWRIGHT_CHROMIUM_VERSION,
+  PLAYWRIGHT_FIREFOX_VERSION,
+  PLAYWRIGHT_WEBKIT_VERSION,
+} from "./playwright_browser_versions.js"
+
+export const jsenvRuntimeSupportDuringDev = {
+  chrome: PLAYWRIGHT_CHROMIUM_VERSION,
+  firefox: PLAYWRIGHT_FIREFOX_VERSION,
+  safari: PLAYWRIGHT_WEBKIT_VERSION,
+  node: process.version.slice(1),
+}

package/src/launchBrowser.js

@@ -13,6 +13,11 @@ import { validateResponseStatusIsOk } from "./internal/validateResponseStatusIsO
 import { trackPageToNotify } from "./internal/browser-launcher/trackPageToNotify.js"
 import { createSharing } from "./internal/browser-launcher/createSharing.js"
 import { executeHtmlFile } from "./internal/browser-launcher/executeHtmlFile.js"
+import {
+  PLAYWRIGHT_CHROMIUM_VERSION,
+  PLAYWRIGHT_FIREFOX_VERSION,
+  PLAYWRIGHT_WEBKIT_VERSION,
+} from "./playwright_browser_versions.js"
 
 const chromiumSharing = createSharing()
 
@@ -99,7 +104,7 @@ export const launchChromium = async ({
   return {
     browser,
     runtimeName: "chromium",
-    runtimeVersion: "82.0.4057.0",
+    runtimeVersion: PLAYWRIGHT_CHROMIUM_VERSION,
     stop: ressourceTracker.cleanup,
     ...browserToRuntimeHooks(browser, {
       browserServerLogLevel,
@@ -175,7 +180,7 @@ export const launchFirefox = async ({
   return {
     browser,
     runtimeName: "firefox",
-    runtimeVersion: "73.0b13",
+    runtimeVersion: PLAYWRIGHT_FIREFOX_VERSION,
     stop: ressourceTracker.cleanup,
     ...browserToRuntimeHooks(browser, {
       browserServerLogLevel,
@@ -250,7 +255,7 @@ export const launchWebkit = async ({
   return {
     browser,
     runtimeName: "webkit",
-    runtimeVersion: "13.0.4",
+    runtimeVersion: PLAYWRIGHT_WEBKIT_VERSION,
     stop: ressourceTracker.cleanup,
     ...browserToRuntimeHooks(browser, {
       browserServerLogLevel,

package/src/playwright_browser_versions.js

@@ -0,0 +1,5 @@
+export const PLAYWRIGHT_CHROMIUM_VERSION = "94.0.4595.0"
+
+export const PLAYWRIGHT_FIREFOX_VERSION = "91.0"
+
+export const PLAYWRIGHT_WEBKIT_VERSION = "15.0"

package/src/startExploring.js

@@ -28,6 +28,7 @@ import {
   jsenvExploringIndexJsFileInfo,
   jsenvToolbarJsFileInfo,
 } from "./internal/jsenvInternalFiles.js"
+import { jsenvRuntimeSupportDuringDev } from "./jsenvRuntimeSupportDuringDev.js"
 
 export const startExploring = async ({
   cancellationToken = createCancellationToken(),
@@ -36,12 +37,13 @@ export const startExploring = async ({
   explorableConfig = jsenvExplorableConfig,
   projectDirectoryUrl,
   jsenvDirectoryRelativeUrl,
-  outDirectoryName,
+  outDirectoryName = 'out-dev',
   jsenvToolbar = true,
   livereloading = true,
   inlineImportMapIntoHTML = true,
   keepProcessAlive = true,
 
+  runtimeSupportDuringDev = jsenvRuntimeSupportDuringDev,
   compileServerLogLevel,
   compileServerCanReadFromFilesystem,
   compileServerCanWriteOnFilesystem,
@@ -86,15 +88,12 @@ export const startExploring = async ({
       cancellationToken,
       projectDirectoryUrl,
       keepProcessAlive,
-      cors: true,
       livereloadSSE: livereloading,
       accessControlAllowRequestOrigin: true,
       accessControlAllowRequestMethod: true,
       accessControlAllowRequestHeaders: true,
       accessControlAllowCredentials: true,
       stopOnPackageVersionChange: true,
-      watchAndSyncImportMap: true,
-      compileGroupCount: 2,
       jsenvToolbarInjection: jsenvToolbar,
       customServices: {
         "service:exploring-redirect": (request) => redirectFiles(request),
@@ -108,6 +107,7 @@ export const startExploring = async ({
       compileServerLogLevel,
       compileServerCanReadFromFilesystem,
       compileServerCanWriteOnFilesystem,
+      runtimeSupport: runtimeSupportDuringDev,
       ...rest,
     })
 

package/src/convertCommonJsWithBabel.js

@@ -1,72 +0,0 @@
-import { require } from "./internal/require.js"
-import { transformJs } from "./internal/compiling/js-compilation-service/transformJs.js"
-import { babelPluginReplaceExpressions } from "./internal/babel-plugin-replace-expressions.js"
-
-export const convertCommonJsWithBabel = async ({
-  projectDirectoryUrl,
-  code,
-  url,
-  replaceGlobalObject = true,
-  replaceGlobalFilename = true,
-  replaceGlobalDirname = true,
-  replaceProcessEnvNodeEnv = true,
-  processEnvNodeEnv = process.env.NODE_ENV,
-  replaceMap = {},
-}) => {
-  const transformCommonJs = require("babel-plugin-transform-commonjs")
-
-  // maybe we should use babel core here instead of transformJs
-  const result = await transformJs({
-    projectDirectoryUrl,
-    code,
-    url,
-    babelPluginMap: {
-      "transform-commonjs": [transformCommonJs],
-      "transform-replace-expressions": [
-        babelPluginReplaceExpressions,
-        {
-          replaceMap: {
-            ...(replaceProcessEnvNodeEnv
-              ? { "process.env.NODE_ENV": `("${processEnvNodeEnv}")` }
-              : {}),
-            ...(replaceGlobalObject ? { global: "globalThis" } : {}),
-            ...(replaceGlobalFilename
-              ? { __filename: __filenameReplacement }
-              : {}),
-            ...(replaceGlobalDirname
-              ? { __dirname: __dirnameReplacement }
-              : {}),
-            ...replaceMap,
-          },
-        },
-      ],
-    },
-  })
-  return result
-}
-
-const __filenameReplacement = `import.meta.url.slice('file:///'.length)`
-
-const __dirnameReplacement = `import.meta.url.slice('file:///'.length).replace(/[\\\/\\\\][^\\\/\\\\]*$/, '')`
-
-// const createInlineProcessNodeEnvBabelPlugin = ({ value = process.env.NODE_ENV }) => {
-//   return ({ types: t }) => {
-//     return {
-//       name: "inline-process-node-env",
-//       visitor: {
-//         MemberExpression(path) {
-//           if (path.matchesPattern("process.env.NODE_ENV")) {
-//             path.replaceWith(t.valueToNode(value))
-
-//             if (path.parentPath.isBinaryExpression()) {
-//               const evaluated = path.parentPath.evaluate()
-//               if (evaluated.confident) {
-//                 path.parentPath.replaceWith(t.valueToNode(evaluated.value))
-//               }
-//             }
-//           }
-//         },
-//       },
-//     }
-//   }
-// }

package/src/getBabelPluginMapForNode.js

@@ -1,18 +0,0 @@
-import { computeBabelPluginMapForRuntime } from "./internal/generateGroupMap/computeBabelPluginMapForRuntime.js"
-import { jsenvBabelPluginMap } from "./jsenvBabelPluginMap.js"
-
-export const getBabelPluginMapForNode = ({
-  babelPluginMap = jsenvBabelPluginMap,
-  nodeMinimumVersion = decideNodeMinimumVersion(),
-} = {}) => {
-  const babelPluginMapForNode = computeBabelPluginMapForRuntime({
-    babelPluginMap,
-    runtimeName: "node",
-    runtimeVersion: nodeMinimumVersion,
-  })
-  return babelPluginMapForNode
-}
-
-const decideNodeMinimumVersion = () => {
-  return process.version.slice(1)
-}