vxrn 0.1.50 → 0.1.52

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

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

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

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../../src/utils/Users/n8/vxrn/packages/vxrn/src/utils/readVXRNConfig.ts"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,sBAAoB,iCAEpB,cAA6B,iBAC7B,cAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEjB,SAAsBA,iBAAAA;SAAAA,gBAAAA,MAAAA,MAAAA,SAAAA;;SAAAA,kBAAAA;AAAAA,2BAAf,oBAAA,WAAA;QAMGC,aAGAC,YAC8BA,qBAM9BC,MAKAD,aAK8BA,sBAC7BE;;;;AA1BH,iBAAA;;YAAMC,gBAAAA,QAAQC,WAAW,gBAAA;;;AAA/B,cAAI,CAAE,OAAA,KAAA;AACJ,mBAAA;;cAAO,CAAC;;AAGV,cAAIC,QAAQC,IAAIC;AACRR,qCAAcS,YAAAA,SAAKH,QAAQI,IAAG,GAAI;cACtCC,YAAY;YACd,CAAA,GACMV,aAAaD,YAAY,kBAAA,GAC/B;;cAAOY,8BAA6BX,sBAAAA,cAAAA,OAAAA,SAAAA,WAAYY,aAAO,QAAnBZ,wBAAAA,SAAAA,sBAAuB,CAAC,CAAA;;;;;;;;;cAM/C;;gBAAMa,0BAAa;cAC9BC,UAAU;cACVC,SAAS;YACX,CAAA;;;AAHMd,wBAAO,OAAA,KAAA,GAKM;;YAAMA,KAAKe,cAAc,oBAAoB;cAC9DC,eAAe;YACjB,CAAA;;;AAFMjB,+BAAa,OAAA,KAAA,GAInB;;YAAMC,KAAKiB,MAAK;;;AAAhB,wBAAA,KAAA,GACA;;YAAOP,8BAA6BX,uBAAAA,eAAAA,OAAAA,SAAAA,YAAYY,aAAO,QAAnBZ,yBAAAA,SAAAA,uBAAuB,CAAC,CAAA;;;AACrDE,sBAAAA,OAAAA,KAAAA,GACPiB,QAAQC,KAAM;;EAEN,OAAVlB,IAAImB,OAAM;;qCAAA,CAAA,GAGFnB;;;;;;;EAEV,CAAA,GAnCsBJ,gBAAAA,MAAAA,MAAAA,SAAAA;;SAqCPa,6BAA6BW,OAAU;SAAvCX,8BAAAA,MAAAA,MAAAA,SAAAA;;SAAAA,gCAAAA;AAAAA,yCAAf,oBAAA,SAA4CW,OAAU;;;;iBAChD,OAAOA,SAAU,eACnBA,QAAQA,MAAAA,IAED,YAALA,OAAiBC,OAAAA,IACX;;YAAMD;cADZA;;;;;AACFA,kBAAQ,OAAA,KAAA;;AAEV,iBAAA;;YAAOA;;;;EACT,CAAA,GAReX,8BAAAA,MAAAA,MAAAA,SAAAA;;",
-  "names": ["readVXRNConfig", "requireFile", "userConfig", "vite", "err", "FSExtra", "pathExists", "process", "env", "VXRN_CJS", "jiti", "cwd", "esmResolve", "resolveOptionalAsyncFunction", "default", "createServer", "logLevel", "appType", "ssrLoadModule", "fixStacktrace", "close", "console", "info", "stack", "value", "Promise"]
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,sBAAoB,iCAEpB,mBAAqB,sBACrB,iBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEtB,SAAsBA,iBAAAA;SAAAA,gBAAAA,MAAAA,MAAAA,SAAAA;;SAAAA,kBAAAA;AAAAA,2BAAf,oBAAA,WAAA;QAKCC,SAcEC,gBAGCC;;;;AArBH,iBAAA;;YAAMC,gBAAAA,QAAQC,WAAW,gBAAA;;;AAA/B,cAAI,CAAE,OAAA,KAAA;AACJ,mBAAA;;cAAO,CAAC;;AAGJJ,wBAAUK,uBAAKC,QAAQC,IAAG,GAAI,gBAAA;;;;;;;cAIlC;;gBAAMC,sBAAM;cACVC,aAAW;gBAAG;;cACdC,QAAQ;cACRV;cACAW,UAAU;cACVC,QAAQ;cACRC,WAAW;cACXC,QAAQ;YACV,CAAA;;;AARA,wBAAA,KAAA,GAUwB;;YAAM,OAAOd;;;AAA/BC,kCAAkB,OAAA,KAAA,EAAuBc,SAExC;;YAAMC,6BAA6Bf,cAAAA;;;AAA1C,iBAAA;;YAAO,OAAA,KAAA;;;AACAC,sBAAAA,OAAAA,KAAAA,GACPe,QAAQC,MAAO,uCAAA,GACThB;;AAENC,iCAAAA,QAAQgB,WAAWnB,OAAAA;;;;;;;;;EAEvB,CAAA,GA5BsBD,gBAAAA,MAAAA,MAAAA,SAAAA;;SA8BPiB,6BAA6BI,OAAU;SAAvCJ,8BAAAA,MAAAA,MAAAA,SAAAA;;SAAAA,gCAAAA;AAAAA,yCAAf;IAAA,SAA4CI,OAAU;;;;mBAChD,OAAOA,SAAU,eACnBA,QAAQA,MAAAA,IAED,YAALA,OAAiBC,OAAAA,IACX;;cAAMD;gBADZA;;;;;AACFA,oBAAQ,OAAA,KAAA;;AAEV,mBAAA;;cAAOA;;;;IACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAReJ,8BAAAA,MAAAA,MAAAA,SAAAA;;",
+  "names": ["readVXRNConfig", "outfile", "exportedConfig", "err", "FSExtra", "pathExists", "join", "process", "cwd", "build", "entryPoints", "bundle", "platform", "format", "sourcemap", "minify", "default", "resolveOptionalAsyncFunction", "console", "error", "removeSync", "value", "Promise"]
 }

