@wix/cli-app 1.1.81 → 1.1.82

package/build/{chunk-DBASREIW.js → chunk-PGKXOCZN.js}

@@ -3,7 +3,7 @@ const require = _createRequire(import.meta.url);
 import {
   getBackendEventSlug,
   require_baseUniq
-} from "./chunk-OPFPQV74.js";
+} from "./chunk-XDWVTYW3.js";
 import {
   BLOCKS_WIDGETS_PANELS_PATTERN,
   BLOCKS_WIDGETS_PATTERN,
@@ -50,6 +50,7 @@ import {
   require_build,
   require_lib,
   require_picomatch,
+  require_src,
   virtualBlocksWidgetPanelScriptAssets,
   virtualBlocksWidgetScriptAssets,
   virtualCustomElementPanelHTMLAssets,
@@ -64,7 +65,7 @@ import {
   virtualPathForCustomElementPanelHTMLAsset,
   virtualPathForHTMLAsset,
   z
-} from "./chunk-2Y6DEXNR.js";
+} from "./chunk-GGQMSU4O.js";
 import {
   __commonJS,
   __esm,
@@ -75,6 +76,233 @@ import {
   init_esm_shims
 } from "./chunk-PYIAC2GK.js";
 
+// ../../node_modules/globrex/index.js
+var require_globrex = __commonJS({
+  "../../node_modules/globrex/index.js"(exports, module) {
+    "use strict";
+    init_esm_shims();
+    var isWin = process.platform === "win32";
+    var SEP = isWin ? `\\\\+` : `\\/`;
+    var SEP_ESC = isWin ? `\\\\` : `/`;
+    var GLOBSTAR2 = `((?:[^/]*(?:/|$))*)`;
+    var WILDCARD = `([^/]*)`;
+    var GLOBSTAR_SEGMENT = `((?:[^${SEP_ESC}]*(?:${SEP_ESC}|$))*)`;
+    var WILDCARD_SEGMENT = `([^${SEP_ESC}]*)`;
+    function globrex(glob, { extended = false, globstar = false, strict = false, filepath = false, flags = "" } = {}) {
+      let regex = "";
+      let segment = "";
+      let path9 = { regex: "", segments: [] };
+      let inGroup = false;
+      let inRange = false;
+      const ext2 = [];
+      function add2(str, { split: split2, last, only } = {}) {
+        if (only !== "path") regex += str;
+        if (filepath && only !== "regex") {
+          path9.regex += str === "\\/" ? SEP : str;
+          if (split2) {
+            if (last) segment += str;
+            if (segment !== "") {
+              if (!flags.includes("g")) segment = `^${segment}$`;
+              path9.segments.push(new RegExp(segment, flags));
+            }
+            segment = "";
+          } else {
+            segment += str;
+          }
+        }
+      }
+      let c, n3;
+      for (let i = 0; i < glob.length; i++) {
+        c = glob[i];
+        n3 = glob[i + 1];
+        if (["\\", "$", "^", ".", "="].includes(c)) {
+          add2(`\\${c}`);
+          continue;
+        }
+        if (c === "/") {
+          add2(`\\${c}`, { split: true });
+          if (n3 === "/" && !strict) regex += "?";
+          continue;
+        }
+        if (c === "(") {
+          if (ext2.length) {
+            add2(c);
+            continue;
+          }
+          add2(`\\${c}`);
+          continue;
+        }
+        if (c === ")") {
+          if (ext2.length) {
+            add2(c);
+            let type = ext2.pop();
+            if (type === "@") {
+              add2("{1}");
+            } else if (type === "!") {
+              add2("([^/]*)");
+            } else {
+              add2(type);
+            }
+            continue;
+          }
+          add2(`\\${c}`);
+          continue;
+        }
+        if (c === "|") {
+          if (ext2.length) {
+            add2(c);
+            continue;
+          }
+          add2(`\\${c}`);
+          continue;
+        }
+        if (c === "+") {
+          if (n3 === "(" && extended) {
+            ext2.push(c);
+            continue;
+          }
+          add2(`\\${c}`);
+          continue;
+        }
+        if (c === "@" && extended) {
+          if (n3 === "(") {
+            ext2.push(c);
+            continue;
+          }
+        }
+        if (c === "!") {
+          if (extended) {
+            if (inRange) {
+              add2("^");
+              continue;
+            }
+            if (n3 === "(") {
+              ext2.push(c);
+              add2("(?!");
+              i++;
+              continue;
+            }
+            add2(`\\${c}`);
+            continue;
+          }
+          add2(`\\${c}`);
+          continue;
+        }
+        if (c === "?") {
+          if (extended) {
+            if (n3 === "(") {
+              ext2.push(c);
+            } else {
+              add2(".");
+            }
+            continue;
+          }
+          add2(`\\${c}`);
+          continue;
+        }
+        if (c === "[") {
+          if (inRange && n3 === ":") {
+            i++;
+            let value = "";
+            while (glob[++i] !== ":") value += glob[i];
+            if (value === "alnum") add2("(\\w|\\d)");
+            else if (value === "space") add2("\\s");
+            else if (value === "digit") add2("\\d");
+            i++;
+            continue;
+          }
+          if (extended) {
+            inRange = true;
+            add2(c);
+            continue;
+          }
+          add2(`\\${c}`);
+          continue;
+        }
+        if (c === "]") {
+          if (extended) {
+            inRange = false;
+            add2(c);
+            continue;
+          }
+          add2(`\\${c}`);
+          continue;
+        }
+        if (c === "{") {
+          if (extended) {
+            inGroup = true;
+            add2("(");
+            continue;
+          }
+          add2(`\\${c}`);
+          continue;
+        }
+        if (c === "}") {
+          if (extended) {
+            inGroup = false;
+            add2(")");
+            continue;
+          }
+          add2(`\\${c}`);
+          continue;
+        }
+        if (c === ",") {
+          if (inGroup) {
+            add2("|");
+            continue;
+          }
+          add2(`\\${c}`);
+          continue;
+        }
+        if (c === "*") {
+          if (n3 === "(" && extended) {
+            ext2.push(c);
+            continue;
+          }
+          let prevChar = glob[i - 1];
+          let starCount = 1;
+          while (glob[i + 1] === "*") {
+            starCount++;
+            i++;
+          }
+          let nextChar = glob[i + 1];
+          if (!globstar) {
+            add2(".*");
+          } else {
+            let isGlobstar = starCount > 1 && // multiple "*"'s
+            (prevChar === "/" || prevChar === void 0) && // from the start of the segment
+            (nextChar === "/" || nextChar === void 0);
+            if (isGlobstar) {
+              add2(GLOBSTAR2, { only: "regex" });
+              add2(GLOBSTAR_SEGMENT, { only: "path", last: true, split: true });
+              i++;
+            } else {
+              add2(WILDCARD, { only: "regex" });
+              add2(WILDCARD_SEGMENT, { only: "path" });
+            }
+          }
+          continue;
+        }
+        add2(c);
+      }
+      if (!flags.includes("g")) {
+        regex = `^${regex}$`;
+        segment = `^${segment}$`;
+        if (filepath) path9.regex = `^${path9.regex}$`;
+      }
+      const result = { regex: new RegExp(regex, flags) };
+      if (filepath) {
+        path9.segments.push(new RegExp(segment, flags));
+        path9.regex = new RegExp(path9.regex, flags);
+        path9.globstar = new RegExp(!flags.includes("g") ? `^${GLOBSTAR_SEGMENT}$` : GLOBSTAR_SEGMENT, flags);
+        result.path = path9;
+      }
+      return result;
+    }
+    module.exports = globrex;
+  }
+});
+
 // ../../node_modules/picocolors/picocolors.js
 var require_picocolors = __commonJS({
   "../../node_modules/picocolors/picocolors.js"(exports, module) {
@@ -158,11 +386,11 @@ var require_universalify = __commonJS({
       return Object.defineProperty(function(...args) {
         if (typeof args[args.length - 1] === "function") fn.apply(this, args);
         else {
-          return new Promise((resolve3, reject) => {
+          return new Promise((resolve6, reject) => {
             fn.call(
               this,
               ...args,
-              (err, res) => err != null ? reject(err) : resolve3(res)
+              (err, res) => err != null ? reject(err) : resolve6(res)
             );
           });
         }
@@ -186,7 +414,7 @@ var require_polyfills = __commonJS({
     var constants = __require("constants");
     var origCwd = process.cwd;
     var cwd = null;
-    var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform;
+    var platform2 = process.env.GRACEFUL_FS_PLATFORM || process.platform;
     process.cwd = function() {
       if (!cwd)
         cwd = origCwd.call(process);
@@ -206,54 +434,54 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module.exports = patch;
-    function patch(fs2) {
+    function patch(fs3) {
       if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-        patchLchmod(fs2);
-      }
-      if (!fs2.lutimes) {
-        patchLutimes(fs2);
-      }
-      fs2.chown = chownFix(fs2.chown);
-      fs2.fchown = chownFix(fs2.fchown);
-      fs2.lchown = chownFix(fs2.lchown);
-      fs2.chmod = chmodFix(fs2.chmod);
-      fs2.fchmod = chmodFix(fs2.fchmod);
-      fs2.lchmod = chmodFix(fs2.lchmod);
-      fs2.chownSync = chownFixSync(fs2.chownSync);
-      fs2.fchownSync = chownFixSync(fs2.fchownSync);
-      fs2.lchownSync = chownFixSync(fs2.lchownSync);
-      fs2.chmodSync = chmodFixSync(fs2.chmodSync);
-      fs2.fchmodSync = chmodFixSync(fs2.fchmodSync);
-      fs2.lchmodSync = chmodFixSync(fs2.lchmodSync);
-      fs2.stat = statFix(fs2.stat);
-      fs2.fstat = statFix(fs2.fstat);
-      fs2.lstat = statFix(fs2.lstat);
-      fs2.statSync = statFixSync(fs2.statSync);
-      fs2.fstatSync = statFixSync(fs2.fstatSync);
-      fs2.lstatSync = statFixSync(fs2.lstatSync);
-      if (fs2.chmod && !fs2.lchmod) {
-        fs2.lchmod = function(path8, mode, cb) {
+        patchLchmod(fs3);
+      }
+      if (!fs3.lutimes) {
+        patchLutimes(fs3);
+      }
+      fs3.chown = chownFix(fs3.chown);
+      fs3.fchown = chownFix(fs3.fchown);
+      fs3.lchown = chownFix(fs3.lchown);
+      fs3.chmod = chmodFix(fs3.chmod);
+      fs3.fchmod = chmodFix(fs3.fchmod);
+      fs3.lchmod = chmodFix(fs3.lchmod);
+      fs3.chownSync = chownFixSync(fs3.chownSync);
+      fs3.fchownSync = chownFixSync(fs3.fchownSync);
+      fs3.lchownSync = chownFixSync(fs3.lchownSync);
+      fs3.chmodSync = chmodFixSync(fs3.chmodSync);
+      fs3.fchmodSync = chmodFixSync(fs3.fchmodSync);
+      fs3.lchmodSync = chmodFixSync(fs3.lchmodSync);
+      fs3.stat = statFix(fs3.stat);
+      fs3.fstat = statFix(fs3.fstat);
+      fs3.lstat = statFix(fs3.lstat);
+      fs3.statSync = statFixSync(fs3.statSync);
+      fs3.fstatSync = statFixSync(fs3.fstatSync);
+      fs3.lstatSync = statFixSync(fs3.lstatSync);
+      if (fs3.chmod && !fs3.lchmod) {
+        fs3.lchmod = function(path9, mode, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs2.lchmodSync = function() {
+        fs3.lchmodSync = function() {
         };
       }
-      if (fs2.chown && !fs2.lchown) {
-        fs2.lchown = function(path8, uid, gid, cb) {
+      if (fs3.chown && !fs3.lchown) {
+        fs3.lchown = function(path9, uid, gid, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs2.lchownSync = function() {
+        fs3.lchownSync = function() {
         };
       }
-      if (platform === "win32") {
-        fs2.rename = typeof fs2.rename !== "function" ? fs2.rename : function(fs$rename) {
+      if (platform2 === "win32") {
+        fs3.rename = typeof fs3.rename !== "function" ? fs3.rename : function(fs$rename) {
           function rename(from, to, cb) {
             var start = Date.now();
             var backoff = 0;
             fs$rename(from, to, function CB(er) {
               if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
                 setTimeout(function() {
-                  fs2.stat(to, function(stater, st) {
+                  fs3.stat(to, function(stater, st) {
                     if (stater && stater.code === "ENOENT")
                       fs$rename(from, to, CB);
                     else
@@ -269,9 +497,9 @@ var require_polyfills = __commonJS({
           }
           if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
           return rename;
-        }(fs2.rename);
+        }(fs3.rename);
       }
-      fs2.read = typeof fs2.read !== "function" ? fs2.read : function(fs$read) {
+      fs3.read = typeof fs3.read !== "function" ? fs3.read : function(fs$read) {
         function read(fd, buffer, offset2, length3, position, callback_) {
           var callback;
           if (callback_ && typeof callback_ === "function") {
@@ -279,22 +507,22 @@ var require_polyfills = __commonJS({
             callback = function(er, _, __) {
               if (er && er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
-                return fs$read.call(fs2, fd, buffer, offset2, length3, position, callback);
+                return fs$read.call(fs3, fd, buffer, offset2, length3, position, callback);
               }
               callback_.apply(this, arguments);
             };
           }
-          return fs$read.call(fs2, fd, buffer, offset2, length3, position, callback);
+          return fs$read.call(fs3, fd, buffer, offset2, length3, position, callback);
         }
         if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
         return read;
-      }(fs2.read);
-      fs2.readSync = typeof fs2.readSync !== "function" ? fs2.readSync : /* @__PURE__ */ function(fs$readSync) {
+      }(fs3.read);
+      fs3.readSync = typeof fs3.readSync !== "function" ? fs3.readSync : /* @__PURE__ */ function(fs$readSync) {
         return function(fd, buffer, offset2, length3, position) {
           var eagCounter = 0;
           while (true) {
             try {
-              return fs$readSync.call(fs2, fd, buffer, offset2, length3, position);
+              return fs$readSync.call(fs3, fd, buffer, offset2, length3, position);
             } catch (er) {
               if (er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
@@ -304,11 +532,11 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      }(fs2.readSync);
-      function patchLchmod(fs3) {
-        fs3.lchmod = function(path8, mode, callback) {
-          fs3.open(
-            path8,
+      }(fs3.readSync);
+      function patchLchmod(fs4) {
+        fs4.lchmod = function(path9, mode, callback) {
+          fs4.open(
+            path9,
             constants.O_WRONLY | constants.O_SYMLINK,
             mode,
             function(err, fd) {
@@ -316,80 +544,80 @@ var require_polyfills = __commonJS({
                 if (callback) callback(err);
                 return;
               }
-              fs3.fchmod(fd, mode, function(err2) {
-                fs3.close(fd, function(err22) {
+              fs4.fchmod(fd, mode, function(err2) {
+                fs4.close(fd, function(err22) {
                   if (callback) callback(err2 || err22);
                 });
               });
             }
           );
         };
-        fs3.lchmodSync = function(path8, mode) {
-          var fd = fs3.openSync(path8, constants.O_WRONLY | constants.O_SYMLINK, mode);
+        fs4.lchmodSync = function(path9, mode) {
+          var fd = fs4.openSync(path9, constants.O_WRONLY | constants.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs3.fchmodSync(fd, mode);
+            ret = fs4.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs3.closeSync(fd);
+                fs4.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs3.closeSync(fd);
+              fs4.closeSync(fd);
             }
           }
           return ret;
         };
       }
-      function patchLutimes(fs3) {
-        if (constants.hasOwnProperty("O_SYMLINK") && fs3.futimes) {
-          fs3.lutimes = function(path8, at2, mt, cb) {
-            fs3.open(path8, constants.O_SYMLINK, function(er, fd) {
+      function patchLutimes(fs4) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs4.futimes) {
+          fs4.lutimes = function(path9, at2, mt, cb) {
+            fs4.open(path9, constants.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb) cb(er);
                 return;
               }
-              fs3.futimes(fd, at2, mt, function(er2) {
-                fs3.close(fd, function(er22) {
+              fs4.futimes(fd, at2, mt, function(er2) {
+                fs4.close(fd, function(er22) {
                   if (cb) cb(er2 || er22);
                 });
               });
             });
           };
-          fs3.lutimesSync = function(path8, at2, mt) {
-            var fd = fs3.openSync(path8, constants.O_SYMLINK);
+          fs4.lutimesSync = function(path9, at2, mt) {
+            var fd = fs4.openSync(path9, constants.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs3.futimesSync(fd, at2, mt);
+              ret = fs4.futimesSync(fd, at2, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs3.closeSync(fd);
+                  fs4.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs3.closeSync(fd);
+                fs4.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs3.futimes) {
-          fs3.lutimes = function(_a, _b, _c, cb) {
+        } else if (fs4.futimes) {
+          fs4.lutimes = function(_a, _b, _c, cb) {
             if (cb) process.nextTick(cb);
           };
-          fs3.lutimesSync = function() {
+          fs4.lutimesSync = function() {
           };
         }
       }
       function chmodFix(orig) {
         if (!orig) return orig;
         return function(target, mode, cb) {
-          return orig.call(fs2, target, mode, function(er) {
+          return orig.call(fs3, target, mode, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -399,7 +627,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, mode) {
           try {
-            return orig.call(fs2, target, mode);
+            return orig.call(fs3, target, mode);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -408,7 +636,7 @@ var require_polyfills = __commonJS({
       function chownFix(orig) {
         if (!orig) return orig;
         return function(target, uid, gid, cb) {
-          return orig.call(fs2, target, uid, gid, function(er) {
+          return orig.call(fs3, target, uid, gid, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -418,7 +646,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, uid, gid) {
           try {
-            return orig.call(fs2, target, uid, gid);
+            return orig.call(fs3, target, uid, gid);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -438,13 +666,13 @@ var require_polyfills = __commonJS({
             }
             if (cb) cb.apply(this, arguments);
           }
-          return options ? orig.call(fs2, target, options, callback) : orig.call(fs2, target, callback);
+          return options ? orig.call(fs3, target, options, callback) : orig.call(fs3, target, callback);
         };
       }
       function statFixSync(orig) {
         if (!orig) return orig;
         return function(target, options) {
-          var stats = options ? orig.call(fs2, target, options) : orig.call(fs2, target);
+          var stats = options ? orig.call(fs3, target, options) : orig.call(fs3, target);
           if (stats) {
             if (stats.uid < 0) stats.uid += 4294967296;
             if (stats.gid < 0) stats.gid += 4294967296;
@@ -475,16 +703,16 @@ var require_legacy_streams = __commonJS({
     init_esm_shims();
     var Stream = __require("stream").Stream;
     module.exports = legacy;
-    function legacy(fs2) {
+    function legacy(fs3) {
       return {
         ReadStream,
         WriteStream
       };
-      function ReadStream(path8, options) {
-        if (!(this instanceof ReadStream)) return new ReadStream(path8, options);
+      function ReadStream(path9, options) {
+        if (!(this instanceof ReadStream)) return new ReadStream(path9, options);
         Stream.call(this);
         var self2 = this;
-        this.path = path8;
+        this.path = path9;
         this.fd = null;
         this.readable = true;
         this.paused = false;
@@ -518,7 +746,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs2.open(this.path, this.flags, this.mode, function(err, fd) {
+        fs3.open(this.path, this.flags, this.mode, function(err, fd) {
           if (err) {
             self2.emit("error", err);
             self2.readable = false;
@@ -529,10 +757,10 @@ var require_legacy_streams = __commonJS({
           self2._read();
         });
       }
-      function WriteStream(path8, options) {
-        if (!(this instanceof WriteStream)) return new WriteStream(path8, options);
+      function WriteStream(path9, options) {
+        if (!(this instanceof WriteStream)) return new WriteStream(path9, options);
         Stream.call(this);
-        this.path = path8;
+        this.path = path9;
         this.fd = null;
         this.writable = true;
         this.flags = "w";
@@ -557,7 +785,7 @@ var require_legacy_streams = __commonJS({
         this.busy = false;
         this._queue = [];
         if (this.fd === null) {
-          this._open = fs2.open;
+          this._open = fs3.open;
           this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
           this.flush();
         }
@@ -595,7 +823,7 @@ var require_graceful_fs = __commonJS({
   "../../node_modules/graceful-fs/graceful-fs.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var fs2 = __require("fs");
+    var fs3 = __require("fs");
     var polyfills = require_polyfills();
     var legacy = require_legacy_streams();
     var clone4 = require_clone();
@@ -618,21 +846,21 @@ var require_graceful_fs = __commonJS({
         }
       });
     }
-    var debug = noop;
+    var debug2 = noop;
     if (util.debuglog)
-      debug = util.debuglog("gfs4");
+      debug2 = util.debuglog("gfs4");
     else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ""))
-      debug = function() {
+      debug2 = function() {
         var m = util.format.apply(util, arguments);
         m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
         console.error(m);
       };
-    if (!fs2[gracefulQueue]) {
+    if (!fs3[gracefulQueue]) {
       queue = global[gracefulQueue] || [];
-      publishQueue(fs2, queue);
-      fs2.close = function(fs$close) {
+      publishQueue(fs3, queue);
+      fs3.close = function(fs$close) {
         function close(fd, cb) {
-          return fs$close.call(fs2, fd, function(err) {
+          return fs$close.call(fs3, fd, function(err) {
             if (!err) {
               resetQueue();
             }
@@ -644,48 +872,48 @@ var require_graceful_fs = __commonJS({
           value: fs$close
         });
         return close;
-      }(fs2.close);
-      fs2.closeSync = function(fs$closeSync) {
+      }(fs3.close);
+      fs3.closeSync = function(fs$closeSync) {
         function closeSync(fd) {
-          fs$closeSync.apply(fs2, arguments);
+          fs$closeSync.apply(fs3, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync;
-      }(fs2.closeSync);
+      }(fs3.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug(fs2[gracefulQueue]);
-          __require("assert").equal(fs2[gracefulQueue].length, 0);
+          debug2(fs3[gracefulQueue]);
+          __require("assert").equal(fs3[gracefulQueue].length, 0);
         });
       }
     }
     var queue;
     if (!global[gracefulQueue]) {
-      publishQueue(global, fs2[gracefulQueue]);
-    }
-    module.exports = patch(clone4(fs2));
-    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs2.__patched) {
-      module.exports = patch(fs2);
-      fs2.__patched = true;
-    }
-    function patch(fs3) {
-      polyfills(fs3);
-      fs3.gracefulify = patch;
-      fs3.createReadStream = createReadStream;
-      fs3.createWriteStream = createWriteStream;
-      var fs$readFile = fs3.readFile;
-      fs3.readFile = readFile5;
-      function readFile5(path8, options, cb) {
+      publishQueue(global, fs3[gracefulQueue]);
+    }
+    module.exports = patch(clone4(fs3));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs3.__patched) {
+      module.exports = patch(fs3);
+      fs3.__patched = true;
+    }
+    function patch(fs4) {
+      polyfills(fs4);
+      fs4.gracefulify = patch;
+      fs4.createReadStream = createReadStream;
+      fs4.createWriteStream = createWriteStream;
+      var fs$readFile = fs4.readFile;
+      fs4.readFile = readFile5;
+      function readFile5(path9, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$readFile(path8, options, cb);
-        function go$readFile(path9, options2, cb2, startTime) {
-          return fs$readFile(path9, options2, function(err) {
+        return go$readFile(path9, options, cb);
+        function go$readFile(path10, options2, cb2, startTime) {
+          return fs$readFile(path10, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$readFile, [path9, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$readFile, [path10, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -693,16 +921,16 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$writeFile = fs3.writeFile;
-      fs3.writeFile = writeFile3;
-      function writeFile3(path8, data2, options, cb) {
+      var fs$writeFile = fs4.writeFile;
+      fs4.writeFile = writeFile3;
+      function writeFile3(path9, data2, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$writeFile(path8, data2, options, cb);
-        function go$writeFile(path9, data3, options2, cb2, startTime) {
-          return fs$writeFile(path9, data3, options2, function(err) {
+        return go$writeFile(path9, data2, options, cb);
+        function go$writeFile(path10, data3, options2, cb2, startTime) {
+          return fs$writeFile(path10, data3, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$writeFile, [path9, data3, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$writeFile, [path10, data3, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -710,17 +938,17 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$appendFile = fs3.appendFile;
+      var fs$appendFile = fs4.appendFile;
       if (fs$appendFile)
-        fs3.appendFile = appendFile;
-      function appendFile(path8, data2, options, cb) {
+        fs4.appendFile = appendFile;
+      function appendFile(path9, data2, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$appendFile(path8, data2, options, cb);
-        function go$appendFile(path9, data3, options2, cb2, startTime) {
-          return fs$appendFile(path9, data3, options2, function(err) {
+        return go$appendFile(path9, data2, options, cb);
+        function go$appendFile(path10, data3, options2, cb2, startTime) {
+          return fs$appendFile(path10, data3, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$appendFile, [path9, data3, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$appendFile, [path10, data3, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -728,9 +956,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$copyFile = fs3.copyFile;
+      var fs$copyFile = fs4.copyFile;
       if (fs$copyFile)
-        fs3.copyFile = copyFile;
+        fs4.copyFile = copyFile;
       function copyFile(src, dest, flags, cb) {
         if (typeof flags === "function") {
           cb = flags;
@@ -748,34 +976,34 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$readdir = fs3.readdir;
-      fs3.readdir = readdir;
+      var fs$readdir = fs4.readdir;
+      fs4.readdir = readdir;
       var noReaddirOptionVersions = /^v[0-5]\./;
-      function readdir(path8, options, cb) {
+      function readdir(path9, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path9, options2, cb2, startTime) {
-          return fs$readdir(path9, fs$readdirCallback(
-            path9,
+        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path10, options2, cb2, startTime) {
+          return fs$readdir(path10, fs$readdirCallback(
+            path10,
             options2,
             cb2,
             startTime
           ));
-        } : function go$readdir2(path9, options2, cb2, startTime) {
-          return fs$readdir(path9, options2, fs$readdirCallback(
-            path9,
+        } : function go$readdir2(path10, options2, cb2, startTime) {
+          return fs$readdir(path10, options2, fs$readdirCallback(
+            path10,
             options2,
             cb2,
             startTime
           ));
         };
-        return go$readdir(path8, options, cb);
-        function fs$readdirCallback(path9, options2, cb2, startTime) {
+        return go$readdir(path9, options, cb);
+        function fs$readdirCallback(path10, options2, cb2, startTime) {
           return function(err, files) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
               enqueue([
                 go$readdir,
-                [path9, options2, cb2],
+                [path10, options2, cb2],
                 err,
                 startTime || Date.now(),
                 Date.now()
@@ -790,21 +1018,21 @@ var require_graceful_fs = __commonJS({
         }
       }
       if (process.version.substr(0, 4) === "v0.8") {
-        var legStreams = legacy(fs3);
+        var legStreams = legacy(fs4);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs3.ReadStream;
+      var fs$ReadStream = fs4.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs3.WriteStream;
+      var fs$WriteStream = fs4.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs3, "ReadStream", {
+      Object.defineProperty(fs4, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -814,7 +1042,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs3, "WriteStream", {
+      Object.defineProperty(fs4, "WriteStream", {
         get: function() {
           return WriteStream;
         },
@@ -825,7 +1053,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream;
-      Object.defineProperty(fs3, "FileReadStream", {
+      Object.defineProperty(fs4, "FileReadStream", {
         get: function() {
           return FileReadStream;
         },
@@ -836,7 +1064,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs3, "FileWriteStream", {
+      Object.defineProperty(fs4, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -846,7 +1074,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      function ReadStream(path8, options) {
+      function ReadStream(path9, options) {
         if (this instanceof ReadStream)
           return fs$ReadStream.apply(this, arguments), this;
         else
@@ -866,7 +1094,7 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function WriteStream(path8, options) {
+      function WriteStream(path9, options) {
         if (this instanceof WriteStream)
           return fs$WriteStream.apply(this, arguments), this;
         else
@@ -884,22 +1112,22 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function createReadStream(path8, options) {
-        return new fs3.ReadStream(path8, options);
+      function createReadStream(path9, options) {
+        return new fs4.ReadStream(path9, options);
       }
-      function createWriteStream(path8, options) {
-        return new fs3.WriteStream(path8, options);
+      function createWriteStream(path9, options) {
+        return new fs4.WriteStream(path9, options);
       }
-      var fs$open = fs3.open;
-      fs3.open = open;
-      function open(path8, flags, mode, cb) {
+      var fs$open = fs4.open;
+      fs4.open = open;
+      function open(path9, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
-        return go$open(path8, flags, mode, cb);
-        function go$open(path9, flags2, mode2, cb2, startTime) {
-          return fs$open(path9, flags2, mode2, function(err, fd) {
+        return go$open(path9, flags, mode, cb);
+        function go$open(path10, flags2, mode2, cb2, startTime) {
+          return fs$open(path10, flags2, mode2, function(err, fd) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$open, [path9, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$open, [path10, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -907,20 +1135,20 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      return fs3;
+      return fs4;
     }
     function enqueue(elem) {
-      debug("ENQUEUE", elem[0].name, elem[1]);
-      fs2[gracefulQueue].push(elem);
+      debug2("ENQUEUE", elem[0].name, elem[1]);
+      fs3[gracefulQueue].push(elem);
       retry();
     }
     var retryTimer;
     function resetQueue() {
       var now = Date.now();
-      for (var i = 0; i < fs2[gracefulQueue].length; ++i) {
-        if (fs2[gracefulQueue][i].length > 2) {
-          fs2[gracefulQueue][i][3] = now;
-          fs2[gracefulQueue][i][4] = now;
+      for (var i = 0; i < fs3[gracefulQueue].length; ++i) {
+        if (fs3[gracefulQueue][i].length > 2) {
+          fs3[gracefulQueue][i][3] = now;
+          fs3[gracefulQueue][i][4] = now;
         }
       }
       retry();
@@ -928,19 +1156,19 @@ var require_graceful_fs = __commonJS({
     function retry() {
       clearTimeout(retryTimer);
       retryTimer = void 0;
-      if (fs2[gracefulQueue].length === 0)
+      if (fs3[gracefulQueue].length === 0)
         return;
-      var elem = fs2[gracefulQueue].shift();
+      var elem = fs3[gracefulQueue].shift();
       var fn = elem[0];
       var args = elem[1];
       var err = elem[2];
       var startTime = elem[3];
       var lastTime = elem[4];
       if (startTime === void 0) {
-        debug("RETRY", fn.name, args);
+        debug2("RETRY", fn.name, args);
         fn.apply(null, args);
       } else if (Date.now() - startTime >= 6e4) {
-        debug("TIMEOUT", fn.name, args);
+        debug2("TIMEOUT", fn.name, args);
         var cb = args.pop();
         if (typeof cb === "function")
           cb.call(null, err);
@@ -949,10 +1177,10 @@ var require_graceful_fs = __commonJS({
         var sinceStart = Math.max(lastTime - startTime, 1);
         var desiredDelay = Math.min(sinceStart * 1.2, 100);
         if (sinceAttempt >= desiredDelay) {
-          debug("RETRY", fn.name, args);
+          debug2("RETRY", fn.name, args);
           fn.apply(null, args.concat([startTime]));
         } else {
-          fs2[gracefulQueue].push(elem);
+          fs3[gracefulQueue].push(elem);
         }
       }
       if (retryTimer === void 0) {
@@ -968,7 +1196,7 @@ var require_fs = __commonJS({
     "use strict";
     init_esm_shims();
     var u = require_universalify().fromCallback;
-    var fs2 = require_graceful_fs();
+    var fs3 = require_graceful_fs();
     var api = [
       "access",
       "appendFile",
@@ -1005,57 +1233,57 @@ var require_fs = __commonJS({
       "utimes",
       "writeFile"
     ].filter((key) => {
-      return typeof fs2[key] === "function";
+      return typeof fs3[key] === "function";
     });
-    Object.assign(exports, fs2);
+    Object.assign(exports, fs3);
     api.forEach((method) => {
-      exports[method] = u(fs2[method]);
+      exports[method] = u(fs3[method]);
     });
     exports.exists = function(filename, callback) {
       if (typeof callback === "function") {
-        return fs2.exists(filename, callback);
+        return fs3.exists(filename, callback);
       }
-      return new Promise((resolve3) => {
-        return fs2.exists(filename, resolve3);
+      return new Promise((resolve6) => {
+        return fs3.exists(filename, resolve6);
       });
     };
     exports.read = function(fd, buffer, offset2, length3, position, callback) {
       if (typeof callback === "function") {
-        return fs2.read(fd, buffer, offset2, length3, position, callback);
+        return fs3.read(fd, buffer, offset2, length3, position, callback);
       }
-      return new Promise((resolve3, reject) => {
-        fs2.read(fd, buffer, offset2, length3, position, (err, bytesRead, buffer2) => {
+      return new Promise((resolve6, reject) => {
+        fs3.read(fd, buffer, offset2, length3, position, (err, bytesRead, buffer2) => {
           if (err) return reject(err);
-          resolve3({ bytesRead, buffer: buffer2 });
+          resolve6({ bytesRead, buffer: buffer2 });
         });
       });
     };
     exports.write = function(fd, buffer, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs2.write(fd, buffer, ...args);
+        return fs3.write(fd, buffer, ...args);
       }
-      return new Promise((resolve3, reject) => {
-        fs2.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
+      return new Promise((resolve6, reject) => {
+        fs3.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
           if (err) return reject(err);
-          resolve3({ bytesWritten, buffer: buffer2 });
+          resolve6({ bytesWritten, buffer: buffer2 });
         });
       });
     };
-    if (typeof fs2.writev === "function") {
+    if (typeof fs3.writev === "function") {
       exports.writev = function(fd, buffers, ...args) {
         if (typeof args[args.length - 1] === "function") {
-          return fs2.writev(fd, buffers, ...args);
+          return fs3.writev(fd, buffers, ...args);
         }
-        return new Promise((resolve3, reject) => {
-          fs2.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
+        return new Promise((resolve6, reject) => {
+          fs3.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
             if (err) return reject(err);
-            resolve3({ bytesWritten, buffers: buffers2 });
+            resolve6({ bytesWritten, buffers: buffers2 });
           });
         });
       };
     }
-    if (typeof fs2.realpath.native === "function") {
-      exports.realpath.native = u(fs2.realpath.native);
+    if (typeof fs3.realpath.native === "function") {
+      exports.realpath.native = u(fs3.realpath.native);
     } else {
       process.emitWarning(
         "fs.realpath.native is not a function. Is fs being monkey-patched?",
@@ -1071,10 +1299,10 @@ var require_utils = __commonJS({
   "../../node_modules/vite-plugin-externals/node_modules/fs-extra/lib/mkdirs/utils.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var path8 = __require("path");
+    var path9 = __require("path");
     module.exports.checkPath = function checkPath(pth) {
       if (process.platform === "win32") {
-        const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path8.parse(pth).root, ""));
+        const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path9.parse(pth).root, ""));
         if (pathHasInvalidWinCharacters) {
           const error = new Error(`Path contains invalid characters: ${pth}`);
           error.code = "EINVAL";
@@ -1090,7 +1318,7 @@ var require_make_dir = __commonJS({
   "../../node_modules/vite-plugin-externals/node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var fs2 = require_fs();
+    var fs3 = require_fs();
     var { checkPath } = require_utils();
     var getMode = (options) => {
       const defaults2 = { mode: 511 };
@@ -1099,14 +1327,14 @@ var require_make_dir = __commonJS({
     };
     module.exports.makeDir = async (dir, options) => {
       checkPath(dir);
-      return fs2.mkdir(dir, {
+      return fs3.mkdir(dir, {
         mode: getMode(options),
         recursive: true
       });
     };
     module.exports.makeDirSync = (dir, options) => {
       checkPath(dir);
-      return fs2.mkdirSync(dir, {
+      return fs3.mkdirSync(dir, {
         mode: getMode(options),
         recursive: true
       });
@@ -1140,13 +1368,13 @@ var require_path_exists = __commonJS({
     "use strict";
     init_esm_shims();
     var u = require_universalify().fromPromise;
-    var fs2 = require_fs();
-    function pathExists(path8) {
-      return fs2.access(path8).then(() => true).catch(() => false);
+    var fs3 = require_fs();
+    function pathExists(path9) {
+      return fs3.access(path9).then(() => true).catch(() => false);
     }
     module.exports = {
       pathExists: u(pathExists),
-      pathExistsSync: fs2.existsSync
+      pathExistsSync: fs3.existsSync
     };
   }
 });
@@ -1156,21 +1384,21 @@ var require_utimes = __commonJS({
   "../../node_modules/vite-plugin-externals/node_modules/fs-extra/lib/util/utimes.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var fs2 = require_graceful_fs();
-    function utimesMillis(path8, atime, mtime, callback) {
-      fs2.open(path8, "r+", (err, fd) => {
+    var fs3 = require_graceful_fs();
+    function utimesMillis(path9, atime, mtime, callback) {
+      fs3.open(path9, "r+", (err, fd) => {
         if (err) return callback(err);
-        fs2.futimes(fd, atime, mtime, (futimesErr) => {
-          fs2.close(fd, (closeErr) => {
+        fs3.futimes(fd, atime, mtime, (futimesErr) => {
+          fs3.close(fd, (closeErr) => {
             if (callback) callback(futimesErr || closeErr);
           });
         });
       });
     }
-    function utimesMillisSync(path8, atime, mtime) {
-      const fd = fs2.openSync(path8, "r+");
-      fs2.futimesSync(fd, atime, mtime);
-      return fs2.closeSync(fd);
+    function utimesMillisSync(path9, atime, mtime) {
+      const fd = fs3.openSync(path9, "r+");
+      fs3.futimesSync(fd, atime, mtime);
+      return fs3.closeSync(fd);
     }
     module.exports = {
       utimesMillis,
@@ -1184,11 +1412,11 @@ var require_stat = __commonJS({
   "../../node_modules/vite-plugin-externals/node_modules/fs-extra/lib/util/stat.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var fs2 = require_fs();
-    var path8 = __require("path");
+    var fs3 = require_fs();
+    var path9 = __require("path");
     var util = __require("util");
     function getStats(src, dest, opts) {
-      const statFunc = opts.dereference ? (file) => fs2.stat(file, { bigint: true }) : (file) => fs2.lstat(file, { bigint: true });
+      const statFunc = opts.dereference ? (file) => fs3.stat(file, { bigint: true }) : (file) => fs3.lstat(file, { bigint: true });
       return Promise.all([
         statFunc(src),
         statFunc(dest).catch((err) => {
@@ -1199,7 +1427,7 @@ var require_stat = __commonJS({
     }
     function getStatsSync(src, dest, opts) {
       let destStat;
-      const statFunc = opts.dereference ? (file) => fs2.statSync(file, { bigint: true }) : (file) => fs2.lstatSync(file, { bigint: true });
+      const statFunc = opts.dereference ? (file) => fs3.statSync(file, { bigint: true }) : (file) => fs3.lstatSync(file, { bigint: true });
       const srcStat = statFunc(src);
       try {
         destStat = statFunc(dest);
@@ -1215,8 +1443,8 @@ var require_stat = __commonJS({
         const { srcStat, destStat } = stats;
         if (destStat) {
           if (areIdentical(srcStat, destStat)) {
-            const srcBaseName = path8.basename(src);
-            const destBaseName = path8.basename(dest);
+            const srcBaseName = path9.basename(src);
+            const destBaseName = path9.basename(dest);
             if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
               return cb(null, { srcStat, destStat, isChangingCase: true });
             }
@@ -1239,8 +1467,8 @@ var require_stat = __commonJS({
       const { srcStat, destStat } = getStatsSync(src, dest, opts);
       if (destStat) {
         if (areIdentical(srcStat, destStat)) {
-          const srcBaseName = path8.basename(src);
-          const destBaseName = path8.basename(dest);
+          const srcBaseName = path9.basename(src);
+          const destBaseName = path9.basename(dest);
           if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
             return { srcStat, destStat, isChangingCase: true };
           }
@@ -1259,10 +1487,10 @@ var require_stat = __commonJS({
       return { srcStat, destStat };
     }
     function checkParentPaths(src, srcStat, dest, funcName, cb) {
-      const srcParent = path8.resolve(path8.dirname(src));
-      const destParent = path8.resolve(path8.dirname(dest));
-      if (destParent === srcParent || destParent === path8.parse(destParent).root) return cb();
-      fs2.stat(destParent, { bigint: true }, (err, destStat) => {
+      const srcParent = path9.resolve(path9.dirname(src));
+      const destParent = path9.resolve(path9.dirname(dest));
+      if (destParent === srcParent || destParent === path9.parse(destParent).root) return cb();
+      fs3.stat(destParent, { bigint: true }, (err, destStat) => {
         if (err) {
           if (err.code === "ENOENT") return cb();
           return cb(err);
@@ -1274,12 +1502,12 @@ var require_stat = __commonJS({
       });
     }
     function checkParentPathsSync(src, srcStat, dest, funcName) {
-      const srcParent = path8.resolve(path8.dirname(src));
-      const destParent = path8.resolve(path8.dirname(dest));
-      if (destParent === srcParent || destParent === path8.parse(destParent).root) return;
+      const srcParent = path9.resolve(path9.dirname(src));
+      const destParent = path9.resolve(path9.dirname(dest));
+      if (destParent === srcParent || destParent === path9.parse(destParent).root) return;
       let destStat;
       try {
-        destStat = fs2.statSync(destParent, { bigint: true });
+        destStat = fs3.statSync(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT") return;
         throw err;
@@ -1293,8 +1521,8 @@ var require_stat = __commonJS({
       return destStat.ino && destStat.dev && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev;
     }
     function isSrcSubdir(src, dest) {
-      const srcArr = path8.resolve(src).split(path8.sep).filter((i) => i);
-      const destArr = path8.resolve(dest).split(path8.sep).filter((i) => i);
+      const srcArr = path9.resolve(src).split(path9.sep).filter((i) => i);
+      const destArr = path9.resolve(dest).split(path9.sep).filter((i) => i);
       return srcArr.reduce((acc, cur, i) => acc && destArr[i] === cur, true);
     }
     function errMsg(src, dest, funcName) {
@@ -1316,8 +1544,8 @@ var require_copy = __commonJS({
   "../../node_modules/vite-plugin-externals/node_modules/fs-extra/lib/copy/copy.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var fs2 = require_graceful_fs();
-    var path8 = __require("path");
+    var fs3 = require_graceful_fs();
+    var path9 = __require("path");
     var mkdirs = require_mkdirs().mkdirs;
     var pathExists = require_path_exists().pathExists;
     var utimesMillis = require_utimes().utimesMillis;
@@ -1352,7 +1580,7 @@ var require_copy = __commonJS({
       });
     }
     function checkParentDir(destStat, src, dest, opts, cb) {
-      const destParent = path8.dirname(dest);
+      const destParent = path9.dirname(dest);
       pathExists(destParent, (err, dirExists) => {
         if (err) return cb(err);
         if (dirExists) return getStats(destStat, src, dest, opts, cb);
@@ -1373,7 +1601,7 @@ var require_copy = __commonJS({
       return getStats(destStat, src, dest, opts, cb);
     }
     function getStats(destStat, src, dest, opts, cb) {
-      const stat3 = opts.dereference ? fs2.stat : fs2.lstat;
+      const stat3 = opts.dereference ? fs3.stat : fs3.lstat;
       stat3(src, (err, srcStat) => {
         if (err) return cb(err);
         if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts, cb);
@@ -1390,7 +1618,7 @@ var require_copy = __commonJS({
     }
     function mayCopyFile(srcStat, src, dest, opts, cb) {
       if (opts.overwrite) {
-        fs2.unlink(dest, (err) => {
+        fs3.unlink(dest, (err) => {
           if (err) return cb(err);
           return copyFile(srcStat, src, dest, opts, cb);
         });
@@ -1399,7 +1627,7 @@ var require_copy = __commonJS({
       } else return cb();
     }
     function copyFile(srcStat, src, dest, opts, cb) {
-      fs2.copyFile(src, dest, (err) => {
+      fs3.copyFile(src, dest, (err) => {
         if (err) return cb(err);
         if (opts.preserveTimestamps) return handleTimestampsAndMode(srcStat.mode, src, dest, cb);
         return setDestMode(dest, srcStat.mode, cb);
@@ -1427,10 +1655,10 @@ var require_copy = __commonJS({
       });
     }
     function setDestMode(dest, srcMode, cb) {
-      return fs2.chmod(dest, srcMode, cb);
+      return fs3.chmod(dest, srcMode, cb);
     }
     function setDestTimestamps(src, dest, cb) {
-      fs2.stat(src, (err, updatedSrcStat) => {
+      fs3.stat(src, (err, updatedSrcStat) => {
         if (err) return cb(err);
         return utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime, cb);
       });
@@ -1440,7 +1668,7 @@ var require_copy = __commonJS({
       return copyDir(src, dest, opts, cb);
     }
     function mkDirAndCopy(srcMode, src, dest, opts, cb) {
-      fs2.mkdir(dest, (err) => {
+      fs3.mkdir(dest, (err) => {
         if (err) return cb(err);
         copyDir(src, dest, opts, (err2) => {
           if (err2) return cb(err2);
@@ -1449,7 +1677,7 @@ var require_copy = __commonJS({
       });
     }
     function copyDir(src, dest, opts, cb) {
-      fs2.readdir(src, (err, items) => {
+      fs3.readdir(src, (err, items) => {
         if (err) return cb(err);
         return copyDirItems(items, src, dest, opts, cb);
       });
@@ -1460,8 +1688,8 @@ var require_copy = __commonJS({
       return copyDirItem(items, item, src, dest, opts, cb);
     }
     function copyDirItem(items, item, src, dest, opts, cb) {
-      const srcItem = path8.join(src, item);
-      const destItem = path8.join(dest, item);
+      const srcItem = path9.join(src, item);
+      const destItem = path9.join(dest, item);
       stat2.checkPaths(srcItem, destItem, "copy", opts, (err, stats) => {
         if (err) return cb(err);
         const { destStat } = stats;
@@ -1472,21 +1700,21 @@ var require_copy = __commonJS({
       });
     }
     function onLink(destStat, src, dest, opts, cb) {
-      fs2.readlink(src, (err, resolvedSrc) => {
+      fs3.readlink(src, (err, resolvedSrc) => {
         if (err) return cb(err);
         if (opts.dereference) {
-          resolvedSrc = path8.resolve(process.cwd(), resolvedSrc);
+          resolvedSrc = path9.resolve(process.cwd(), resolvedSrc);
         }
         if (!destStat) {
-          return fs2.symlink(resolvedSrc, dest, cb);
+          return fs3.symlink(resolvedSrc, dest, cb);
         } else {
-          fs2.readlink(dest, (err2, resolvedDest) => {
+          fs3.readlink(dest, (err2, resolvedDest) => {
             if (err2) {
-              if (err2.code === "EINVAL" || err2.code === "UNKNOWN") return fs2.symlink(resolvedSrc, dest, cb);
+              if (err2.code === "EINVAL" || err2.code === "UNKNOWN") return fs3.symlink(resolvedSrc, dest, cb);
               return cb(err2);
             }
             if (opts.dereference) {
-              resolvedDest = path8.resolve(process.cwd(), resolvedDest);
+              resolvedDest = path9.resolve(process.cwd(), resolvedDest);
             }
             if (stat2.isSrcSubdir(resolvedSrc, resolvedDest)) {
               return cb(new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`));
@@ -1500,9 +1728,9 @@ var require_copy = __commonJS({
       });
     }
     function copyLink(resolvedSrc, dest, cb) {
-      fs2.unlink(dest, (err) => {
+      fs3.unlink(dest, (err) => {
         if (err) return cb(err);
-        return fs2.symlink(resolvedSrc, dest, cb);
+        return fs3.symlink(resolvedSrc, dest, cb);
       });
     }
     module.exports = copy;
@@ -1514,8 +1742,8 @@ var require_copy_sync = __commonJS({
   "../../node_modules/vite-plugin-externals/node_modules/fs-extra/lib/copy/copy-sync.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var fs2 = require_graceful_fs();
-    var path8 = __require("path");
+    var fs3 = require_graceful_fs();
+    var path9 = __require("path");
     var mkdirsSync = require_mkdirs().mkdirsSync;
     var utimesMillisSync = require_utimes().utimesMillisSync;
     var stat2 = require_stat();
@@ -1539,8 +1767,8 @@ var require_copy_sync = __commonJS({
     }
     function handleFilterAndCopy(destStat, src, dest, opts) {
       if (opts.filter && !opts.filter(src, dest)) return;
-      const destParent = path8.dirname(dest);
-      if (!fs2.existsSync(destParent)) mkdirsSync(destParent);
+      const destParent = path9.dirname(dest);
+      if (!fs3.existsSync(destParent)) mkdirsSync(destParent);
       return getStats(destStat, src, dest, opts);
     }
     function startCopy(destStat, src, dest, opts) {
@@ -1548,7 +1776,7 @@ var require_copy_sync = __commonJS({
       return getStats(destStat, src, dest, opts);
     }
     function getStats(destStat, src, dest, opts) {
-      const statSync = opts.dereference ? fs2.statSync : fs2.lstatSync;
+      const statSync = opts.dereference ? fs3.statSync : fs3.lstatSync;
       const srcStat = statSync(src);
       if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts);
       else if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts);
@@ -1563,14 +1791,14 @@ var require_copy_sync = __commonJS({
     }
     function mayCopyFile(srcStat, src, dest, opts) {
       if (opts.overwrite) {
-        fs2.unlinkSync(dest);
+        fs3.unlinkSync(dest);
         return copyFile(srcStat, src, dest, opts);
       } else if (opts.errorOnExist) {
         throw new Error(`'${dest}' already exists`);
       }
     }
     function copyFile(srcStat, src, dest, opts) {
-      fs2.copyFileSync(src, dest);
+      fs3.copyFileSync(src, dest);
       if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest);
       return setDestMode(dest, srcStat.mode);
     }
@@ -1585,10 +1813,10 @@ var require_copy_sync = __commonJS({
       return setDestMode(dest, srcMode | 128);
     }
     function setDestMode(dest, srcMode) {
-      return fs2.chmodSync(dest, srcMode);
+      return fs3.chmodSync(dest, srcMode);
     }
     function setDestTimestamps(src, dest) {
-      const updatedSrcStat = fs2.statSync(src);
+      const updatedSrcStat = fs3.statSync(src);
       return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
     }
     function onDir(srcStat, destStat, src, dest, opts) {
@@ -1596,49 +1824,49 @@ var require_copy_sync = __commonJS({
       return copyDir(src, dest, opts);
     }
     function mkDirAndCopy(srcMode, src, dest, opts) {
-      fs2.mkdirSync(dest);
+      fs3.mkdirSync(dest);
       copyDir(src, dest, opts);
       return setDestMode(dest, srcMode);
     }
     function copyDir(src, dest, opts) {
-      fs2.readdirSync(src).forEach((item) => copyDirItem(item, src, dest, opts));
+      fs3.readdirSync(src).forEach((item) => copyDirItem(item, src, dest, opts));
     }
     function copyDirItem(item, src, dest, opts) {
-      const srcItem = path8.join(src, item);
-      const destItem = path8.join(dest, item);
+      const srcItem = path9.join(src, item);
+      const destItem = path9.join(dest, item);
       const { destStat } = stat2.checkPathsSync(srcItem, destItem, "copy", opts);
       return startCopy(destStat, srcItem, destItem, opts);
     }
     function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = fs2.readlinkSync(src);
+      let resolvedSrc = fs3.readlinkSync(src);
       if (opts.dereference) {
-        resolvedSrc = path8.resolve(process.cwd(), resolvedSrc);
+        resolvedSrc = path9.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs2.symlinkSync(resolvedSrc, dest);
+        return fs3.symlinkSync(resolvedSrc, dest);
       } else {
         let resolvedDest;
         try {
-          resolvedDest = fs2.readlinkSync(dest);
+          resolvedDest = fs3.readlinkSync(dest);
         } catch (err) {
-          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs2.symlinkSync(resolvedSrc, dest);
+          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs3.symlinkSync(resolvedSrc, dest);
           throw err;
         }
         if (opts.dereference) {
-          resolvedDest = path8.resolve(process.cwd(), resolvedDest);
+          resolvedDest = path9.resolve(process.cwd(), resolvedDest);
         }
         if (stat2.isSrcSubdir(resolvedSrc, resolvedDest)) {
           throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
         }
-        if (fs2.statSync(dest).isDirectory() && stat2.isSrcSubdir(resolvedDest, resolvedSrc)) {
+        if (fs3.statSync(dest).isDirectory() && stat2.isSrcSubdir(resolvedDest, resolvedSrc)) {
           throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
         }
         return copyLink(resolvedSrc, dest);
       }
     }
     function copyLink(resolvedSrc, dest) {
-      fs2.unlinkSync(dest);
-      return fs2.symlinkSync(resolvedSrc, dest);
+      fs3.unlinkSync(dest);
+      return fs3.symlinkSync(resolvedSrc, dest);
     }
     module.exports = copySync;
   }
@@ -1662,10 +1890,10 @@ var require_rimraf = __commonJS({
   "../../node_modules/vite-plugin-externals/node_modules/fs-extra/lib/remove/rimraf.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var fs2 = require_graceful_fs();
-    var path8 = __require("path");
+    var fs3 = require_graceful_fs();
+    var path9 = __require("path");
     var assert = __require("assert");
-    var isWindows = process.platform === "win32";
+    var isWindows2 = process.platform === "win32";
     function defaults2(options) {
       const methods = [
         "unlink",
@@ -1676,9 +1904,9 @@ var require_rimraf = __commonJS({
         "readdir"
       ];
       methods.forEach((m) => {
-        options[m] = options[m] || fs2[m];
+        options[m] = options[m] || fs3[m];
         m = m + "Sync";
-        options[m] = options[m] || fs2[m];
+        options[m] = options[m] || fs3[m];
       });
       options.maxBusyTries = options.maxBusyTries || 3;
     }
@@ -1714,7 +1942,7 @@ var require_rimraf = __commonJS({
         if (er && er.code === "ENOENT") {
           return cb(null);
         }
-        if (er && er.code === "EPERM" && isWindows) {
+        if (er && er.code === "EPERM" && isWindows2) {
           return fixWinEPERM(p, options, er, cb);
         }
         if (st && st.isDirectory()) {
@@ -1726,7 +1954,7 @@ var require_rimraf = __commonJS({
               return cb(null);
             }
             if (er2.code === "EPERM") {
-              return isWindows ? fixWinEPERM(p, options, er2, cb) : rmdir(p, options, er2, cb);
+              return isWindows2 ? fixWinEPERM(p, options, er2, cb) : rmdir(p, options, er2, cb);
             }
             if (er2.code === "EISDIR") {
               return rmdir(p, options, er2, cb);
@@ -1808,7 +2036,7 @@ var require_rimraf = __commonJS({
         let errState;
         if (n3 === 0) return options.rmdir(p, cb);
         files.forEach((f) => {
-          rimraf(path8.join(p, f), options, (er2) => {
+          rimraf(path9.join(p, f), options, (er2) => {
             if (errState) {
               return;
             }
@@ -1834,7 +2062,7 @@ var require_rimraf = __commonJS({
         if (er.code === "ENOENT") {
           return;
         }
-        if (er.code === "EPERM" && isWindows) {
+        if (er.code === "EPERM" && isWindows2) {
           fixWinEPERMSync(p, options, er);
         }
       }
@@ -1848,7 +2076,7 @@ var require_rimraf = __commonJS({
         if (er.code === "ENOENT") {
           return;
         } else if (er.code === "EPERM") {
-          return isWindows ? fixWinEPERMSync(p, options, er) : rmdirSync(p, options, er);
+          return isWindows2 ? fixWinEPERMSync(p, options, er) : rmdirSync(p, options, er);
         } else if (er.code !== "EISDIR") {
           throw er;
         }
@@ -1873,8 +2101,8 @@ var require_rimraf = __commonJS({
     function rmkidsSync(p, options) {
       assert(p);
       assert(options);
-      options.readdirSync(p).forEach((f) => rimrafSync(path8.join(p, f), options));
-      if (isWindows) {
+      options.readdirSync(p).forEach((f) => rimrafSync(path9.join(p, f), options));
+      if (isWindows2) {
         const startTime = Date.now();
         do {
           try {
@@ -1898,16 +2126,16 @@ var require_remove = __commonJS({
   "../../node_modules/vite-plugin-externals/node_modules/fs-extra/lib/remove/index.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var fs2 = require_graceful_fs();
+    var fs3 = require_graceful_fs();
     var u = require_universalify().fromCallback;
     var rimraf = require_rimraf();
-    function remove2(path8, callback) {
-      if (fs2.rm) return fs2.rm(path8, { recursive: true, force: true }, callback);
-      rimraf(path8, callback);
+    function remove2(path9, callback) {
+      if (fs3.rm) return fs3.rm(path9, { recursive: true, force: true }, callback);
+      rimraf(path9, callback);
     }
-    function removeSync(path8) {
-      if (fs2.rmSync) return fs2.rmSync(path8, { recursive: true, force: true });
-      rimraf.sync(path8);
+    function removeSync(path9) {
+      if (fs3.rmSync) return fs3.rmSync(path9, { recursive: true, force: true });
+      rimraf.sync(path9);
     }
     module.exports = {
       remove: u(remove2),
@@ -1922,28 +2150,28 @@ var require_empty = __commonJS({
     "use strict";
     init_esm_shims();
     var u = require_universalify().fromPromise;
-    var fs2 = require_fs();
-    var path8 = __require("path");
+    var fs3 = require_fs();
+    var path9 = __require("path");
     var mkdir = require_mkdirs();
     var remove2 = require_remove();
     var emptyDir = u(async function emptyDir2(dir) {
       let items;
       try {
-        items = await fs2.readdir(dir);
+        items = await fs3.readdir(dir);
       } catch {
         return mkdir.mkdirs(dir);
       }
-      return Promise.all(items.map((item) => remove2.remove(path8.join(dir, item))));
+      return Promise.all(items.map((item) => remove2.remove(path9.join(dir, item))));
     });
     function emptyDirSync2(dir) {
       let items;
       try {
-        items = fs2.readdirSync(dir);
+        items = fs3.readdirSync(dir);
       } catch {
         return mkdir.mkdirsSync(dir);
       }
       items.forEach((item) => {
-        item = path8.join(dir, item);
+        item = path9.join(dir, item);
         remove2.removeSync(item);
       });
     }
@@ -1962,20 +2190,20 @@ var require_file = __commonJS({
     "use strict";
     init_esm_shims();
     var u = require_universalify().fromCallback;
-    var path8 = __require("path");
-    var fs2 = require_graceful_fs();
+    var path9 = __require("path");
+    var fs3 = require_graceful_fs();
     var mkdir = require_mkdirs();
     function createFile(file, callback) {
       function makeFile() {
-        fs2.writeFile(file, "", (err) => {
+        fs3.writeFile(file, "", (err) => {
           if (err) return callback(err);
           callback();
         });
       }
-      fs2.stat(file, (err, stats) => {
+      fs3.stat(file, (err, stats) => {
         if (!err && stats.isFile()) return callback();
-        const dir = path8.dirname(file);
-        fs2.stat(dir, (err2, stats2) => {
+        const dir = path9.dirname(file);
+        fs3.stat(dir, (err2, stats2) => {
           if (err2) {
             if (err2.code === "ENOENT") {
               return mkdir.mkdirs(dir, (err3) => {
@@ -1987,7 +2215,7 @@ var require_file = __commonJS({
           }
           if (stats2.isDirectory()) makeFile();
           else {
-            fs2.readdir(dir, (err3) => {
+            fs3.readdir(dir, (err3) => {
               if (err3) return callback(err3);
             });
           }
@@ -1997,20 +2225,20 @@ var require_file = __commonJS({
     function createFileSync(file) {
       let stats;
       try {
-        stats = fs2.statSync(file);
+        stats = fs3.statSync(file);
       } catch {
       }
       if (stats && stats.isFile()) return;
-      const dir = path8.dirname(file);
+      const dir = path9.dirname(file);
       try {
-        if (!fs2.statSync(dir).isDirectory()) {
-          fs2.readdirSync(dir);
+        if (!fs3.statSync(dir).isDirectory()) {
+          fs3.readdirSync(dir);
         }
       } catch (err) {
         if (err && err.code === "ENOENT") mkdir.mkdirsSync(dir);
         else throw err;
       }
-      fs2.writeFileSync(file, "");
+      fs3.writeFileSync(file, "");
     }
     module.exports = {
       createFile: u(createFile),
@@ -2025,26 +2253,26 @@ var require_link = __commonJS({
     "use strict";
     init_esm_shims();
     var u = require_universalify().fromCallback;
-    var path8 = __require("path");
-    var fs2 = require_graceful_fs();
+    var path9 = __require("path");
+    var fs3 = require_graceful_fs();
     var mkdir = require_mkdirs();
     var pathExists = require_path_exists().pathExists;
     var { areIdentical } = require_stat();
     function createLink(srcpath, dstpath, callback) {
       function makeLink(srcpath2, dstpath2) {
-        fs2.link(srcpath2, dstpath2, (err) => {
+        fs3.link(srcpath2, dstpath2, (err) => {
           if (err) return callback(err);
           callback(null);
         });
       }
-      fs2.lstat(dstpath, (_, dstStat) => {
-        fs2.lstat(srcpath, (err, srcStat) => {
+      fs3.lstat(dstpath, (_, dstStat) => {
+        fs3.lstat(srcpath, (err, srcStat) => {
           if (err) {
             err.message = err.message.replace("lstat", "ensureLink");
             return callback(err);
           }
           if (dstStat && areIdentical(srcStat, dstStat)) return callback(null);
-          const dir = path8.dirname(dstpath);
+          const dir = path9.dirname(dstpath);
           pathExists(dir, (err2, dirExists) => {
             if (err2) return callback(err2);
             if (dirExists) return makeLink(srcpath, dstpath);
@@ -2059,21 +2287,21 @@ var require_link = __commonJS({
     function createLinkSync(srcpath, dstpath) {
       let dstStat;
       try {
-        dstStat = fs2.lstatSync(dstpath);
+        dstStat = fs3.lstatSync(dstpath);
       } catch {
       }
       try {
-        const srcStat = fs2.lstatSync(srcpath);
+        const srcStat = fs3.lstatSync(srcpath);
         if (dstStat && areIdentical(srcStat, dstStat)) return;
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
       }
-      const dir = path8.dirname(dstpath);
-      const dirExists = fs2.existsSync(dir);
-      if (dirExists) return fs2.linkSync(srcpath, dstpath);
+      const dir = path9.dirname(dstpath);
+      const dirExists = fs3.existsSync(dir);
+      if (dirExists) return fs3.linkSync(srcpath, dstpath);
       mkdir.mkdirsSync(dir);
-      return fs2.linkSync(srcpath, dstpath);
+      return fs3.linkSync(srcpath, dstpath);
     }
     module.exports = {
       createLink: u(createLink),
@@ -2087,12 +2315,12 @@ var require_symlink_paths = __commonJS({
   "../../node_modules/vite-plugin-externals/node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var path8 = __require("path");
-    var fs2 = require_graceful_fs();
+    var path9 = __require("path");
+    var fs3 = require_graceful_fs();
     var pathExists = require_path_exists().pathExists;
     function symlinkPaths(srcpath, dstpath, callback) {
-      if (path8.isAbsolute(srcpath)) {
-        return fs2.lstat(srcpath, (err) => {
+      if (path9.isAbsolute(srcpath)) {
+        return fs3.lstat(srcpath, (err) => {
           if (err) {
             err.message = err.message.replace("lstat", "ensureSymlink");
             return callback(err);
@@ -2103,8 +2331,8 @@ var require_symlink_paths = __commonJS({
           });
         });
       } else {
-        const dstdir = path8.dirname(dstpath);
-        const relativeToDst = path8.join(dstdir, srcpath);
+        const dstdir = path9.dirname(dstpath);
+        const relativeToDst = path9.join(dstdir, srcpath);
         return pathExists(relativeToDst, (err, exists) => {
           if (err) return callback(err);
           if (exists) {
@@ -2113,14 +2341,14 @@ var require_symlink_paths = __commonJS({
               toDst: srcpath
             });
           } else {
-            return fs2.lstat(srcpath, (err2) => {
+            return fs3.lstat(srcpath, (err2) => {
               if (err2) {
                 err2.message = err2.message.replace("lstat", "ensureSymlink");
                 return callback(err2);
               }
               return callback(null, {
                 toCwd: srcpath,
-                toDst: path8.relative(dstdir, srcpath)
+                toDst: path9.relative(dstdir, srcpath)
               });
             });
           }
@@ -2129,28 +2357,28 @@ var require_symlink_paths = __commonJS({
     }
     function symlinkPathsSync(srcpath, dstpath) {
       let exists;
-      if (path8.isAbsolute(srcpath)) {
-        exists = fs2.existsSync(srcpath);
+      if (path9.isAbsolute(srcpath)) {
+        exists = fs3.existsSync(srcpath);
         if (!exists) throw new Error("absolute srcpath does not exist");
         return {
           toCwd: srcpath,
           toDst: srcpath
         };
       } else {
-        const dstdir = path8.dirname(dstpath);
-        const relativeToDst = path8.join(dstdir, srcpath);
-        exists = fs2.existsSync(relativeToDst);
+        const dstdir = path9.dirname(dstpath);
+        const relativeToDst = path9.join(dstdir, srcpath);
+        exists = fs3.existsSync(relativeToDst);
         if (exists) {
           return {
             toCwd: relativeToDst,
             toDst: srcpath
           };
         } else {
-          exists = fs2.existsSync(srcpath);
+          exists = fs3.existsSync(srcpath);
           if (!exists) throw new Error("relative srcpath does not exist");
           return {
             toCwd: srcpath,
-            toDst: path8.relative(dstdir, srcpath)
+            toDst: path9.relative(dstdir, srcpath)
           };
         }
       }
@@ -2167,12 +2395,12 @@ var require_symlink_type = __commonJS({
   "../../node_modules/vite-plugin-externals/node_modules/fs-extra/lib/ensure/symlink-type.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var fs2 = require_graceful_fs();
+    var fs3 = require_graceful_fs();
     function symlinkType(srcpath, type, callback) {
       callback = typeof type === "function" ? type : callback;
       type = typeof type === "function" ? false : type;
       if (type) return callback(null, type);
-      fs2.lstat(srcpath, (err, stats) => {
+      fs3.lstat(srcpath, (err, stats) => {
         if (err) return callback(null, "file");
         type = stats && stats.isDirectory() ? "dir" : "file";
         callback(null, type);
@@ -2182,7 +2410,7 @@ var require_symlink_type = __commonJS({
       let stats;
       if (type) return type;
       try {
-        stats = fs2.lstatSync(srcpath);
+        stats = fs3.lstatSync(srcpath);
       } catch {
         return "file";
       }
@@ -2201,8 +2429,8 @@ var require_symlink = __commonJS({
     "use strict";
     init_esm_shims();
     var u = require_universalify().fromCallback;
-    var path8 = __require("path");
-    var fs2 = require_fs();
+    var path9 = __require("path");
+    var fs3 = require_fs();
     var _mkdirs = require_mkdirs();
     var mkdirs = _mkdirs.mkdirs;
     var mkdirsSync = _mkdirs.mkdirsSync;
@@ -2217,11 +2445,11 @@ var require_symlink = __commonJS({
     function createSymlink(srcpath, dstpath, type, callback) {
       callback = typeof type === "function" ? type : callback;
       type = typeof type === "function" ? false : type;
-      fs2.lstat(dstpath, (err, stats) => {
+      fs3.lstat(dstpath, (err, stats) => {
         if (!err && stats.isSymbolicLink()) {
           Promise.all([
-            fs2.stat(srcpath),
-            fs2.stat(dstpath)
+            fs3.stat(srcpath),
+            fs3.stat(dstpath)
           ]).then(([srcStat, dstStat]) => {
             if (areIdentical(srcStat, dstStat)) return callback(null);
             _createSymlink(srcpath, dstpath, type, callback);
@@ -2230,18 +2458,18 @@ var require_symlink = __commonJS({
       });
     }
     function _createSymlink(srcpath, dstpath, type, callback) {
-      symlinkPaths(srcpath, dstpath, (err, relative) => {
+      symlinkPaths(srcpath, dstpath, (err, relative2) => {
         if (err) return callback(err);
-        srcpath = relative.toDst;
-        symlinkType(relative.toCwd, type, (err2, type2) => {
+        srcpath = relative2.toDst;
+        symlinkType(relative2.toCwd, type, (err2, type2) => {
           if (err2) return callback(err2);
-          const dir = path8.dirname(dstpath);
+          const dir = path9.dirname(dstpath);
           pathExists(dir, (err3, dirExists) => {
             if (err3) return callback(err3);
-            if (dirExists) return fs2.symlink(srcpath, dstpath, type2, callback);
+            if (dirExists) return fs3.symlink(srcpath, dstpath, type2, callback);
             mkdirs(dir, (err4) => {
               if (err4) return callback(err4);
-              fs2.symlink(srcpath, dstpath, type2, callback);
+              fs3.symlink(srcpath, dstpath, type2, callback);
             });
           });
         });
@@ -2250,22 +2478,22 @@ var require_symlink = __commonJS({
     function createSymlinkSync(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = fs2.lstatSync(dstpath);
+        stats = fs3.lstatSync(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
-        const srcStat = fs2.statSync(srcpath);
-        const dstStat = fs2.statSync(dstpath);
+        const srcStat = fs3.statSync(srcpath);
+        const dstStat = fs3.statSync(dstpath);
         if (areIdentical(srcStat, dstStat)) return;
       }
-      const relative = symlinkPathsSync(srcpath, dstpath);
-      srcpath = relative.toDst;
-      type = symlinkTypeSync(relative.toCwd, type);
-      const dir = path8.dirname(dstpath);
-      const exists = fs2.existsSync(dir);
-      if (exists) return fs2.symlinkSync(srcpath, dstpath, type);
+      const relative2 = symlinkPathsSync(srcpath, dstpath);
+      srcpath = relative2.toDst;
+      type = symlinkTypeSync(relative2.toCwd, type);
+      const dir = path9.dirname(dstpath);
+      const exists = fs3.existsSync(dir);
+      if (exists) return fs3.symlinkSync(srcpath, dstpath, type);
       mkdirsSync(dir);
-      return fs2.symlinkSync(srcpath, dstpath, type);
+      return fs3.symlinkSync(srcpath, dstpath, type);
     }
     module.exports = {
       createSymlink: u(createSymlink),
@@ -2337,9 +2565,9 @@ var require_jsonfile = __commonJS({
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs2 = options.fs || _fs;
+      const fs3 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
-      let data2 = await universalify.fromCallback(fs2.readFile)(file, options);
+      let data2 = await universalify.fromCallback(fs3.readFile)(file, options);
       data2 = stripBom(data2);
       let obj;
       try {
@@ -2355,14 +2583,14 @@ var require_jsonfile = __commonJS({
       return obj;
     }
     var readFile5 = universalify.fromPromise(_readFile);
-    function readFileSync(file, options = {}) {
+    function readFileSync2(file, options = {}) {
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs2 = options.fs || _fs;
+      const fs3 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
       try {
-        let content = fs2.readFileSync(file, options);
+        let content = fs3.readFileSync(file, options);
         content = stripBom(content);
         return JSON.parse(content, options.reviver);
       } catch (err) {
@@ -2375,19 +2603,19 @@ var require_jsonfile = __commonJS({
       }
     }
     async function _writeFile(file, obj, options = {}) {
-      const fs2 = options.fs || _fs;
+      const fs3 = options.fs || _fs;
       const str = stringify2(obj, options);
-      await universalify.fromCallback(fs2.writeFile)(file, str, options);
+      await universalify.fromCallback(fs3.writeFile)(file, str, options);
     }
     var writeFile3 = universalify.fromPromise(_writeFile);
     function writeFileSync(file, obj, options = {}) {
-      const fs2 = options.fs || _fs;
+      const fs3 = options.fs || _fs;
       const str = stringify2(obj, options);
-      return fs2.writeFileSync(file, str, options);
+      return fs3.writeFileSync(file, str, options);
     }
     var jsonfile = {
       readFile: readFile5,
-      readFileSync,
+      readFileSync: readFileSync2,
       writeFile: writeFile3,
       writeFileSync
     };
@@ -2417,8 +2645,8 @@ var require_output_file = __commonJS({
     "use strict";
     init_esm_shims();
     var u = require_universalify().fromCallback;
-    var fs2 = require_graceful_fs();
-    var path8 = __require("path");
+    var fs3 = require_graceful_fs();
+    var path9 = __require("path");
     var mkdir = require_mkdirs();
     var pathExists = require_path_exists().pathExists;
     function outputFile(file, data2, encoding, callback) {
@@ -2426,23 +2654,23 @@ var require_output_file = __commonJS({
         callback = encoding;
         encoding = "utf8";
       }
-      const dir = path8.dirname(file);
+      const dir = path9.dirname(file);
       pathExists(dir, (err, itDoes) => {
         if (err) return callback(err);
-        if (itDoes) return fs2.writeFile(file, data2, encoding, callback);
+        if (itDoes) return fs3.writeFile(file, data2, encoding, callback);
         mkdir.mkdirs(dir, (err2) => {
           if (err2) return callback(err2);
-          fs2.writeFile(file, data2, encoding, callback);
+          fs3.writeFile(file, data2, encoding, callback);
         });
       });
     }
     function outputFileSync(file, ...args) {
-      const dir = path8.dirname(file);
-      if (fs2.existsSync(dir)) {
-        return fs2.writeFileSync(file, ...args);
+      const dir = path9.dirname(file);
+      if (fs3.existsSync(dir)) {
+        return fs3.writeFileSync(file, ...args);
       }
       mkdir.mkdirsSync(dir);
-      fs2.writeFileSync(file, ...args);
+      fs3.writeFileSync(file, ...args);
     }
     module.exports = {
       outputFile: u(outputFile),
@@ -2505,8 +2733,8 @@ var require_move = __commonJS({
   "../../node_modules/vite-plugin-externals/node_modules/fs-extra/lib/move/move.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var fs2 = require_graceful_fs();
-    var path8 = __require("path");
+    var fs3 = require_graceful_fs();
+    var path9 = __require("path");
     var copy = require_copy2().copy;
     var remove2 = require_remove().remove;
     var mkdirp = require_mkdirs().mkdirp;
@@ -2525,7 +2753,7 @@ var require_move = __commonJS({
         stat2.checkParentPaths(src, srcStat, dest, "move", (err2) => {
           if (err2) return cb(err2);
           if (isParentRoot(dest)) return doRename(src, dest, overwrite2, isChangingCase, cb);
-          mkdirp(path8.dirname(dest), (err3) => {
+          mkdirp(path9.dirname(dest), (err3) => {
             if (err3) return cb(err3);
             return doRename(src, dest, overwrite2, isChangingCase, cb);
           });
@@ -2533,8 +2761,8 @@ var require_move = __commonJS({
       });
     }
     function isParentRoot(dest) {
-      const parent = path8.dirname(dest);
-      const parsedPath = path8.parse(parent);
+      const parent = path9.dirname(dest);
+      const parsedPath = path9.parse(parent);
       return parsedPath.root === parent;
     }
     function doRename(src, dest, overwrite2, isChangingCase, cb) {
@@ -2552,7 +2780,7 @@ var require_move = __commonJS({
       });
     }
     function rename(src, dest, overwrite2, cb) {
-      fs2.rename(src, dest, (err) => {
+      fs3.rename(src, dest, (err) => {
         if (!err) return cb();
         if (err.code !== "EXDEV") return cb(err);
         return moveAcrossDevice(src, dest, overwrite2, cb);
@@ -2577,8 +2805,8 @@ var require_move_sync = __commonJS({
   "../../node_modules/vite-plugin-externals/node_modules/fs-extra/lib/move/move-sync.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var fs2 = require_graceful_fs();
-    var path8 = __require("path");
+    var fs3 = require_graceful_fs();
+    var path9 = __require("path");
     var copySync = require_copy2().copySync;
     var removeSync = require_remove().removeSync;
     var mkdirpSync = require_mkdirs().mkdirpSync;
@@ -2588,12 +2816,12 @@ var require_move_sync = __commonJS({
       const overwrite2 = opts.overwrite || opts.clobber || false;
       const { srcStat, isChangingCase = false } = stat2.checkPathsSync(src, dest, "move", opts);
       stat2.checkParentPathsSync(src, srcStat, dest, "move");
-      if (!isParentRoot(dest)) mkdirpSync(path8.dirname(dest));
+      if (!isParentRoot(dest)) mkdirpSync(path9.dirname(dest));
       return doRename(src, dest, overwrite2, isChangingCase);
     }
     function isParentRoot(dest) {
-      const parent = path8.dirname(dest);
-      const parsedPath = path8.parse(parent);
+      const parent = path9.dirname(dest);
+      const parsedPath = path9.parse(parent);
       return parsedPath.root === parent;
     }
     function doRename(src, dest, overwrite2, isChangingCase) {
@@ -2602,12 +2830,12 @@ var require_move_sync = __commonJS({
         removeSync(dest);
         return rename(src, dest, overwrite2);
       }
-      if (fs2.existsSync(dest)) throw new Error("dest already exists.");
+      if (fs3.existsSync(dest)) throw new Error("dest already exists.");
       return rename(src, dest, overwrite2);
     }
     function rename(src, dest, overwrite2) {
       try {
-        fs2.renameSync(src, dest);
+        fs3.renameSync(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV") throw err;
         return moveAcrossDevice(src, dest, overwrite2);
@@ -5252,10 +5480,10 @@ var require_helpers = __commonJS({
         return !arr.includes(node, i + 1);
       });
       nodes.sort(function(a, b) {
-        var relative = compareDocumentPosition(a, b);
-        if (relative & DocumentPosition.PRECEDING) {
+        var relative2 = compareDocumentPosition(a, b);
+        if (relative2 & DocumentPosition.PRECEDING) {
           return -1;
-        } else if (relative & DocumentPosition.FOLLOWING) {
+        } else if (relative2 & DocumentPosition.FOLLOWING) {
           return 1;
         }
         return 0;
@@ -27134,6 +27362,383 @@ var require_rfdc = __commonJS({
 // src/vite/configs/backend.ts
 init_esm_shims();
 
+// ../../node_modules/vite-tsconfig-paths/dist/index.js
+init_esm_shims();
+var import_globrex = __toESM(require_globrex(), 1);
+var import_debug = __toESM(require_src(), 1);
+import * as fs from "fs";
+import { resolve as resolve3 } from "path";
+import { inspect } from "util";
+import { normalizePath as normalizePath2, searchForWorkspaceRoot } from "vite";
+import { resolve } from "path";
+import * as os from "os";
+import * as path from "path";
+import { normalizePath } from "vite";
+import { dirname } from "path";
+function resolvePathMappings(paths, base) {
+  const sortedPatterns = Object.keys(paths).sort(
+    (a, b) => getPrefixLength(b) - getPrefixLength(a)
+  );
+  const resolved = [];
+  for (let pattern of sortedPatterns) {
+    const relativePaths = paths[pattern];
+    pattern = escapeStringRegexp(pattern).replace(/\*/g, "(.+)");
+    resolved.push({
+      pattern: new RegExp("^" + pattern + "$"),
+      paths: relativePaths.map((relativePath) => resolve(base, relativePath))
+    });
+  }
+  return resolved;
+}
+function getPrefixLength(pattern) {
+  const prefixLength = pattern.indexOf("*");
+  return pattern.substr(0, prefixLength).length;
+}
+function escapeStringRegexp(string) {
+  return string.replace(/[|\\{}()[\]^$+?.]/g, "\\$&").replace(/-/g, "\\x2d");
+}
+var isWindows = os.platform() == "win32";
+var resolve2 = isWindows ? (...paths) => normalizePath(path.win32.resolve(...paths)) : path.posix.resolve;
+var isAbsolute = isWindows ? path.win32.isAbsolute : path.posix.isAbsolute;
+var join = path.posix.join;
+var relative = path.posix.relative;
+var basename = path.posix.basename;
+var debug = (0, import_debug.default)("vite-tsconfig-paths");
+var debugResolve = (0, import_debug.default)("vite-tsconfig-paths:resolve");
+if (process.env.TEST) {
+  import_debug.default.log = console.log.bind(console);
+}
+var notApplicable = [void 0, false];
+var notFound = [void 0, true];
+var src_default = (opts = {}) => {
+  let resolversByDir;
+  return {
+    name: "vite-tsconfig-paths",
+    enforce: "pre",
+    async configResolved(config) {
+      let projectRoot = config.root;
+      let workspaceRoot;
+      let { root } = opts;
+      if (root) {
+        root = resolve3(projectRoot, root);
+      } else {
+        workspaceRoot = searchForWorkspaceRoot(projectRoot);
+      }
+      debug("options.root   ==", root);
+      debug("project root   ==", projectRoot);
+      debug("workspace root ==", workspaceRoot);
+      if (root) {
+        projectRoot = root;
+        workspaceRoot = root;
+      }
+      const tsconfck = await import("./src-MHMTXBSY.js");
+      const projects = opts.projects ? opts.projects.map((file) => {
+        if (!file.endsWith(".json")) {
+          file = join(file, "tsconfig.json");
+        }
+        return resolve3(projectRoot, file);
+      }) : await tsconfck.findAll(workspaceRoot, {
+        configNames: opts.configNames || ["tsconfig.json", "jsconfig.json"],
+        skip(dir) {
+          if (dir === ".git" || dir === "node_modules") {
+            return true;
+          }
+          if (typeof opts.skip === "function") {
+            return opts.skip(dir);
+          }
+          return false;
+        }
+      });
+      debug("projects:", projects);
+      let hasTypeScriptDep = false;
+      if (opts.parseNative) {
+        try {
+          const pkgJson = fs.readFileSync(
+            join(workspaceRoot, "package.json"),
+            "utf8"
+          );
+          const pkg = JSON.parse(pkgJson);
+          const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+          hasTypeScriptDep = "typescript" in deps;
+        } catch (e) {
+          if (e.code != "ENOENT") {
+            throw e;
+          }
+        }
+      }
+      let firstError;
+      const parseOptions = {
+        cache: new tsconfck.TSConfckCache()
+      };
+      const parsedProjects = new Set(
+        await Promise.all(
+          projects.map((tsconfigFile) => {
+            if (tsconfigFile === null) {
+              debug("tsconfig file not found:", tsconfigFile);
+              return null;
+            }
+            return (hasTypeScriptDep ? tsconfck.parseNative(tsconfigFile, parseOptions) : tsconfck.parse(tsconfigFile, parseOptions)).catch((error) => {
+              if (opts.ignoreConfigErrors) {
+                debug("tsconfig file caused a parsing error:", tsconfigFile);
+              } else {
+                config.logger.error(
+                  '[tsconfig-paths] An error occurred while parsing "' + tsconfigFile + '". See below for details.' + (firstError ? "" : " To disable this message, set the `ignoreConfigErrors` option to true."),
+                  { error }
+                );
+                if (config.logger.hasErrorLogged(error)) {
+                  console.error(error);
+                }
+                firstError = error;
+              }
+              return null;
+            });
+          })
+        )
+      );
+      resolversByDir = {};
+      parsedProjects.forEach((project) => {
+        if (!project) {
+          return;
+        }
+        if (project.referenced) {
+          project.referenced.forEach((projectRef) => {
+            parsedProjects.add(projectRef);
+          });
+          parsedProjects.delete(project);
+          parsedProjects.add(project);
+          project.referenced = void 0;
+        } else {
+          const resolver = createResolver(project);
+          if (resolver) {
+            const projectDir = normalizePath2(dirname(project.tsconfigFile));
+            const resolvers = resolversByDir[projectDir] || (resolversByDir[projectDir] = []);
+            resolvers.push(resolver);
+          }
+        }
+      });
+    },
+    async resolveId(id, importer, options) {
+      if (debugResolve.enabled) {
+        debugResolve("resolving:", { id, importer });
+      }
+      if (!importer) {
+        debugResolve("importer is empty or undefined. skipping...");
+        return;
+      }
+      if (relativeImportRE.test(id)) {
+        debugResolve("id is a relative import. skipping...");
+        return;
+      }
+      if (isAbsolute(id)) {
+        debugResolve("id is an absolute path. skipping...");
+        return;
+      }
+      if (id.includes("\0")) {
+        debugResolve("id is a virtual module. skipping...");
+        return;
+      }
+      const resolveOptions2 = { ...options, skipSelf: true };
+      const viteResolve = async (id2, importer2) => {
+        var _a;
+        return (_a = await this.resolve(id2, importer2, resolveOptions2)) == null ? void 0 : _a.id;
+      };
+      let prevProjectDir;
+      let projectDir = normalizePath2(dirname(importer));
+      loop:
+        while (projectDir && projectDir != prevProjectDir) {
+          const resolvers = resolversByDir[projectDir];
+          if (resolvers) {
+            for (const resolve42 of resolvers) {
+              const [resolved, matched] = await resolve42(viteResolve, id, importer);
+              if (resolved) {
+                return resolved;
+              }
+              if (matched) {
+                break loop;
+              }
+            }
+          }
+          prevProjectDir = projectDir;
+          projectDir = dirname(prevProjectDir);
+        }
+    }
+  };
+  function resolvePathsRootDir(project) {
+    var _a, _b, _c, _d;
+    if ("result" in project) {
+      return (_b = (_a = project.result.options) == null ? void 0 : _a.pathsBasePath) != null ? _b : dirname(project.tsconfigFile);
+    }
+    const baseUrl = (_c = project.tsconfig.compilerOptions) == null ? void 0 : _c.baseUrl;
+    if (baseUrl) {
+      return baseUrl;
+    }
+    const projectWithPaths = (_d = project.extended) == null ? void 0 : _d.find(
+      (p) => {
+        var _a2;
+        return (_a2 = p.tsconfig.compilerOptions) == null ? void 0 : _a2.paths;
+      }
+    );
+    return dirname((projectWithPaths != null ? projectWithPaths : project).tsconfigFile);
+  }
+  function createResolver(project) {
+    var _a, _b, _c, _d;
+    const configPath = normalizePath2(project.tsconfigFile);
+    const config = project.tsconfig;
+    debug("config loaded:", inspect({ configPath, config }, false, 10, true));
+    if (((_a = config.files) == null ? void 0 : _a.length) == 0 && !((_b = config.include) == null ? void 0 : _b.length)) {
+      debug(
+        `[!] skipping "${configPath}" as no files can be matched since "files" is empty and "include" is missing or empty`
+      );
+      return null;
+    }
+    const options = config.compilerOptions || {};
+    const { baseUrl, paths } = options;
+    if (!baseUrl && !paths) {
+      debug(`[!] missing baseUrl and paths: "${configPath}"`);
+      return null;
+    }
+    const resolveWithBaseUrl = baseUrl ? (viteResolve, id, importer) => {
+      const absoluteId = join(baseUrl, id);
+      debugResolve("trying with baseUrl:", absoluteId);
+      return viteResolve(absoluteId, importer);
+    } : void 0;
+    let resolveId;
+    if (paths) {
+      const pathsRootDir = resolvePathsRootDir(project);
+      const pathMappings = resolvePathMappings(paths, pathsRootDir);
+      const resolveWithPaths = async (viteResolve, id, importer) => {
+        for (const mapping of pathMappings) {
+          const match5 = id.match(mapping.pattern);
+          if (!match5) {
+            continue;
+          }
+          for (let pathTemplate of mapping.paths) {
+            let starCount = 0;
+            const mappedId = pathTemplate.replace(/\*/g, () => {
+              const matchIndex = Math.min(++starCount, match5.length - 1);
+              return match5[matchIndex];
+            });
+            debugResolve("found match, trying to resolve:", mappedId);
+            const resolved = await viteResolve(mappedId, importer);
+            if (resolved) {
+              return resolved;
+            }
+          }
+        }
+      };
+      if (resolveWithBaseUrl) {
+        resolveId = (viteResolve, id, importer) => resolveWithPaths(viteResolve, id, importer).then((resolved) => {
+          return resolved != null ? resolved : resolveWithBaseUrl(viteResolve, id, importer);
+        });
+      } else {
+        resolveId = resolveWithPaths;
+      }
+    } else {
+      resolveId = resolveWithBaseUrl;
+    }
+    const configDir = dirname(configPath);
+    let { outDir } = options;
+    if (outDir && isAbsolute(outDir)) {
+      outDir = relative(configDir, outDir);
+    }
+    const isIncludedRelative = getIncluder(
+      (_c = config.include) == null ? void 0 : _c.map((p) => ensureRelative(configDir, p)),
+      (_d = config.exclude) == null ? void 0 : _d.map((p) => ensureRelative(configDir, p)),
+      outDir
+    );
+    const importerExtRE = opts.loose ? /./ : options.allowJs || basename(configPath).startsWith("jsconfig.") ? jsLikeRE : /\.[mc]?tsx?$/;
+    const resolutionCache = /* @__PURE__ */ new Map();
+    return async (viteResolve, id, importer) => {
+      var _a2;
+      importer = normalizePath2(importer);
+      const importerFile = importer.replace(/[#?].+$/, "");
+      if (!importerExtRE.test(importerFile)) {
+        debugResolve("importer has unsupported extension. skipping...");
+        return notApplicable;
+      }
+      const relativeImporterFile = relative(configDir, importerFile);
+      if (!isIncludedRelative(relativeImporterFile)) {
+        debugResolve("importer is not included. skipping...");
+        return notApplicable;
+      }
+      const suffix = (_a2 = /\?.+$/.exec(id)) == null ? void 0 : _a2[0];
+      if (suffix) {
+        id = id.slice(0, -suffix.length);
+      }
+      let resolvedId = resolutionCache.get(id);
+      if (!resolvedId) {
+        resolvedId = await resolveId(viteResolve, id, importer);
+        if (!resolvedId) {
+          return notFound;
+        }
+        resolutionCache.set(id, resolvedId);
+        if (debugResolve.enabled) {
+          debugResolve("resolved without error:", {
+            id,
+            importer,
+            resolvedId,
+            configPath
+          });
+        }
+      }
+      if (suffix) {
+        resolvedId += suffix;
+      }
+      return [resolvedId, true];
+    };
+  }
+};
+var jsLikeRE = /\.(vue|svelte|mdx|[mc]?[jt]sx?)$/;
+var relativeImportRE = /^\.\.?(\/|$)/;
+var defaultInclude = ["**/*"];
+var defaultExclude = [
+  "**/node_modules",
+  "**/bower_components",
+  "**/jspm_packages"
+];
+function getIncluder(includePaths = defaultInclude, excludePaths = defaultExclude, outDir) {
+  if (outDir) {
+    excludePaths = excludePaths.concat(outDir);
+  }
+  if (includePaths.length || excludePaths.length) {
+    const includers = [];
+    const excluders = [];
+    includePaths.forEach(addCompiledGlob, includers);
+    excludePaths.forEach(addCompiledGlob, excluders);
+    debug(`compiled globs:`, { includers, excluders });
+    return (path22) => {
+      path22 = path22.replace(/\?.+$/, "");
+      if (!relativeImportRE.test(path22)) {
+        path22 = "./" + path22;
+      }
+      const test = (glob) => glob.test(path22);
+      return includers.some(test) && !excluders.some(test);
+    };
+  }
+  return () => true;
+}
+function addCompiledGlob(glob) {
+  const endsWithGlob = glob.split("/").pop().includes("*");
+  const relativeGlob = relativeImportRE.test(glob) ? glob : "./" + glob;
+  if (endsWithGlob) {
+    this.push(compileGlob(relativeGlob));
+  } else {
+    this.push(compileGlob(relativeGlob + "/**"));
+    if (/\.\w+$/.test(glob)) {
+      this.push(compileGlob(relativeGlob));
+    }
+  }
+}
+function compileGlob(glob) {
+  return (0, import_globrex.default)(glob, {
+    extended: true,
+    globstar: true
+  }).regex;
+}
+function ensureRelative(dir, path22) {
+  return isAbsolute(path22) ? relative(dir, path22) : path22;
+}
+
 // ../cli-miniflare/src/index.ts
 init_esm_shims();
 
@@ -27150,7 +27755,7 @@ import { fetchModule } from "vite";
 // ../../node_modules/get-port/index.js
 init_esm_shims();
 import net from "node:net";
-import os from "node:os";
+import os2 from "node:os";
 var Locked = class extends Error {
   constructor(port) {
     super(`${port} is locked`);
@@ -27163,7 +27768,7 @@ var lockedPorts = {
 var releaseOldLockedPortsIntervalMs = 1e3 * 15;
 var timeout;
 var getLocalHosts = () => {
-  const interfaces = os.networkInterfaces();
+  const interfaces = os2.networkInterfaces();
   const results = /* @__PURE__ */ new Set([void 0, "0.0.0.0"]);
   for (const _interface of Object.values(interfaces)) {
     for (const config of _interface) {
@@ -27172,14 +27777,14 @@ var getLocalHosts = () => {
   }
   return results;
 };
-var checkAvailablePort = (options) => new Promise((resolve3, reject) => {
+var checkAvailablePort = (options) => new Promise((resolve6, reject) => {
   const server = net.createServer();
   server.unref();
   server.on("error", reject);
   server.listen(options, () => {
     const { port } = server.address();
     server.close(() => {
-      resolve3(port);
+      resolve6(port);
     });
   });
 });
@@ -27449,8 +28054,8 @@ for (let i = 0; i < chars.length; i++) {
   intToChar[i] = c;
   charToInt[c] = i;
 }
-function encodeInteger(builder, num, relative) {
-  let delta = num - relative;
+function encodeInteger(builder, num, relative2) {
+  let delta = num - relative2;
   delta = delta < 0 ? -delta << 1 | 1 : delta << 1;
   do {
     let clamped = delta & 31;
@@ -28543,7 +29148,7 @@ var E;
 
 // ../vite-optimize-backend-dependencies/src/utils.ts
 init_esm_shims();
-import { join } from "node:path";
+import { join as join2 } from "node:path";
 import { readFile as readFile2 } from "node:fs/promises";
 var postfixRE = /[?#].*$/;
 var OPTIMIZABLE_ENTRY_RE = /\.[cm]?[jt]s$/;
@@ -28555,7 +29160,7 @@ function cleanUrl(url) {
   return url.replace(postfixRE, "");
 }
 function isViteOptimized(id, projectFolder) {
-  return id.startsWith(join(projectFolder, "node_modules/.vite/deps_ssr"));
+  return id.startsWith(join2(projectFolder, "node_modules/.vite/deps_ssr"));
 }
 async function shouldOptimizeDependency(url) {
   return url.includes("node_modules") && OPTIMIZABLE_ENTRY_RE.test(url) && !await fileHasModuleSyntax(url);
@@ -28572,7 +29177,7 @@ async function fileHasModuleSyntax(filePath) {
 init_esm_shims();
 import esbuild from "esbuild";
 import { readFile as readFile3 } from "node:fs/promises";
-import path, { join as join2 } from "node:path";
+import path2, { join as join3 } from "node:path";
 async function optimizeCjsDependency({
   url,
   projectFolder
@@ -28599,7 +29204,7 @@ async function optimizeCjsDependency({
     });
   });
   const [output] = Object.entries(metafile.outputs).find(
-    ([, output2]) => output2.entryPoint && path.resolve(projectFolder, output2.entryPoint) === url
+    ([, output2]) => output2.entryPoint && path2.resolve(projectFolder, output2.entryPoint) === url
   ) ?? [];
   if (!output) {
     throw new CliError({
@@ -28607,7 +29212,7 @@ async function optimizeCjsDependency({
       cause: null
     });
   }
-  return readFile3(join2(projectFolder, output), "utf-8").catch(
+  return readFile3(join3(projectFolder, output), "utf-8").catch(
     (error) => {
       throw new CliError({
         code: CliErrorCode.FailedReadingEsbuildOutputFile(),
@@ -28884,6 +29489,10 @@ async function getViteConfig(model, options, { appSecret, webhookPublicKey }) {
         ),
         customLogger: options.customLogger,
         invalidateGlobPatterns: [EVENTS_PATTERN, SERVICE_PLUGINS_PATTERN]
+      }),
+      src_default({
+        ignoreConfigErrors: true,
+        root: model.projectFolder
       })
     ]
   };
@@ -30141,7 +30750,7 @@ function isObject3(o) {
 
 // ../../node_modules/vite-plugin-externals/dist/es/src/index.js
 var import_fs_extra = __toESM(require_lib2());
-import path2 from "path";
+import path3 from "path";
 
 // ../../node_modules/vite-plugin-externals/dist/es/src/options.js
 init_esm_shims();
@@ -35728,14 +36337,14 @@ var __asyncValues = function(o) {
   }, i);
   function verb(n3) {
     i[n3] = o[n3] && function(v) {
-      return new Promise(function(resolve3, reject) {
-        v = o[n3](v), settle(resolve3, reject, v.done, v.value);
+      return new Promise(function(resolve6, reject) {
+        v = o[n3](v), settle(resolve6, reject, v.done, v.value);
       });
     };
   }
-  function settle(resolve3, reject, d, v) {
+  function settle(resolve6, reject, d, v) {
     Promise.resolve(v).then(function(v2) {
-      resolve3({ value: v2, done: d });
+      resolve6({ value: v2, done: d });
     }, reject);
   }
 };
@@ -35784,13 +36393,13 @@ function viteExternalsPlugin(externals = {}, userOptions = {}) {
       } else if (Array.isArray(alias)) {
         newAlias.push(...alias);
       }
-      const cachePath = path2.join(process.cwd(), NODE_MODULES_FLAG, CACHE_DIR);
+      const cachePath = path3.join(process.cwd(), NODE_MODULES_FLAG, CACHE_DIR);
       await (0, import_fs_extra.ensureDir)(cachePath);
       await (0, import_fs_extra.emptyDirSync)(cachePath);
       try {
         for (var externalsKeys_1 = __asyncValues(externalsKeys), externalsKeys_1_1; externalsKeys_1_1 = await externalsKeys_1.next(), !externalsKeys_1_1.done; ) {
           const externalKey = externalsKeys_1_1.value;
-          const externalCachePath = path2.join(cachePath, `${externalKey}.js`);
+          const externalCachePath = path3.join(cachePath, `${externalKey}.js`);
           newAlias.push({ find: new RegExp(`^${externalKey}$`), replacement: externalCachePath });
           await (0, import_fs_extra.ensureFile)(externalCachePath);
           await (0, import_fs_extra.writeFile)(externalCachePath, `module.exports = ${transformModuleName(externals[externalKey])};`);
@@ -35880,7 +36489,7 @@ function compatSsrInOptions(options) {
 // src/vite/configs/build-command/browser.ts
 var import_monitoring_buildtime2 = __toESM(require_build(), 1);
 var import_variant2 = __toESM(require_lib(), 1);
-import { resolve } from "node:path";
+import { resolve as resolve4 } from "node:path";
 
 // src/vite/plugins/inline-html.ts
 init_esm_shims();
@@ -36396,7 +37005,7 @@ var getDashboardComponentBuildTemplate = (appId, dashboardComponent) => {
 
 // src/vite/plugins/module-bundle/custom-elements.ts
 init_esm_shims();
-var getCustomElementBaseTemplate = (path8, tagName, appId) => (
+var getCustomElementBaseTemplate = (path9, tagName, appId) => (
   // In UsersCustomElementClass we have class that will be registered in customElements registry
   // Then this class will be used to create instances for each of elements of our CustomElement
   // That's why we patching it's proto with accessTokenListener (in case user do not have it), so then platform could call it on each of instances
@@ -36407,7 +37016,7 @@ var getCustomElementBaseTemplate = (path8, tagName, appId) => (
       await import('https://unpkg.com/react@16.14.0/umd/react.production.min.js');
       await import('https://unpkg.com/react-dom@16.14.0/umd/react-dom.production.min.js');
     }
-    const { default: UsersCustomElementClass } = await import('${path8}');
+    const { default: UsersCustomElementClass } = await import('${path9}');
 
     let accessTokenListenerFn = UsersCustomElementClass.prototype.accessTokenListener;
     if (!accessTokenListenerFn) {
@@ -36638,10 +37247,10 @@ function draftJs() {
 // src/vite/plugins/embedded-script-sdk-support.ts
 init_esm_shims();
 var import_variant = __toESM(require_lib(), 1);
-import { join as join3 } from "node:path";
+import { join as join4 } from "node:path";
 var import_node_html_parser = __toESM(require_dist(), 1);
 function getEmbeddedScriptEntries(model) {
-  const entries = model.components.filter((0, import_variant.isType)(DevCenterComponent.EmbeddedScript)).map((comp) => join3(model.projectFolder, comp.relativePath));
+  const entries = model.components.filter((0, import_variant.isType)(DevCenterComponent.EmbeddedScript)).map((comp) => join4(model.projectFolder, comp.relativePath));
   return new Set(entries);
 }
 function getEmbeddedScriptHtmlUrl(filename) {
@@ -36830,7 +37439,7 @@ function fbjsHotfixPlugin() {
 
 // src/vite/plugins/config-extensions-file-emitter.ts
 init_esm_shims();
-import path3 from "node:path";
+import path4 from "node:path";
 function configExtensionsFileEmitter(model) {
   return {
     name: "config-extensions-file-emitter",
@@ -36843,7 +37452,7 @@ function configExtensionsFileEmitter(model) {
         const content = new Uint8Array(await readFile(resolved.id));
         const fileName = this.emitFile({
           type: "asset",
-          name: path3.basename(resolved.id),
+          name: path4.basename(resolved.id),
           originalFileName: assetUrl,
           source: content
         });
@@ -36875,7 +37484,7 @@ function configExtensionsFileEmitter(model) {
 
 // src/vite/plugins/web-methods-plugin.ts
 init_esm_shims();
-import path5 from "node:path";
+import path6 from "node:path";
 
 // ../../node_modules/minimatch/dist/esm/index.js
 init_esm_shims();
@@ -37556,11 +38165,11 @@ var qmarksTestNoExtDot = ([$0]) => {
   return (f) => f.length === len && f !== "." && f !== "..";
 };
 var defaultPlatform = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
-var path4 = {
+var path5 = {
   win32: { sep: "\\" },
   posix: { sep: "/" }
 };
-var sep = defaultPlatform === "win32" ? path4.win32.sep : path4.posix.sep;
+var sep = defaultPlatform === "win32" ? path5.win32.sep : path5.posix.sep;
 minimatch.sep = sep;
 var GLOBSTAR = Symbol("globstar **");
 minimatch.GLOBSTAR = GLOBSTAR;
@@ -38232,7 +38841,7 @@ function webMethodsPlugin({
         return;
       }
       const relativeId = normalizeGlobbyPattern(
-        path5.relative(projectFolder, id)
+        path6.relative(projectFolder, id)
       );
       if (!minimatch(relativeId, normalizedWebMethodPattern)) {
         throw new CliError({
@@ -38249,7 +38858,7 @@ function webMethodsPlugin({
             export const ${method} = async (...args) => {
               return await callWebMethod({
                 args,
-                filename: '${path5.relative(projectFolder, url)}',
+                filename: '${path6.relative(projectFolder, url)}',
                 method: '${method}',
                 baseURL: __webMethodsBaseUrl,
               });
@@ -38304,7 +38913,7 @@ async function getViteConfig2(model, options, { baseBackendUrl } = {}) {
   const virtualDashboardScriptEntries = [
     ...virtualDashboardScriptAssets(model)
   ].map(([assetId, component]) => [`script-asset-${component.id}`, assetId]);
-  const embeddedScriptEntries = model.components.filter((0, import_variant2.isType)(DevCenterComponent.EmbeddedScript)).map((comp) => [comp.id, resolve(model.projectFolder, comp.relativePath)]);
+  const embeddedScriptEntries = model.components.filter((0, import_variant2.isType)(DevCenterComponent.EmbeddedScript)).map((comp) => [comp.id, resolve4(model.projectFolder, comp.relativePath)]);
   const virtualCustomElementHTMLEntries = [
     ...virtualCustomElementPanelHTMLAssets(model)
   ].map(([assetId, component]) => [`html-asset-${component.id}`, assetId]);
@@ -38396,7 +39005,11 @@ async function getViteConfig2(model, options, { baseBackendUrl } = {}) {
         ...options
       }),
       configExtensionsFileEmitter(model),
-      ...monitoringPlugins ?? []
+      ...monitoringPlugins ?? [],
+      src_default({
+        ignoreConfigErrors: true,
+        root: model.projectFolder
+      })
     ],
     experimental: {
       /*
@@ -38477,15 +39090,15 @@ var exportsCustodian = ({
       if (id === EXPORTS_CUSTODIAN_ENTRY) {
         return [
           ...Array.from(virtualBlocksWidgetAssets.keys()).map(
-            (path8, index) => `
-                import { init as init${index}, api as api${index} } from '${path8}';
+            (path9, index) => `
+                import { init as init${index}, api as api${index} } from '${path9}';
                 init${index}();
                 api${index}();
               `
           ),
           ...Array.from(virtualBlocksWidgetPanelAssets.keys()).map(
-            (path8, index) => `
-                import { init as initPanel${index} } from '${path8}';
+            (path9, index) => `
+                import { init as initPanel${index} } from '${path9}';
                 initPanel${index}();
               `
           )
@@ -38570,7 +39183,11 @@ async function getViteConfig3(model, options, { baseBackendUrl } = {}) {
         initialModel: model,
         ...options
       }),
-      ...monitoringPlugins ?? []
+      ...monitoringPlugins ?? [],
+      src_default({
+        ignoreConfigErrors: true,
+        root: model.projectFolder
+      })
     ]
   };
 }
@@ -38582,7 +39199,7 @@ init_esm_shims();
 init_esm_shims();
 var import_monitoring_buildtime4 = __toESM(require_build(), 1);
 var import_variant3 = __toESM(require_lib(), 1);
-import { resolve as resolve2 } from "node:path";
+import { resolve as resolve5 } from "node:path";
 
 // src/vite/plugins/ssl.ts
 init_esm_shims();
@@ -38591,7 +39208,7 @@ init_esm_shims();
 init_esm_shims();
 var import_selfsigned = __toESM(require_selfsigned(), 1);
 import { readFile as readFile4, writeFile as writeFile2, stat } from "node:fs/promises";
-import path6 from "node:path";
+import path7 from "node:path";
 var PEM_FILENAME = "wix-cli.pem";
 var PEM_MAX_DAYS = 30;
 var attrs = [
@@ -38634,7 +39251,7 @@ var shouldRecreatePem = async (wixCliPemPath) => {
 };
 var generateHostCert = async () => {
   const wixDataDir = getDataDirPath();
-  const wixCliPemPath = path6.join(wixDataDir, PEM_FILENAME);
+  const wixCliPemPath = path7.join(wixDataDir, PEM_FILENAME);
   const recreatePem = await shouldRecreatePem(wixCliPemPath);
   if (!recreatePem) {
     const cachedCert = await readFile4(wixCliPemPath, {
@@ -38731,15 +39348,15 @@ function autoOrigin() {
 
 // src/vite/plugins/absolute-html-url.ts
 init_esm_shims();
-import { dirname, isAbsolute, join as join4 } from "node:path";
+import { dirname as dirname2, isAbsolute as isAbsolute2, join as join5 } from "node:path";
 import { URL as URL2 } from "node:url";
 function getAbsoluteAssetUrl(originalUrl, assetUrl, viteAddress) {
   let url = new URL2(assetUrl, viteAddress).href;
   if (assetUrl.startsWith("/@vite")) {
     return url;
   }
-  if (!isAbsolute(assetUrl)) {
-    const assetPath = join4(dirname(originalUrl), assetUrl);
+  if (!isAbsolute2(assetUrl)) {
+    const assetPath = join5(dirname2(originalUrl), assetUrl);
     url = new URL2(assetPath, viteAddress).href;
   }
   return url;
@@ -38784,7 +39401,7 @@ async function getViteConfig4(model, options, { baseBackendUrl } = {}) {
   const virtualDashboardScriptEntries = [
     ...virtualDashboardScriptAssets(model)
   ].map(([assetId, component]) => [`script-asset-${component.id}`, assetId]);
-  const embeddedScriptEntries = model.components.filter((0, import_variant3.isType)(DevCenterComponent.EmbeddedScript)).map((comp) => [comp.id, resolve2(model.projectFolder, comp.relativePath)]);
+  const embeddedScriptEntries = model.components.filter((0, import_variant3.isType)(DevCenterComponent.EmbeddedScript)).map((comp) => [comp.id, resolve5(model.projectFolder, comp.relativePath)]);
   const virtualCustomElementHTMLEntries = [
     ...virtualCustomElementPanelHTMLAssets(model)
   ].map(([assetId, component]) => [`html-asset-${component.id}`, assetId]);
@@ -38891,7 +39508,11 @@ async function getViteConfig4(model, options, { baseBackendUrl } = {}) {
         ...options
       }),
       configExtensionsFileEmitter(model),
-      ...monitoringPlugins ?? []
+      ...monitoringPlugins ?? [],
+      src_default({
+        ignoreConfigErrors: true,
+        root: model.projectFolder
+      })
     ],
     experimental: {
       /*
@@ -39026,13 +39647,13 @@ init_esm_shims();
 var import_variant5 = __toESM(require_lib(), 1);
 var import_uniqWith = __toESM(require_uniqWith(), 1);
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { dirname as dirname2, join as join5 } from "node:path";
+import { dirname as dirname3, join as join6 } from "node:path";
 function isTruthy(x) {
   return x != null && x !== false;
 }
 function parseImageField(asset, relativePath) {
   if (RELATIVE_ASSET_PATH_REGEX.test(asset)) {
-    return join5(dirname2(`/${relativePath}`), asset);
+    return join6(dirname3(`/${relativePath}`), asset);
   }
   return asset;
 }
@@ -39462,7 +40083,7 @@ async function createAppManifest({
 // src/app-manifest/component-source.ts
 init_esm_shims();
 var import_variant6 = __toESM(require_lib(), 1);
-import path7, { join as join6 } from "node:path";
+import path8, { join as join7 } from "node:path";
 import { pathToFileURL } from "node:url";
 
 // src/app-manifest/build-output-data-extractor.ts
@@ -39548,7 +40169,7 @@ async function getEventDevSlugs(component, backendDevServerUrl) {
 }
 async function getRegisteredExtensions(model) {
   const backendBuildFolder = getAppBackendBuildFolder(model.projectFolder);
-  const outputFilepath = join6(
+  const outputFilepath = join7(
     backendBuildFolder,
     "getRegisteredExtensions.mjs"
   );
@@ -39627,7 +40248,7 @@ var embeddedScriptBuilder = async (model, component, source) => {
   return {
     template: source.buildSource ? extractModuleBundleContent(
       source.buildSource.browserBuildOutput,
-      path7.resolve(model.projectFolder, component.relativePath)
+      path8.resolve(model.projectFolder, component.relativePath)
     ) : await getEmbeddedScriptDevTemplate(
       component,
       source.devSource.devServerUrl
@@ -39760,7 +40381,7 @@ function getComponentBuildSourceBuilder(model, browserBuildSource, workerBuildSo
 
 // ../cli-app-manifest/build/index.js
 init_esm_shims();
-import fs from "node:fs/promises";
+import fs2 from "node:fs/promises";
 var import_rfdc = __toESM(require_rfdc(), 1);
 var import_rfdc2 = __toESM(require_rfdc(), 1);
 var import_rfdc3 = __toESM(require_rfdc(), 1);
@@ -40249,7 +40870,7 @@ var appManifestSchema = z.object({
 });
 async function readAppManifest(filePath) {
   try {
-    const configData = await fs.readFile(filePath, "utf-8");
+    const configData = await fs2.readFile(filePath, "utf-8");
     return appManifestSchema.parse(JSON.parse(configData));
   } catch (e) {
     const causeMessage = e instanceof Error ? e.toString() : JSON.stringify(e);
@@ -40260,8 +40881,8 @@ async function readAppManifest(filePath) {
 }
 var cloneDeep = (0, import_rfdc.default)();
 var cloneDeep2 = (0, import_rfdc2.default)();
-var normalizeUrl = (url, baseUrl) => {
-  return new URL(url, baseUrl).href;
+var normalizeUrl = (url, normalizedBaseUrl) => {
+  return new URL(url.startsWith("/") ? `.${url}` : url, normalizedBaseUrl).href;
 };
 var overrideComponentSourceWithNormalizedUrls = (componentSource, normalizedBaseUrl) => {
   const { scriptAsset, iframeUrl } = componentSource;
@@ -40635,4 +41256,4 @@ export {
 he/he.js:
   (*! https://mths.be/he v1.2.0 by @mathias | MIT license *)
 */
-//# sourceMappingURL=chunk-DBASREIW.js.map
+//# sourceMappingURL=chunk-PGKXOCZN.js.map