@vxrn/compiler 1.1.397

package/src/transformBabel.ts

@@ -0,0 +1,218 @@
+import babel from '@babel/core'
+import { relative } from 'node:path'
+import { configuration } from './configure'
+import { asyncGeneratorRegex, debug } from './constants'
+import type { GetTransformProps, GetTransformResponse } from './types'
+
+type Props = GetTransformProps & {
+  userSetting?: GetTransformResponse
+}
+
+export function getBabelOptions(props: Props): babel.TransformOptions | null {
+  if (props.userSetting === 'babel') {
+    return {
+      plugins: getPlugins(props, true),
+    }
+  }
+  if (
+    typeof props.userSetting === 'undefined' ||
+    (typeof props.userSetting === 'object' && props.userSetting.transform === 'babel')
+  ) {
+    if (props.userSetting?.excludeDefaultPlugins) {
+      return props.userSetting
+    }
+    const plugins = getPlugins(props)
+    if (plugins.length) {
+      return {
+        plugins,
+      }
+    }
+  }
+  return null
+}
+
+const getPlugins = (props: Props, force = false) => {
+  let plugins: babel.PluginItem[] = []
+
+  if (force || shouldBabelGenerators(props)) {
+    plugins = getBasePlugins(props)
+  }
+
+  if (shouldBabelReanimated(props)) {
+    debug?.(`Using babel reanimated on file`)
+    plugins.push('react-native-reanimated/plugin')
+  }
+
+  if (shouldBabelReactCompiler(props)) {
+    debug?.(`Using babel react compiler on file`)
+    plugins.push(getBabelReactCompilerPlugin(props))
+  }
+
+  if (shouldBabelReactNativeCodegen(props)) {
+    debug?.(`Using babel @react-native/babel-plugin-codegen on file`)
+    plugins.push('@react-native/babel-plugin-codegen')
+  }
+
+  return plugins
+}
+/**
+ * Transform input to mostly ES5 compatible code, keep ESM syntax, and transform generators.
+ */
+export async function transformBabel(id: string, code: string, options: babel.TransformOptions) {
+  const compilerPlugin = options.plugins?.find((x) => x && x[0] === 'babel-plugin-react-compiler')
+
+  const out = await new Promise<string>((res, rej) => {
+    babel.transform(
+      code,
+      {
+        filename: id,
+        compact: false,
+        minified: false,
+        presets: ['@babel/preset-typescript'],
+        ...options,
+      },
+      (err: any, result) => {
+        if (!result || err) {
+          return rej(err || 'no res')
+        }
+        res(result!.code!)
+      }
+    )
+  })
+
+  if (
+    compilerPlugin &&
+    out.includes(compilerPlugin[1] === '18' ? `react-compiler-runtime` : `react/compiler-runtime`)
+  ) {
+    console.info(` 🪄 [compiler] ${relative(process.cwd(), id)}`)
+  }
+
+  return out
+}
+
+const getBasePlugins = ({ development }: Props) =>
+  [
+    ['@babel/plugin-transform-destructuring'],
+    ['@babel/plugin-transform-react-jsx', { development }],
+    ['@babel/plugin-transform-async-generator-functions'],
+    ['@babel/plugin-transform-async-to-generator'],
+    [
+      '@babel/plugin-transform-runtime',
+      {
+        helpers: true,
+        // NOTE THIS WAS SPELLED WRONG BEFOER THIS COMMIT MAYBE IT WAS UNINTENTIONALLY WORKING
+        regenerator: false,
+      },
+    ],
+  ] satisfies babel.PluginItem[]
+
+/**
+ * ----- react native codegen ----
+ */
+
+// Codegen specification files need to go through the react-native codegen babel plugin.
+// See:
+// * https://reactnative.dev/docs/fabric-native-components-introduction#1-define-specification-for-codegen
+// * https://reactnative.dev/docs/turbo-native-modules-introduction#1-declare-typed-specification
+
+const NATIVE_COMPONENT_RE = /NativeComponent\.[jt]sx?$/
+const SPEC_FILE_RE = /[\/\\]specs?[\/\\]/
+
+const shouldBabelReactNativeCodegen = ({ id, environment }: Props) => {
+  return (
+    (environment === 'ios' || environment === 'android') &&
+    (NATIVE_COMPONENT_RE.test(id) || SPEC_FILE_RE.test(id))
+  )
+}
+
+/**
+ * ----- react compiler -----
+ */
+
+const shouldBabelReactCompiler = (props: Props) => {
+  if (!configuration.enableCompiler) {
+    return false
+  }
+  if (Array.isArray(configuration.enableCompiler)) {
+    if (!configuration.enableCompiler.includes(props.environment)) {
+      return false
+    }
+  }
+  if (!/.*(.tsx?)$/.test(props.id)) return false
+  if (props.code.startsWith('// disable-compiler')) return false
+  // may want to disable in node modules? but rare to have tsx in node mods
+  return true
+}
+
+const getBabelReactCompilerPlugin = (props: Props) => {
+  const target =
+    props.reactForRNVersion === '18' &&
+    (props.environment === 'ios' || props.environment === 'android')
+      ? '18'
+      : '19'
+
+  return ['babel-plugin-react-compiler', { target }]
+}
+
+/**
+ * ----- generators ------
+ */
+
+function shouldBabelGenerators({ code }: Props) {
+  if (process.env.VXRN_USE_BABEL_FOR_GENERATORS) {
+    return asyncGeneratorRegex.test(code)
+  }
+}
+
+/**
+ * ------- reanimated --------
+ */
+
+/**
+ * Taken from https://github.com/software-mansion/react-native-reanimated/blob/3.15.1/packages/react-native-reanimated/plugin/src/autoworkletization.ts#L19-L59, need to check if this is up-to-date when supporting newer versions of react-native-reanimated.
+ */
+const REANIMATED_AUTOWORKLETIZATION_KEYWORDS = [
+  'worklet',
+  'useAnimatedGestureHandler',
+  'useAnimatedScrollHandler',
+  'useFrameCallback',
+  'useAnimatedStyle',
+  'useAnimatedProps',
+  'createAnimatedPropAdapter',
+  'useDerivedValue',
+  'useAnimatedReaction',
+  'useWorkletCallback',
+  'withTiming',
+  'withSpring',
+  'withDecay',
+  'withRepeat',
+  'runOnUI',
+  'executeOnUIRuntimeSync',
+]
+
+/**
+ * Regex to test if a piece of code should be processed by react-native-reanimated's Babel plugin.
+ */
+const REANIMATED_REGEX = new RegExp(REANIMATED_AUTOWORKLETIZATION_KEYWORDS.join('|'))
+
+const REANIMATED_IGNORED_PATHS = [
+  // React and React Native libraries are not likely to use reanimated.
+  // This can also avoid the "[BABEL] Note: The code generator has deoptimised the styling of ... as it exceeds the max of 500KB" warning since the react-native source code also contains `useAnimatedProps`.
+  'react-native-prebuilt',
+  'node_modules/.vxrn/react-native',
+]
+
+const REANIMATED_IGNORED_PATHS_REGEX = new RegExp(
+  REANIMATED_IGNORED_PATHS.map((s) => s.replace(/\//g, '/')).join('|')
+)
+
+function shouldBabelReanimated({ code, id }: Props) {
+  if (!configuration.enableReanimated) {
+    return false
+  }
+  if (!REANIMATED_IGNORED_PATHS_REGEX.test(id) && REANIMATED_REGEX.test(code)) {
+    // console.info(` 🪄 [reanimated] ${relative(process.cwd(), id)}`)
+    return true
+  }
+  return false
+}

package/src/transformSWC.ts

@@ -0,0 +1,381 @@
+import {
+  transform,
+  type Output,
+  type ParserConfig,
+  type Options as SWCOptions,
+  type TransformConfig,
+} from '@swc/core'
+import type { SourceMapPayload } from 'node:module'
+import { extname } from 'node:path'
+import { merge } from 'ts-deepmerge'
+import { configuration } from './configure'
+import { asyncGeneratorRegex, debug, parsers, runtimePublicPath } from './constants'
+import type { Options } from './types'
+
+export async function transformSWC(
+  id: string,
+  code: string,
+  options: Options & { es5?: boolean },
+  swcOptions?: SWCOptions
+) {
+  if (id.includes('.vite')) {
+    return
+  }
+
+  id = id
+    .split('?')[0]
+    // fixes hmr
+    .replace(process.cwd(), '')
+
+  if (id === runtimePublicPath) {
+    return
+  }
+
+  const parser = getParser(id, options.forceJSX)
+
+  if (!parser) {
+    return
+  }
+
+  const enableNativeCSS =
+    configuration.enableNativeCSS &&
+    // temp fix idk why  this error:
+    // node_modules/react-native-reanimated/src/component/LayoutAnimationConfig.tsx (19:9): "createInteropElement" is not exported by "../../node_modules/react-native-css-interop/dist/runtime/jsx-dev-runtime.js", imported by "node_modules/react-native-reanimated/src/component/LayoutAnimationConfig.tsx
+    !id.includes('node_modules')
+
+  const refresh =
+    options.environment !== 'ssr' && !options.production && !options.noHMR && !options.forceJSX
+
+  const reactConfig = {
+    refresh,
+    development: !options.forceJSX && !options.production,
+    runtime: 'automatic',
+    importSource: 'react',
+    ...(enableNativeCSS
+      ? {
+          importSource: 'react-native-css-interop',
+          pragma: 'createInteropElement',
+          // swc doesnt actually change the import right
+          runtime: 'classic',
+        }
+      : {}),
+  } satisfies TransformConfig['react']
+
+  const transformOptions = ((): SWCOptions => {
+    if (options.environment === 'client' || options.environment === 'ssr') {
+      return {
+        sourceMaps: true,
+        jsc: {
+          target: 'es2020',
+          parser,
+          transform: {
+            useDefineForClassFields: true,
+            react: reactConfig,
+          },
+        },
+      }
+    }
+
+    const shouldEs5Transform =
+      options.es5 || (!process.env.VXRN_USE_BABEL_FOR_GENERATORS && asyncGeneratorRegex.test(code))
+
+    const opts: SWCOptions = shouldEs5Transform
+      ? {
+          jsc: {
+            parser,
+            target: 'es5',
+            transform: {
+              useDefineForClassFields: true,
+              react: reactConfig,
+            },
+          },
+        }
+      : {
+          ...(!options.forceJSX && { env: SWC_ENV }),
+          jsc: {
+            ...(options.forceJSX && { target: 'esnext' }),
+            parser,
+            transform: {
+              useDefineForClassFields: true,
+              react: reactConfig,
+            },
+          },
+        }
+
+    return {
+      sourceMaps: shouldSourceMap(),
+      module: {
+        importInterop: 'none',
+        type: 'nodenext',
+      },
+      ...(options.mode === 'serve-cjs' && {
+        module: {
+          importInterop: 'none',
+          type: 'commonjs',
+          strict: true,
+        },
+      }),
+      ...opts,
+    }
+  })()
+
+  const finalOptions = merge(
+    {
+      filename: id,
+      swcrc: false,
+      configFile: false,
+      ...transformOptions,
+    },
+    swcOptions || {}
+  ) satisfies SWCOptions
+
+  const result: Output = await (async () => {
+    try {
+      debug?.(`transformSWC ${id} using options:\n${JSON.stringify(finalOptions, null, 2)}`)
+
+      return await transform(code, finalOptions)
+    } catch (e: any) {
+      const message: string = e.message
+      const fileStartIndex = message.indexOf('╭─[')
+      if (fileStartIndex !== -1) {
+        const match = message.slice(fileStartIndex).match(/:(\d+):(\d+)]/)
+        if (match) {
+          e.line = match[1]
+          e.column = match[2]
+        }
+      }
+      throw e
+    }
+  })()
+
+  if (enableNativeCSS) {
+    if (result.code.includes(`createInteropElement`)) {
+      result.code = `import { createInteropElement } from 'react-native-css-interop/jsx-dev-runtime'\n${result.code}`
+    }
+  }
+
+  const shouldHMR = refresh && refreshContentRE.test(result.code)
+
+  // fix for node_modules that ship tsx but don't use type-specific imports
+  if (
+    options.fixNonTypeSpecificImports ||
+    (id.includes('node_modules') && parser.syntax === 'typescript')
+  ) {
+    // we need to keep fake objects for type exports
+    const typeExportsMatch = code.match(/^\s*export\s+type\s+([^\s]+)/gi)
+    if (typeExportsMatch) {
+      for (const typeExport of Array.from(typeExportsMatch)) {
+        const [_export, _type, name] = typeExport.split(/\s+/)
+        // FIXME: support `export { ... } from '...'`
+        if (name.startsWith('{')) continue
+
+        // FIXME: support `export type Type<T> = ...`
+        if (name.includes('<')) continue
+
+        // basic sanity check it isn't exported already
+        const alreadyExported = new RegExp(`export (const|let|class|function) ${name}\\s+`).test(
+          result.code
+        )
+
+        if (!alreadyExported) {
+          const fakeExport = `export let ${name} = {};`
+          console.info(
+            ` ⚠️ Fixing non-type-specifc import in node_module, this should be fixed upstream: ${fakeExport} in ${id}`
+          )
+          result.code += `\n${fakeExport}\n`
+        }
+      }
+    }
+  }
+
+  if (!result || options.noHMR || !shouldHMR) {
+    return result
+  }
+
+  wrapSourceInRefreshRuntime(id, result, options, shouldHMR)
+
+  // TODO bring back?
+  // if (result.map) {
+  //   const sourceMap: SourceMapPayload = JSON.parse(result.map)
+  //   sourceMap.mappings = ';;;;;;;;' + sourceMap.mappings
+  //   return { code: result.code, map: sourceMap }
+  // }
+
+  return { code: result.code }
+}
+
+const SWC_ENV = {
+  targets: {
+    node: '4',
+  },
+  // debug: true,
+  include: [],
+  // this breaks the uniswap app for any file with a ...spread
+  exclude: [
+    'transform-spread',
+    'transform-destructuring',
+    'transform-object-rest-spread',
+    // `transform-async-to-generator` is relying on `transform-destructuring`.
+    // If we exclude `transform-destructuring` but not `transform-async-to-generator`, the SWC binary will panic
+    // with error: `called `Option::unwrap()` on a `None` value`.
+    // See: https://github.com/swc-project/swc/blob/v1.7.14/crates/swc_ecma_compat_es2015/src/generator.rs#L703-L705
+    'transform-async-to-generator',
+    'transform-regenerator', // Similar to above
+  ],
+} satisfies SWCOptions['env']
+
+const refreshContentRE = /\$Refresh(?:Reg|Sig)\$\(/
+
+function shouldSourceMap() {
+  return process.env.VXRN_ENABLE_SOURCE_MAP === '1'
+}
+
+function wrapSourceInRefreshRuntime(
+  id: string,
+  result: Output,
+  options: Options,
+  shouldHMR: boolean
+) {
+  if (options.environment === 'client' || options.environment === 'ssr') {
+    return wrapSourceInRefreshRuntimeWeb(id, result, shouldHMR)
+  }
+  return wrapSourceInRefreshRuntimeNative(id, result, options, shouldHMR)
+}
+
+function wrapSourceInRefreshRuntimeWeb(id: string, result: Output, shouldHMR: boolean) {
+  const sourceMap: SourceMapPayload = JSON.parse(result.map!)
+  sourceMap.mappings = ';;' + sourceMap.mappings
+
+  result.code = `import * as RefreshRuntime from "${runtimePublicPath}";
+
+${result.code}`
+
+  if (shouldHMR) {
+    sourceMap.mappings = ';;;;;;' + sourceMap.mappings
+    result.code = `if (!window.$RefreshReg$) throw new Error("React refresh preamble was not loaded. Something is wrong.");
+const prevRefreshReg = window.$RefreshReg$;
+const prevRefreshSig = window.$RefreshSig$;
+window.$RefreshReg$ = RefreshRuntime.getRefreshReg("${id}");
+window.$RefreshSig$ = RefreshRuntime.createSignatureFunctionForTransform;
+
+${result.code}
+
+window.$RefreshReg$ = prevRefreshReg;
+window.$RefreshSig$ = prevRefreshSig;
+`
+  }
+
+  result.code += `
+RefreshRuntime.__hmr_import(import.meta.url).then((currentExports) => {
+  RefreshRuntime.registerExportsForReactRefresh("${id}", currentExports);
+  import.meta.hot.accept((nextExports) => {
+    if (!nextExports) return;
+    const invalidateMessage = RefreshRuntime.validateRefreshBoundaryAndEnqueueUpdate("${id}", currentExports, nextExports);
+    if (invalidateMessage) import.meta.hot.invalidate(invalidateMessage);
+  });
+});
+`
+}
+
+function wrapSourceInRefreshRuntimeNative(
+  id: string,
+  result: Output,
+  options: Options,
+  shouldHMR: boolean
+) {
+  const prefixCode =
+    options.mode === 'build'
+      ? `
+  import 'react-native'
+  import 'react'
+  import '@vxrn/vite-native-client'
+  `
+      : ``
+
+  if (options.production) {
+    return `
+${prefixCode}
+module.url = '${id}'
+${result.code}
+`
+  }
+
+  if (shouldHMR) {
+    result.code = `const RefreshRuntime = __cachedModules["react-refresh/cjs/react-refresh-runtime.development"];
+  const prevRefreshReg = globalThis.$RefreshReg$;
+  const prevRefreshSig = globalThis.$RefreshSig$ || (() => {
+    console.info("no react refresh setup!")
+    return (x) => x
+  });
+  globalThis.$RefreshReg$ = (type, id) => RefreshRuntime.register(type, "${id}" + " " + id);
+  globalThis.$RefreshSig$ = RefreshRuntime.createSignatureFunctionForTransform;
+
+${prefixCode}
+
+  module.url = '${id}'
+  module.hot = createHotContext(module.url)
+
+${result.code}
+
+  if (module.hot) {
+    globalThis.$RefreshReg$ = prevRefreshReg;
+    globalThis.$RefreshSig$ = prevRefreshSig;
+    globalThis['lastHmrExports'] = JSON.stringify(Object.keys(exports))
+  }
+`
+  }
+
+  result.code = `${result.code}
+
+if (module.hot) {
+  if (module.hot.accept) {
+    module.hot.accept((nextExports) => {
+      RefreshRuntime.performReactRefresh()
+    });
+  }
+}`
+}
+
+function getParser(id: string, forceJSX = false) {
+  if (id.endsWith('one-entry-native')) {
+    return parsers['.tsx']
+  }
+
+  const extension = extname(id)
+  let parser: ParserConfig = !extension ? parsers['.js'] : parsers[extension]
+
+  if (extension === '.js') {
+    if (forceJSX) {
+      parser = parsers['.jsx']
+    }
+
+    if (id.includes('expo-modules-core')) {
+      parser = parsers['.jsx']
+    }
+  }
+
+  return parser
+}
+
+export const transformSWCStripJSX = async (id: string, code: string) => {
+  const parser = getParser(id)
+  if (!parser) return
+  return await transform(code, {
+    filename: id,
+    swcrc: false,
+    configFile: false,
+    sourceMaps: shouldSourceMap(),
+    jsc: {
+      target: 'es2019',
+      parser,
+      transform: {
+        useDefineForClassFields: true,
+        react: {
+          development: true,
+          runtime: 'automatic',
+          refresh: false,
+        },
+      },
+    },
+  })
+}

package/src/types.ts

@@ -0,0 +1,36 @@
+import type { Options as SWCOptions } from '@swc/core'
+
+export type Environment = 'ios' | 'android' | 'ssr' | 'client'
+
+export type Options = {
+  environment: Environment
+  mode: 'serve' | 'serve-cjs' | 'build'
+  forceJSX?: boolean
+  noHMR?: boolean
+  production?: boolean
+  fixNonTypeSpecificImports?: boolean
+  transform?: GetTransform
+}
+
+export type GetTransformProps = {
+  id: string
+  code: string
+  development: boolean
+  environment: Environment
+  reactForRNVersion: '18' | '19'
+}
+
+export type GetTransform = (props: GetTransformProps) => GetTransformResponse
+
+export type GetTransformResponse = boolean | 'babel' | 'swc' | TransformOptions
+
+export type TransformOptions = BabelTransformOptions | SWCTransformOptions
+
+export type SWCTransformOptions = {
+  transform: 'swc'
+} & SWCOptions
+
+export type BabelTransformOptions = {
+  transform: 'babel'
+  excludeDefaultPlugins?: boolean
+} & babel.TransformOptions

package/types/configure.d.ts

@@ -0,0 +1,10 @@
+import type { Environment } from './types';
+type Conf = {
+    enableReanimated?: boolean;
+    enableCompiler?: boolean | Environment[];
+    enableNativeCSS?: boolean;
+};
+export declare const configuration: Conf;
+export declare function configureVXRNCompilerPlugin(_: Conf): void;
+export {};
+//# sourceMappingURL=configure.d.ts.map

package/types/configure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"configure.d.ts","sourceRoot":"","sources":["../src/configure.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAE1C,KAAK,IAAI,GAAG;IACV,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,cAAc,CAAC,EAAE,OAAO,GAAG,WAAW,EAAE,CAAA;IACxC,eAAe,CAAC,EAAE,OAAO,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,aAAa,EAAE,IAI3B,CAAA;AAED,wBAAgB,2BAA2B,CAAC,CAAC,EAAE,IAAI,QAElD"}

package/types/constants.d.ts

@@ -0,0 +1,9 @@
+import type { ParserConfig } from '@swc/core';
+export declare const debug: (((...args: any[]) => any) & {
+    namespace: string;
+}) | undefined;
+export declare const runtimePublicPath = "/@react-refresh";
+export declare const asyncGeneratorRegex: RegExp;
+export declare const parsers: Record<string, ParserConfig>;
+export declare const validParsers: Set<string>;
+//# sourceMappingURL=constants.d.ts.map

package/types/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AAI7C,eAAO,MAAQ,KAAK;;cAA2C,CAAA;AAE/D,eAAO,MAAM,iBAAiB,oBAAoB,CAAA;AAElD,eAAO,MAAM,mBAAmB,QAA0C,CAAA;AAE1E,eAAO,MAAM,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAQhD,CAAA;AAED,eAAO,MAAM,YAAY,aAA6C,CAAA"}

package/types/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Adapted from https://github.com/vitejs/vite-plugin-react-swc/blob/main/src/index.ts
+ * to work on both native and web, and with reanimated and other babel fallbacks
+ */
+import type { PluginOption } from 'vite';
+import type { Options } from './types';
+export * from './configure';
+export * from './transformBabel';
+export * from './transformSWC';
+export type { GetTransform } from './types';
+export declare function createVXRNCompilerPlugin(optionsIn?: Partial<Options>): Promise<PluginOption[]>;
+//# sourceMappingURL=index.d.ts.map

package/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,OAAO,KAAK,EAAE,YAAY,EAAc,MAAM,MAAM,CAAA;AAIpD,OAAO,KAAK,EAAkC,OAAO,EAAE,MAAM,SAAS,CAAA;AAEtE,cAAc,aAAa,CAAA;AAC3B,cAAc,kBAAkB,CAAA;AAChC,cAAc,gBAAgB,CAAA;AAC9B,YAAY,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAE3C,wBAAsB,wBAAwB,CAC5C,SAAS,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,GAC3B,OAAO,CAAC,YAAY,EAAE,CAAC,CA+IzB"}

package/types/transformBabel.d.ts

@@ -0,0 +1,12 @@
+import babel from '@babel/core';
+import type { GetTransformProps, GetTransformResponse } from './types';
+type Props = GetTransformProps & {
+    userSetting?: GetTransformResponse;
+};
+export declare function getBabelOptions(props: Props): babel.TransformOptions | null;
+/**
+ * Transform input to mostly ES5 compatible code, keep ESM syntax, and transform generators.
+ */
+export declare function transformBabel(id: string, code: string, options: babel.TransformOptions): Promise<string>;
+export {};
+//# sourceMappingURL=transformBabel.d.ts.map

package/types/transformBabel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformBabel.d.ts","sourceRoot":"","sources":["../src/transformBabel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,aAAa,CAAA;AAI/B,OAAO,KAAK,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA;AAEtE,KAAK,KAAK,GAAG,iBAAiB,GAAG;IAC/B,WAAW,CAAC,EAAE,oBAAoB,CAAA;CACnC,CAAA;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAAC,gBAAgB,GAAG,IAAI,CAqB3E;AA0BD;;GAEG;AACH,wBAAsB,cAAc,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC,gBAAgB,mBA8B7F"}