package/dist/cjs/utils/resolveFile.js

@@ -0,0 +1,28 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var resolveFile_exports = {};
+__export(resolveFile_exports, {
+  resolveFile: () => resolveFile
+});
+module.exports = __toCommonJS(resolveFile_exports);
+var import_import_meta_resolve = require("import-meta-resolve");
+const import_meta = {}, resolveFile = (path) => {
+  try {
+    return (0, import_import_meta_resolve.resolve)(path, import_meta.url).replace("file://", "");
+  } catch {
+    return require.resolve(path);
+  }
+};
+//# sourceMappingURL=resolveFile.js.map

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

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/resolveFile.ts"],
+  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iCAA6C;AAA7C,wBAEa,cAAc,CAAC,SAAiB;AAC3C,MAAI;AACF,eAAO,2BAAAA,SAAkB,MAAM,YAAY,GAAG,EAAE,QAAQ,WAAW,EAAE;AAAA,EACvE,QAAQ;AACN,WAAO,QAAQ,QAAQ,IAAI;AAAA,EAC7B;AACF;",
+  "names": ["importMetaResolve"]
+}

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

@@ -0,0 +1,34 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var resolveFile_exports = {};
+__export(resolveFile_exports, {
+  resolveFile: () => resolveFile
+});
+module.exports = __toCommonJS(resolveFile_exports);
+var import_import_meta_resolve = require("import-meta-resolve");
+const import_meta = {};
+var resolveFile = function(path) {
+  try {
+    return (0, import_import_meta_resolve.resolve)(path, import_meta.url).replace("file://", "");
+  } catch {
+    return require.resolve(path);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolveFile
+});
+//# sourceMappingURL=resolveFile.js.map

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

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/Users/n8/vxrn/packages/vxrn/src/utils/resolveFile.ts"],
+  "mappings": ";;;;;;;;;;;;;;;AAAA;;;;;iCAA6C;AAA7C;AAEO,IAAMA,cAAc,SAACC,MAAAA;AAC1B,MAAI;AACF,eAAOC,2BAAAA,SAAkBD,MAAM,YAAYE,GAAG,EAAEC,QAAQ,WAAW,EAAA;EACrE,QAAQ;AACN,WAAOC,QAAQC,QAAQL,IAAAA;EACzB;AACF;",
+  "names": ["resolveFile", "path", "importMetaResolve", "url", "replace", "require", "resolve"]
+}

