@vxrn/compiler 1.25.5 → 1.25.7

package/dist/cjs/transformBabel.cjs

@@ -0,0 +1,269 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+// If the importer is in node compatibility mode or this is not an ESM
+// file that has been converted to a CommonJS file using a Babel-
+// compatible transform (i.e. "__esModule" has not been set), then set
+// "default" to the CommonJS "module.exports" for node compatibility.
+isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var transformBabel_exports = {};
+__export(transformBabel_exports, {
+  getBabelOptions: () => getBabelOptions,
+  transformBabel: () => transformBabel,
+  transformOxcReactCompiler: () => transformOxcReactCompiler
+});
+module.exports = __toCommonJS(transformBabel_exports);
+var import_node_path = require("node:path");
+var import_core = __toESM(require("@babel/core"), 1);
+var import_utils = require("@vxrn/utils");
+var import_babel_plugin_syntax_hermes_parser = __toESM(require("babel-plugin-syntax-hermes-parser"), 1);
+var import_vite = require("vite");
+var import_configure = require("./configure.cjs");
+var import_constants = require("./constants.cjs");
+function getBabelOptions(props) {
+  props = {
+    ...props,
+    id: (0, import_vite.normalizePath)(props.id.split("?")[0])
+  };
+  if (props.userSetting === "babel") {
+    return getOptions(props, true);
+  }
+  if (typeof props.userSetting === "undefined" || typeof props.userSetting === "object" && props.userSetting.transform === "babel") {
+    if (props.userSetting?.excludeDefaultPlugins) {
+      return props.userSetting;
+    }
+    return getOptions(props);
+  }
+  return null;
+}
+const getOptions = (props, force = false) => {
+  let plugins = [];
+  if (force || shouldBabelGenerators(props)) {
+    plugins = getBasePlugins(props);
+  }
+  const enableNativewind = import_configure.configuration.enableNativewind && (props.environment === "ios" || props.environment === "android") &&
+  // if reanimated gets wrapped in transform it causes circular dep issues
+  !/node_modules/.test(props.id) &&
+  // only needed for createElement calls, so be a bit conservative
+  props.code.includes("createElement");
+  if (enableNativewind) {
+    if (!props.id.includes("node_modules")) {
+      plugins.push((0, import_utils.resolvePath)("react-native-css-interop/dist/babel-plugin.js"));
+    }
+  }
+  if (enableNativewind || shouldBabelReanimated(props)) {
+    (0, import_constants.debug)?.(`Using babel worklets on file ${props.id}`);
+    plugins.push((0, import_utils.resolvePath)("react-native-worklets/plugin", props.projectRoot));
+  }
+  if (shouldBabelReactCompiler(props)) {
+    (0, import_constants.debug)?.(`Using babel react compiler on file`);
+    plugins.push(getBabelReactCompilerPlugin(props));
+  }
+  if (shouldBabelReactNativeCodegen(props)) {
+    (0, import_constants.debug)?.(`Using babel @react-native/babel-plugin-codegen on file`);
+    plugins.push("@react-native/babel-plugin-codegen");
+  }
+  if (plugins.length) {
+    return {
+      plugins
+    };
+  }
+  return null;
+};
+async function transformOxcReactCompiler(id, code, target) {
+  const {
+    transform
+  } = await import("oxc-transform-react");
+  const result = await transform(id, code, {
+    jsx: "preserve",
+    reactCompiler: {
+      target
+    }
+  });
+  if (result.fatal) {
+    throw new Error(`[vxrn:compiler] oxc react compiler failed on ${id}: ${(result.errors ?? []).map(e => e.message ?? String(e)).join(", ")}`);
+  }
+  if (result.errors?.length) {
+    (0, import_constants.debug)?.(`[compiler/bailout] ${id}: ${result.errors.map(e => e.message ?? String(e)).join(", ")}`);
+  }
+  return {
+    code: result.code,
+    map: void 0
+  };
+}
+async function transformBabel(id, code, options) {
+  const extension = (0, import_node_path.extname)(id);
+  const isTSX = extension === ".tsx";
+  const isTS = isTSX || extension === ".ts";
+  const babelOptions = {
+    filename: id,
+    compact: false,
+    babelrc: false,
+    configFile: false,
+    sourceMaps: false,
+    minified: false,
+    ...options,
+    presets: [isTS ? ["@babel/preset-typescript", {
+      isTSX,
+      allExtensions: isTSX
+    }] : "", ...(options.presets || [])].filter(Boolean),
+    // non-TS files use React Native's Flow dialect. RN's own component specs are
+    // Flow `.js` (`import type`, `codegenNativeComponent<T>(…)`, `(expr: Type)` casts).
+    // enable Hermes Flow parsing + stripping, mirroring the TypeScript preset above
+    // (`@react-native/babel-preset` uses the same parser for JS). without it babel
+    // can't parse current RN Flow syntax such as `call<T>(...) as HostComponent<T>`, so
+    // plugins like
+    // @react-native/babel-plugin-codegen silently fail on RN specs and the runtime
+    // "Codegen didn't run" warning fires. TS path is byte-identical (empty slice).
+    plugins: [...(isTS ? [] : [[import_babel_plugin_syntax_hermes_parser.default, {
+      parseLangTypes: "flow",
+      reactRuntimeTarget: "19"
+    }]]), ...(options.plugins || []), ...(isTS ? [] : ["@babel/plugin-transform-flow-strip-types"])]
+  };
+  try {
+    const out = await new Promise((res, rej) => {
+      import_core.default.transform(code, babelOptions, (err, result) => {
+        if (!result || err) {
+          return rej(err || "no res");
+        }
+        res(result);
+      });
+    });
+    return out;
+  } catch (err) {
+    if (err?.message?.includes("Could not find component config")) {
+      return;
+    }
+    console.error(`[vxrn:compiler] babel transform error`, err, `with options`, babelOptions);
+    console.error("code", code);
+    console.error("id", id);
+  }
+}
+const getBasePlugins = ({
+  development
+}) => [["@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
+}]];
+const NATIVE_COMPONENT_RE = /NativeComponent\.[jt]sx?$/;
+const SPEC_FILE_RE = /[/\\]specs?[/\\]/;
+const shouldBabelReactNativeCodegen = ({
+  id,
+  environment
+}) => {
+  return (environment === "ios" || environment === "android") && (NATIVE_COMPONENT_RE.test(id) || SPEC_FILE_RE.test(id));
+};
+const shouldBabelReactCompiler = props => {
+  if (props.environment === "ssr") {
+    return false;
+  }
+  if (!import_configure.configuration.enableCompiler) {
+    return false;
+  }
+  const {
+    enableCompiler
+  } = import_configure.configuration;
+  if (typeof enableCompiler === "object" && !Array.isArray(enableCompiler) && !(enableCompiler instanceof RegExp)) {
+    const isNative = props.environment === "ios" || props.environment === "android";
+    const filter = isNative ? enableCompiler.native : enableCompiler.web;
+    if (!filter) return false;
+    return applyCompilerFilter(filter, props);
+  }
+  if (typeof enableCompiler === "function") {
+    return enableCompiler(props.id, props.environment);
+  }
+  if (enableCompiler instanceof RegExp) {
+    return enableCompiler.test(props.id);
+  }
+  if (Array.isArray(enableCompiler)) {
+    if (!enableCompiler.includes(props.environment)) {
+      return false;
+    }
+  }
+  return applyDefaultFilters(props);
+};
+function applyCompilerFilter(filter, props) {
+  if (typeof filter === "function") {
+    return filter(props.id, props.environment);
+  }
+  if (filter instanceof RegExp) {
+    return filter.test(props.id);
+  }
+  if (filter === true) {
+    return applyDefaultFilters(props);
+  }
+  return false;
+}
+function applyDefaultFilters(props) {
+  if (!/(\.tsx?)$/.test(props.id)) return false;
+  if (props.id.includes("node_modules")) return false;
+  if (props.id.includes("+api.")) return false;
+  if (props.code.startsWith("// disable-compiler")) return false;
+  return true;
+}
+const getBabelReactCompilerPlugin = props => {
+  const target = props.reactForRNVersion === "18" && (props.environment === "ios" || props.environment === "android") ? "18" : "19";
+  return ["babel-plugin-react-compiler", {
+    target
+  }];
+};
+function shouldBabelGenerators({
+  code
+}) {
+  if (process.env.VXRN_USE_BABEL_FOR_GENERATORS) {
+    return import_constants.asyncGeneratorRegex.test(code);
+  }
+}
+const REANIMATED_AUTOWORKLETIZATION_KEYWORDS = ["worklet", "useAnimatedGestureHandler", "useAnimatedScrollHandler", "useFrameCallback", "useAnimatedStyle", "useAnimatedProps", "createAnimatedPropAdapter", "useDerivedValue", "useAnimatedReaction", "useWorkletCallback", "withTiming", "withSpring", "withDecay", "withRepeat", "runOnUI", "executeOnUIRuntimeSync"];
+const REANIMATED_REGEX = new RegExp(REANIMATED_AUTOWORKLETIZATION_KEYWORDS.join("|"));
+const REANIMATED_IGNORED_PATHS = [
+// Prebuilt/vendored react-native that shouldn't be transformed
+"react-native-prebuilt", "node_modules/.vxrn/react-native",
+// Known false positives - they mention worklet keywords in comments/strings but don't use them
+"node_modules/react/", "node_modules/react-dom/", "node_modules/react-native/", "node_modules/react-native-web/"];
+const REANIMATED_IGNORED_PATHS_REGEX = new RegExp(REANIMATED_IGNORED_PATHS.join("|"));
+function shouldBabelReanimated({
+  code,
+  id
+}) {
+  if (!import_configure.configuration.enableReanimated) {
+    return false;
+  }
+  if (REANIMATED_IGNORED_PATHS_REGEX.test(id)) {
+    return false;
+  }
+  if (REANIMATED_REGEX.test(code)) {
+    const location = id.includes("node_modules") ? "node_modules" : "user-code";
+    (0, import_constants.debug)?.(` \u{1FA84} [reanimated/${location}] ${(0, import_node_path.relative)(process.cwd(), id)}`);
+    return true;
+  }
+  return false;
+}

