vxrn 0.0.7 → 0.1.0

package/dist/cjs/dev/createDevServer.native.js

@@ -0,0 +1,424 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__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: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var createDevServer_exports = {};
+__export(createDevServer_exports, {
+  createDevServer: () => createDevServer
+});
+module.exports = __toCommonJS(createDevServer_exports);
+var import_lite = __toESM(require("mime/lite"), 1), import_constants = require("../utils/constants"), import_src = require("../vendor/repack/dev-server/src"), import_bindKeypressInput = require("./bindKeypressInput");
+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 asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+  try {
+    var info = gen[key](arg), value = info.value;
+  } catch (error) {
+    reject(error);
+    return;
+  }
+  info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _async_to_generator(fn) {
+  return function() {
+    var self = this, args = arguments;
+    return new Promise(function(resolve, reject) {
+      var gen = fn.apply(self, args);
+      function _next(value) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+      }
+      function _throw(err) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+      }
+      _next(void 0);
+    });
+  };
+}
+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 _object_without_properties(source, excluded) {
+  if (source == null)
+    return {};
+  var target = _object_without_properties_loose(source, excluded), key, i;
+  if (Object.getOwnPropertySymbols) {
+    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+    for (i = 0; i < sourceSymbolKeys.length; i++)
+      key = sourceSymbolKeys[i], !(excluded.indexOf(key) >= 0) && Object.prototype.propertyIsEnumerable.call(source, key) && (target[key] = source[key]);
+  }
+  return target;
+}
+function _object_without_properties_loose(source, excluded) {
+  if (source == null)
+    return {};
+  var target = {}, sourceKeys = Object.keys(source), key, i;
+  for (i = 0; i < sourceKeys.length; i++)
+    key = sourceKeys[i], !(excluded.indexOf(key) >= 0) && (target[key] = source[key]);
+  return 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 _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
+    };
+  }
+}
+function createDevServer(options, _) {
+  return _createDevServer.apply(this, arguments);
+}
+function _createDevServer() {
+  return _createDevServer = _async_to_generator(function(options, param) {
+    var listenForHMR, hotUpdatedCJSFiles, _options_port;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          return listenForHMR = param.listenForHMR, hotUpdatedCJSFiles = param.hotUpdatedCJSFiles, [
+            4,
+            (0, import_src.createServer)({
+              options: {
+                rootDir: options.root,
+                host: options.host,
+                port: (_options_port = options.port) !== null && _options_port !== void 0 ? _options_port : import_constants.DEFAULT_PORT
+              },
+              // https: args.https
+              //   ? {
+              //       cert: args.cert,
+              //       key: args.key,
+              //     }
+              //   : undefined,
+              delegate: function(ctx) {
+                (0, import_bindKeypressInput.bindKeypressInput)(ctx);
+                var platform = "ios";
+                return listenForHMR(function(update) {
+                  ctx.notifyBuildEnd(platform), ctx.broadcastToHmrClients({
+                    action: "built",
+                    body: {
+                      errors: [],
+                      warnings: [],
+                      hash: "".concat(Math.random()),
+                      modules: {},
+                      name: "",
+                      time: 0
+                    }
+                  }, platform);
+                }), {
+                  hotFiles: {
+                    getSource: function(path) {
+                      var next = hotUpdatedCJSFiles.get(path);
+                      return next || "";
+                    }
+                  },
+                  compiler: {
+                    getAsset: function() {
+                      var _ref = _async_to_generator(function(filename, platform2, sendProgress) {
+                        return _ts_generator(this, function(_state2) {
+                          return console.info("[GET] - ", filename), [
+                            2,
+                            ""
+                          ];
+                        });
+                      });
+                      return function(filename, platform2, sendProgress) {
+                        return _ref.apply(this, arguments);
+                      };
+                    }(),
+                    // return (await compiler.getAsset(filename, platform, sendProgress)).data
+                    getMimeType: function(filename) {
+                      return import_lite.default.getType(filename) || "application/javascript";
+                    },
+                    inferPlatform: function(uri) {
+                      var url = new URL(uri, "protocol://domain");
+                      if (!url.searchParams.get("platform")) {
+                        var _exec, _ref = _sliced_to_array((_exec = /^\/(.+)\/.+$/.exec(url.pathname)) !== null && _exec !== void 0 ? _exec : [], 2), platform2 = _ref[1];
+                        return platform2;
+                      }
+                    }
+                  },
+                  symbolicator: {
+                    getSource: function() {
+                      var _ref = _async_to_generator(function(fileUrl) {
+                        return _ts_generator(this, function(_state2) {
+                          return console.info("get source", fileUrl), [
+                            2,
+                            ""
+                          ];
+                        });
+                      });
+                      return function(fileUrl) {
+                        return _ref.apply(this, arguments);
+                      };
+                    }(),
+                    getSourceMap: function() {
+                      var _ref = _async_to_generator(function(fileUrl) {
+                        return _ts_generator(this, function(_state2) {
+                          return [
+                            2,
+                            ""
+                          ];
+                        });
+                      });
+                      return function(fileUrl) {
+                        return _ref.apply(this, arguments);
+                      };
+                    }(),
+                    shouldIncludeFrame: function(frame) {
+                      return !/webpack[/\\]runtime[/\\].+\s/.test(frame.file);
+                    }
+                  },
+                  hmr: {
+                    getUriPath: function() {
+                      return "/__hmr";
+                    },
+                    onClientConnected: function(platform2, clientId) {
+                    }
+                  },
+                  // todo
+                  // const lastStats = {}
+                  // ctx.broadcastToHmrClients(
+                  //   { action: 'sync', body: createHmrBody(lastStats) },
+                  //   platform,
+                  //   [clientId]
+                  // )
+                  messages: {
+                    getStatus: function() {
+                      return "packager-status:running";
+                    }
+                  },
+                  logger: {
+                    onMessage: function(log) {
+                      var logEntry = makeLogEntryFromFastifyLog(log);
+                      logEntry.issuer = "DevServer", logEntry.type !== "debug" && console.info("[logger]", logEntry.type === "info" ? "" : logEntry.type, logEntry.message.map(function(m) {
+                        return "".concat(m.msg);
+                      }).join(", "));
+                    }
+                  },
+                  // reporter.process(logEntry)
+                  api: {
+                    // getPlatforms: async () => Object.keys(compiler.workers),
+                    getPlatforms: /* @__PURE__ */ _async_to_generator(function() {
+                      return _ts_generator(this, function(_state2) {
+                        return [
+                          2,
+                          [
+                            "ios"
+                          ]
+                        ];
+                      });
+                    }),
+                    getAssets: function() {
+                      var _ref = _async_to_generator(function(platform2) {
+                        return _ts_generator(this, function(_state2) {
+                          return console.info("get assets", platform2), [
+                            2,
+                            []
+                          ];
+                        });
+                      });
+                      return function(platform2) {
+                        return _ref.apply(this, arguments);
+                      };
+                    }(),
+                    // return Object.entries(compiler.assetsCache[platform] ?? {}).map(([name, asset]) => ({
+                    //   name,
+                    //   size: asset.info.size,
+                    // })),
+                    getCompilationStats: function() {
+                      var _ref = _async_to_generator(function(platform2) {
+                        return _ts_generator(this, function(_state2) {
+                          return [
+                            2,
+                            null
+                          ];
+                        });
+                      });
+                      return function(platform2) {
+                        return _ref.apply(this, arguments);
+                      };
+                    }()
+                  }
+                };
+              }
+            })
+          ];
+        case 1:
+          return [
+            2,
+            _state.sent()
+          ];
+      }
+    });
+  }), _createDevServer.apply(this, arguments);
+}
+function makeLogEntryFromFastifyLog(data) {
+  var level = data.level, time = data.time, pid = data.pid, hostname = data.hostname, rest = _object_without_properties(data, [
+    "level",
+    "time",
+    "pid",
+    "hostname"
+  ]), levelToTypeMapping = {
+    10: "debug",
+    20: "debug",
+    30: "info",
+    40: "warn",
+    50: "error",
+    60: "error"
+  };
+  return {
+    type: levelToTypeMapping[level],
+    timestamp: time,
+    issuer: "",
+    message: [
+      rest
+    ]
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createDevServer
+});
+//# sourceMappingURL=createDevServer.js.map

