vxrn 0.0.6 → 0.1.0

package/dist/esm/create.native.js

@@ -0,0 +1,1118 @@
+import wsAdapter from "crossws/adapters/node";
+import { readFile } from "fs/promises";
+import { createApp, createRouter, defineEventHandler, defineWebSocketHandler, eventHandler, getQuery, toNodeListener } from "h3";
+import { createProxyEventHandler } from "h3-proxy";
+import { createServer as nodeCreateServer } from "node:http";
+import { dirname, join, relative, resolve } from "node:path";
+import readline from "readline";
+import viteInspectPlugin from "vite-plugin-inspect";
+import { WebSocket } from "ws";
+import * as babel from "@babel/core";
+import react from "@vitejs/plugin-react-swc";
+import { buildReact, buildReactJSX, buildReactNative } from "@vxrn/react-native-prebuilt";
+import viteReactPlugin, { swcTransform, transformForBuild } from "@vxrn/vite-native-swc";
+import { parse } from "es-module-lexer";
+import FSExtra from "fs-extra";
+import { build, createServer, mergeConfig, resolveConfig, transformWithEsbuild } from "vite";
+import { resolve as importMetaResolve } from "import-meta-resolve";
+import { clientInjectionsPlugin } from "./dev/clientInjectPlugin";
+import { getVitePath } from "./getVitePath";
+import { nativePlugin } from "./nativePlugin";
+function _array_like_to_array(arr, len) {
+  (len == null || len > arr.length) && (len = arr.length);
+  for (var i = 0, arr2 = new Array(len); i < len; i++)
+    arr2[i] = arr[i];
+  return arr2;
+}
+function _array_with_holes(arr) {
+  if (Array.isArray(arr))
+    return arr;
+}
+function _array_without_holes(arr) {
+  if (Array.isArray(arr))
+    return _array_like_to_array(arr);
+}
+function asyncGeneratorStep(gen, resolve2, reject, _next, _throw, key, arg) {
+  try {
+    var info = gen[key](arg), value = info.value;
+  } catch (error) {
+    reject(error);
+    return;
+  }
+  info.done ? resolve2(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _async_to_generator(fn) {
+  return function() {
+    var self = this, args = arguments;
+    return new Promise(function(resolve2, reject) {
+      var gen = fn.apply(self, args);
+      function _next(value) {
+        asyncGeneratorStep(gen, resolve2, reject, _next, _throw, "next", value);
+      }
+      function _throw(err) {
+        asyncGeneratorStep(gen, resolve2, reject, _next, _throw, "throw", err);
+      }
+      _next(void 0);
+    });
+  };
+}
+function _define_property(obj, key, value) {
+  return key in obj ? Object.defineProperty(obj, key, {
+    value,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : obj[key] = value, obj;
+}
+function _iterable_to_array(iter) {
+  if (typeof Symbol < "u" && iter[Symbol.iterator] != null || iter["@@iterator"] != null)
+    return Array.from(iter);
+}
+function _iterable_to_array_limit(arr, i) {
+  var _i = arr == null ? null : typeof Symbol < "u" && arr[Symbol.iterator] || arr["@@iterator"];
+  if (_i != null) {
+    var _arr = [], _n = !0, _d = !1, _s, _e;
+    try {
+      for (_i = _i.call(arr); !(_n = (_s = _i.next()).done) && (_arr.push(_s.value), !(i && _arr.length === i)); _n = !0)
+        ;
+    } catch (err) {
+      _d = !0, _e = err;
+    } finally {
+      try {
+        !_n && _i.return != null && _i.return();
+      } finally {
+        if (_d)
+          throw _e;
+      }
+    }
+    return _arr;
+  }
+}
+function _non_iterable_rest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _non_iterable_spread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {}, ownKeys2 = Object.keys(source);
+    typeof Object.getOwnPropertySymbols == "function" && (ownKeys2 = ownKeys2.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+      return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+    }))), ownKeys2.forEach(function(key) {
+      _define_property(target, key, source[key]);
+    });
+  }
+  return target;
+}
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    enumerableOnly && (symbols = symbols.filter(function(sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    })), keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _object_spread_props(target, source) {
+  return source = source ?? {}, Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key) {
+    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+  }), target;
+}
+function _sliced_to_array(arr, i) {
+  return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _to_consumable_array(arr) {
+  return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+  if (o) {
+    if (typeof o == "string")
+      return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor && (n = o.constructor.name), n === "Map" || n === "Set")
+      return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+      return _array_like_to_array(o, minLen);
+  }
+}
+function _ts_generator(thisArg, body) {
+  var f, y, t, g, _ = {
+    label: 0,
+    sent: function() {
+      if (t[0] & 1)
+        throw t[1];
+      return t[1];
+    },
+    trys: [],
+    ops: []
+  };
+  return g = {
+    next: verb(0),
+    throw: verb(1),
+    return: verb(2)
+  }, typeof Symbol == "function" && (g[Symbol.iterator] = function() {
+    return this;
+  }), g;
+  function verb(n) {
+    return function(v) {
+      return step([
+        n,
+        v
+      ]);
+    };
+  }
+  function step(op) {
+    if (f)
+      throw new TypeError("Generator is already executing.");
+    for (; _; )
+      try {
+        if (f = 1, y && (t = op[0] & 2 ? y.return : op[0] ? y.throw || ((t = y.return) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+          return t;
+        switch (y = 0, t && (op = [
+          op[0] & 2,
+          t.value
+        ]), op[0]) {
+          case 0:
+          case 1:
+            t = op;
+            break;
+          case 4:
+            return _.label++, {
+              value: op[1],
+              done: !1
+            };
+          case 5:
+            _.label++, y = op[1], op = [
+              0
+            ];
+            continue;
+          case 7:
+            op = _.ops.pop(), _.trys.pop();
+            continue;
+          default:
+            if (t = _.trys, !(t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+              _ = 0;
+              continue;
+            }
+            if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+              _.label = op[1];
+              break;
+            }
+            if (op[0] === 6 && _.label < t[1]) {
+              _.label = t[1], t = op;
+              break;
+            }
+            if (t && _.label < t[2]) {
+              _.label = t[2], _.ops.push(op);
+              break;
+            }
+            t[2] && _.ops.pop(), _.trys.pop();
+            continue;
+        }
+        op = body.call(thisArg, _);
+      } catch (e) {
+        op = [
+          6,
+          e
+        ], y = 0;
+      } finally {
+        f = t = 0;
+      }
+    if (op[0] & 5)
+      throw op[1];
+    return {
+      value: op[0] ? op[1] : void 0,
+      done: !0
+    };
+  }
+}
+var resolveFile = function(path) {
+  try {
+    return importMetaResolve(path, import.meta.url).replace("file://", "");
+  } catch {
+    return require.resolve(path);
+  }
+}, nativeExtensions = [
+  ".native.tsx",
+  ".native.jsx",
+  ".native.js",
+  ".tsx",
+  ".ts",
+  ".js",
+  ".css",
+  ".json"
+], extensions = [
+  ".web.tsx",
+  ".tsx",
+  ".web.ts",
+  ".ts",
+  ".web.jsx",
+  ".jsx",
+  ".web.js",
+  ".js",
+  ".css",
+  ".json"
+], ensureDir = FSExtra.ensureDir, pathExists = FSExtra.pathExists, pathExistsSync = FSExtra.pathExistsSync, create = function() {
+  var _ref = _async_to_generator(function(options) {
+    var _options_host, host, _options_root, root, _options_port, port, entryRoot, _url, packageRootDir, cacheDir, prebuilds, templateFile, hmrListeners, hotUpdatedCJSFiles, jsxRuntime, _tmp, virtualModules, _tmp1, _, _tmp2, _tmp3, swapRnPlugin, depsToOptimize, serverConfig, resolvedConfig, viteRNClientPlugin, viteServer, isBuilding, vitePort, router, app, handleUpgrade, clients, socket, proxyEventHandler, server;
+    function getBundleCode() {
+      return _getBundleCode.apply(this, arguments);
+    }
+    function _getBundleCode() {
+      return _getBundleCode = _async_to_generator(function() {
+        var tmpBundle, res, done, buildConfig, buildOutput, appCode, appRootParent, template, out;
+        function babelReanimated(input, filename) {
+          return _babelReanimated.apply(this, arguments);
+        }
+        function _babelReanimated() {
+          return _babelReanimated = _async_to_generator(function(input, filename) {
+            return _ts_generator(this, function(_state) {
+              switch (_state.label) {
+                case 0:
+                  return [
+                    4,
+                    new Promise(function(res2, rej) {
+                      babel.transform(input, {
+                        plugins: [
+                          "react-native-reanimated/plugin"
+                        ],
+                        filename
+                      }, function(err, result) {
+                        (!result || err) && rej(err || "no res"), res2(result.code);
+                      });
+                    })
+                  ];
+                case 1:
+                  return [
+                    2,
+                    _state.sent()
+                  ];
+              }
+            });
+          }), _babelReanimated.apply(this, arguments);
+        }
+        return _ts_generator(this, function(_state) {
+          switch (_state.label) {
+            case 0:
+              return process.env.LOAD_TMP_BUNDLE ? (tmpBundle = join(process.cwd(), "bundle.tmp.js"), [
+                4,
+                pathExists(tmpBundle)
+              ]) : [
+                3,
+                3
+              ];
+            case 1:
+              return _state.sent() ? (console.info("\u26A0\uFE0F\u26A0\uFE0F\u26A0\uFE0F\u26A0\uFE0F\u26A0\uFE0F\u26A0\uFE0F\u26A0\uFE0F\u26A0\uFE0F\u26A0\uFE0F\u26A0\uFE0F\u26A0\uFE0F\u26A0\uFE0F returning temp bundle \u26A0\uFE0F\u26A0\uFE0F\u26A0\uFE0F\u26A0\uFE0F\u26A0\uFE0F\u26A0\uFE0F\u26A0\uFE0F\u26A0\uFE0F\u26A0\uFE0F\u26A0\uFE0F", tmpBundle), [
+                4,
+                readFile(tmpBundle, "utf-8")
+              ]) : [
+                3,
+                3
+              ];
+            case 2:
+              return [
+                2,
+                _state.sent()
+              ];
+            case 3:
+              return isBuilding ? [
+                4,
+                isBuilding
+              ] : [
+                3,
+                5
+              ];
+            case 4:
+              return res = _state.sent(), [
+                2,
+                res
+              ];
+            case 5:
+              return isBuilding = new Promise(function(res2) {
+                done = res2;
+              }), buildConfig = {
+                plugins: [
+                  swapRnPlugin,
+                  {
+                    name: "reanimated",
+                    transform: function(code, id) {
+                      return _async_to_generator(function() {
+                        var out2;
+                        return _ts_generator(this, function(_state2) {
+                          switch (_state2.label) {
+                            case 0:
+                              return code.includes("worklet") ? [
+                                4,
+                                babelReanimated(code, id)
+                              ] : [
+                                3,
+                                2
+                              ];
+                            case 1:
+                              return out2 = _state2.sent(), [
+                                2,
+                                out2
+                              ];
+                            case 2:
+                              return [
+                                2
+                              ];
+                          }
+                        });
+                      })();
+                    }
+                  },
+                  viteRNClientPlugin,
+                  nativePlugin({
+                    root,
+                    port,
+                    mode: "build"
+                  }),
+                  viteReactPlugin({
+                    tsDecorators: !0,
+                    mode: "build"
+                  }),
+                  viteInspectPlugin({
+                    build: !0,
+                    outputDir: ".vite-inspect"
+                  }),
+                  {
+                    name: "treat-js-files-as-jsx",
+                    transform: function(code, id) {
+                      return _async_to_generator(function() {
+                        return _ts_generator(this, function(_state2) {
+                          return id.match(/expo-status-bar/) ? [
+                            2,
+                            transformWithEsbuild(code, id, {
+                              loader: "jsx",
+                              jsx: "automatic"
+                            })
+                          ] : [
+                            2,
+                            null
+                          ];
+                        });
+                      })();
+                    }
+                  },
+                  {
+                    name: "native-extensions"
+                  }
+                ],
+                // async config(config) {
+                //   config.resolve!.extensions = nativeExtensions
+                //   config.optimizeDeps!.esbuildOptions!.resolveExtensions = nativeExtensions
+                //   return config
+                // },
+                appType: "custom",
+                root,
+                clearScreen: !1,
+                optimizeDeps: {
+                  include: depsToOptimize,
+                  esbuildOptions: {
+                    jsx: "automatic"
+                  }
+                },
+                build: {
+                  ssr: !1,
+                  minify: !1,
+                  commonjsOptions: {
+                    transformMixedEsModules: !0
+                  },
+                  rollupOptions: {
+                    treeshake: !1,
+                    preserveEntrySignatures: "strict",
+                    output: {
+                      preserveModules: !0,
+                      format: "cjs"
+                    }
+                  }
+                },
+                resolve: {
+                  extensions: nativeExtensions
+                },
+                mode: "development",
+                define: {
+                  "process.env.NODE_ENV": '"development"'
+                }
+              }, options.buildConfig && (buildConfig = mergeConfig(buildConfig, options.buildConfig)), [
+                4,
+                resolveConfig(buildConfig, "build")
+              ];
+            case 6:
+              return _state.sent(), [
+                4,
+                build(buildConfig)
+              ];
+            case 7:
+              if (buildOutput = _state.sent(), !("output" in buildOutput) || (appCode = buildOutput.output.sort(function(a, b) {
+                return a.isEntry ? 1 : -1;
+              }).map(function(outputModule) {
+                if (outputModule.type == "chunk") {
+                  var importsMap = {}, _iteratorNormalCompletion = !0, _didIteratorError = !1, _iteratorError = void 0;
+                  try {
+                    for (var _iterator = outputModule.imports[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) {
+                      var imp = _step.value, relativePath = relative(dirname(outputModule.fileName), imp);
+                      importsMap[relativePath[0] === "." ? relativePath : "./" + relativePath] = imp;
+                    }
+                  } catch (err) {
+                    _didIteratorError = !0, _iteratorError = err;
+                  } finally {
+                    try {
+                      !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
+                    } finally {
+                      if (_didIteratorError)
+                        throw _iteratorError;
+                    }
+                  }
+                  return outputModule.isEntry && (entryRoot = dirname(outputModule.fileName)), `
+___modules___["`.concat(outputModule.fileName, `"] = ((exports, module) => {
+  const require = createRequire(`).concat(JSON.stringify(importsMap, null, 2), `)
+
+  `).concat(outputModule.code, `
+})
+
+`).concat(outputModule.isEntry ? `
+// run entry
+const __require = createRequire({})
+__require("react-native")
+__require("`.concat(outputModule.fileName, `")
+`) : "", `
+`);
+                }
+              }).join(`
+`), !appCode))
+                throw "\u274C";
+              return appCode = appCode.replaceAll("undefined.accept(() => {})", "").replaceAll("undefined.accept(function() {});", "").replaceAll("(void 0).accept(() => {})", "").replaceAll("(void 0).accept(function() {});", ""), appRootParent = join(root, "..", ".."), [
+                4,
+                readFile(templateFile, "utf-8")
+              ];
+            case 8:
+              return template = _state.sent().replace("_virtual/virtual_react-native.js", relative(appRootParent, prebuilds.reactNative)).replace("_virtual/virtual_react.js", relative(appRootParent, prebuilds.react)).replaceAll("_virtual/virtual_react-jsx.js", relative(appRootParent, prebuilds.reactJSX)), out = template + appCode, done(out), isBuilding = null, [
+                2,
+                out
+              ];
+          }
+        });
+      }), _getBundleCode.apply(this, arguments);
+    }
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          return _options_host = options.host, host = _options_host === void 0 ? "127.0.0.1" : _options_host, _options_root = options.root, root = _options_root === void 0 ? process.cwd() : _options_root, _options_port = options.port, port = _options_port === void 0 ? 8081 : _options_port, bindKeypressInput(), entryRoot = "", packageRootDir = join((_url = import.meta.url) !== null && _url !== void 0 ? _url : __filename, ".."), cacheDir = join(root, "node_modules", ".cache", "vxrn"), [
+            4,
+            ensureDir(cacheDir)
+          ];
+        case 1:
+          return _state.sent(), prebuilds = {
+            reactJSX: join(cacheDir, "react-jsx-runtime.js"),
+            react: join(cacheDir, "react.js"),
+            reactNative: join(cacheDir, "react-native.js")
+          }, [
+            4,
+            pathExists(prebuilds.reactNative)
+          ];
+        case 2:
+          return _state.sent() ? [
+            3,
+            4
+          ] : (console.info("Pre-building react, react-native react/jsx-runtime (one time cost)..."), [
+            4,
+            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
+              })
+            ])
+          ]);
+        case 3:
+          _state.sent(), _state.label = 4;
+        case 4:
+          return templateFile = resolveFile("vxrn/react-native-template.js"), hmrListeners = [], hotUpdatedCJSFiles = /* @__PURE__ */ new Map(), _tmp = {
+            // alias: 'virtual:react-jsx',
+            alias: prebuilds.reactJSX
+          }, [
+            4,
+            readFile(prebuilds.reactJSX, "utf-8")
+          ];
+        case 5:
+          return jsxRuntime = (_tmp.contents = _state.sent(), _tmp), _tmp1 = {}, _ = "react-native", _tmp2 = {
+            // alias: 'virtual:react-native',
+            alias: prebuilds.reactNative
+          }, [
+            4,
+            readFile(prebuilds.reactNative, "utf-8")
+          ];
+        case 6:
+          return _tmp1[_] = (_tmp2.contents = _state.sent(), _tmp2), _tmp3 = {
+            // alias: 'virtual:react',
+            alias: prebuilds.react
+          }, [
+            4,
+            readFile(prebuilds.react, "utf-8")
+          ];
+        case 7:
+          return virtualModules = (_tmp1.react = (_tmp3.contents = _state.sent(), _tmp3), _tmp1["react/jsx-runtime"] = jsxRuntime, _tmp1["react/jsx-dev-runtime"] = jsxRuntime, _tmp1), swapRnPlugin = {
+            name: "swap-react-native",
+            enforce: "pre",
+            resolveId: function(id) {
+              var importer = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "";
+              if (id.startsWith("react-native/Libraries"))
+                return "virtual:rn-internals:".concat(id);
+              if (id === "react-native-web")
+                return prebuilds.reactNative;
+              for (var targetId in virtualModules)
+                if (id === targetId || id.includes("node_modules/".concat(targetId, "/"))) {
+                  var info = virtualModules[targetId];
+                  return info.alias;
+                }
+              if (id[0] === ".") {
+                var absolutePath = resolve(dirname(importer), id), nativePath = absolutePath.replace(/(.m?js)/, ".native.js");
+                if (nativePath === id)
+                  return;
+                try {
+                  var directoryPath = absolutePath + "/index.native.js", directoryNonNativePath = absolutePath + "/index.js";
+                  if (pathExistsSync(directoryPath))
+                    return directoryPath;
+                  if (pathExistsSync(directoryNonNativePath))
+                    return directoryNonNativePath;
+                  if (pathExistsSync(nativePath))
+                    return nativePath;
+                } catch (err) {
+                  console.warn("error probably fine", err);
+                }
+              }
+            },
+            load: function(id) {
+              if (id.startsWith("virtual:rn-internals")) {
+                var idOut = id.replace("virtual:rn-internals:", "");
+                return 'const val = __cachedModules["'.concat(idOut, `"]
+          export const PressabilityDebugView = val.PressabilityDebugView
+          export default val ? val.default || val : val`);
+              }
+              for (var targetId in virtualModules) {
+                var info = virtualModules[targetId];
+                if (id === info.alias)
+                  return info.contents;
+              }
+            }
+          }, depsToOptimize = [
+            "react",
+            "react-dom",
+            "@react-native/normalize-color"
+          ], serverConfig = {
+            root,
+            mode: "development",
+            clearScreen: !1,
+            define: {
+              __DEV__: "true",
+              "process.env.NODE_ENV": '"development"'
+            },
+            resolve: {
+              // dedupe: ['react', 'react-dom'],
+              alias: {
+                // ...Object.fromEntries(Object.entries(virtualModules).map(([k, v]) => [k, v.alias])),
+                "react-native": resolveFile("react-native-web-lite")
+              }
+            },
+            optimizeDeps: {
+              include: depsToOptimize,
+              exclude: Object.values(virtualModules).map(function(v) {
+                return v.alias;
+              }),
+              force: !0,
+              esbuildOptions: {
+                resolveExtensions: extensions
+              }
+            },
+            build: {
+              commonjsOptions: {
+                transformMixedEsModules: !0
+              }
+            },
+            plugins: [
+              // this breaks web, but for native maybe we need to manually run in the native handleHotUpdate below
+              // swapRnPlugin,
+              react(),
+              // viteReactPlugin({
+              //   tsDecorators: true,
+              //   mode: 'serve',
+              // }),
+              {
+                name: "client-transform",
+                handleHotUpdate: function(param) {
+                  var read = param.read, modules = param.modules, file = param.file;
+                  return _async_to_generator(function() {
+                    var _this, _this1, _modules, module, id, code, source, importsMap, _parse, imports, accumulatedSliceOffset, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, specifier, importName, start, id1, len, extraLen, err, hotUpdateSource, err1;
+                    return _ts_generator(this, function(_state2) {
+                      switch (_state2.label) {
+                        case 0:
+                          return _state2.trys.push([
+                            0,
+                            12,
+                            ,
+                            13
+                          ]), isWithin(root, file) ? (_modules = _sliced_to_array(modules, 1), module = _modules[0], module ? (id = (module == null ? void 0 : module.url) || file.replace(root, ""), [
+                            4,
+                            read()
+                          ]) : [
+                            2
+                          ]) : [
+                            2
+                          ];
+                        case 1:
+                          return code = _state2.sent(), code.startsWith("'use strict';") ? [
+                            2
+                          ] : code ? (source = code, [
+                            4,
+                            transformForBuild(id, source)
+                          ]) : [
+                            2
+                          ];
+                        case 2:
+                          source = ((_this = _state2.sent()) === null || _this === void 0 ? void 0 : _this.code) || "", importsMap = {}, _parse = _sliced_to_array(parse(source), 1), imports = _parse[0], accumulatedSliceOffset = 0, _iteratorNormalCompletion = !0, _didIteratorError = !1, _iteratorError = void 0, _state2.label = 3;
+                        case 3:
+                          _state2.trys.push([
+                            3,
+                            8,
+                            9,
+                            10
+                          ]), _iterator = imports[Symbol.iterator](), _state2.label = 4;
+                        case 4:
+                          return (_iteratorNormalCompletion = (_step = _iterator.next()).done) ? [
+                            3,
+                            7
+                          ] : (specifier = _step.value, importName = specifier.n, start = specifier.s, importName ? [
+                            4,
+                            getVitePath(entryRoot, file, importName)
+                          ] : [
+                            3,
+                            6
+                          ]);
+                        case 5:
+                          if (id1 = _state2.sent(), !id1)
+                            return console.warn("???"), [
+                              3,
+                              6
+                            ];
+                          importsMap[id1] = id1.replace(/^(\.\.\/)+/, ""), len = importName.length, extraLen = id1.length - len, source = source.slice(0, start + accumulatedSliceOffset) + id1 + source.slice(start + accumulatedSliceOffset + len), accumulatedSliceOffset += extraLen, _state2.label = 6;
+                        case 6:
+                          return _iteratorNormalCompletion = !0, [
+                            3,
+                            4
+                          ];
+                        case 7:
+                          return [
+                            3,
+                            10
+                          ];
+                        case 8:
+                          return err = _state2.sent(), _didIteratorError = !0, _iteratorError = err, [
+                            3,
+                            10
+                          ];
+                        case 9:
+                          try {
+                            !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
+                          } finally {
+                            if (_didIteratorError)
+                              throw _iteratorError;
+                          }
+                          return [
+                            7
+                          ];
+                        case 10:
+                          return [
+                            4,
+                            swcTransform(id, source, {
+                              mode: "serve-cjs"
+                            })
+                          ];
+                        case 11:
+                          if (source = ((_this1 = _state2.sent()) === null || _this1 === void 0 ? void 0 : _this1.code) || "", !source)
+                            throw "\u274C no source";
+                          return hotUpdateSource = `exports = ((exports) => {
+              const require = createRequire(`.concat(JSON.stringify(importsMap, null, 2), `)
+              `).concat(source.replace("import.meta.hot.accept(() => {})", "").replaceAll(/import.meta.glob\(.*\)/gi, "globalThis['__importMetaGlobbed'] || {}"), `;
+              return exports })({})`), process.env.DEBUG && console.info("Sending hot update", hotUpdateSource), hotUpdatedCJSFiles.set(id, hotUpdateSource), [
+                            3,
+                            13
+                          ];
+                        case 12:
+                          return err1 = _state2.sent(), console.error("Error processing hmr update:", err1), [
+                            3,
+                            13
+                          ];
+                        case 13:
+                          return [
+                            2
+                          ];
+                      }
+                    });
+                  })();
+                }
+              }
+            ],
+            server: {
+              hmr: {
+                path: "/__vxrnhmr"
+              },
+              cors: !0,
+              host
+            }
+          }, options.webConfig && (serverConfig = mergeConfig(serverConfig, options.webConfig)), [
+            4,
+            resolveConfig(serverConfig, "serve")
+          ];
+        case 8:
+          return resolvedConfig = _state.sent(), viteRNClientPlugin = clientInjectionsPlugin(resolvedConfig), serverConfig = _object_spread_props(_object_spread({}, serverConfig), {
+            plugins: _to_consumable_array(serverConfig.plugins)
+          }), [
+            4,
+            createServer(serverConfig)
+          ];
+        case 9:
+          return viteServer = _state.sent(), viteServer.watcher.addListener("change", function() {
+            var _ref2 = _async_to_generator(function(path) {
+              var id;
+              return _ts_generator(this, function(_state2) {
+                if (id = path.replace(process.cwd(), ""), !id.endsWith("tsx") && !id.endsWith("jsx"))
+                  return [
+                    2
+                  ];
+                try {
+                  viteServer.transformRequest(id);
+                } catch (err) {
+                  console.info("err", err);
+                }
+                return [
+                  2
+                ];
+              });
+            });
+            return function(path) {
+              return _ref2.apply(this, arguments);
+            };
+          }()), isBuilding = null, [
+            4,
+            viteServer.listen()
+          ];
+        case 10:
+          return _state.sent(), vitePort = viteServer.config.server.port, console.info("vite running on", vitePort), router = createRouter(), app = createApp({
+            onError: function(error) {
+              console.error(error);
+            },
+            onRequest: function(event) {
+              console.info(" \u2192", event.path);
+            }
+          }), router.get("/file", defineEventHandler(function(e) {
+            var query = getQuery(e);
+            if (typeof query.file == "string") {
+              var source = hotUpdatedCJSFiles.get(query.file);
+              return new Response(source, {
+                headers: {
+                  "content-type": "text/javascript"
+                }
+              });
+            }
+          })), router.get("/index.bundle", defineEventHandler(function() {
+            var _ref2 = _async_to_generator(function(e) {
+              var _2;
+              return _ts_generator(this, function(_state2) {
+                switch (_state2.label) {
+                  case 0:
+                    return _2 = Response.bind, [
+                      4,
+                      getBundleCode()
+                    ];
+                  case 1:
+                    return [
+                      2,
+                      new (_2.apply(Response, [
+                        void 0,
+                        _state2.sent(),
+                        {
+                          headers: {
+                            "content-type": "text/javascript"
+                          }
+                        }
+                      ]))()
+                    ];
+                }
+              });
+            });
+            return function(e) {
+              return _ref2.apply(this, arguments);
+            };
+          }())), router.get("/status", defineEventHandler(function() {
+            return "packager-status:running";
+          })), app.use(router), app.use(defineEventHandler(function() {
+            var _ref2 = _async_to_generator(function(param) {
+              var req, _req_headers_useragent, _req_url;
+              return _ts_generator(this, function(_state2) {
+                return req = param.node.req, !((_req_headers_useragent = req.headers["user-agent"]) === null || _req_headers_useragent === void 0) && _req_headers_useragent.match(/Expo|React/) ? req.url === "/" || !((_req_url = req.url) === null || _req_url === void 0) && _req_url.startsWith("/?platform=") ? [
+                  2,
+                  getIndexJsonResponse({
+                    port,
+                    root
+                  })
+                ] : [
+                  2
+                ] : [
+                  2
+                ];
+              });
+            });
+            return function(_2) {
+              return _ref2.apply(this, arguments);
+            };
+          }())), handleUpgrade = wsAdapter(app.websocket).handleUpgrade, vitePort && (clients = /* @__PURE__ */ new Set(), socket = new WebSocket("ws://localhost:".concat(vitePort, "/__vxrnhmr"), "vite-hmr"), console.info("connecting to vite..."), socket.on("open", function() {
+            console.info("...connected to vite!");
+          }), socket.on("message", function(msg) {
+            var message = msg.toString();
+            console.info(clients.size, "message", message);
+            var _iteratorNormalCompletion = !0, _didIteratorError = !1, _iteratorError = void 0;
+            try {
+              for (var _iterator = _to_consumable_array(clients)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) {
+                var listener = _step.value;
+                listener.send(message);
+              }
+            } catch (err) {
+              _didIteratorError = !0, _iteratorError = err;
+            } finally {
+              try {
+                !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
+              } finally {
+                if (_didIteratorError)
+                  throw _iteratorError;
+              }
+            }
+          }), socket.on("error", function(err) {
+            console.info("err", err);
+          }), app.use("/__vxrnhmr", defineWebSocketHandler({
+            open: function(peer) {
+              console.debug("[hmr:web] open", peer), clients.add(peer);
+            },
+            message: function(peer, message) {
+              socket.send(message.rawData);
+            },
+            close: function(peer, event) {
+              console.info("[hmr:web] close", peer, event), clients.delete(peer);
+            },
+            error: function(peer, error) {
+              console.error("[hmr:web] error", peer, error);
+            }
+          }))), app.use("/__hmr", defineWebSocketHandler({
+            open: function(peer) {
+              console.debug("[hmr] open", peer);
+            },
+            message: function(peer, message) {
+              console.info("[hmr] message", peer, message), message.text().includes("ping") && peer.send("pong");
+            },
+            close: function(peer, event) {
+              console.info("[hmr] close", peer, event);
+            },
+            error: function(peer, error) {
+              console.error("[hmr] error", peer, error);
+            }
+          })), app.use("/__client", defineWebSocketHandler({
+            open: function(peer) {
+              console.info("[client] open", peer);
+            },
+            message: function(peer, messageRaw) {
+              var message2 = JSON.parse(messageRaw.text());
+              switch (message2.type) {
+                case "client-log": {
+                  var _console;
+                  (_console = console).info.apply(_console, [
+                    "\u{1FAB5} [".concat(message2.level, "]")
+                  ].concat(_to_consumable_array(message2.data)));
+                  return;
+                }
+                default:
+                  console.warn("[client] Unknown message type", message2);
+              }
+            },
+            close: function(peer, event) {
+              console.info("[client] close", peer, event);
+            },
+            error: function(peer, error) {
+              console.error("[client] error", peer, error);
+            }
+          })), proxyEventHandler = createProxyEventHandler({
+            target: "http://127.0.0.1:".concat(vitePort),
+            enableLogger: !!process.env.DEBUG
+          }), app.use(eventHandler(proxyEventHandler)), server = nodeCreateServer(toNodeListener(app)), server.on("upgrade", handleUpgrade), [
+            2,
+            {
+              nativeServer: server,
+              viteServer,
+              start: function() {
+                return _async_to_generator(function() {
+                  return _ts_generator(this, function(_state2) {
+                    return server.listen(port), console.info("Server running on http://localhost:".concat(port)), [
+                      2,
+                      {
+                        closePromise: new Promise(function(res) {
+                          var _viteServer_httpServer;
+                          return (_viteServer_httpServer = viteServer.httpServer) === null || _viteServer_httpServer === void 0 ? void 0 : _viteServer_httpServer.on("close", res);
+                        })
+                      }
+                    ];
+                  });
+                })();
+              },
+              stop: /* @__PURE__ */ _async_to_generator(function() {
+                return _ts_generator(this, function(_state2) {
+                  switch (_state2.label) {
+                    case 0:
+                      return [
+                        4,
+                        Promise.all([
+                          server.close(),
+                          viteServer.close()
+                        ])
+                      ];
+                    case 1:
+                      return _state2.sent(), [
+                        2
+                      ];
+                  }
+                });
+              })
+            }
+          ];
+      }
+    });
+  });
+  return function(options) {
+    return _ref.apply(this, arguments);
+  };
+}();
+function getIndexJsonResponse(param) {
+  var port = param.port, root = param.root;
+  return {
+    name: "myapp",
+    slug: "myapp",
+    scheme: "myapp",
+    version: "1.0.0",
+    jsEngine: "jsc",
+    orientation: "portrait",
+    icon: "./assets/icon.png",
+    userInterfaceStyle: "light",
+    splash: {
+      image: "./assets/splash.png",
+      resizeMode: "contain",
+      backgroundColor: "#ffffff",
+      imageUrl: "http://127.0.0.1:8081/assets/./assets/splash.png"
+    },
+    updates: {
+      fallbackToCacheTimeout: 0
+    },
+    assetBundlePatterns: [
+      "**/*"
+    ],
+    ios: {
+      supportsTablet: !0,
+      bundleIdentifier: "com.natew.myapp"
+    },
+    android: {
+      package: "com.tamagui.myapp",
+      adaptiveIcon: {
+        foregroundImage: "./assets/adaptive-icon.png",
+        backgroundColor: "#FFFFFF",
+        foregroundImageUrl: "http://127.0.0.1:8081/assets/./assets/adaptive-icon.png"
+      }
+    },
+    web: {
+      favicon: "./assets/favicon.png"
+    },
+    extra: {
+      eas: {
+        projectId: "061b4470-78c7-4d6a-b850-8167fb0a3434"
+      }
+    },
+    _internal: {
+      isDebug: !1,
+      projectRoot: root,
+      dynamicConfigPath: null,
+      staticConfigPath: join(root, "app.json"),
+      packageJsonPath: join(root, "package.json")
+    },
+    sdkVersion: "47.0.0",
+    platforms: [
+      "ios",
+      "android",
+      "web"
+    ],
+    iconUrl: "http://127.0.0.1:".concat(port, "/assets/./assets/icon.png"),
+    debuggerHost: "127.0.0.1:".concat(port),
+    logUrl: "http://127.0.0.1:".concat(port, "/logs"),
+    developer: {
+      tool: "expo-cli",
+      projectRoot: root
+    },
+    packagerOpts: {
+      dev: !0
+    },
+    mainModuleName: "index",
+    __flipperHack: "React Native packager is running",
+    hostUri: "127.0.0.1:".concat(port),
+    bundleUrl: "http://127.0.0.1:".concat(port, "/index.bundle?platform=ios&dev=true&hot=false&lazy=true"),
+    id: "@anonymous/myapp-473c4543-3c36-4786-9db1-c66a62ac9b78"
+  };
+}
+function bindKeypressInput() {
+  if (!process.stdin.setRawMode) {
+    console.warn({
+      msg: "Interactive mode is not supported in this environment"
+    });
+    return;
+  }
+  readline.emitKeypressEvents(process.stdin), process.stdin.setRawMode(!0), process.stdin.on("keypress", function(_key, data) {
+    var ctrl = data.ctrl, name = data.name;
+    if (ctrl === !0)
+      switch (name) {
+        case "c":
+          process.exit();
+        case "z":
+          process.emit("SIGTSTP", "SIGTSTP");
+          break;
+      }
+    else
+      switch (name) {
+        case "r":
+          break;
+        case "d":
+          break;
+        case "c":
+          process.stdout.write("\x1B[2J\x1B[0;0H");
+          break;
+      }
+  });
+}
+function isWithin(outer, inner) {
+  var rel = relative(outer, inner);
+  return !rel.startsWith("../") && rel !== "..";
+}
+export {
+  bindKeypressInput,
+  create
+};
+//# sourceMappingURL=create.js.map