vxrn 0.1.57 → 0.1.59

package/dist/cjs/exports/createServer.js

@@ -0,0 +1,55 @@
+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 createServer_exports = {};
+__export(createServer_exports, {
+  createProdServer: () => createProdServer
+});
+module.exports = __toCommonJS(createServer_exports);
+var import_h3 = require("h3"), import_sirv = __toESM(require("sirv"), 1);
+const createProdServer = async (options) => {
+  const app = (0, import_h3.createApp)(), sirvStaticMiddleware = (0, import_sirv.default)("dist/static", {
+    gzip: !0
+  });
+  options.serve && options.serve(options, app), app.use(
+    (0, import_h3.defineEventHandler)(async ({ node: { req, res } }) => {
+      await new Promise((response) => {
+        sirvStaticMiddleware(req, res, () => {
+          response();
+        });
+      });
+    })
+  );
+  const sirvMiddleware = (0, import_sirv.default)("dist/client", {
+    gzip: !0
+  });
+  return app.use(
+    (0, import_h3.defineEventHandler)(async ({ node: { req, res } }) => {
+      await new Promise((response) => {
+        sirvMiddleware(req, res, () => {
+          response();
+        });
+      });
+    })
+  ), app;
+};
+//# sourceMappingURL=createServer.js.map

package/dist/cjs/exports/createServer.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/exports/createServer.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAA8C,eAC9C,cAAiB;AAGV,MAAM,mBAAmB,OAAO,YAAwB;AAC7D,QAAM,UAAM,qBAAU,GAEhB,2BAAuB,YAAAA,SAAK,eAAe;AAAA,IAC/C,MAAM;AAAA,EACR,CAAC;AAED,EAAI,QAAQ,SACV,QAAQ,MAAM,SAAS,GAAG,GAG5B,IAAI;AAAA,QACF,8BAAmB,OAAO,EAAE,MAAM,EAAE,KAAK,IAAI,EAAE,MAAM;AACnD,YAAM,IAAI,QAAc,CAAC,aAAa;AACpC,6BAAqB,KAAK,KAAK,MAAM;AACnC,mBAAS;AAAA,QACX,CAAC;AAAA,MACH,CAAC;AAAA,IACH,CAAC;AAAA,EACH;AAEA,QAAM,qBAAiB,YAAAA,SAAK,eAAe;AAAA,IACzC,MAAM;AAAA,EACR,CAAC;AAED,aAAI;AAAA,QACF,8BAAmB,OAAO,EAAE,MAAM,EAAE,KAAK,IAAI,EAAE,MAAM;AACnD,YAAM,IAAI,QAAc,CAAC,aAAa;AACpC,uBAAe,KAAK,KAAK,MAAM;AAC7B,mBAAS;AAAA,QACX,CAAC;AAAA,MACH,CAAC;AAAA,IACH,CAAC;AAAA,EACH,GAEO;AACT;",
+  "names": ["sirv"]
+}

package/dist/cjs/exports/createServer.native.js

@@ -0,0 +1,215 @@
+"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 createServer_exports = {};
+__export(createServer_exports, {
+  createProdServer: () => createProdServer
+});
+module.exports = __toCommonJS(createServer_exports);
+var import_h3 = require("h3"), import_sirv = __toESM(require("sirv"), 1);
+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 _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 createProdServer = function() {
+  var _ref = _async_to_generator(function(options) {
+    var app, sirvStaticMiddleware, sirvMiddleware;
+    return _ts_generator(this, function(_state) {
+      return app = (0, import_h3.createApp)(), sirvStaticMiddleware = (0, import_sirv.default)("dist/static", {
+        gzip: !0
+      }), options.serve && options.serve(options, app), app.use((0, import_h3.defineEventHandler)(function() {
+        var _ref2 = _async_to_generator(function(param) {
+          var _param_node, req, res;
+          return _ts_generator(this, function(_state2) {
+            switch (_state2.label) {
+              case 0:
+                return _param_node = param.node, req = _param_node.req, res = _param_node.res, [
+                  4,
+                  new Promise(function(response) {
+                    sirvStaticMiddleware(req, res, function() {
+                      response();
+                    });
+                  })
+                ];
+              case 1:
+                return _state2.sent(), [
+                  2
+                ];
+            }
+          });
+        });
+        return function(_) {
+          return _ref2.apply(this, arguments);
+        };
+      }())), sirvMiddleware = (0, import_sirv.default)("dist/client", {
+        gzip: !0
+      }), app.use((0, import_h3.defineEventHandler)(function() {
+        var _ref2 = _async_to_generator(function(param) {
+          var _param_node, req, res;
+          return _ts_generator(this, function(_state2) {
+            switch (_state2.label) {
+              case 0:
+                return _param_node = param.node, req = _param_node.req, res = _param_node.res, [
+                  4,
+                  new Promise(function(response) {
+                    sirvMiddleware(req, res, function() {
+                      response();
+                    });
+                  })
+                ];
+              case 1:
+                return _state2.sent(), [
+                  2
+                ];
+            }
+          });
+        });
+        return function(_) {
+          return _ref2.apply(this, arguments);
+        };
+      }())), [
+        2,
+        app
+      ];
+    });
+  });
+  return function(options) {
+    return _ref.apply(this, arguments);
+  };
+}();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createProdServer
+});
+//# sourceMappingURL=createServer.js.map