package/dist/cjs/dev/createDevServer.native.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/dev/Users/n8/vxrn/packages/vxrn/src/dev/createDevServer.ts"],
+  "mappings": "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",
+  "names": ["createDevServer", "options", "listenForHMR", "hotUpdatedCJSFiles", "createServer", "rootDir", "root", "host", "port", "DEFAULT_PORT", "delegate", "ctx", "bindKeypressInput", "platform", "update", "notifyBuildEnd", "broadcastToHmrClients", "action", "body", "errors", "warnings", "hash", "Math", "random", "modules", "name", "time", "hotFiles", "getSource", "path", "next", "get", "compiler", "getAsset", "filename", "sendProgress", "console", "info", "getMimeType", "mime", "getType", "inferPlatform", "uri", "url", "URL", "searchParams", "exec", "pathname", "symbolicator", "fileUrl", "getSourceMap", "shouldIncludeFrame", "frame", "test", "file", "hmr", "getUriPath", "onClientConnected", "clientId", "messages", "getStatus", "logger", "onMessage", "log", "logEntry", "makeLogEntryFromFastifyLog", "issuer", "type", "message", "map", "m", "msg", "join", "api", "getPlatforms", "getAssets", "getCompilationStats", "makeLogEntryFromFastifyLog", "data", "level", "time", "pid", "hostname", "rest", "levelToTypeMapping", "type", "timestamp", "issuer", "message"]
+}

