@jsenv/core 27.0.0-alpha.3 → 27.0.0-alpha.32

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

@@ -0,0 +1,161 @@
+import { getBabelHelperFileUrl, requireBabelPlugin } from "@jsenv/babel-plugins"
+import { babelPluginCompatMap } from "./babel_plugins_compatibility.js"
+
+export const getBaseBabelPluginStructure = ({ url, isSupported }) => {
+  const isBabelPluginNeeded = (babelPluginName) => {
+    return !isSupported(babelPluginCompatMap[babelPluginName])
+  }
+
+  const babelPluginStructure = {}
+  if (isBabelPluginNeeded("proposal-numeric-separator")) {
+    babelPluginStructure["proposal-numeric-separator"] = requireBabelPlugin(
+      "@babel/plugin-proposal-numeric-separator",
+    )
+  }
+  if (isBabelPluginNeeded("proposal-json-strings")) {
+    babelPluginStructure["proposal-json-strings"] = requireBabelPlugin(
+      "@babel/plugin-proposal-json-strings",
+    )
+  }
+  if (isBabelPluginNeeded("proposal-object-rest-spread")) {
+    babelPluginStructure["proposal-object-rest-spread"] = requireBabelPlugin(
+      "@babel/plugin-proposal-object-rest-spread",
+    )
+  }
+  if (isBabelPluginNeeded("proposal-optional-catch-binding")) {
+    babelPluginStructure["proposal-optional-catch-binding"] =
+      requireBabelPlugin("@babel/plugin-proposal-optional-catch-binding")
+  }
+  if (isBabelPluginNeeded("proposal-unicode-property-regex")) {
+    babelPluginStructure["proposal-unicode-property-regex"] =
+      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"),
+      {
+        topLevelAwait: "ignore", // will be handled by "jsenv:top_level_await" plugin
+      },
+    ]
+  }
+  if (isBabelPluginNeeded("transform-arrow-functions")) {
+    babelPluginStructure["transform-arrow-functions"] = requireBabelPlugin(
+      "@babel/plugin-transform-arrow-functions",
+    )
+  }
+  if (isBabelPluginNeeded("transform-block-scoped-functions")) {
+    babelPluginStructure["transform-block-scoped-functions"] =
+      requireBabelPlugin("@babel/plugin-transform-block-scoped-functions")
+  }
+  if (isBabelPluginNeeded("transform-block-scoping")) {
+    babelPluginStructure["transform-block-scoping"] = requireBabelPlugin(
+      "@babel/plugin-transform-block-scoping",
+    )
+  }
+  if (isBabelPluginNeeded("transform-classes")) {
+    babelPluginStructure["transform-classes"] = requireBabelPlugin(
+      "@babel/plugin-transform-classes",
+    )
+  }
+  if (isBabelPluginNeeded("transform-computed-properties")) {
+    babelPluginStructure["transform-computed-properties"] = requireBabelPlugin(
+      "@babel/plugin-transform-computed-properties",
+    )
+  }
+  if (isBabelPluginNeeded("transform-destructuring")) {
+    babelPluginStructure["transform-destructuring"] = requireBabelPlugin(
+      "@babel/plugin-transform-destructuring",
+    )
+  }
+  if (isBabelPluginNeeded("transform-dotall-regex")) {
+    babelPluginStructure["transform-dotall-regex"] = requireBabelPlugin(
+      "@babel/plugin-transform-dotall-regex",
+    )
+  }
+  if (isBabelPluginNeeded("transform-duplicate-keys")) {
+    babelPluginStructure["transform-duplicate-keys"] = requireBabelPlugin(
+      "@babel/plugin-transform-duplicate-keys",
+    )
+  }
+  if (isBabelPluginNeeded("transform-exponentiation-operator")) {
+    babelPluginStructure["transform-exponentiation-operator"] =
+      requireBabelPlugin("@babel/plugin-transform-exponentiation-operator")
+  }
+  if (isBabelPluginNeeded("transform-for-of")) {
+    babelPluginStructure["transform-for-of"] = requireBabelPlugin(
+      "@babel/plugin-transform-for-of",
+    )
+  }
+  if (isBabelPluginNeeded("transform-function-name")) {
+    babelPluginStructure["transform-function-name"] = requireBabelPlugin(
+      "@babel/plugin-transform-function-name",
+    )
+  }
+  if (isBabelPluginNeeded("transform-literals")) {
+    babelPluginStructure["transform-literals"] = requireBabelPlugin(
+      "@babel/plugin-transform-literals",
+    )
+  }
+  if (isBabelPluginNeeded("transform-new-target")) {
+    babelPluginStructure["transform-new-target"] = requireBabelPlugin(
+      "@babel/plugin-transform-new-target",
+    )
+  }
+  if (isBabelPluginNeeded("transform-object-super")) {
+    babelPluginStructure["transform-object-super"] = requireBabelPlugin(
+      "@babel/plugin-transform-object-super",
+    )
+  }
+  if (isBabelPluginNeeded("transform-parameters")) {
+    babelPluginStructure["transform-parameters"] = requireBabelPlugin(
+      "@babel/plugin-transform-parameters",
+    )
+  }
+  if (isBabelPluginNeeded("transform-regenerator")) {
+    babelPluginStructure["transform-regenerator"] = [
+      requireBabelPlugin("@babel/plugin-transform-regenerator"),
+      {
+        asyncGenerators: true,
+        generators: true,
+        async: false,
+      },
+    ]
+  }
+  if (isBabelPluginNeeded("transform-shorthand-properties")) {
+    babelPluginStructure["transform-shorthand-properties"] = [
+      requireBabelPlugin("@babel/plugin-transform-shorthand-properties"),
+    ]
+  }
+  if (isBabelPluginNeeded("transform-spread")) {
+    babelPluginStructure["transform-spread"] = [
+      requireBabelPlugin("@babel/plugin-transform-spread"),
+    ]
+  }
+  if (isBabelPluginNeeded("transform-sticky-regex")) {
+    babelPluginStructure["transform-sticky-regex"] = [
+      requireBabelPlugin("@babel/plugin-transform-sticky-regex"),
+    ]
+  }
+  if (isBabelPluginNeeded("transform-template-literals")) {
+    babelPluginStructure["transform-template-literals"] = [
+      requireBabelPlugin("@babel/plugin-transform-template-literals"),
+    ]
+  }
+  if (
+    isBabelPluginNeeded("transform-typeof-symbol") &&
+    // prevent "typeof" to be injected into itself:
+    // - not needed
+    // - would create infinite attempt to transform typeof
+    url !== getBabelHelperFileUrl("typeof")
+  ) {
+    babelPluginStructure["transform-typeof-symbol"] = [
+      requireBabelPlugin("@babel/plugin-transform-typeof-symbol"),
+    ]
+  }
+  if (isBabelPluginNeeded("transform-unicode-regex")) {
+    babelPluginStructure["transform-unicode-regex"] = [
+      requireBabelPlugin("@babel/plugin-transform-unicode-regex"),
+    ]
+  }
+  return babelPluginStructure
+}

