vxrn 0.1.50 → 0.1.52

package/dist/esm/utils/readVXRNConfig.native.js

@@ -1,6 +1,6 @@
 import FSExtra from "fs-extra";
-import { createServer } from "vite";
-import jiti from "jiti";
+import { join } from "node:path";
+import { build } from "esbuild";
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
   try {
     var info = gen[key](arg), value = info.value;
@@ -124,7 +124,7 @@ function readVXRNConfig() {
 }
 function _readVXRNConfig() {
   return _readVXRNConfig = _async_to_generator(function() {
-    var requireFile, userConfig, _userConfig_default, vite, userConfig1, _userConfig_default1, err;
+    var outfile, exportedConfig, err;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         case 0:
@@ -138,51 +138,49 @@ function _readVXRNConfig() {
               2,
               {}
             ];
-          if (process.env.VXRN_CJS)
-            return requireFile = jiti(process.cwd(), {
-              esmResolve: !0
-            }), userConfig = requireFile("./vxrn.config.ts"), [
-              2,
-              resolveOptionalAsyncFunction((_userConfig_default = userConfig == null ? void 0 : userConfig.default) !== null && _userConfig_default !== void 0 ? _userConfig_default : {})
-            ];
-          _state.label = 2;
+          outfile = join(process.cwd(), "vxrn.config.js"), _state.label = 2;
         case 2:
           return _state.trys.push([
             2,
             6,
-            ,
-            7
+            7,
+            8
           ]), [
             4,
-            createServer({
-              logLevel: "silent",
-              appType: "custom"
+            build({
+              entryPoints: [
+                "vxrn.config.ts"
+              ],
+              bundle: !1,
+              outfile,
+              platform: "node",
+              format: "esm",
+              sourcemap: !1,
+              minify: !1
             })
           ];
         case 3:
-          return vite = _state.sent(), [
+          return _state.sent(), [
             4,
-            vite.ssrLoadModule("./vxrn.config.ts", {
-              fixStacktrace: !0
-            })
+            import(outfile)
           ];
         case 4:
-          return userConfig1 = _state.sent(), [
+          return exportedConfig = _state.sent().default, [
             4,
-            vite.close()
+            resolveOptionalAsyncFunction(exportedConfig)
           ];
         case 5:
-          return _state.sent(), [
+          return [
             2,
-            resolveOptionalAsyncFunction((_userConfig_default1 = userConfig1 == null ? void 0 : userConfig1.default) !== null && _userConfig_default1 !== void 0 ? _userConfig_default1 : {})
+            _state.sent()
           ];
         case 6:
-          throw err = _state.sent(), console.info(` [vxrn] Error loading config via ESM:
-
-`.concat(err.stack, `
-    
- To load as CommonJS, set VXRN_CJS=1`)), err;
+          throw err = _state.sent(), console.error(" [vxrn] Error building vxrn.config.ts"), err;
         case 7:
+          return FSExtra.removeSync(outfile), [
+            7
+          ];
+        case 8:
           return [
             2
           ];
@@ -194,27 +192,84 @@ function resolveOptionalAsyncFunction(value) {
   return _resolveOptionalAsyncFunction.apply(this, arguments);
 }
 function _resolveOptionalAsyncFunction() {
-  return _resolveOptionalAsyncFunction = _async_to_generator(function(value) {
-    return _ts_generator(this, function(_state) {
-      switch (_state.label) {
-        case 0:
-          return typeof value == "function" && (value = value()), _instanceof(value, Promise) ? [
-            4,
-            value
-          ] : [
-            3,
-            2
-          ];
-        case 1:
-          value = _state.sent(), _state.label = 2;
-        case 2:
-          return [
-            2,
-            value
-          ];
-      }
-    });
-  }), _resolveOptionalAsyncFunction.apply(this, arguments);
+  return _resolveOptionalAsyncFunction = _async_to_generator(
+    function(value) {
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            return typeof value == "function" && (value = value()), _instanceof(value, Promise) ? [
+              4,
+              value
+            ] : [
+              3,
+              2
+            ];
+          case 1:
+            value = _state.sent(), _state.label = 2;
+          case 2:
+            return [
+              2,
+              value
+            ];
+        }
+      });
+    }
+    // // vite version:
+    // import FSExtra from 'fs-extra'
+    // import type { VXRNConfig } from '../types'
+    // import { join } from 'node:path'
+    // import { build } from 'vite'
+    // export async function readVXRNConfig(): Promise<VXRNConfig> {
+    //   if (!(await FSExtra.pathExists('vxrn.config.ts'))) {
+    //     return {}
+    //   }
+    //   const outfile = join(process.cwd(), 'vxrn.config.js')
+    //   try {
+    //     // output to same place so paths and relative things work
+    //     // build using vite:
+    //     await build({
+    //       logLevel: 'silent',
+    //       build: {
+    //         lib: {
+    //           entry: 'vxrn.config.ts',
+    //           formats: ['es'],
+    //           fileName: () => 'vxrn.config.js',
+    //         },
+    //         rollupOptions: {
+    //           external: (id) => {
+    //             if (id.includes('vxrn')) {
+    //               return false
+    //             }
+    //             // exclude node_modules:
+    //             return !id.startsWith('.') && !id.startsWith('/')
+    //           },
+    //         },
+    //         outDir: process.cwd(),
+    //         copyPublicDir: false,
+    //         assetsDir: '',
+    //         minify: false,
+    //         emptyOutDir: false,
+    //       },
+    //     })
+    //     const exportedConfig = (await import(outfile)).default
+    //     return await resolveOptionalAsyncFunction(exportedConfig)
+    //   } catch (err) {
+    //     console.error(` [vxrn] Error building vxrn.config.ts`)
+    //     throw err
+    //   } finally {
+    //     // FSExtra.removeSync(outfile)
+    //   }
+    // }
+    // async function resolveOptionalAsyncFunction(value: any) {
+    //   if (typeof value === 'function') {
+    //     value = value()
+    //   }
+    //   if (value instanceof Promise) {
+    //     value = await value
+    //   }
+    //   return value
+    // }
+  ), _resolveOptionalAsyncFunction.apply(this, arguments);
 }
 export {
   readVXRNConfig

package/dist/esm/utils/readVXRNConfig.native.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../../src/utils/Users/n8/vxrn/packages/vxrn/src/utils/readVXRNConfig.ts"],
-  "mappings": "AAAA,OAAOA,aAAa;AAEpB,SAASC,oBAAoB;AAC7B,OAAOC,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEjB,SAAsBC,iBAAAA;SAAAA,gBAAAA,MAAAA,MAAAA,SAAAA;;SAAAA,kBAAAA;AAAAA,2BAAf,oBAAA,WAAA;QAMGC,aAGAC,YAC8BA,qBAM9BC,MAKAD,aAK8BA,sBAC7BE;;;;AA1BH,iBAAA;;YAAMP,QAAQQ,WAAW,gBAAA;;;AAA/B,cAAI,CAAE,OAAA,KAAA;AACJ,mBAAA;;cAAO,CAAC;;AAGV,cAAIC,QAAQC,IAAIC;AACRP,iCAAcF,KAAKO,QAAQG,IAAG,GAAI;cACtCC,YAAY;YACd,CAAA,GACMR,aAAaD,YAAY,kBAAA,GAC/B;;cAAOU,8BAA6BT,sBAAAA,cAAAA,OAAAA,SAAAA,WAAYU,aAAO,QAAnBV,wBAAAA,SAAAA,sBAAuB,CAAC,CAAA;;;;;;;;;cAM/C;;YAAMJ,aAAa;cAC9Be,UAAU;cACVC,SAAS;YACX,CAAA;;;AAHMX,wBAAO,OAAA,KAAA,GAKM;;YAAMA,KAAKY,cAAc,oBAAoB;cAC9DC,eAAe;YACjB,CAAA;;;AAFMd,+BAAa,OAAA,KAAA,GAInB;;YAAMC,KAAKc,MAAK;;;AAAhB,wBAAA,KAAA,GACA;;YAAON,8BAA6BT,uBAAAA,eAAAA,OAAAA,SAAAA,YAAYU,aAAO,QAAnBV,yBAAAA,SAAAA,uBAAuB,CAAC,CAAA;;;AACrDE,sBAAAA,OAAAA,KAAAA,GACPc,QAAQC,KAAM;;EAEN,OAAVf,IAAIgB,OAAM;;qCAAA,CAAA,GAGFhB;;;;;;;EAEV,CAAA,GAnCsBJ,gBAAAA,MAAAA,MAAAA,SAAAA;;SAqCPW,6BAA6BU,OAAU;SAAvCV,8BAAAA,MAAAA,MAAAA,SAAAA;;SAAAA,gCAAAA;AAAAA,yCAAf,oBAAA,SAA4CU,OAAU;;;;iBAChD,OAAOA,SAAU,eACnBA,QAAQA,MAAAA,IAED,YAALA,OAAiBC,OAAAA,IACX;;YAAMD;cADZA;;;;;AACFA,kBAAQ,OAAA,KAAA;;AAEV,iBAAA;;YAAOA;;;;EACT,CAAA,GAReV,8BAAAA,MAAAA,MAAAA,SAAAA;;",
-  "names": ["FSExtra", "createServer", "jiti", "readVXRNConfig", "requireFile", "userConfig", "vite", "err", "pathExists", "process", "env", "VXRN_CJS", "cwd", "esmResolve", "resolveOptionalAsyncFunction", "default", "logLevel", "appType", "ssrLoadModule", "fixStacktrace", "close", "console", "info", "stack", "value", "Promise"]
+  "mappings": "AAAA,OAAOA,aAAa;AAEpB,SAASC,YAAY;AACrB,SAASC,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEtB,SAAsBC,iBAAAA;SAAAA,gBAAAA,MAAAA,MAAAA,SAAAA;;SAAAA,kBAAAA;AAAAA,2BAAf,oBAAA,WAAA;QAKCC,SAcEC,gBAGCC;;;;AArBH,iBAAA;;YAAMN,QAAQO,WAAW,gBAAA;;;AAA/B,cAAI,CAAE,OAAA,KAAA;AACJ,mBAAA;;cAAO,CAAC;;AAGJH,oBAAUH,KAAKO,QAAQC,IAAG,GAAI,gBAAA;;;;;;;cAIlC;;YAAMP,MAAM;cACVQ,aAAW;gBAAG;;cACdC,QAAQ;cACRP;cACAQ,UAAU;cACVC,QAAQ;cACRC,WAAW;cACXC,QAAQ;YACV,CAAA;;;AARA,wBAAA,KAAA,GAUwB;;YAAM,OAAOX;;;AAA/BC,kCAAkB,OAAA,KAAA,EAAuBW,SAExC;;YAAMC,6BAA6BZ,cAAAA;;;AAA1C,iBAAA;;YAAO,OAAA,KAAA;;;AACAC,sBAAAA,OAAAA,KAAAA,GACPY,QAAQC,MAAO,uCAAA,GACTb;;AAENN,yBAAQoB,WAAWhB,OAAAA;;;;;;;;;EAEvB,CAAA,GA5BsBD,gBAAAA,MAAAA,MAAAA,SAAAA;;SA8BPc,6BAA6BI,OAAU;SAAvCJ,8BAAAA,MAAAA,MAAAA,SAAAA;;SAAAA,gCAAAA;AAAAA,yCAAf;IAAA,SAA4CI,OAAU;;;;mBAChD,OAAOA,SAAU,eACnBA,QAAQA,MAAAA,IAED,YAALA,OAAiBC,OAAAA,IACX;;cAAMD;gBADZA;;;;;AACFA,oBAAQ,OAAA,KAAA;;AAEV,mBAAA;;cAAOA;;;;IACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAReJ,8BAAAA,MAAAA,MAAAA,SAAAA;;",
+  "names": ["FSExtra", "join", "build", "readVXRNConfig", "outfile", "exportedConfig", "err", "pathExists", "process", "cwd", "entryPoints", "bundle", "platform", "format", "sourcemap", "minify", "default", "resolveOptionalAsyncFunction", "console", "error", "removeSync", "value", "Promise"]
 }

package/dist/esm/utils/resolveFile.js

@@ -0,0 +1,12 @@
+import { resolve as importMetaResolve } from "import-meta-resolve";
+const resolveFile = (path) => {
+  try {
+    return importMetaResolve(path, import.meta.url).replace("file://", "");
+  } catch {
+    return require.resolve(path);
+  }
+};
+export {
+  resolveFile
+};
+//# sourceMappingURL=resolveFile.js.map

package/dist/esm/utils/resolveFile.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/resolveFile.ts"],
+  "mappings": "AAAA,SAAS,WAAW,yBAAyB;AAEtC,MAAM,cAAc,CAAC,SAAiB;AAC3C,MAAI;AACF,WAAO,kBAAkB,MAAM,YAAY,GAAG,EAAE,QAAQ,WAAW,EAAE;AAAA,EACvE,QAAQ;AACN,WAAO,QAAQ,QAAQ,IAAI;AAAA,EAC7B;AACF;",
+  "names": []
+}

package/dist/esm/utils/resolveFile.mjs

@@ -0,0 +1,9 @@
+import { resolve as importMetaResolve } from "import-meta-resolve";
+const resolveFile = path => {
+  try {
+    return importMetaResolve(path, import.meta.url).replace("file://", "");
+  } catch {
+    return require.resolve(path);
+  }
+};
+export { resolveFile };

package/dist/esm/utils/resolveFile.native.js

@@ -0,0 +1,12 @@
+import { resolve as importMetaResolve } from "import-meta-resolve";
+var resolveFile = function(path) {
+  try {
+    return importMetaResolve(path, import.meta.url).replace("file://", "");
+  } catch {
+    return require.resolve(path);
+  }
+};
+export {
+  resolveFile
+};
+//# sourceMappingURL=resolveFile.js.map

package/dist/esm/utils/resolveFile.native.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/Users/n8/vxrn/packages/vxrn/src/utils/resolveFile.ts"],
+  "mappings": "AAAA,SAASA,WAAWC,yBAAyB;AAEtC,IAAMC,cAAc,SAACC,MAAAA;AAC1B,MAAI;AACF,WAAOF,kBAAkBE,MAAM,YAAYC,GAAG,EAAEC,QAAQ,WAAW,EAAA;EACrE,QAAQ;AACN,WAAOC,QAAQN,QAAQG,IAAAA;EACzB;AACF;",
+  "names": ["resolve", "importMetaResolve", "resolveFile", "path", "url", "replace", "require"]
+}

package/dist/esm/utils/swapPrebuiltReactModules.js

@@ -0,0 +1,89 @@
+import { readFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { buildReact, buildReactJSX, buildReactNative } from "@vxrn/react-native-prebuilt";
+import { resolveFile } from "./resolveFile";
+import FSExtra from "fs-extra";
+import { isBuildingNativeBundle } from "./isBuildingNativeBundle";
+async function swapPrebuiltReactModules(cacheDir) {
+  const prebuilds = {
+    reactJSX: join(cacheDir, "react-jsx-runtime.js"),
+    react: join(cacheDir, "react.js"),
+    reactNative: join(cacheDir, "react-native.js")
+  };
+  await FSExtra.pathExists(prebuilds.reactNative) || (console.info("Pre-building react, react-native react/jsx-runtime (one time cost)..."), await Promise.all([
+    buildReactNative({
+      entryPoints: [resolveFile("react-native")],
+      outfile: prebuilds.reactNative
+    }),
+    buildReact({
+      entryPoints: [resolveFile("react")],
+      outfile: prebuilds.react
+    }),
+    buildReactJSX({
+      entryPoints: [resolveFile("react/jsx-dev-runtime")],
+      outfile: prebuilds.reactJSX
+    })
+  ]));
+  const jsxRuntime = {
+    // alias: 'virtual:react-jsx',
+    alias: prebuilds.reactJSX,
+    contents: await readFile(prebuilds.reactJSX, "utf-8")
+  }, virtualModules = {
+    "react-native": {
+      // alias: 'virtual:react-native',
+      alias: prebuilds.reactNative,
+      contents: await readFile(prebuilds.reactNative, "utf-8")
+    },
+    react: {
+      // alias: 'virtual:react',
+      alias: prebuilds.react,
+      contents: await readFile(prebuilds.react, "utf-8")
+    },
+    "react/jsx-runtime": jsxRuntime,
+    "react/jsx-dev-runtime": jsxRuntime
+  };
+  return {
+    name: "swap-react-native",
+    enforce: "pre",
+    resolveId(id, importer = "") {
+      if (id.startsWith("react-native/Libraries"))
+        return `virtual:rn-internals:${id}`;
+      if (id === "react-native-web")
+        return prebuilds.reactNative;
+      for (const targetId in virtualModules)
+        if (id === targetId || id.includes(`node_modules/${targetId}/`))
+          return virtualModules[targetId].alias;
+      if (isBuildingNativeBundle && id[0] === ".") {
+        const absolutePath = resolve(dirname(importer), id), nativePath = absolutePath.replace(/(.m?js)/, ".native.js");
+        if (nativePath === id)
+          return;
+        try {
+          const directoryPath = absolutePath + "/index.native.js", directoryNonNativePath = absolutePath + "/index.js";
+          if (FSExtra.pathExistsSync(directoryPath))
+            return directoryPath;
+          if (FSExtra.pathExistsSync(directoryNonNativePath))
+            return directoryNonNativePath;
+          if (FSExtra.pathExistsSync(nativePath))
+            return nativePath;
+        } catch (err) {
+          console.warn("error probably fine", err);
+        }
+      }
+    },
+    load(id) {
+      if (id.startsWith("virtual:rn-internals"))
+        return `const ___val = __cachedModules["${id.replace("virtual:rn-internals:", "")}"]
+        const ___defaultVal = ___val ? ___val.default || ___val : ___val
+        export default ___defaultVal`;
+      for (const targetId in virtualModules) {
+        const info = virtualModules[targetId];
+        if (id === info.alias)
+          return info.contents;
+      }
+    }
+  };
+}
+export {
+  swapPrebuiltReactModules
+};
+//# sourceMappingURL=swapPrebuiltReactModules.js.map

package/dist/esm/utils/swapPrebuiltReactModules.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/swapPrebuiltReactModules.ts"],
+  "mappings": "AAAA,SAAS,gBAAgB;AACzB,SAAS,SAAS,MAAM,eAAe;AACvC,SAAS,YAAY,eAAe,wBAAwB;AAE5D,SAAS,mBAAmB;AAC5B,OAAO,aAAa;AACpB,SAAS,8BAA8B;AAKvC,eAAsB,yBAAyB,UAAkB;AAC/D,QAAM,YAAY;AAAA,IAChB,UAAU,KAAK,UAAU,sBAAsB;AAAA,IAC/C,OAAO,KAAK,UAAU,UAAU;AAAA,IAChC,aAAa,KAAK,UAAU,iBAAiB;AAAA,EAC/C;AAEA,EAAM,MAAM,QAAQ,WAAW,UAAU,WAAW,MAClD,QAAQ,KAAK,uEAAuE,GACpF,MAAM,QAAQ,IAAI;AAAA,IAChB,iBAAiB;AAAA,MACf,aAAa,CAAC,YAAY,cAAc,CAAC;AAAA,MACzC,SAAS,UAAU;AAAA,IACrB,CAAC;AAAA,IACD,WAAW;AAAA,MACT,aAAa,CAAC,YAAY,OAAO,CAAC;AAAA,MAClC,SAAS,UAAU;AAAA,IACrB,CAAC;AAAA,IACD,cAAc;AAAA,MACZ,aAAa,CAAC,YAAY,uBAAuB,CAAC;AAAA,MAClD,SAAS,UAAU;AAAA,IACrB,CAAC;AAAA,EACH,CAAC;AAIH,QAAM,aAAa;AAAA;AAAA,IAEjB,OAAO,UAAU;AAAA,IACjB,UAAU,MAAM,SAAS,UAAU,UAAU,OAAO;AAAA,EACtD,GAEM,iBAAiB;AAAA,IACrB,gBAAgB;AAAA;AAAA,MAEd,OAAO,UAAU;AAAA,MACjB,UAAU,MAAM,SAAS,UAAU,aAAa,OAAO;AAAA,IACzD;AAAA,IACA,OAAO;AAAA;AAAA,MAEL,OAAO,UAAU;AAAA,MACjB,UAAU,MAAM,SAAS,UAAU,OAAO,OAAO;AAAA,IACnD;AAAA,IACA,qBAAqB;AAAA,IACrB,yBAAyB;AAAA,EAC3B;AAEA,SAAO;AAAA,IACL,MAAM;AAAA,IACN,SAAS;AAAA,IAET,UAAU,IAAI,WAAW,IAAI;AAC3B,UAAI,GAAG,WAAW,wBAAwB;AACxC,eAAO,wBAAwB,EAAE;AAInC,UAAI,OAAO;AACT,eAAO,UAAU;AAGnB,iBAAW,YAAY;AACrB,YAAI,OAAO,YAAY,GAAG,SAAS,gBAAgB,QAAQ,GAAG;AAG5D,iBAFa,eAAe,QAAQ,EAExB;AAQhB,UAAI,0BACE,GAAG,CAAC,MAAM,KAAK;AACjB,cAAM,eAAe,QAAQ,QAAQ,QAAQ,GAAG,EAAE,GAC5C,aAAa,aAAa,QAAQ,WAAW,YAAY;AAC/D,YAAI,eAAe;AAAI;AACvB,YAAI;AACF,gBAAM,gBAAgB,eAAe,oBAC/B,yBAAyB,eAAe;AAC9C,cAAI,QAAQ,eAAe,aAAa;AACtC,mBAAO;AAET,cAAI,QAAQ,eAAe,sBAAsB;AAC/C,mBAAO;AAET,cAAI,QAAQ,eAAe,UAAU;AACnC,mBAAO;AAAA,QAEX,SAAS,KAAK;AACZ,kBAAQ,KAAK,uBAAuB,GAAG;AAAA,QACzC;AAAA,MACF;AAAA,IAEJ;AAAA,IAEA,KAAK,IAAI;AACP,UAAI,GAAG,WAAW,sBAAsB;AAKtC,eAHU,mCADI,GAAG,QAAQ,yBAAyB,EAAE,CACF;AAAA;AAAA;AAMpD,iBAAW,YAAY,gBAAgB;AACrC,cAAM,OAAO,eAAe,QAAuC;AACnE,YAAI,OAAO,KAAK;AACd,iBAAO,KAAK;AAAA,MAEhB;AAAA,IACF;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/esm/utils/swapPrebuiltReactModules.mjs

@@ -0,0 +1,75 @@
+import { readFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { buildReact, buildReactJSX, buildReactNative } from "@vxrn/react-native-prebuilt";
+import { resolveFile } from "./resolveFile.mjs";
+import FSExtra from "fs-extra";
+import { isBuildingNativeBundle } from "./isBuildingNativeBundle.mjs";
+async function swapPrebuiltReactModules(cacheDir) {
+  const prebuilds = {
+    reactJSX: join(cacheDir, "react-jsx-runtime.js"),
+    react: join(cacheDir, "react.js"),
+    reactNative: join(cacheDir, "react-native.js")
+  };
+  (await FSExtra.pathExists(prebuilds.reactNative)) || (console.info("Pre-building react, react-native react/jsx-runtime (one time cost)..."), await Promise.all([buildReactNative({
+    entryPoints: [resolveFile("react-native")],
+    outfile: prebuilds.reactNative
+  }), buildReact({
+    entryPoints: [resolveFile("react")],
+    outfile: prebuilds.react
+  }), buildReactJSX({
+    entryPoints: [resolveFile("react/jsx-dev-runtime")],
+    outfile: prebuilds.reactJSX
+  })]));
+  const jsxRuntime = {
+      // alias: 'virtual:react-jsx',
+      alias: prebuilds.reactJSX,
+      contents: await readFile(prebuilds.reactJSX, "utf-8")
+    },
+    virtualModules = {
+      "react-native": {
+        // alias: 'virtual:react-native',
+        alias: prebuilds.reactNative,
+        contents: await readFile(prebuilds.reactNative, "utf-8")
+      },
+      react: {
+        // alias: 'virtual:react',
+        alias: prebuilds.react,
+        contents: await readFile(prebuilds.react, "utf-8")
+      },
+      "react/jsx-runtime": jsxRuntime,
+      "react/jsx-dev-runtime": jsxRuntime
+    };
+  return {
+    name: "swap-react-native",
+    enforce: "pre",
+    resolveId(id, importer = "") {
+      if (id.startsWith("react-native/Libraries")) return `virtual:rn-internals:${id}`;
+      if (id === "react-native-web") return prebuilds.reactNative;
+      for (const targetId in virtualModules) if (id === targetId || id.includes(`node_modules/${targetId}/`)) return virtualModules[targetId].alias;
+      if (isBuildingNativeBundle && id[0] === ".") {
+        const absolutePath = resolve(dirname(importer), id),
+          nativePath = absolutePath.replace(/(.m?js)/, ".native.js");
+        if (nativePath === id) return;
+        try {
+          const directoryPath = absolutePath + "/index.native.js",
+            directoryNonNativePath = absolutePath + "/index.js";
+          if (FSExtra.pathExistsSync(directoryPath)) return directoryPath;
+          if (FSExtra.pathExistsSync(directoryNonNativePath)) return directoryNonNativePath;
+          if (FSExtra.pathExistsSync(nativePath)) return nativePath;
+        } catch (err) {
+          console.warn("error probably fine", err);
+        }
+      }
+    },
+    load(id) {
+      if (id.startsWith("virtual:rn-internals")) return `const ___val = __cachedModules["${id.replace("virtual:rn-internals:", "")}"]
+        const ___defaultVal = ___val ? ___val.default || ___val : ___val
+        export default ___defaultVal`;
+      for (const targetId in virtualModules) {
+        const info = virtualModules[targetId];
+        if (id === info.alias) return info.contents;
+      }
+    }
+  };
+}
+export { swapPrebuiltReactModules };