package/dist/cjs/transformBabel.test.cjs

@@ -0,0 +1,88 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+// If the importer is in node compatibility mode or this is not an ESM
+// file that has been converted to a CommonJS file using a Babel-
+// compatible transform (i.e. "__esModule" has not been set), then set
+// "default" to the CommonJS "module.exports" for node compatibility.
+isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_os = __toESM(require("node:os"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_vitest = require("vitest");
+var import_configure = require("./configure.cjs");
+var import_transformBabel = require("./transformBabel.cjs");
+(0, import_vitest.afterEach)(() => {
+  (0, import_configure.configureVXRNCompilerPlugin)({
+    enableReanimated: false
+  });
+});
+(0, import_vitest.describe)("getBabelOptions Worklets resolution", () => {
+  (0, import_vitest.it)("uses the app-installed Worklets Babel plugin", () => {
+    const projectRoot = import_node_fs.default.realpathSync(import_node_fs.default.mkdtempSync(import_node_path.default.join(import_node_os.default.tmpdir(), "vxrn-worklets-")));
+    const packageRoot = import_node_path.default.join(projectRoot, "node_modules", "react-native-worklets");
+    const pluginPath = import_node_path.default.join(packageRoot, "plugin.js");
+    import_node_fs.default.mkdirSync(packageRoot, {
+      recursive: true
+    });
+    import_node_fs.default.writeFileSync(import_node_path.default.join(packageRoot, "package.json"), JSON.stringify({
+      name: "react-native-worklets",
+      version: "99.0.0"
+    }));
+    import_node_fs.default.writeFileSync(pluginPath, "module.exports = () => ({ visitor: {} })");
+    try {
+      (0, import_configure.configureVXRNCompilerPlugin)({
+        enableReanimated: true
+      });
+      const options = (0, import_transformBabel.getBabelOptions)({
+        id: import_node_path.default.join(projectRoot, "input.ts"),
+        code: `export const worklet = () => {
+          'worklet'
+        }`,
+        development: true,
+        environment: "ios",
+        reactForRNVersion: "19",
+        projectRoot
+      });
+      (0, import_vitest.expect)(options?.plugins).toContain(pluginPath);
+    } finally {
+      import_node_fs.default.rmSync(projectRoot, {
+        recursive: true,
+        force: true
+      });
+    }
+  });
+});
+(0, import_vitest.describe)("transformBabel Flow parsing", () => {
+  (0, import_vitest.it)("parses and strips React Native Flow as-casts", async () => {
+    const result = await (0, import_transformBabel.transformBabel)("/project/VirtualViewNativeComponent.js", `
+        // @flow strict-local
+        import type { HostComponent } from './HostComponent'
+        import codegenNativeComponent from './codegenNativeComponent'
+
+        type Props = $ReadOnly<{ enabled?: boolean }>
+
+        export default codegenNativeComponent<Props>('VirtualView') as HostComponent<Props>
+      `, {
+      plugins: []
+    });
+    (0, import_vitest.expect)(result?.code).toContain("codegenNativeComponent('VirtualView')");
+    (0, import_vitest.expect)(result?.code).not.toContain("HostComponent");
+  });
+});

package/dist/cjs/transformSWC.cjs

@@ -0,0 +1,318 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var transformSWC_exports = {};
+__export(transformSWC_exports, {
+  transformSWC: () => transformSWC,
+  transformSWCStripJSX: () => transformSWCStripJSX
+});
+module.exports = __toCommonJS(transformSWC_exports);
+var import_node_path = require("node:path");
+var import_core = require("@swc/core");
+var import_ts_deepmerge = require("ts-deepmerge");
+var import_vite = require("vite");
+var import_configure = require("./configure.cjs");
+var import_constants = require("./constants.cjs");
+const ignoreId = /node_modules\/(\.vite|vite)\//;
+async function transformSWC(id, code, options, swcOptions) {
+  id = (0, import_vite.normalizePath)(id.split("?")[0]).replace((0, import_vite.normalizePath)(process.cwd()), "");
+  if (ignoreId.test(id)) {
+    return;
+  }
+  if (id === import_constants.runtimePublicPath) {
+    return;
+  }
+  const parser = getParser(id, options.forceJSX);
+  if (!parser) {
+    return;
+  }
+  const refresh = options.environment !== "ssr" && !options.production && !options.noHMR && !options.forceJSX && !id.includes("node_modules");
+  const reactConfig = {
+    refresh,
+    development: !options.forceJSX && !options.production,
+    runtime: "automatic",
+    importSource: "react",
+    ...(import_configure.configuration.enableNativewind && !id.includes("node_modules") ? {
+      importSource: "nativewind"
+      // pragma: 'createInteropElement',
+      // pragmaFrag: '_InteropFragment',
+      // swc doesnt actually change the import right
+      // runtime: 'classic',
+    } : {})
+  };
+  const transformOptions = (() => {
+    if (options.environment === "client" || options.environment === "ssr") {
+      return {
+        sourceMaps: shouldSourceMap(),
+        jsc: {
+          target: "es2020",
+          parser,
+          transform: {
+            useDefineForClassFields: true,
+            react: reactConfig
+          }
+        }
+      };
+    }
+    const shouldEs5Transform = options.es5 || !process.env.VXRN_USE_BABEL_FOR_GENERATORS && import_constants.asyncGeneratorRegex.test(code);
+    const opts = 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 = (0, import_ts_deepmerge.merge)({
+    filename: id,
+    swcrc: false,
+    configFile: false,
+    ...transformOptions
+  }, swcOptions || {});
+  const result = await (async () => {
+    try {
+      (0, import_constants.debug)?.(`transformSWC ${id} using options:
+${JSON.stringify(finalOptions, null, 2)}`);
+      return await (0, import_core.transform)(code, finalOptions);
+    } catch (e) {
+      const message = e.message;
+      const fileStartIndex = message.indexOf("\u256D\u2500[");
+      if (fileStartIndex !== -1) {
+        const match = message.slice(fileStartIndex).match(/:(\d+):(\d+)]/);
+        if (match) {
+          e.line = match[1];
+          e.column = match[2];
+        }
+      }
+      throw e;
+    }
+  })();
+  if (import_configure.configuration.enableNativeCSS) {
+    if (result.code.includes(`createInteropElement(`)) {
+      result.code = `import { createInteropElement, Fragment as _InteropFragment } from 'react-native-css-interop/jsx-dev-runtime'
+${result.code}`;
+    }
+  }
+  const hasRefreshRuntime = refresh && refreshContentRE.test(result.code);
+  if (options.fixNonTypeSpecificImports || id.includes("node_modules") && parser.syntax === "typescript") {
+    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+/);
+        if (name.startsWith("{")) continue;
+        if (name.includes("<")) continue;
+        const alreadyExported = new RegExp(`export (const|let|class|function) ${name}\\s+`).test(result.code);
+        if (!alreadyExported) {
+          const fakeExport = `export let ${name} = {};`;
+          console.info(` \u26A0\uFE0F Fixing non-type-specific import in node_module, this should be fixed upstream: ${fakeExport} in ${id}`);
+          result.code += `
+${fakeExport}
+`;
+        }
+      }
+    }
+  }
+  if (result && !options.production && !options.noHMR) {
+    return wrapSourceInRefreshRuntime(id, result, options, hasRefreshRuntime);
+  }
+  return result;
+}
+function wrapSourceInRefreshRuntime(id, result, options, hasRefreshRuntime) {
+  if (options.environment === "ssr") {
+    return result;
+  }
+  if (options.environment === "client") {
+    return wrapSourceInRefreshRuntimeWeb(id, result, hasRefreshRuntime);
+  }
+  return wrapSourceInRefreshRuntimeNative(id, result, options, hasRefreshRuntime);
+}
+function wrapSourceInRefreshRuntimeWeb(id, result, hasRefreshRuntime) {
+  const sourceMap = result.map ? JSON.parse(result.map) : void 0;
+  if (sourceMap) {
+    sourceMap.mappings = ";;" + sourceMap.mappings;
+  }
+  result.code = `import * as RefreshRuntime from "${import_constants.runtimePublicPath}";
+
+${result.code}`;
+  if (hasRefreshRuntime) {
+    if (sourceMap) {
+      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);
+  });
+});
+`;
+  return {
+    code: result.code,
+    map: sourceMap
+  };
+}
+function wrapSourceInRefreshRuntimeNative(id, result, options, hasRefreshRuntime) {
+  const postfixCode = `if (module.hot) {
+  if (module.hot.accept) {
+    module.hot.accept((nextExports) => {
+      RefreshRuntime.performReactRefresh()
+    });
+  }
+}`;
+  if (hasRefreshRuntime) {
+    const prefixCode = `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;
+module.url = '${id}'
+module.hot = createHotContext(module.url)`;
+    const sourceMap = result.map ? JSON.parse(result.map) : void 0;
+    if (sourceMap) {
+      const prefixLen = prefixCode.split("\n").length + 1;
+      sourceMap.mappings = new Array(prefixLen).fill(";").join("") + sourceMap.mappings;
+    }
+    return {
+      code: `${prefixCode}
+${result.code}
+
+if (module.hot) {
+  globalThis.$RefreshReg$ = prevRefreshReg;
+  globalThis.$RefreshSig$ = prevRefreshSig;
+  globalThis['lastHmrExports'] = JSON.stringify(Object.keys(exports))
+}
+
+${postfixCode}
+`,
+      map: sourceMap
+    };
+  }
+  result.code += postfixCode;
+  return result;
+}
+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
+  ]
+};
+const refreshContentRE = /\$Refresh(?:Reg|Sig)\$\(/;
+function shouldSourceMap() {
+  return process.env.VXRN_ENABLE_SOURCE_MAP === "1";
+}
+function getParser(id, forceJSX = false) {
+  if (id.endsWith("one-entry-native")) {
+    return import_constants.parsers[".tsx"];
+  }
+  const extension = (0, import_node_path.extname)(id);
+  let parser = !extension ? import_constants.parsers[".js"] : import_constants.parsers[extension];
+  if (extension === ".js" || extension === ".mjs") {
+    if (forceJSX) {
+      parser = import_constants.parsers[".jsx"];
+    }
+    if (id.includes("expo-modules-core")) {
+      parser = import_constants.parsers[".jsx"];
+    }
+  }
+  return parser;
+}
+const transformSWCStripJSX = async (id, code) => {
+  const parser = getParser(id);
+  if (!parser) return;
+  return await (0, import_core.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/dist/cjs/types.cjs

@@ -0,0 +1,18 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);