@jsenv/core 21.1.0 → 22.0.3

package/src/internal/compiling/rollup_plugin_commonjs_named_exports.js

@@ -0,0 +1,186 @@
+// https://github.com/snowpackjs/snowpack/blob/main/esinstall/src/rollup-plugins/rollup-plugin-wrap-install-targets.ts
+
+import { readFileSync } from "node:fs"
+import { fileURLToPath } from "node:url"
+import { VM as VM2 } from "vm2"
+import isValidIdentifier from "is-valid-identifier"
+import resolve from "resolve"
+import { init, parse } from "cjs-module-lexer"
+import { fileSystemPathToUrl } from "@jsenv/filesystem"
+
+export const rollupPluginCommonJsNamedExports = ({ logger }) => {
+  const inputSummaries = {}
+  const cjsScannedNamedExports = {}
+
+  return {
+    async buildStart({ input }) {
+      await init()
+
+      Object.keys(input).forEach((key) => {
+        const inputFilePath = input[key]
+        const inputFileUrl = fileSystemPathToUrl(inputFilePath)
+        inputSummaries[inputFileUrl] = {
+          all: false,
+          default: false,
+          namespace: false,
+          named: [],
+        }
+
+        const cjsExports =
+          detectStaticExports({ logger, fileUrl: inputFileUrl }) ||
+          detectExportsUsingSandboxedRuntime({ logger, fileUrl: inputFileUrl })
+
+        if (cjsExports && cjsExports.length) {
+          cjsScannedNamedExports[inputFileUrl] = cjsExports
+        }
+        input[key] = `jsenv:${inputFileUrl}`
+      })
+    },
+    resolveId(source) {
+      if (source.startsWith("jsenv:")) {
+        return source
+      }
+
+      return null
+    },
+    load(id) {
+      if (!id.startsWith("jsenv:")) {
+        return null
+      }
+
+      const inputFileUrl = id.substring("jsenv:".length)
+      const inputSummary = inputSummaries[inputFileUrl]
+      let uniqueNamedExports = inputSummary.named
+      const scannedNamedExports = cjsScannedNamedExports[inputFileUrl]
+      if (scannedNamedExports) {
+        uniqueNamedExports = scannedNamedExports || []
+        inputSummary.default = true
+      }
+      const codeForExports = generateCodeForExports({
+        uniqueNamedExports,
+        inputSummary,
+        inputFileUrl,
+      })
+      return codeForExports
+    },
+  }
+}
+
+/**
+ * Attempt #1: Static analysis: Lower Fidelity, but faster.
+ * Do our best job to statically scan a file for named exports. This uses "cjs-module-lexer", the
+ * same CJS export scanner that Node.js uses internally. Very fast, but only works on some modules,
+ * depending on how they were build/written/compiled.
+ */
+const detectStaticExports = ({ logger, fileUrl, visited = new Set() }) => {
+  const isMainEntrypoint = visited.size === 0
+  // Prevent infinite loops via circular dependencies.
+  if (visited.has(fileUrl)) {
+    return []
+  }
+  visited.add(fileUrl)
+
+  const fileContents = readFileSync(new URL(fileUrl), "utf8")
+  try {
+    const { exports, reexports } = parse(fileContents)
+    // If re-exports were detected (`exports.foo = require(...)`) then resolve them here.
+    let resolvedReexports = []
+    if (reexports.length > 0) {
+      reexports.forEach((reexport) => {
+        const reExportedFilePath = resolve.sync(reexport, {
+          basedir: fileURLToPath(new URL("./", fileUrl)),
+        })
+        const reExportedFileUrl = fileSystemPathToUrl(reExportedFilePath)
+        const staticExports = detectStaticExports({
+          logger,
+          fileUrl: reExportedFileUrl,
+          visited,
+        })
+        if (staticExports) {
+          resolvedReexports = [...resolvedReexports, ...staticExports]
+        }
+      })
+    }
+    const resolvedExports = Array.from(
+      new Set([...exports, ...resolvedReexports]),
+    ).filter(isValidNamedExport)
+
+    if (isMainEntrypoint && resolvedExports.length === 0) {
+      return undefined
+    }
+
+    return resolvedExports
+  } catch (err) {
+    // Safe to ignore, this is usually due to the file not being CJS.
+    logger.debug(`detectStaticExports ${fileUrl}: ${err.message}`)
+    return undefined
+  }
+}
+
+/**
+ * Attempt #2b - Sandboxed runtime analysis: More powerful, but slower.
+ * This will only work on UMD and very simple CJS files (require not supported).
+ * Uses VM2 to run safely sandbox untrusted code (no access no Node.js primitives, just JS).
+ * If nothing was detected, return undefined.
+ */
+const detectExportsUsingSandboxedRuntime = ({ logger, fileUrl }) => {
+  try {
+    const fileContents = readFileSync(new URL(fileUrl), "utf8")
+    const vm = new VM2({ wasm: false, fixAsync: false })
+    const vmResult = vm.run(wrapCodeToRunInVm(fileContents))
+    const exportsResult = Object.keys(vmResult)
+    logger.debug(
+      `detectExportsUsingSandboxedRuntime success ${fileUrl}: ${exportsResult}`,
+    )
+    return exportsResult.filter((identifier) => isValidIdentifier(identifier))
+  } catch (err) {
+    logger.debug(
+      `detectExportsUsingSandboxedRuntime error ${fileUrl}: ${err.message}`,
+    )
+    return undefined
+  }
+}
+
+const isValidNamedExport = (name) =>
+  name !== "default" && name !== "__esModule" && isValidIdentifier(name)
+
+const wrapCodeToRunInVm = (code) => {
+  return `const exports = {};
+const module = { exports };
+${code};;
+module.exports;`
+}
+
+const generateCodeForExports = ({
+  uniqueNamedExports,
+  inputSummary,
+  inputFileUrl,
+}) => {
+  const from =
+    process.platform === "win32"
+      ? inputFileUrl.slice("file:///".length)
+      : inputFileUrl.slice("file://".length)
+  const lines = [
+    ...(inputSummary.namespace ? [stringifyNamespaceReExport({ from })] : []),
+    ...(inputSummary.default ? [stringifyDefaultReExport({ from })] : []),
+    stringifyNamedReExports({
+      namedExports: uniqueNamedExports,
+      from,
+    }),
+  ]
+  return lines.join(`
+`)
+}
+
+const stringifyNamespaceReExport = ({ from }) => {
+  return `export * from "${from}";`
+}
+
+const stringifyDefaultReExport = ({ from }) => {
+  return `import __jsenv_default_import__ from "${from}";
+export default __jsenv_default_import__;`
+}
+
+const stringifyNamedReExports = ({ namedExports, from }) => {
+  return `export { ${namedExports.join(",")} } from "${from}";`
+}