package/dist/{getVitePath.js → cjs/getVitePath.js}

@@ -25,7 +25,7 @@ __export(getVitePath_exports, {
   getVitePath: () => getVitePath
 });
 module.exports = __toCommonJS(getVitePath_exports);
-var import_path = require("path"), import_esm_resolve = __toESM(require("esm-resolve")), import_fs_extra = require("fs-extra");
+var import_path = require("path"), import_esm_resolve = __toESM(require("esm-resolve"), 1), import_fs_extra = __toESM(require("fs-extra"), 1);
 async function getVitePath(rootPath, importer, moduleName, absolute = !1) {
   if (moduleName === "react-native")
     return "react-native";
@@ -42,13 +42,9 @@ async function getVitePath(rootPath, importer, moduleName, absolute = !1) {
     const sourceFile = (0, import_path.join)(process.cwd(), "index.js"), resolved = (0, import_esm_resolve.default)(sourceFile)(moduleName);
     if (!resolved)
       throw new Error("\u274C cant find");
-    const real = await (0, import_fs_extra.realpath)(resolved);
+    const real = await import_fs_extra.default.realpath(resolved);
     let id = real;
     return absolute || (id = (0, import_path.relative)(importer, real)), id.endsWith("/react/jsx-dev-runtime.js") && (id = "react/jsx-runtime"), id;
   }
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  getVitePath
-});
 //# sourceMappingURL=getVitePath.js.map

package/dist/{getVitePath.js.map → cjs/getVitePath.js.map}

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["../src/getVitePath.ts"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAwC,iBAExC,qBAAoB,iCACpB,kBAAyB;AAEzB,eAAsB,YACpB,UACA,UACA,YACA,WAAW,IACX;AAEA,MAAI,eAAe;AACjB,WAAO;AAET,MAAI,eAAe;AACjB,WAAO;AAET,MAAI,eAAe;AACjB,WAAO;AAET,MAAI,eAAe;AACjB,WAAO;AAGT,MAAI,WAAW,CAAC,MAAM,KAAK;AACzB,UAAM,SAAS,SAAS,QAAQ,QAAQ;AAExC,eADa,sBAAK,qBAAQ,SAAS,MAAM,MAAM,CAAC,GAAG,UAAU,IAC/C;AAAA,EAChB,OAAO;AACL,UAAM,iBAAa,kBAAK,QAAQ,IAAI,GAAG,UAAU,GAC3C,eAAW,mBAAAA,SAAQ,UAAU,EAAE,UAAU;AAE/C,QAAI,CAAC;AACH,YAAM,IAAI,MAAM,kBAAa;AAE/B,UAAM,OAAO,UAAM,0BAAS,QAAQ;AACpC,QAAI,KAAK;AACT,WAAK,aACH,SAAK,sBAAS,UAAU,IAAI,IAE1B,GAAG,SAAS,2BAA2B,MACzC,KAAK,sBAEA;AAAA,EACT;AACF;",
-  "names": ["resolve"]
+  "sources": ["../../src/getVitePath.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAwC,iBAExC,qBAAoB,oCACpB,kBAAoB;AAEpB,eAAsB,YACpB,UACA,UACA,YACA,WAAW,IACX;AAEA,MAAI,eAAe;AACjB,WAAO;AAET,MAAI,eAAe;AACjB,WAAO;AAET,MAAI,eAAe;AACjB,WAAO;AAET,MAAI,eAAe;AACjB,WAAO;AAGT,MAAI,WAAW,CAAC,MAAM,KAAK;AACzB,UAAM,SAAS,SAAS,QAAQ,QAAQ;AAExC,eADa,sBAAK,qBAAQ,SAAS,MAAM,MAAM,CAAC,GAAG,UAAU,IAC/C;AAAA,EAChB,OAAO;AACL,UAAM,iBAAa,kBAAK,QAAQ,IAAI,GAAG,UAAU,GAC3C,eAAW,mBAAAA,SAAQ,UAAU,EAAE,UAAU;AAE/C,QAAI,CAAC;AACH,YAAM,IAAI,MAAM,kBAAa;AAE/B,UAAM,OAAO,MAAM,gBAAAC,QAAQ,SAAS,QAAQ;AAC5C,QAAI,KAAK;AACT,WAAK,aACH,SAAK,sBAAS,UAAU,IAAI,IAE1B,GAAG,SAAS,2BAA2B,MACzC,KAAK,sBAEA;AAAA,EACT;AACF;",
+  "names": ["resolve", "FSExtra"]
 }

package/dist/cjs/getVitePath.native.js

@@ -0,0 +1,197 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__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: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var getVitePath_exports = {};
+__export(getVitePath_exports, {
+  getVitePath: () => getVitePath
+});
+module.exports = __toCommonJS(getVitePath_exports);
+var import_path = require("path"), import_esm_resolve = __toESM(require("esm-resolve"), 1), import_fs_extra = __toESM(require("fs-extra"), 1);
+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 _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
+    };
+  }
+}
+function getVitePath(rootPath, importer, moduleName) {
+  return _getVitePath.apply(this, arguments);
+}
+function _getVitePath() {
+  return _getVitePath = _async_to_generator(function(rootPath, importer, moduleName) {
+    var absolute, rootAt, base, sourceFile, resolved, real, id, _arguments = arguments;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          return absolute = _arguments.length > 3 && _arguments[3] !== void 0 ? _arguments[3] : !1, moduleName === "react-native" ? [
+            2,
+            "react-native"
+          ] : moduleName === "react" ? [
+            2,
+            "react"
+          ] : moduleName === "react/jsx-runtime" ? [
+            2,
+            "react/jsx-runtime"
+          ] : moduleName === "react/jsx-dev-runtime" ? [
+            2,
+            "react/jsx-dev-runtime"
+          ] : moduleName[0] !== "." ? [
+            3,
+            1
+          ] : (rootAt = importer.indexOf(rootPath), base = (0, import_path.join)((0, import_path.dirname)(importer.slice(rootAt)), moduleName), [
+            2,
+            base + ".js"
+          ]);
+        case 1:
+          if (sourceFile = (0, import_path.join)(process.cwd(), "index.js"), resolved = (0, import_esm_resolve.default)(sourceFile)(moduleName), !resolved)
+            throw new Error("\u274C cant find");
+          return [
+            4,
+            import_fs_extra.default.realpath(resolved)
+          ];
+        case 2:
+          return real = _state.sent(), id = real, absolute || (id = (0, import_path.relative)(importer, real)), id.endsWith("/react/jsx-dev-runtime.js") && (id = "react/jsx-runtime"), [
+            2,
+            id
+          ];
+        case 3:
+          return [
+            2
+          ];
+      }
+    });
+  }), _getVitePath.apply(this, arguments);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getVitePath
+});
+//# sourceMappingURL=getVitePath.js.map