package/dist/cjs/exports/createServer.native.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/exports/Users/n8/vxrn/packages/vxrn/src/exports/createServer.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,gBAA8C,eAC9C,cAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGV,IAAMA,mBAAAA,WAAAA;aAAmB,oBAAA,SAAOC,SAAAA;QAC/BC,KAEAC,sBAkBAC;;AApBAF,uBAAMG,qBAAAA,GAENF,2BAAuBG,YAAAA,SAAK,eAAe;QAC/CC,MAAM;MACR,CAAA,GAEIN,QAAQO,SACVP,QAAQO,MAAMP,SAASC,GAAAA,GAGzBA,IAAIO,QACFC,8BAAAA,WAAAA;oBAAmB,oBAAA,SAAA,OAAA;2BAAiBC,KAAKC;;;;2CAAbC,MAAQF,MAAAA,YAAAA,KAAKC,MAAAA,YAAAA,KACvC;;kBAAM,IAAIE,QAAc,SAACC,UAAAA;AACvBZ,yCAAqBQ,KAAKC,KAAK,WAAA;AAC7BG,+BAAAA;oBACF,CAAA;kBACF,CAAA;;;AAJA,uBAAAC,QAAA,KAAA;;;;;QAKF,CAAA;;;;aAGIZ,qBAAiBE,YAAAA,SAAK,eAAe;QACzCC,MAAM;MACR,CAAA,GAEAL,IAAIO,QACFC,8BAAAA,WAAAA;oBAAmB,oBAAA,SAAA,OAAA;2BAAiBC,KAAKC;;;;2CAAbC,MAAQF,MAAAA,YAAAA,KAAKC,MAAAA,YAAAA,KACvC;;kBAAM,IAAIE,QAAc,SAACC,UAAAA;AACvBX,mCAAeO,KAAKC,KAAK,WAAA;AACvBG,+BAAAA;oBACF,CAAA;kBACF,CAAA;;;AAJA,uBAAAC,QAAA,KAAA;;;;;QAKF,CAAA;;;;aAGF;;QAAOd;;;EACT,CAAA;kBApCuCD,SAAAA;;;;",
+  "names": ["createProdServer", "options", "app", "sirvStaticMiddleware", "sirvMiddleware", "createApp", "sirv", "gzip", "serve", "use", "defineEventHandler", "req", "res", "node", "Promise", "response", "_state"]
+}

package/dist/cjs/exports/serve.js