package/dist/cjs/utils/swapPrebuiltReactModules.js

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

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

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/swapPrebuiltReactModules.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,sBAAyB,6BACzB,mBAAuC,sBACvC,+BAA4D,wCAE5D,qBAA4B,0BAC5B,kBAAoB,iCACpB,gCAAuC;AAKvC,eAAsB,yBAAyB,UAAkB;AAC/D,QAAM,YAAY;AAAA,IAChB,cAAU,uBAAK,UAAU,sBAAsB;AAAA,IAC/C,WAAO,uBAAK,UAAU,UAAU;AAAA,IAChC,iBAAa,uBAAK,UAAU,iBAAiB;AAAA,EAC/C;AAEA,EAAM,MAAM,gBAAAA,QAAQ,WAAW,UAAU,WAAW,MAClD,QAAQ,KAAK,uEAAuE,GACpF,MAAM,QAAQ,IAAI;AAAA,QAChB,+CAAiB;AAAA,MACf,aAAa,KAAC,gCAAY,cAAc,CAAC;AAAA,MACzC,SAAS,UAAU;AAAA,IACrB,CAAC;AAAA,QACD,yCAAW;AAAA,MACT,aAAa,KAAC,gCAAY,OAAO,CAAC;AAAA,MAClC,SAAS,UAAU;AAAA,IACrB,CAAC;AAAA,QACD,4CAAc;AAAA,MACZ,aAAa,KAAC,gCAAY,uBAAuB,CAAC;AAAA,MAClD,SAAS,UAAU;AAAA,IACrB,CAAC;AAAA,EACH,CAAC;AAIH,QAAM,aAAa;AAAA;AAAA,IAEjB,OAAO,UAAU;AAAA,IACjB,UAAU,UAAM,0BAAS,UAAU,UAAU,OAAO;AAAA,EACtD,GAEM,iBAAiB;AAAA,IACrB,gBAAgB;AAAA;AAAA,MAEd,OAAO,UAAU;AAAA,MACjB,UAAU,UAAM,0BAAS,UAAU,aAAa,OAAO;AAAA,IACzD;AAAA,IACA,OAAO;AAAA;AAAA,MAEL,OAAO,UAAU;AAAA,MACjB,UAAU,UAAM,0BAAS,UAAU,OAAO,OAAO;AAAA,IACnD;AAAA,IACA,qBAAqB;AAAA,IACrB,yBAAyB;AAAA,EAC3B;AAEA,SAAO;AAAA,IACL,MAAM;AAAA,IACN,SAAS;AAAA,IAET,UAAU,IAAI,WAAW,IAAI;AAC3B,UAAI,GAAG,WAAW,wBAAwB;AACxC,eAAO,wBAAwB,EAAE;AAInC,UAAI,OAAO;AACT,eAAO,UAAU;AAGnB,iBAAW,YAAY;AACrB,YAAI,OAAO,YAAY,GAAG,SAAS,gBAAgB,QAAQ,GAAG;AAG5D,iBAFa,eAAe,QAAQ,EAExB;AAQhB,UAAI,wDACE,GAAG,CAAC,MAAM,KAAK;AACjB,cAAM,mBAAe,8BAAQ,0BAAQ,QAAQ,GAAG,EAAE,GAC5C,aAAa,aAAa,QAAQ,WAAW,YAAY;AAC/D,YAAI,eAAe;AAAI;AACvB,YAAI;AACF,gBAAM,gBAAgB,eAAe,oBAC/B,yBAAyB,eAAe;AAC9C,cAAI,gBAAAA,QAAQ,eAAe,aAAa;AACtC,mBAAO;AAET,cAAI,gBAAAA,QAAQ,eAAe,sBAAsB;AAC/C,mBAAO;AAET,cAAI,gBAAAA,QAAQ,eAAe,UAAU;AACnC,mBAAO;AAAA,QAEX,SAAS,KAAK;AACZ,kBAAQ,KAAK,uBAAuB,GAAG;AAAA,QACzC;AAAA,MACF;AAAA,IAEJ;AAAA,IAEA,KAAK,IAAI;AACP,UAAI,GAAG,WAAW,sBAAsB;AAKtC,eAHU,mCADI,GAAG,QAAQ,yBAAyB,EAAE,CACF;AAAA;AAAA;AAMpD,iBAAW,YAAY,gBAAgB;AACrC,cAAM,OAAO,eAAe,QAAuC;AACnE,YAAI,OAAO,KAAK;AACd,iBAAO,KAAK;AAAA,MAEhB;AAAA,IACF;AAAA,EACF;AACF;",
+  "names": ["FSExtra"]
+}