package/src/{omega/core_plugins → plugins/transpilation}/babel/jsenv_plugin_babel.js

@@ -1,27 +1,45 @@
 import { applyBabelPlugins } from "@jsenv/utils/js_ast/apply_babel_plugins.js"
 
+import { RUNTIME_COMPAT } from "@jsenv/core/src/omega/compat/runtime_compat.js"
 import { getBaseBabelPluginStructure } from "./helpers/babel_plugin_structure.js"
+import { babelPluginBabelHelpersAsJsenvImports } from "./helpers/babel_plugin_babel_helpers_as_jsenv_imports.js"
 import { babelPluginNewStylesheetAsJsenvImport } from "./new_stylesheet/babel_plugin_new_stylesheet_as_jsenv_import.js"
 import { babelPluginGlobalThisAsJsenvImport } from "./global_this/babel_plugin_global_this_as_jsenv_import.js"
 import { babelPluginRegeneratorRuntimeAsJsenvImport } from "./regenerator_runtime/babel_plugin_regenerator_runtime_as_jsenv_import.js"
-import { babelPluginBabelHelpersAsJsenvImports } from "./babel_helper/babel_plugin_babel_helpers_as_jsenv_imports.js"
 
-export const jsenvPluginBabel = ({
-  getCustomBabelPlugins,
-  topLevelAwait,
-} = {}) => {
+export const jsenvPluginBabel = ({ getCustomBabelPlugins } = {}) => {
   const transformWithBabel = async (urlInfo, context) => {
     const isJsModule = urlInfo.type === "js_module"
-    const isWorker =
-      urlInfo.subtype === "worker" || urlInfo.subtype === "service_worker"
-    const { isSupportedOnRuntime, referenceUtils } = context
+    const isWorker = urlInfo.subtype === "worker"
+    const isServiceWorker = urlInfo.subtype === "service_worker"
+    const isSharedWorker = urlInfo.subtype === "shared_worker"
+    const isWorkerContext = isWorker || isServiceWorker || isSharedWorker
+
+    let { clientRuntimeCompat } = context
+    if (isWorker) {
+      clientRuntimeCompat = RUNTIME_COMPAT.add(clientRuntimeCompat, "worker")
+    } else if (isServiceWorker) {
+      // when code is executed by a service worker we can assume
+      // the execution context supports more than the default one
+      // for instance arrow function are supported
+      clientRuntimeCompat = RUNTIME_COMPAT.add(
+        clientRuntimeCompat,
+        "service_worker",
+      )
+    } else if (isSharedWorker) {
+      clientRuntimeCompat = RUNTIME_COMPAT.add(
+        clientRuntimeCompat,
+        "shared_worker",
+      )
+    }
+
+    const { referenceUtils } = context
+    const isSupported = (feature) =>
+      RUNTIME_COMPAT.isSupported(clientRuntimeCompat, feature)
     const babelPluginStructure = getBaseBabelPluginStructure({
       url: urlInfo.url,
-      isSupportedOnRuntime,
-      topLevelAwait,
-      usesTopLevelAwait: urlInfo.data.usesTopLevelAwait,
-      isJsModule,
-      isWorker,
+      isSupported,
+      isWorkerContext,
     })
     if (getCustomBabelPlugins) {
       Object.assign(babelPluginStructure, getCustomBabelPlugins(context))
@@ -31,11 +49,12 @@ export const jsenvPluginBabel = ({
       const getImportSpecifier = (clientFileUrl) => {
         const [reference] = referenceUtils.inject({
           type: "js_import_export",
+          expectedType: "js_module",
           specifier: clientFileUrl,
         })
         return JSON.parse(reference.generatedSpecifier)
       }
-      if (!isSupportedOnRuntime("global_this")) {
+      if (!isSupported("global_this")) {
         babelPluginStructure["global-this-as-jsenv-import"] = [
           babelPluginGlobalThisAsJsenvImport,
           {
@@ -43,7 +62,7 @@ export const jsenvPluginBabel = ({
           },
         ]
       }
-      if (!isSupportedOnRuntime("async_generator_function")) {
+      if (!isSupported("async_generator_function")) {
         babelPluginStructure["regenerator-runtime-as-jsenv-import"] = [
           babelPluginRegeneratorRuntimeAsJsenvImport,
           {
@@ -51,7 +70,7 @@ export const jsenvPluginBabel = ({
           },
         ]
       }
-      if (!isSupportedOnRuntime("new_stylesheet")) {
+      if (!isSupported("new_stylesheet")) {
         babelPluginStructure["new-stylesheet-as-jsenv-import"] = [
           babelPluginNewStylesheetAsJsenvImport,
           {
@@ -76,22 +95,19 @@ export const jsenvPluginBabel = ({
     )
     const { code, map } = await applyBabelPlugins({
       babelPlugins,
-      url: urlInfo.url,
-      generatedUrl: urlInfo.generatedUrl,
-      content: urlInfo.content,
+      urlInfo,
     })
     return {
       content: code,
       sourcemap: map,
     }
   }
-
   return {
     name: "jsenv:babel",
     appliesDuring: "*",
-    transform: {
-      js_module: transformWithBabel,
+    finalizeUrlContent: {
       js_classic: transformWithBabel,
+      js_module: transformWithBabel,
     },
   }
 }

package/src/{omega/core_plugins → plugins/transpilation}/babel/new_stylesheet/babel_plugin_new_stylesheet_as_jsenv_import.js

@@ -1,9 +1,3 @@
-/*
- * TODO:
- * - code should also inject helper when code uses new keyword on "CSSStyleSheet"
- * - code should also inject helper when code uses "document.adoptedStylesheets"
- */
-
 import { pathToFileURL } from "node:url"
 
 import { injectImport } from "@jsenv/utils/js_ast/babel_utils.js"
@@ -27,6 +21,18 @@ export const babelPluginNewStylesheetAsJsenvImport = (
         }
         let usesNewStylesheet = false
         programPath.traverse({
+          NewExpression: (path) => {
+            usesNewStylesheet = isNewCssStyleSheetCall(path.node)
+            if (usesNewStylesheet) {
+              path.stop()
+            }
+          },
+          MemberExpression: (path) => {
+            usesNewStylesheet = isDocumentAdoptedStyleSheets(path.node)
+            if (usesNewStylesheet) {
+              path.stop()
+            }
+          },
           CallExpression: (path) => {
             if (path.node.callee.type !== "Import") {
               // Some other function call, not import();
@@ -90,6 +96,24 @@ export const babelPluginNewStylesheetAsJsenvImport = (
   }
 }
 
+const isNewCssStyleSheetCall = (node) => {
+  return (
+    node.type === "NewExpression" &&
+    node.callee.type === "Identifier" &&
+    node.callee.name === "CSSStyleSheet"
+  )
+}
+
+const isDocumentAdoptedStyleSheets = (node) => {
+  return (
+    node.type === "MemberExpression" &&
+    node.object.type === "Identifier" &&
+    node.object.name === "document" &&
+    node.property.type === "Identifier" &&
+    node.property.name === "adoptedStyleSheets"
+  )
+}
+
 const hasCssModuleQueryParam = (path) => {
   const { node } = path
   return (

package/src/plugins/transpilation/css_parcel/jsenv_plugin_css_parcel.js

@@ -0,0 +1,18 @@
+import { transpileWithParcel } from "@jsenv/utils/css_ast/parcel_css.js"
+
+// https://github.com/parcel-bundler/parcel-css
+export const jsenvPluginCssParcel = () => {
+  return {
+    name: "jsenv:css_parcel",
+    appliesDuring: "*",
+    transformUrlContent: {
+      css: (urlInfo, context) => {
+        const { code, map } = transpileWithParcel(urlInfo, context)
+        return {
+          content: String(code),
+          sourcemap: map,
+        }
+      },
+    },
+  }
+}

package/src/plugins/transpilation/fetch_original_url_info.js

@@ -0,0 +1,30 @@
+export const fetchOriginalUrlInfo = async ({
+  urlInfo,
+  context,
+  searchParam,
+  expectedType,
+}) => {
+  const urlObject = new URL(urlInfo.url)
+  const { searchParams } = urlObject
+  if (!searchParams.has(searchParam)) {
+    return null
+  }
+  searchParams.delete(searchParam)
+  const originalUrl = urlObject.href
+  const originalReference = {
+    ...(context.reference.original || context.reference),
+    expectedType,
+  }
+  originalReference.url = originalUrl
+  const originalUrlInfo = context.urlGraph.reuseOrCreateUrlInfo(
+    originalReference.url,
+  )
+  await context.fetchUrlContent({
+    reference: originalReference,
+    urlInfo: originalUrlInfo,
+  })
+  if (originalUrlInfo.dependents.size === 0) {
+    context.urlGraph.deleteUrlInfo(originalUrlInfo.url)
+  }
+  return originalUrlInfo
+}

package/src/plugins/transpilation/import_assertions/jsenv_plugin_import_assertions.js

@@ -0,0 +1,225 @@
+import { urlToFilename } from "@jsenv/filesystem"
+
+import { applyBabelPlugins } from "@jsenv/utils/js_ast/apply_babel_plugins.js"
+import { createMagicSource } from "@jsenv/utils/sourcemap/magic_source.js"
+import { injectQueryParamsIntoSpecifier } from "@jsenv/utils/urls/url_utils.js"
+import { JS_QUOTES } from "@jsenv/utils/string/js_quotes.js"
+
+import { fetchOriginalUrlInfo } from "../fetch_original_url_info.js"
+import { babelPluginMetadataImportAssertions } from "./helpers/babel_plugin_metadata_import_assertions.js"
+
+export const jsenvPluginImportAssertions = () => {
+  const importAssertions = {
+    name: "jsenv:import_assertions",
+    appliesDuring: "*",
+    transformUrlContent: {
+      js_module: async (urlInfo, context) => {
+        const importTypesToTranspile = getImportTypesToTranspile(context)
+        if (importTypesToTranspile.length === 0) {
+          return null
+        }
+        const { metadata } = await applyBabelPlugins({
+          babelPlugins: [babelPluginMetadataImportAssertions],
+          urlInfo,
+        })
+        const { importAssertions } = metadata
+        const magicSource = createMagicSource(urlInfo.content)
+        importAssertions.forEach((importAssertion) => {
+          const assertType = importAssertion.assert.type
+          if (!importTypesToTranspile.includes(assertType)) {
+            return
+          }
+          const { searchParam } = importAsInfos[assertType]
+          const { path } = importAssertion
+          const { node } = path
+          if (node.type === "CallExpression") {
+            const importSpecifierPath = path.get("arguments")[0]
+            const specifier = importSpecifierPath.node.value
+            const reference = context.referenceUtils.findByGeneratedSpecifier(
+              JSON.stringify(specifier),
+            )
+            const [newReference] = context.referenceUtils.update(reference, {
+              expectedType: "js_module",
+              specifier: injectQueryParamsIntoSpecifier(specifier, {
+                [searchParam]: "",
+              }),
+              filename: `${urlToFilename(reference.url)}.js`,
+            })
+            magicSource.replace({
+              start: importSpecifierPath.node.start,
+              end: importSpecifierPath.node.end,
+              replacement: newReference.generatedSpecifier,
+            })
+            const secondArgPath = path.get("arguments")[1]
+            magicSource.remove({
+              start: secondArgPath.node.start,
+              end: secondArgPath.node.end,
+            })
+            return
+          }
+          const importSpecifierPath = path.get("source")
+          const specifier = importSpecifierPath.node.value
+          const reference = context.referenceUtils.findByGeneratedSpecifier(
+            JSON.stringify(specifier),
+          )
+          const [newReference] = context.referenceUtils.update(reference, {
+            expectedType: "js_module",
+            specifier: injectQueryParamsIntoSpecifier(specifier, {
+              [searchParam]: "",
+            }),
+            filename: `${urlToFilename(reference.url)}.js`,
+          })
+          magicSource.replace({
+            start: importSpecifierPath.node.start,
+            end: importSpecifierPath.node.end,
+            replacement: newReference.generatedSpecifier,
+          })
+          const assertionsPath = path.get("assertions")[0]
+          magicSource.remove({
+            start: assertionsPath.node.start,
+            end: assertionsPath.node.end,
+          })
+        })
+        return magicSource.toContentAndSourcemap()
+      },
+    },
+  }
+  return [importAssertions, ...jsenvPluginAsModules()]
+}
+
+const jsenvPluginAsModules = () => {
+  const inlineContentClientFileUrl = new URL(
+    "../../inline/client/inline_content.js",
+    import.meta.url,
+  ).href
+
+  const asJsonModule = {
+    name: `jsenv:as_json_module`,
+    appliesDuring: "*",
+    fetchUrlContent: async (urlInfo, context) => {
+      const originalUrlInfo = await fetchOriginalUrlInfo({
+        urlInfo,
+        context,
+        searchParam: "as_json_module",
+        expectedType: "json",
+      })
+      if (!originalUrlInfo) {
+        return null
+      }
+      const jsonText = JSON.stringify(originalUrlInfo.content.trim())
+      return {
+        type: "js_module",
+        contentType: "text/javascript",
+        // here we could `export default ${jsonText}`:
+        // but js engine are optimized to recognize JSON.parse
+        // and use a faster parsing strategy
+        content: `export default JSON.parse(${jsonText})`,
+      }
+    },
+  }
+
+  const asCssModule = {
+    name: `jsenv:as_css_module`,
+    appliesDuring: "*",
+    fetchUrlContent: async (urlInfo, context) => {
+      const originalUrlInfo = await fetchOriginalUrlInfo({
+        urlInfo,
+        context,
+        searchParam: "as_css_module",
+        expectedType: "css",
+      })
+      if (!originalUrlInfo) {
+        return null
+      }
+      const cssText = JS_QUOTES.escapeSpecialChars(originalUrlInfo.content, {
+        // If template string is choosen and runtime do not support template literals
+        // it's ok because "jsenv:new_inline_content" plugin executes after this one
+        // and convert template strings into raw strings
+        canUseTemplateString: true,
+      })
+      return {
+        type: "js_module",
+        contentType: "text/javascript",
+        content: `import { InlineContent } from ${JSON.stringify(
+          inlineContentClientFileUrl,
+        )}
+  
+  const inlineContent = new InlineContent(${cssText}, { type: "text/css" })
+  const stylesheet = new CSSStyleSheet()
+  stylesheet.replaceSync(inlineContent.text)
+  export default stylesheet`,
+      }
+    },
+  }
+
+  const asTextModule = {
+    name: `jsenv:as_text_module`,
+    appliesDuring: "*",
+    fetchUrlContent: async (urlInfo, context) => {
+      const originalUrlInfo = await fetchOriginalUrlInfo({
+        urlInfo,
+        context,
+        searchParam: "as_text_module",
+        expectedType: "text",
+      })
+      if (!originalUrlInfo) {
+        return null
+      }
+      const textPlain = JS_QUOTES.escapeSpecialChars(urlInfo.content, {
+        // If template string is choosen and runtime do not support template literals
+        // it's ok because "jsenv:new_inline_content" plugin executes after this one
+        // and convert template strings into raw strings
+        canUseTemplateString: true,
+      })
+      return {
+        type: "js_module",
+        contentType: "text/javascript",
+        content: `import { InlineContent } from ${JSON.stringify(
+          inlineContentClientFileUrl,
+        )}
+  
+const inlineContent = new InlineContent(${textPlain}, { type: "text/plain" })
+export default inlineContent.text`,
+      }
+    },
+  }
+
+  return [asJsonModule, asCssModule, asTextModule]
+}
+
+const importAsInfos = {
+  json: {
+    searchParam: "as_json_module",
+  },
+  css: {
+    searchParam: "as_css_module",
+  },
+  text: {
+    searchParam: "as_text_module",
+  },
+}
+
+const getImportTypesToTranspile = ({
+  scenario,
+  isSupportedOnCurrentClients,
+}) => {
+  // during build always replace import assertions with the js:
+  // - means rollup can bundle more js file together
+  // - means url versioning can work for css inlined in js
+  // - avoid rollup to see import assertions
+  //   We would have to tell rollup to ignore import with assertion
+  if (scenario === "build") {
+    return ["json", "css", "text"]
+  }
+  const importTypes = []
+  if (!isSupportedOnCurrentClients("import_type_json")) {
+    importTypes.push("json")
+  }
+  if (!isSupportedOnCurrentClients("import_type_css")) {
+    importTypes.push("css")
+  }
+  if (!isSupportedOnCurrentClients("import_type_text")) {
+    importTypes.push("text")
+  }
+  return importTypes
+}

package/src/plugins/transpilation/jsenv_plugin_top_level_await.js

@@ -0,0 +1,37 @@
+import { requireBabelPlugin } from "@jsenv/babel-plugins"
+
+import { applyBabelPlugins } from "@jsenv/utils/js_ast/apply_babel_plugins.js"
+
+export const jsenvPluginTopLevelAwait = () => {
+  return {
+    name: "jsenv:top_level_await",
+    appliesDuring: "*",
+    transformUrlContent: {
+      js_module: async (urlInfo, context) => {
+        if (!urlInfo.data.usesTopLevelAwait) {
+          return null
+        }
+        if (context.isSupportedOnCurrentClients("top_level_await")) {
+          return null
+        }
+        const { code, map } = await applyBabelPlugins({
+          urlInfo,
+          babelPlugins: [
+            [
+              requireBabelPlugin("babel-plugin-transform-async-to-promises"),
+              {
+                // Maybe we could pass target: "es6" when we support arrow function
+                // https://github.com/rpetrich/babel-plugin-transform-async-to-promises/blob/92755ff8c943c97596523e586b5fa515c2e99326/async-to-promises.ts#L55
+                topLevelAwait: "simple",
+              },
+            ],
+          ],
+        })
+        return {
+          content: code,
+          sourcemap: map,
+        }
+      },
+    },
+  }
+}