@@ -1,8 +1,7 @@
-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 __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: !0 });
@@ -12,47 +11,16 @@ var __export = (target, all) => {
       !__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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
 var serve_exports = {};
 __export(serve_exports, {
   serve: () => serve
 });
 module.exports = __toCommonJS(serve_exports);
-var import_node_http = require("node:http"), import_sirv = __toESM(require("sirv"), 1), import_getOptionsFilled = require("../utils/getOptionsFilled"), import_h3 = require("h3");
+var import_h3 = require("h3"), import_node_http = require("node:http"), import_createServer = require("./createServer"), import_getOptionsFilled = require("../utils/getOptionsFilled");
 const serve = async (optionsIn) => {
-  const options = await (0, import_getOptionsFilled.getOptionsFilled)(optionsIn), app = (0, import_h3.createApp)(), sirvStaticMiddleware = (0, import_sirv.default)("dist/static", {
-    gzip: !0
-  });
-  options.serve && options.serve(options, app), app.use(
-    (0, import_h3.defineEventHandler)(async ({ node: { req, res } }) => {
-      await new Promise((response) => {
-        sirvStaticMiddleware(req, res, () => {
-          response();
-        });
-      });
-    })
-  );
-  const sirvMiddleware = (0, import_sirv.default)("dist/client", {
-    gzip: !0
-  });
-  app.use(
-    (0, import_h3.defineEventHandler)(async ({ node: { req, res } }) => {
-      await new Promise((response) => {
-        sirvMiddleware(req, res, () => {
-          response();
-        });
-      });
-    })
-  );
-  const server = (0, import_node_http.createServer)((0, import_h3.toNodeListener)(app));
-  server.listen(3333), console.info("Listening on http://localhost:3333"), await new Promise((res) => {
+  const options = await (0, import_getOptionsFilled.getOptionsFilled)(optionsIn), app = await (0, import_createServer.createProdServer)(options), server = (0, import_node_http.createServer)((0, import_h3.toNodeListener)(app));
+  server.listen(), console.info(`Listening on http://localhost:${options.port}`), await new Promise((res) => {
     server.on("close", () => {
       res();
     });

package/dist/cjs/exports/serve.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../../src/exports/serve.ts"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,uBAA6B,sBAC7B,cAAiB,6BAEjB,0BAAiC,sCACjC,YAA8D;AAEvD,MAAM,QAAQ,OAAO,cAA0B;AACpD,QAAM,UAAU,UAAM,0CAAiB,SAAS,GAE1C,UAAM,qBAAU,GAEhB,2BAAuB,YAAAA,SAAK,eAAe;AAAA,IAC/C,MAAM;AAAA,EACR,CAAC;AAED,EAAI,QAAQ,SACV,QAAQ,MAAM,SAAS,GAAG,GAG5B,IAAI;AAAA,QACF,8BAAmB,OAAO,EAAE,MAAM,EAAE,KAAK,IAAI,EAAE,MAAM;AACnD,YAAM,IAAI,QAAc,CAAC,aAAa;AACpC,6BAAqB,KAAK,KAAK,MAAM;AACnC,mBAAS;AAAA,QACX,CAAC;AAAA,MACH,CAAC;AAAA,IACH,CAAC;AAAA,EACH;AAEA,QAAM,qBAAiB,YAAAA,SAAK,eAAe;AAAA,IACzC,MAAM;AAAA,EACR,CAAC;AAED,MAAI;AAAA,QACF,8BAAmB,OAAO,EAAE,MAAM,EAAE,KAAK,IAAI,EAAE,MAAM;AACnD,YAAM,IAAI,QAAc,CAAC,aAAa;AACpC,uBAAe,KAAK,KAAK,MAAM;AAC7B,mBAAS;AAAA,QACX,CAAC;AAAA,MACH,CAAC;AAAA,IACH,CAAC;AAAA,EACH;AAEA,QAAM,aAAS,mCAAa,0BAAe,GAAG,CAAC;AAC/C,SAAO,OAAO,IAAI,GAClB,QAAQ,KAAK,oCAAoC,GAEjD,MAAM,IAAI,QAAc,CAAC,QAAQ;AAC/B,WAAO,GAAG,SAAS,MAAM;AACvB,UAAI;AAAA,IACN,CAAC;AAAA,EACH,CAAC;AACH;",
-  "names": ["sirv"]
+  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAA+B,eAC/B,mBAA6B,sBAE7B,sBAAiC,2BACjC,0BAAiC;AAE1B,MAAM,QAAQ,OAAO,cAA0B;AACpD,QAAM,UAAU,UAAM,0CAAiB,SAAS,GAC1C,MAAM,UAAM,sCAAiB,OAAO,GACpC,aAAS,mCAAa,0BAAe,GAAG,CAAC;AAC/C,SAAO,OAAO,GACd,QAAQ,KAAK,iCAAiC,QAAQ,IAAI,EAAE,GAC5D,MAAM,IAAI,QAAc,CAAC,QAAQ;AAC/B,WAAO,GAAG,SAAS,MAAM;AACvB,UAAI;AAAA,IACN,CAAC;AAAA,EACH,CAAC;AACH;",
+  "names": []
 }

package/dist/cjs/exports/serve.native.js

@@ -1,9 +1,8 @@
 "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 __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: !0 });
@@ -13,20 +12,13 @@ var __export = (target, all) => {
       !__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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
 var serve_exports = {};
 __export(serve_exports, {
   serve: () => serve
 });
 module.exports = __toCommonJS(serve_exports);
-var import_node_http = require("node:http"), import_sirv = __toESM(require("sirv"), 1), import_getOptionsFilled = require("../utils/getOptionsFilled"), import_h3 = require("h3");
+var import_h3 = require("h3"), import_node_http = require("node:http"), import_createServer = require("./createServer"), import_getOptionsFilled = require("../utils/getOptionsFilled");
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
   try {
     var info = gen[key](arg), value = info.value;
@@ -144,7 +136,7 @@ function _ts_generator(thisArg, body) {
 }
 var serve = function() {
   var _ref = _async_to_generator(function(optionsIn) {
-    var options, app, sirvStaticMiddleware, sirvMiddleware, server;
+    var options, app, server;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         case 0:
@@ -153,59 +145,12 @@ var serve = function() {
             (0, import_getOptionsFilled.getOptionsFilled)(optionsIn)
           ];
         case 1:
-          return options = _state.sent(), app = (0, import_h3.createApp)(), sirvStaticMiddleware = (0, import_sirv.default)("dist/static", {
-            gzip: !0
-          }), options.serve && options.serve(options, app), app.use((0, import_h3.defineEventHandler)(function() {
-            var _ref2 = _async_to_generator(function(param) {
-              var _param_node, req, res;
-              return _ts_generator(this, function(_state2) {
-                switch (_state2.label) {
-                  case 0:
-                    return _param_node = param.node, req = _param_node.req, res = _param_node.res, [
-                      4,
-                      new Promise(function(response) {
-                        sirvStaticMiddleware(req, res, function() {
-                          response();
-                        });
-                      })
-                    ];
-                  case 1:
-                    return _state2.sent(), [
-                      2
-                    ];
-                }
-              });
-            });
-            return function(_) {
-              return _ref2.apply(this, arguments);
-            };
-          }())), sirvMiddleware = (0, import_sirv.default)("dist/client", {
-            gzip: !0
-          }), app.use((0, import_h3.defineEventHandler)(function() {
-            var _ref2 = _async_to_generator(function(param) {
-              var _param_node, req, res;
-              return _ts_generator(this, function(_state2) {
-                switch (_state2.label) {
-                  case 0:
-                    return _param_node = param.node, req = _param_node.req, res = _param_node.res, [
-                      4,
-                      new Promise(function(response) {
-                        sirvMiddleware(req, res, function() {
-                          response();
-                        });
-                      })
-                    ];
-                  case 1:
-                    return _state2.sent(), [
-                      2
-                    ];
-                }
-              });
-            });
-            return function(_) {
-              return _ref2.apply(this, arguments);
-            };
-          }())), server = (0, import_node_http.createServer)((0, import_h3.toNodeListener)(app)), server.listen(3333), console.info("Listening on http://localhost:3333"), [
+          return options = _state.sent(), [
+            4,
+            (0, import_createServer.createProdServer)(options)
+          ];
+        case 2:
+          return app = _state.sent(), server = (0, import_node_http.createServer)((0, import_h3.toNodeListener)(app)), server.listen(), console.info("Listening on http://localhost:".concat(options.port)), [
             4,
             new Promise(function(res) {
               server.on("close", function() {
@@ -213,7 +158,7 @@ var serve = function() {
               });
             })
           ];
-        case 2:
+        case 3:
           return _state.sent(), [
             2
           ];

package/dist/cjs/exports/serve.native.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../../src/exports/Users/n8/vxrn/packages/vxrn/src/exports/serve.ts"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,uBAA6B,sBAC7B,cAAiB,6BAEjB,0BAAiC,sCACjC,YAA8D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEvD,IAAMA,QAAAA,WAAAA;aAAQ,oBAAA,SAAOC,WAAAA;QACpBC,SAEAC,KAEAC,sBAkBAC,gBAcAC;;;;AApCU,iBAAA;;gBAAMC,0CAAiBN,SAAAA;;;AAAjCC,2BAAU,OAAA,KAAA,GAEVC,UAAMK,qBAAAA,GAENJ,2BAAuBK,YAAAA,SAAK,eAAe;YAC/CC,MAAM;UACR,CAAA,GAEIR,QAAQF,SACVE,QAAQF,MAAME,SAASC,GAAAA,GAGzBA,IAAIQ,QACFC,8BAAAA,WAAAA;wBAAmB,oBAAA,SAAA,OAAA;+BAAiBC,KAAKC;;;;+CAAbC,MAAQF,MAAAA,YAAAA,KAAKC,MAAAA,YAAAA,KACvC;;sBAAM,IAAIE,QAAc,SAACC,UAAAA;AACvBb,6CAAqBS,KAAKC,KAAK,WAAA;AAC7BG,mCAAAA;wBACF,CAAA;sBACF,CAAA;;;AAJA,2BAAAC,QAAA,KAAA;;;;;YAKF,CAAA;;;;iBAGIb,qBAAiBI,YAAAA,SAAK,eAAe;YACzCC,MAAM;UACR,CAAA,GAEAP,IAAIQ,QACFC,8BAAAA,WAAAA;wBAAmB,oBAAA,SAAA,OAAA;+BAAiBC,KAAKC;;;;+CAAbC,MAAQF,MAAAA,YAAAA,KAAKC,MAAAA,YAAAA,KACvC;;sBAAM,IAAIE,QAAc,SAACC,UAAAA;AACvBZ,uCAAeQ,KAAKC,KAAK,WAAA;AACvBG,mCAAAA;wBACF,CAAA;sBACF,CAAA;;;AAJA,2BAAAC,QAAA,KAAA;;;;;YAKF,CAAA;;;;iBAGIZ,aAASa,mCAAaC,0BAAejB,GAAAA,CAAAA,GAC3CG,OAAOe,OAAO,IAAA,GACdC,QAAQC,KAAM,oCAAA,GAEd;;YAAM,IAAIP,QAAc,SAACF,KAAAA;AACvBR,qBAAOkB,GAAG,SAAS,WAAA;AACjBV,oBAAAA;cACF,CAAA;YACF,CAAA;;;AAJA,wBAAA,KAAA;;;;;EAKF,CAAA;kBA9C4Bb,WAAAA;;;;",
-  "names": ["serve", "optionsIn", "options", "app", "sirvStaticMiddleware", "sirvMiddleware", "server", "getOptionsFilled", "createApp", "sirv", "gzip", "use", "defineEventHandler", "req", "res", "node", "Promise", "response", "_state", "createServer", "toNodeListener", "listen", "console", "info", "on"]
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA,gBAA+B,eAC/B,mBAA6B,sBAE7B,sBAAiC,2BACjC,0BAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE1B,IAAMA,QAAAA,WAAAA;aAAQ,oBAAA,SAAOC,WAAAA;QACpBC,SACAC,KACAC;;;;AAFU,iBAAA;;gBAAMC,0CAAiBJ,SAAAA;;;AAAjCC,2BAAU,OAAA,KAAA,GACJ;;gBAAMI,sCAAiBJ,OAAAA;;;AAA7BC,uBAAM,OAAA,KAAA,GACNC,aAASG,mCAAaC,0BAAeL,GAAAA,CAAAA,GAC3CC,OAAOK,OAAM,GACbC,QAAQC,KAAM,iCAA6C,OAAbT,QAAQU,IAAI,CAAA,GAC1D;;YAAM,IAAIC,QAAc,SAACC,KAAAA;AACvBV,qBAAOW,GAAG,SAAS,WAAA;AACjBD,oBAAAA;cACF,CAAA;YACF,CAAA;;;AAJA,wBAAA,KAAA;;;;;EAKF,CAAA;kBAX4Bb,WAAAA;;;;",
+  "names": ["serve", "optionsIn", "options", "app", "server", "getOptionsFilled", "createProdServer", "createServer", "toNodeListener", "listen", "console", "info", "port", "Promise", "res", "on"]
 }

package/dist/esm/exports/createServer.js

@@ -0,0 +1,32 @@
+import { createApp, defineEventHandler } from "h3";
+import sirv from "sirv";
+const createProdServer = async (options) => {
+  const app = createApp(), sirvStaticMiddleware = sirv("dist/static", {
+    gzip: !0
+  });
+  options.serve && options.serve(options, app), app.use(
+    defineEventHandler(async ({ node: { req, res } }) => {
+      await new Promise((response) => {
+        sirvStaticMiddleware(req, res, () => {
+          response();
+        });
+      });
+    })
+  );
+  const sirvMiddleware = sirv("dist/client", {
+    gzip: !0
+  });
+  return app.use(
+    defineEventHandler(async ({ node: { req, res } }) => {
+      await new Promise((response) => {
+        sirvMiddleware(req, res, () => {
+          response();
+        });
+      });
+    })
+  ), app;
+};
+export {
+  createProdServer
+};
+//# sourceMappingURL=createServer.js.map

package/dist/esm/exports/createServer.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/exports/createServer.ts"],
+  "mappings": "AAAA,SAAS,WAAW,0BAA0B;AAC9C,OAAO,UAAU;AAGV,MAAM,mBAAmB,OAAO,YAAwB;AAC7D,QAAM,MAAM,UAAU,GAEhB,uBAAuB,KAAK,eAAe;AAAA,IAC/C,MAAM;AAAA,EACR,CAAC;AAED,EAAI,QAAQ,SACV,QAAQ,MAAM,SAAS,GAAG,GAG5B,IAAI;AAAA,IACF,mBAAmB,OAAO,EAAE,MAAM,EAAE,KAAK,IAAI,EAAE,MAAM;AACnD,YAAM,IAAI,QAAc,CAAC,aAAa;AACpC,6BAAqB,KAAK,KAAK,MAAM;AACnC,mBAAS;AAAA,QACX,CAAC;AAAA,MACH,CAAC;AAAA,IACH,CAAC;AAAA,EACH;AAEA,QAAM,iBAAiB,KAAK,eAAe;AAAA,IACzC,MAAM;AAAA,EACR,CAAC;AAED,aAAI;AAAA,IACF,mBAAmB,OAAO,EAAE,MAAM,EAAE,KAAK,IAAI,EAAE,MAAM;AACnD,YAAM,IAAI,QAAc,CAAC,aAAa;AACpC,uBAAe,KAAK,KAAK,MAAM;AAC7B,mBAAS;AAAA,QACX,CAAC;AAAA,MACH,CAAC;AAAA,IACH,CAAC;AAAA,EACH,GAEO;AACT;",
+  "names": []
+}

package/dist/esm/exports/createServer.mjs

@@ -0,0 +1,36 @@
+import { createApp, defineEventHandler } from "h3";
+import sirv from "sirv";
+const createProdServer = async options => {
+  const app = createApp(),
+    sirvStaticMiddleware = sirv("dist/static", {
+      gzip: !0
+    });
+  options.serve && options.serve(options, app), app.use(defineEventHandler(async ({
+    node: {
+      req,
+      res
+    }
+  }) => {
+    await new Promise(response => {
+      sirvStaticMiddleware(req, res, () => {
+        response();
+      });
+    });
+  }));
+  const sirvMiddleware = sirv("dist/client", {
+    gzip: !0
+  });
+  return app.use(defineEventHandler(async ({
+    node: {
+      req,
+      res
+    }
+  }) => {
+    await new Promise(response => {
+      sirvMiddleware(req, res, () => {
+        response();
+      });
+    });
+  })), app;
+};
+export { createProdServer };

package/dist/esm/exports/createServer.native.js

@@ -0,0 +1,187 @@
+import { createApp, defineEventHandler } from "h3";
+import sirv from "sirv";
+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 _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 createProdServer = function() {
+  var _ref = _async_to_generator(function(options) {
+    var app, sirvStaticMiddleware, sirvMiddleware;
+    return _ts_generator(this, function(_state) {
+      return app = createApp(), sirvStaticMiddleware = sirv("dist/static", {
+        gzip: !0
+      }), options.serve && options.serve(options, app), app.use(defineEventHandler(function() {
+        var _ref2 = _async_to_generator(function(param) {
+          var _param_node, req, res;
+          return _ts_generator(this, function(_state2) {
+            switch (_state2.label) {
+              case 0:
+                return _param_node = param.node, req = _param_node.req, res = _param_node.res, [
+                  4,
+                  new Promise(function(response) {
+                    sirvStaticMiddleware(req, res, function() {
+                      response();
+                    });
+                  })
+                ];
+              case 1:
+                return _state2.sent(), [
+                  2
+                ];
+            }
+          });
+        });
+        return function(_) {
+          return _ref2.apply(this, arguments);
+        };
+      }())), sirvMiddleware = sirv("dist/client", {
+        gzip: !0
+      }), app.use(defineEventHandler(function() {
+        var _ref2 = _async_to_generator(function(param) {
+          var _param_node, req, res;
+          return _ts_generator(this, function(_state2) {
+            switch (_state2.label) {
+              case 0:
+                return _param_node = param.node, req = _param_node.req, res = _param_node.res, [
+                  4,
+                  new Promise(function(response) {
+                    sirvMiddleware(req, res, function() {
+                      response();
+                    });
+                  })
+                ];
+              case 1:
+                return _state2.sent(), [
+                  2
+                ];
+            }
+          });
+        });
+        return function(_) {
+          return _ref2.apply(this, arguments);
+        };
+      }())), [
+        2,
+        app
+      ];
+    });
+  });
+  return function(options) {
+    return _ref.apply(this, arguments);
+  };
+}();
+export {
+  createProdServer
+};
+//# sourceMappingURL=createServer.js.map

package/dist/esm/exports/createServer.native.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/exports/Users/n8/vxrn/packages/vxrn/src/exports/createServer.ts"],
+  "mappings": "AAAA,SAASA,WAAWC,0BAA0B;AAC9C,OAAOC,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGV,IAAMC,mBAAAA,WAAAA;aAAmB,oBAAA,SAAOC,SAAAA;QAC/BC,KAEAC,sBAkBAC;;AApBAF,mBAAML,UAAAA,GAENM,uBAAuBJ,KAAK,eAAe;QAC/CM,MAAM;MACR,CAAA,GAEIJ,QAAQK,SACVL,QAAQK,MAAML,SAASC,GAAAA,GAGzBA,IAAIK,IACFT,mBAAAA,WAAAA;oBAAmB,oBAAA,SAAA,OAAA;2BAAiBU,KAAKC;;;;2CAAbC,MAAQF,MAAAA,YAAAA,KAAKC,MAAAA,YAAAA,KACvC;;kBAAM,IAAIE,QAAc,SAACC,UAAAA;AACvBT,yCAAqBK,KAAKC,KAAK,WAAA;AAC7BG,+BAAAA;oBACF,CAAA;kBACF,CAAA;;;AAJA,uBAAAC,QAAA,KAAA;;;;;QAKF,CAAA;;;;aAGIT,iBAAiBL,KAAK,eAAe;QACzCM,MAAM;MACR,CAAA,GAEAH,IAAIK,IACFT,mBAAAA,WAAAA;oBAAmB,oBAAA,SAAA,OAAA;2BAAiBU,KAAKC;;;;2CAAbC,MAAQF,MAAAA,YAAAA,KAAKC,MAAAA,YAAAA,KACvC;;kBAAM,IAAIE,QAAc,SAACC,UAAAA;AACvBR,mCAAeI,KAAKC,KAAK,WAAA;AACvBG,+BAAAA;oBACF,CAAA;kBACF,CAAA;;;AAJA,uBAAAC,QAAA,KAAA;;;;;QAKF,CAAA;;;;aAGF;;QAAOX;;;EACT,CAAA;kBApCuCD,SAAAA;;;;",
+  "names": ["createApp", "defineEventHandler", "sirv", "createProdServer", "options", "app", "sirvStaticMiddleware", "sirvMiddleware", "gzip", "serve", "use", "req", "res", "node", "Promise", "response", "_state"]
+}

package/dist/esm/exports/serve.js

@@ -1,34 +1,10 @@
+import { toNodeListener } from "h3";
 import { createServer } from "node:http";
-import sirv from "sirv";
+import { createProdServer } from "./createServer";
 import { getOptionsFilled } from "../utils/getOptionsFilled";
-import { createApp, defineEventHandler, toNodeListener } from "h3";
 const serve = async (optionsIn) => {
-  const options = await getOptionsFilled(optionsIn), app = createApp(), sirvStaticMiddleware = sirv("dist/static", {
-    gzip: !0
-  });
-  options.serve && options.serve(options, app), app.use(
-    defineEventHandler(async ({ node: { req, res } }) => {
-      await new Promise((response) => {
-        sirvStaticMiddleware(req, res, () => {
-          response();
-        });
-      });
-    })
-  );
-  const sirvMiddleware = sirv("dist/client", {
-    gzip: !0
-  });
-  app.use(
-    defineEventHandler(async ({ node: { req, res } }) => {
-      await new Promise((response) => {
-        sirvMiddleware(req, res, () => {
-          response();
-        });
-      });
-    })
-  );
-  const server = createServer(toNodeListener(app));
-  server.listen(3333), console.info("Listening on http://localhost:3333"), await new Promise((res) => {
+  const options = await getOptionsFilled(optionsIn), app = await createProdServer(options), server = createServer(toNodeListener(app));
+  server.listen(), console.info(`Listening on http://localhost:${options.port}`), await new Promise((res) => {
     server.on("close", () => {
       res();
     });

package/dist/esm/exports/serve.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../../src/exports/serve.ts"],
-  "mappings": "AAAA,SAAS,oBAAoB;AAC7B,OAAO,UAAU;AAEjB,SAAS,wBAAwB;AACjC,SAAS,WAAW,oBAAoB,sBAAsB;AAEvD,MAAM,QAAQ,OAAO,cAA0B;AACpD,QAAM,UAAU,MAAM,iBAAiB,SAAS,GAE1C,MAAM,UAAU,GAEhB,uBAAuB,KAAK,eAAe;AAAA,IAC/C,MAAM;AAAA,EACR,CAAC;AAED,EAAI,QAAQ,SACV,QAAQ,MAAM,SAAS,GAAG,GAG5B,IAAI;AAAA,IACF,mBAAmB,OAAO,EAAE,MAAM,EAAE,KAAK,IAAI,EAAE,MAAM;AACnD,YAAM,IAAI,QAAc,CAAC,aAAa;AACpC,6BAAqB,KAAK,KAAK,MAAM;AACnC,mBAAS;AAAA,QACX,CAAC;AAAA,MACH,CAAC;AAAA,IACH,CAAC;AAAA,EACH;AAEA,QAAM,iBAAiB,KAAK,eAAe;AAAA,IACzC,MAAM;AAAA,EACR,CAAC;AAED,MAAI;AAAA,IACF,mBAAmB,OAAO,EAAE,MAAM,EAAE,KAAK,IAAI,EAAE,MAAM;AACnD,YAAM,IAAI,QAAc,CAAC,aAAa;AACpC,uBAAe,KAAK,KAAK,MAAM;AAC7B,mBAAS;AAAA,QACX,CAAC;AAAA,MACH,CAAC;AAAA,IACH,CAAC;AAAA,EACH;AAEA,QAAM,SAAS,aAAa,eAAe,GAAG,CAAC;AAC/C,SAAO,OAAO,IAAI,GAClB,QAAQ,KAAK,oCAAoC,GAEjD,MAAM,IAAI,QAAc,CAAC,QAAQ;AAC/B,WAAO,GAAG,SAAS,MAAM;AACvB,UAAI;AAAA,IACN,CAAC;AAAA,EACH,CAAC;AACH;",
+  "mappings": "AAAA,SAAS,sBAAsB;AAC/B,SAAS,oBAAoB;AAE7B,SAAS,wBAAwB;AACjC,SAAS,wBAAwB;AAE1B,MAAM,QAAQ,OAAO,cAA0B;AACpD,QAAM,UAAU,MAAM,iBAAiB,SAAS,GAC1C,MAAM,MAAM,iBAAiB,OAAO,GACpC,SAAS,aAAa,eAAe,GAAG,CAAC;AAC/C,SAAO,OAAO,GACd,QAAQ,KAAK,iCAAiC,QAAQ,IAAI,EAAE,GAC5D,MAAM,IAAI,QAAc,CAAC,QAAQ;AAC/B,WAAO,GAAG,SAAS,MAAM;AACvB,UAAI;AAAA,IACN,CAAC;AAAA,EACH,CAAC;AACH;",
   "names": []
 }

package/dist/esm/exports/serve.mjs

@@ -1,42 +1,12 @@
+import { toNodeListener } from "h3";
 import { createServer } from "node:http";
-import sirv from "sirv";
+import { createProdServer } from "./createServer.mjs";
 import { getOptionsFilled } from "../utils/getOptionsFilled.mjs";
-import { createApp, defineEventHandler, toNodeListener } from "h3";
 const serve = async optionsIn => {
   const options = await getOptionsFilled(optionsIn),
-    app = createApp(),
-    sirvStaticMiddleware = sirv("dist/static", {
-      gzip: !0
-    });
-  options.serve && options.serve(options, app), app.use(defineEventHandler(async ({
-    node: {
-      req,
-      res
-    }
-  }) => {
-    await new Promise(response => {
-      sirvStaticMiddleware(req, res, () => {
-        response();
-      });
-    });
-  }));
-  const sirvMiddleware = sirv("dist/client", {
-    gzip: !0
-  });
-  app.use(defineEventHandler(async ({
-    node: {
-      req,
-      res
-    }
-  }) => {
-    await new Promise(response => {
-      sirvMiddleware(req, res, () => {
-        response();
-      });
-    });
-  }));
-  const server = createServer(toNodeListener(app));
-  server.listen(3333), console.info("Listening on http://localhost:3333"), await new Promise(res => {
+    app = await createProdServer(options),
+    server = createServer(toNodeListener(app));
+  server.listen(), console.info(`Listening on http://localhost:${options.port}`), await new Promise(res => {
     server.on("close", () => {
       res();
     });

package/dist/esm/exports/serve.native.js

@@ -1,7 +1,7 @@
+import { toNodeListener } from "h3";
 import { createServer } from "node:http";
-import sirv from "sirv";
+import { createProdServer } from "./createServer";
 import { getOptionsFilled } from "../utils/getOptionsFilled";
-import { createApp, defineEventHandler, toNodeListener } from "h3";
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
   try {
     var info = gen[key](arg), value = info.value;
@@ -119,7 +119,7 @@ function _ts_generator(thisArg, body) {
 }
 var serve = function() {
   var _ref = _async_to_generator(function(optionsIn) {
-    var options, app, sirvStaticMiddleware, sirvMiddleware, server;
+    var options, app, server;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         case 0:
@@ -128,59 +128,12 @@ var serve = function() {
             getOptionsFilled(optionsIn)
           ];
         case 1:
-          return options = _state.sent(), app = createApp(), sirvStaticMiddleware = sirv("dist/static", {
-            gzip: !0
-          }), options.serve && options.serve(options, app), app.use(defineEventHandler(function() {
-            var _ref2 = _async_to_generator(function(param) {
-              var _param_node, req, res;
-              return _ts_generator(this, function(_state2) {
-                switch (_state2.label) {
-                  case 0:
-                    return _param_node = param.node, req = _param_node.req, res = _param_node.res, [
-                      4,
-                      new Promise(function(response) {
-                        sirvStaticMiddleware(req, res, function() {
-                          response();
-                        });
-                      })
-                    ];
-                  case 1:
-                    return _state2.sent(), [
-                      2
-                    ];
-                }
-              });
-            });
-            return function(_) {
-              return _ref2.apply(this, arguments);
-            };
-          }())), sirvMiddleware = sirv("dist/client", {
-            gzip: !0
-          }), app.use(defineEventHandler(function() {
-            var _ref2 = _async_to_generator(function(param) {
-              var _param_node, req, res;
-              return _ts_generator(this, function(_state2) {
-                switch (_state2.label) {
-                  case 0:
-                    return _param_node = param.node, req = _param_node.req, res = _param_node.res, [
-                      4,
-                      new Promise(function(response) {
-                        sirvMiddleware(req, res, function() {
-                          response();
-                        });
-                      })
-                    ];
-                  case 1:
-                    return _state2.sent(), [
-                      2
-                    ];
-                }
-              });
-            });
-            return function(_) {
-              return _ref2.apply(this, arguments);
-            };
-          }())), server = createServer(toNodeListener(app)), server.listen(3333), console.info("Listening on http://localhost:3333"), [
+          return options = _state.sent(), [
+            4,
+            createProdServer(options)
+          ];
+        case 2:
+          return app = _state.sent(), server = createServer(toNodeListener(app)), server.listen(), console.info("Listening on http://localhost:".concat(options.port)), [
             4,
             new Promise(function(res) {
               server.on("close", function() {
@@ -188,7 +141,7 @@ var serve = function() {
               });
             })
           ];
-        case 2:
+        case 3:
           return _state.sent(), [
             2
           ];

package/dist/esm/exports/serve.native.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../../src/exports/Users/n8/vxrn/packages/vxrn/src/exports/serve.ts"],
-  "mappings": "AAAA,SAASA,oBAAoB;AAC7B,OAAOC,UAAU;AAEjB,SAASC,wBAAwB;AACjC,SAASC,WAAWC,oBAAoBC,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEvD,IAAMC,QAAAA,WAAAA;aAAQ,oBAAA,SAAOC,WAAAA;QACpBC,SAEAC,KAEAC,sBAkBAC,gBAcAC;;;;AApCU,iBAAA;;YAAMV,iBAAiBK,SAAAA;;;AAAjCC,2BAAU,OAAA,KAAA,GAEVC,MAAMN,UAAAA,GAENO,uBAAuBT,KAAK,eAAe;YAC/CY,MAAM;UACR,CAAA,GAEIL,QAAQF,SACVE,QAAQF,MAAME,SAASC,GAAAA,GAGzBA,IAAIK,IACFV,mBAAAA,WAAAA;wBAAmB,oBAAA,SAAA,OAAA;+BAAiBW,KAAKC;;;;+CAAbC,MAAQF,MAAAA,YAAAA,KAAKC,MAAAA,YAAAA,KACvC;;sBAAM,IAAIE,QAAc,SAACC,UAAAA;AACvBT,6CAAqBK,KAAKC,KAAK,WAAA;AAC7BG,mCAAAA;wBACF,CAAA;sBACF,CAAA;;;AAJA,2BAAAC,QAAA,KAAA;;;;;YAKF,CAAA;;;;iBAGIT,iBAAiBV,KAAK,eAAe;YACzCY,MAAM;UACR,CAAA,GAEAJ,IAAIK,IACFV,mBAAAA,WAAAA;wBAAmB,oBAAA,SAAA,OAAA;+BAAiBW,KAAKC;;;;+CAAbC,MAAQF,MAAAA,YAAAA,KAAKC,MAAAA,YAAAA,KACvC;;sBAAM,IAAIE,QAAc,SAACC,UAAAA;AACvBR,uCAAeI,KAAKC,KAAK,WAAA;AACvBG,mCAAAA;wBACF,CAAA;sBACF,CAAA;;;AAJA,2BAAAC,QAAA,KAAA;;;;;YAKF,CAAA;;;;iBAGIR,SAASZ,aAAaK,eAAeI,GAAAA,CAAAA,GAC3CG,OAAOS,OAAO,IAAA,GACdC,QAAQC,KAAM,oCAAA,GAEd;;YAAM,IAAIL,QAAc,SAACF,KAAAA;AACvBJ,qBAAOY,GAAG,SAAS,WAAA;AACjBR,oBAAAA;cACF,CAAA;YACF,CAAA;;;AAJA,wBAAA,KAAA;;;;;EAKF,CAAA;kBA9C4BT,WAAAA;;;;",
-  "names": ["createServer", "sirv", "getOptionsFilled", "createApp", "defineEventHandler", "toNodeListener", "serve", "optionsIn", "options", "app", "sirvStaticMiddleware", "sirvMiddleware", "server", "gzip", "use", "req", "res", "node", "Promise", "response", "_state", "listen", "console", "info", "on"]
+  "mappings": "AAAA,SAASA,sBAAsB;AAC/B,SAASC,oBAAoB;AAE7B,SAASC,wBAAwB;AACjC,SAASC,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE1B,IAAMC,QAAAA,WAAAA;aAAQ,oBAAA,SAAOC,WAAAA;QACpBC,SACAC,KACAC;;;;AAFU,iBAAA;;YAAML,iBAAiBE,SAAAA;;;AAAjCC,2BAAU,OAAA,KAAA,GACJ;;YAAMJ,iBAAiBI,OAAAA;;;AAA7BC,uBAAM,OAAA,KAAA,GACNC,SAASP,aAAaD,eAAeO,GAAAA,CAAAA,GAC3CC,OAAOC,OAAM,GACbC,QAAQC,KAAM,iCAA6C,OAAbL,QAAQM,IAAI,CAAA,GAC1D;;YAAM,IAAIC,QAAc,SAACC,KAAAA;AACvBN,qBAAOO,GAAG,SAAS,WAAA;AACjBD,oBAAAA;cACF,CAAA;YACF,CAAA;;;AAJA,wBAAA,KAAA;;;;;EAKF,CAAA;kBAX4BT,WAAAA;;;;",
+  "names": ["toNodeListener", "createServer", "createProdServer", "getOptionsFilled", "serve", "optionsIn", "options", "app", "server", "listen", "console", "info", "port", "Promise", "res", "on"]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vxrn",
-  "version": "0.1.57",
+  "version": "0.1.59",
   "source": "src/index.ts",
   "types": "./types/index.d.ts",
   "type": "module",
@@ -23,18 +23,23 @@
       "types": "./types/index.d.ts",
       "import": "./dist/esm/index.mjs",
       "require": "./dist/cjs/index.js"
+    },
+    "./serve": {
+      "types": "./types/exports/createServer.d.ts",
+      "import": "./dist/esm/exports/createServer.mjs",
+      "require": "./dist/cjs/exports/createServer.js"
     }
   },
   "dependencies": {
     "@babel/code-frame": "^7.21.4",
     "@vitejs/plugin-react": "^4.2.1",
     "@vitejs/plugin-react-swc": "^3.6.0",
-    "@vxrn/react-native-prebuilt": "0.1.57",
-    "@vxrn/safe-area": "0.1.57",
-    "@vxrn/vite-flow": "0.1.57",
-    "@vxrn/vite-native-client": "0.1.57",
-    "@vxrn/vite-native-hmr": "0.1.57",
-    "@vxrn/vite-native-swc": "0.1.57",
+    "@vxrn/react-native-prebuilt": "0.1.59",
+    "@vxrn/safe-area": "0.1.59",
+    "@vxrn/vite-flow": "0.1.59",
+    "@vxrn/vite-native-client": "0.1.59",
+    "@vxrn/vite-native-hmr": "0.1.59",
+    "@vxrn/vite-native-swc": "0.1.59",
     "citty": "^0.1.6",
     "crossws": "^0.2.4",
     "es-module-lexer": "^1.3.0",
@@ -60,8 +65,8 @@
     "sirv": "^2.0.4",
     "source-map": "^0.7.3",
     "url": "^0.11.0",
-    "vite": "alpha",
-    "vxs": "0.1.57",
+    "vite": "6.0.0-alpha.11",
+    "vxs": "0.1.59",
     "ws": "^8.7.0"
   },
   "devDependencies": {

package/src/exports/createServer.ts

@@ -0,0 +1,41 @@
+import { createApp, defineEventHandler } from 'h3'
+import sirv from 'sirv'
+import type { VXRNConfig } from '../types'
+
+export const createProdServer = async (options: VXRNConfig) => {
+  const app = createApp()
+
+  const sirvStaticMiddleware = sirv('dist/static', {
+    gzip: true,
+  })
+
+  if (options.serve) {
+    options.serve(options, app)
+  }
+
+  app.use(
+    defineEventHandler(async ({ node: { req, res } }) => {
+      await new Promise<void>((response) => {
+        sirvStaticMiddleware(req, res, () => {
+          response()
+        })
+      })
+    })
+  )
+
+  const sirvMiddleware = sirv('dist/client', {
+    gzip: true,
+  })
+
+  app.use(
+    defineEventHandler(async ({ node: { req, res } }) => {
+      await new Promise<void>((response) => {
+        sirvMiddleware(req, res, () => {
+          response()
+        })
+      })
+    })
+  )
+
+  return app
+}

package/src/exports/serve.ts

@@ -1,50 +1,15 @@
+import { toNodeListener } from 'h3'
 import { createServer } from 'node:http'
-import sirv from 'sirv'
 import type { VXRNConfig } from '../types'
+import { createProdServer } from './createServer'
 import { getOptionsFilled } from '../utils/getOptionsFilled'
-import { createApp, defineEventHandler, toNodeListener } from 'h3'
 
 export const serve = async (optionsIn: VXRNConfig) => {
   const options = await getOptionsFilled(optionsIn)
-
-  const app = createApp()
-
-  const sirvStaticMiddleware = sirv('dist/static', {
-    gzip: true,
-  })
-
-  if (options.serve) {
-    options.serve(options, app)
-  }
-
-  app.use(
-    defineEventHandler(async ({ node: { req, res } }) => {
-      await new Promise<void>((response) => {
-        sirvStaticMiddleware(req, res, () => {
-          response()
-        })
-      })
-    })
-  )
-
-  const sirvMiddleware = sirv('dist/client', {
-    gzip: true,
-  })
-
-  app.use(
-    defineEventHandler(async ({ node: { req, res } }) => {
-      await new Promise<void>((response) => {
-        sirvMiddleware(req, res, () => {
-          response()
-        })
-      })
-    })
-  )
-
+  const app = await createProdServer(options)
   const server = createServer(toNodeListener(app))
-  server.listen(3333)
-  console.info(`Listening on http://localhost:3333`)
-
+  server.listen()
+  console.info(`Listening on http://localhost:${options.port}`)
   await new Promise<void>((res) => {
     server.on('close', () => {
       res()

package/types/exports/createServer.d.ts

@@ -0,0 +1,3 @@
+import type { VXRNConfig } from '../types';
+export declare const createProdServer: (options: VXRNConfig) => Promise<import("h3").App>;
+//# sourceMappingURL=createServer.d.ts.map