package/src/internal/compiling/startCompileServer.js

@@ -28,7 +28,11 @@ import {
   urlToBasename,
 } from "@jsenv/filesystem"
 
-import { jsenvBabelPluginMap } from "../../jsenvBabelPluginMap.js"
+import { loadBabelPluginMapFromFile } from "./load_babel_plugin_map_from_file.js"
+import {
+  extractSyntaxBabelPluginMap,
+  babelPluginNamesToRemoveFromBest,
+} from "./babel_plugins.js"
 import { generateGroupMap } from "../generateGroupMap/generateGroupMap.js"
 import { createCallbackList } from "../createCallbackList.js"
 import {
@@ -71,7 +75,8 @@ export const startCompileServer = async ({
   replaceGlobalFilename = false,
   replaceGlobalDirname = false,
   replaceMap = {},
-  babelPluginMap = jsenvBabelPluginMap,
+  babelPluginMap,
+  babelConfigFileUrl,
   customCompilers = {},
 
   // options related to the server itself
@@ -126,11 +131,59 @@ export const startCompileServer = async ({
   )
 
   const logger = createLogger({ logLevel: compileServerLogLevel })
+
+  const babelPluginMapFromFile = await loadBabelPluginMapFromFile({
+    projectDirectoryUrl,
+    babelConfigFileUrl,
+  })
+  babelPluginMap = {
+    ...babelPluginMapFromFile,
+    ...babelPluginMap,
+  }
+  Object.keys(babelPluginMap).forEach((key) => {
+    if (
+      key === "transform-modules-commonjs" ||
+      key === "transform-modules-amd" ||
+      key === "transform-modules-systemjs"
+    ) {
+      const declaredInFile = Boolean(babelPluginMapFromFile[key])
+      logger.warn(
+        createDetailedMessage(
+          `WARNING: "${key}" babel plugin should not be enabled, it will be ignored`,
+          {
+            suggestion: declaredInFile
+              ? `To get rid of this warning, remove "${key}" from babel config file. Either with "modules": false in @babel/preset-env or removing "@babel/${key}" from plugins`
+              : `To get rid of this warning, remove "${key}" from babelPluginMap parameter`,
+          },
+        ),
+      )
+      delete babelPluginMap[key]
+    }
+  })
+
+  const { babelSyntaxPluginMap, babelPluginMapWithoutSyntax } =
+    extractSyntaxBabelPluginMap(babelPluginMap)
   const compileServerGroupMap = generateGroupMap({
-    babelPluginMap,
+    babelPluginMap: babelPluginMapWithoutSyntax,
     runtimeSupport,
   })
 
+  const { best } = compileServerGroupMap
+  if (best) {
+    // here it's just that @babel/preset-env is a bit aggressive in the list of babel plugins
+    // that it enables
+    // we don't want to end up transforming code that could run without any compile step
+    // ideally we should maintain our own babel preset list
+    // (would just be the jsenvBabelPluginMap)
+    // so that we have the correct list of babel plugins
+    // and we are not forced to remove some of them
+    // we should also fix the node system not working anymore
+    best.babelPluginRequiredNameArray =
+      best.babelPluginRequiredNameArray.filter((babelPluginName) => {
+        return !babelPluginNamesToRemoveFromBest.includes(babelPluginName)
+      })
+  }
+
   babelPluginMap = {
     "transform-replace-expressions": [
       babelPluginReplaceExpressions,
@@ -149,6 +202,7 @@ export const startCompileServer = async ({
         allowConflictingReplacements: true,
       },
     ],
+    ...babelSyntaxPluginMap,
     ...babelPluginMap,
   }
 
@@ -201,6 +255,7 @@ export const startCompileServer = async ({
     compileServerGroupMap,
     env,
     inlineImportMapIntoHTML,
+    babelPluginMap,
     customCompilers,
   })
   if (compileServerCanWriteOnFilesystem) {
@@ -335,6 +390,7 @@ export const startCompileServer = async ({
     outDirectoryRelativeUrl,
     ...compileServer,
     compileServerGroupMap,
+    babelPluginMap,
   }
 }
 
@@ -893,7 +949,7 @@ const createOutJSONFiles = ({
   const customCompilerPatterns = Object.keys(customCompilers)
   const outDirectoryMeta = {
     jsenvCorePackageVersion,
-    babelPluginMap,
+    babelPluginMap: babelPluginMapAsData(babelPluginMap),
     compileServerGroupMap,
     replaceProcessEnvNodeEnv,
     processEnvNodeEnv,
@@ -927,6 +983,25 @@ const createOutJSONFiles = ({
   return outJSONFiles
 }
 
+const babelPluginMapAsData = (babelPluginMap) => {
+  const data = {}
+  Object.keys(babelPluginMap).forEach((key) => {
+    const value = babelPluginMap[key]
+    if (Array.isArray(value)) {
+      data[key] = value
+      return
+    }
+    if (typeof value === "object") {
+      data[key] = {
+        options: value.options,
+      }
+      return
+    }
+    data[key] = value
+  })
+  return data
+}
+
 const createOutFilesService = async ({
   logger,
   projectDirectoryUrl,

package/src/internal/executing/coverage/relativeUrlToEmptyCoverage.js

@@ -1,7 +1,11 @@
 import { createOperation } from "@jsenv/cancellation"
 import { resolveUrl, urlToFileSystemPath, readFile } from "@jsenv/filesystem"
 
-import { getMinimalBabelPluginArray } from "../../minimalBabelPluginArray.js"
+import {
+  babelPluginsFromBabelPluginMap,
+  getMinimalBabelPluginMap,
+} from "@jsenv/core/src/internal/compiling/babel_plugins.js"
+
 import { babelPluginInstrument } from "./babel-plugin-instrument.js"
 import { createEmptyCoverage } from "./createEmptyCoverage.js"
 
@@ -17,28 +21,32 @@ export const relativeUrlToEmptyCoverage = async (
     start: () => readFile(fileUrl),
   })
 
-  const plugins = [...getMinimalBabelPluginArray()]
-  Object.keys(babelPluginMap).forEach((babelPluginName) => {
-    if (babelPluginName !== "transform-instrument") {
-      plugins.push(babelPluginMap[babelPluginName])
-    }
-  })
-  plugins.push([babelPluginInstrument, { projectDirectoryUrl }])
-
   try {
     const { metadata } = await createOperation({
       cancellationToken,
-      start: () =>
-        transformAsync(source, {
+      start: async () => {
+        babelPluginMap = {
+          ...getMinimalBabelPluginMap(),
+          ...babelPluginMap,
+          "transform-instrument": [
+            babelPluginInstrument,
+            { projectDirectoryUrl },
+          ],
+        }
+
+        const { metadata } = await transformAsync(source, {
           filename: urlToFileSystemPath(fileUrl),
           filenameRelative: relativeUrl,
           configFile: false,
           babelrc: false,
+          ast: true,
           parserOpts: {
             allowAwaitOutsideFunction: true,
           },
-          plugins,
-        }),
+          plugins: babelPluginsFromBabelPluginMap(babelPluginMap),
+        })
+        return { metadata }
+      },
     })
 
     const { coverage } = metadata

package/src/internal/executing/executePlan.js

@@ -39,6 +39,7 @@ export const executePlan = async (
     compileServerCanReadFromFilesystem,
     compileServerCanWriteOnFilesystem,
     babelPluginMap,
+    babelConfigFileUrl,
     customCompilers,
     runtimeSupport,
   } = {},
@@ -53,11 +54,7 @@ export const executePlan = async (
     }
   }
 
-  const {
-    origin: compileServerOrigin,
-    outDirectoryRelativeUrl,
-    stop,
-  } = await startCompileServer({
+  const compileServer = await startCompileServer({
     cancellationToken,
     compileServerLogLevel,
 
@@ -78,6 +75,7 @@ export const executePlan = async (
     compileServerCanWriteOnFilesystem,
     keepProcessAlive: true, // to be sure it stays alive
     babelPluginMap,
+    babelConfigFileUrl,
     customCompilers,
     runtimeSupport,
   })
@@ -85,7 +83,7 @@ export const executePlan = async (
   const executionSteps = await generateExecutionSteps(
     {
       ...plan,
-      [outDirectoryRelativeUrl]: null,
+      [compileServer.outDirectoryRelativeUrl]: null,
     },
     {
       cancellationToken,
@@ -99,14 +97,14 @@ export const executePlan = async (
     cancellationToken,
 
     projectDirectoryUrl,
-    compileServerOrigin,
-    outDirectoryRelativeUrl,
+    compileServerOrigin: compileServer.origin,
+    outDirectoryRelativeUrl: compileServer.outDirectoryRelativeUrl,
 
     // not sure we actually have to pass import params to executeConcurrently
     importResolutionMethod,
     importDefaultExtension,
 
-    babelPluginMap,
+    babelPluginMap: compileServer.babelPluginMap,
 
     defaultMsAllocatedPerExecution,
     concurrencyLimit,
@@ -122,7 +120,7 @@ export const executePlan = async (
     coverageV8MergeConflictIsExpected,
   })
 
-  stop("all execution done")
+  compileServer.stop("all execution done")
 
   return {
     planSummary: result.summary,

package/src/internal/generateGroupMap/generateGroupMap.js

@@ -61,7 +61,6 @@ export const generateGroupMap = ({
   }
 
   const runtimeNames = Object.keys(runtimeSupport)
-  babelPluginMap = withoutSyntaxPlugins(babelPluginMap)
 
   const groupWithoutFeature = {
     babelPluginRequiredNameArray: Object.keys(babelPluginMap),
@@ -89,14 +88,3 @@ export const generateGroupMap = ({
     [COMPILE_ID_OTHERWISE]: groupWithoutFeature,
   }
 }
-
-export const withoutSyntaxPlugins = (babelPluginMap) => {
-  const babelPluginMapWithoutSyntaxPlugins = {}
-  Object.keys(babelPluginMap).forEach((key) => {
-    if (key.startsWith("syntax-")) {
-      return
-    }
-    babelPluginMapWithoutSyntaxPlugins[key] = babelPluginMap[key]
-  })
-  return babelPluginMapWithoutSyntaxPlugins
-}

package/src/internal/generateGroupMap/jsenvBabelPluginCompatMap.js

@@ -427,3 +427,6 @@ export const jsenvBabelPluginCompatMap = {
 // so that async is not transpiled when supported
 jsenvBabelPluginCompatMap["transform-async-to-promises"] =
   jsenvBabelPluginCompatMap["transform-async-to-generator"]
+
+jsenvBabelPluginCompatMap["regenerator-transform"] =
+  jsenvBabelPluginCompatMap["transform-regenerator"]

package/src/internal/import-resolution/import-resolver-importmap.js

@@ -1,5 +1,5 @@
 import { createDetailedMessage } from "@jsenv/logger"
-import { resolveImport } from "@jsenv/import-map/src/resolveImport.js"
+import { resolveImport } from "@jsenv/importmap/src/resolveImport.js"
 
 import { tryToFindProjectRelativeUrl } from "@jsenv/core/src/internal/runtime/module-registration.js"
 

package/src/internal/import-resolution/import-resolver-node.js

@@ -5,7 +5,7 @@ import {
   urlToRelativeUrl,
   readFile,
 } from "@jsenv/filesystem"
-import { isSpecifierForNodeCoreModule } from "@jsenv/import-map/src/isSpecifierForNodeCoreModule.js"
+import { isSpecifierForNodeCoreModule } from "@jsenv/importmap/src/isSpecifierForNodeCoreModule.js"
 
 import { jsenvCoreDirectoryUrl } from "@jsenv/core/src/internal/jsenvCoreDirectoryUrl.js"
 

package/src/internal/runtime/createBrowserRuntime/createBrowserRuntime.js

@@ -1,4 +1,4 @@
-import { normalizeImportMap } from "@jsenv/import-map/src/normalizeImportMap.js"
+import { normalizeImportMap } from "@jsenv/importmap/src/normalizeImportMap.js"
 
 import { unevalException } from "../../unevalException.js"
 // do not use memoize from @jsenv/filesystem to avoid pulling @jsenv/filesystem code into the browser build

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

@@ -5,7 +5,8 @@ We could use https://nodejs.org/api/esm.html#esm_loaders once it gets stable
 */
 
 import { urlToFileSystemPath, resolveUrl } from "@jsenv/filesystem"
-import { isSpecifierForNodeCoreModule } from "@jsenv/import-map/src/isSpecifierForNodeCoreModule.js"
+import { isSpecifierForNodeCoreModule } from "@jsenv/importmap/src/isSpecifierForNodeCoreModule.js"
+
 import { createImportResolverForNode } from "@jsenv/core/src/internal/import-resolution/import-resolver-node.js"
 import { require } from "../../require.js"
 import "../s.js"
@@ -45,8 +46,11 @@ export const createNodeSystem = async ({
     if (isSpecifierForNodeCoreModule(url)) {
       return fromFunctionReturningNamespace(
         () => {
+          const coreNodeModuleSpecifier = url.startsWith("node:")
+            ? url.slice("node:".length)
+            : url
           // eslint-disable-next-line import/no-dynamic-require
-          const moduleExportsForNativeNodeModule = require(url)
+          const moduleExportsForNativeNodeModule = require(coreNodeModuleSpecifier)
           return moduleExportsToModuleNamespace(
             moduleExportsForNativeNodeModule,
           )

package/src/internal/minimalBabelPluginArray.js

@@ -1,16 +0,0 @@
-/**
-
-minimalBabelPluginArray exists so that jsenv support latest js syntax by default.
-Otherwise users have to explicitely enable those syntax when they use it.
-
-*/
-
-import { require } from "./require.js"
-
-export const getMinimalBabelPluginArray = () => {
-  const syntaxDynamicImport = require("@babel/plugin-syntax-dynamic-import")
-  const syntaxImportMeta = require("@babel/plugin-syntax-import-meta")
-  const syntaxNumericSeparator = require("@babel/plugin-syntax-numeric-separator")
-
-  return [syntaxDynamicImport, syntaxImportMeta, syntaxNumericSeparator]
-}

package/src/jsenvBabelPluginMap.js

@@ -1,76 +0,0 @@
-/* eslint-disable import/max-dependencies */
-
-import { require } from "./internal/require.js"
-
-const proposalJSONStrings = require("@babel/plugin-proposal-json-strings")
-const proposalNumericSeparator = require("@babel/plugin-proposal-numeric-separator")
-const proposalObjectRestSpread = require("@babel/plugin-proposal-object-rest-spread")
-const proposalOptionalCatchBinding = require("@babel/plugin-proposal-optional-catch-binding")
-const proposalOptionalChaining = require("@babel/plugin-proposal-optional-chaining")
-const proposalUnicodePropertyRegex = require("@babel/plugin-proposal-unicode-property-regex")
-const syntaxObjectRestSpread = require("@babel/plugin-syntax-object-rest-spread")
-const syntaxOptionalCatchBinding = require("@babel/plugin-syntax-optional-catch-binding")
-const transformArrowFunction = require("@babel/plugin-transform-arrow-functions")
-const transformAsyncToPromises = require("babel-plugin-transform-async-to-promises")
-const transformBlockScopedFunctions = require("@babel/plugin-transform-block-scoped-functions")
-const transformBlockScoping = require("@babel/plugin-transform-block-scoping")
-const transformClasses = require("@babel/plugin-transform-classes")
-const transformComputedProperties = require("@babel/plugin-transform-computed-properties")
-const transformDestructuring = require("@babel/plugin-transform-destructuring")
-const transformDotAllRegex = require("@babel/plugin-transform-dotall-regex")
-const transformDuplicateKeys = require("@babel/plugin-transform-duplicate-keys")
-const transformExponentiationOperator = require("@babel/plugin-transform-exponentiation-operator")
-const transformForOf = require("@babel/plugin-transform-for-of")
-const transformFunctionName = require("@babel/plugin-transform-function-name")
-const transformLiterals = require("@babel/plugin-transform-literals")
-const transformNewTarget = require("@babel/plugin-transform-new-target")
-const transformObjectSuper = require("@babel/plugin-transform-object-super")
-const transformParameters = require("@babel/plugin-transform-parameters")
-const transformRegenerator = require("@babel/plugin-transform-regenerator")
-const transformShorthandProperties = require("@babel/plugin-transform-shorthand-properties")
-const transformSpread = require("@babel/plugin-transform-spread")
-const transformStickyRegex = require("@babel/plugin-transform-sticky-regex")
-const transformTemplateLiterals = require("@babel/plugin-transform-template-literals")
-const transformTypeOfSymbol = require("@babel/plugin-transform-typeof-symbol")
-const transformUnicodeRegex = require("@babel/plugin-transform-unicode-regex")
-
-export const jsenvBabelPluginMap = {
-  "proposal-numeric-separator": [proposalNumericSeparator],
-  "proposal-json-strings": [proposalJSONStrings],
-  "proposal-object-rest-spread": [proposalObjectRestSpread],
-  "proposal-optional-catch-binding": [proposalOptionalCatchBinding],
-  "proposal-optional-chaining": [proposalOptionalChaining],
-  "proposal-unicode-property-regex": [proposalUnicodePropertyRegex],
-  "syntax-object-rest-spread": [syntaxObjectRestSpread],
-  "syntax-optional-catch-binding": [syntaxOptionalCatchBinding],
-  "transform-async-to-promises": [transformAsyncToPromises],
-  "transform-arrow-functions": [transformArrowFunction],
-  "transform-block-scoped-functions": [transformBlockScopedFunctions],
-  "transform-block-scoping": [transformBlockScoping],
-  "transform-classes": [transformClasses],
-  "transform-computed-properties": [transformComputedProperties],
-  "transform-destructuring": [transformDestructuring],
-  "transform-dotall-regex": [transformDotAllRegex],
-  "transform-duplicate-keys": [transformDuplicateKeys],
-  "transform-exponentiation-operator": [transformExponentiationOperator],
-  "transform-for-of": [transformForOf],
-  "transform-function-name": [transformFunctionName],
-  "transform-literals": [transformLiterals],
-  "transform-new-target": [transformNewTarget],
-  "transform-object-super": [transformObjectSuper],
-  "transform-parameters": [transformParameters],
-  "transform-regenerator": [
-    transformRegenerator,
-    {
-      asyncGenerators: true,
-      generators: true,
-      async: false,
-    },
-  ],
-  "transform-shorthand-properties": [transformShorthandProperties],
-  "transform-spread": [transformSpread],
-  "transform-sticky-regex": [transformStickyRegex],
-  "transform-template-literals": [transformTemplateLiterals],
-  "transform-typeof-symbol": [transformTypeOfSymbol],
-  "transform-unicode-regex": [transformUnicodeRegex],
-}