package/dist/cjs/getVitePath.native.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/Users/n8/vxrn/packages/vxrn/src/getVitePath.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,kBAAwC,iBAExC,qBAAoB,oCACpB,kBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEpB,SAAsBA,YACpBC,UACAC,UACAC,YAAkB;SAHEH,aAAAA,MAAAA,MAAAA,SAAAA;;SAAAA,eAAAA;AAAAA,wBAAf,oBAAA,SACLC,UACAC,UACAC,YAAkB;QAClBC,UAiBQC,QACAC,MAGAC,YACAC,UAKAC,MACFC;;;;AAzBN,iBAHAN,WAAAA,WAAAA,SAAAA,KAAAA,WAAAA,CAAAA,MAAAA,SAAAA,WAAAA,CAAAA,IAAW,IAGPD,eAAe,iBACjB;;YAAO;cAELA,eAAe,UACjB;;YAAO;cAELA,eAAe,sBACjB;;YAAO;cAELA,eAAe,0BACjB;;YAAO;cAGLA,WAAW,CAAA,MAAO,MAAlBA;;;eACIE,SAASH,SAASS,QAAQV,QAAAA,GAC1BK,WAAOM,sBAAKC,qBAAQX,SAASY,MAAMT,MAAAA,CAAAA,GAAUF,UAAAA,GACnD;;YAAOG,OAAO;;;AAKd,cAHMC,iBAAaK,kBAAKG,QAAQC,IAAG,GAAI,UAAA,GACjCR,eAAWS,mBAAAA,SAAQV,UAAAA,EAAYJ,UAAAA,GAEjC,CAACK;AACH,kBAAM,IAAIU,MAAO,kBAAA;AAEN,iBAAA;;YAAMC,gBAAAA,QAAQC,SAASZ,QAAAA;;;AAA9BC,wBAAO,OAAA,KAAA,GACTC,KAAKD,MACJL,aACHM,SAAKW,sBAASnB,UAAUO,IAAAA,IAEtBC,GAAGY,SAAU,2BAAA,MACfZ,KAAK,sBAEP;;YAAOA;;;;;;;;EAEX,CAAA,GAzCsBV,aAAAA,MAAAA,MAAAA,SAAAA;;",
+  "names": ["getVitePath", "rootPath", "importer", "moduleName", "absolute", "rootAt", "base", "sourceFile", "resolved", "real", "id", "indexOf", "join", "dirname", "slice", "process", "cwd", "resolve", "Error", "FSExtra", "realpath", "relative", "endsWith"]
+}