vxrn 1.14.4 → 1.14.5

package/dist/utils/patches.native.js

@@ -10,84 +10,112 @@ import semver from "semver";
 import { builtInDepPatches } from "../patches/builtInDepPatches.native.js";
 import { globDir } from "./globDir.native.js";
 function _assert_this_initialized(self) {
-  if (self === void 0) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
   return self;
 }
 function _call_super(_this, derived, args) {
-  return derived = _get_prototype_of(derived), _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+  derived = _get_prototype_of(derived);
+  return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
 }
 function _class_call_check(instance, Constructor) {
-  if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
 }
 function _construct(Parent, args, Class) {
-  return _is_native_reflect_construct() ? _construct = Reflect.construct : _construct = function (Parent2, args2, Class2) {
-    var a = [null];
-    a.push.apply(a, args2);
-    var Constructor = Function.bind.apply(Parent2, a),
-      instance = new Constructor();
-    return Class2 && _set_prototype_of(instance, Class2.prototype), instance;
-  }, _construct.apply(null, arguments);
+  if (_is_native_reflect_construct()) {
+    _construct = Reflect.construct;
+  } else {
+    _construct = function construct(Parent2, args2, Class2) {
+      var a = [null];
+      a.push.apply(a, args2);
+      var Constructor = Function.bind.apply(Parent2, a);
+      var instance = new Constructor();
+      if (Class2) _set_prototype_of(instance, Class2.prototype);
+      return instance;
+    };
+  }
+  return _construct.apply(null, arguments);
 }
 function _get_prototype_of(o) {
-  return _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function (o2) {
+  _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o2) {
     return o2.__proto__ || Object.getPrototypeOf(o2);
-  }, _get_prototype_of(o);
+  };
+  return _get_prototype_of(o);
 }
 function _inherits(subClass, superClass) {
-  if (typeof superClass != "function" && superClass !== null) throw new TypeError("Super expression must either be null or a function");
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  }
   subClass.prototype = Object.create(superClass && superClass.prototype, {
     constructor: {
       value: subClass,
-      writable: !0,
-      configurable: !0
+      writable: true,
+      configurable: true
     }
-  }), superClass && _set_prototype_of(subClass, superClass);
+  });
+  if (superClass) _set_prototype_of(subClass, superClass);
 }
 function _instanceof(left, right) {
-  return right != null && typeof Symbol < "u" && right[Symbol.hasInstance] ? !!right[Symbol.hasInstance](left) : left instanceof right;
+  if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+    return !!right[Symbol.hasInstance](left);
+  } else {
+    return left instanceof right;
+  }
 }
 function _is_native_function(fn) {
   return Function.toString.call(fn).indexOf("[native code]") !== -1;
 }
 function _possible_constructor_return(self, call) {
-  return call && (_type_of(call) === "object" || typeof call == "function") ? call : _assert_this_initialized(self);
+  if (call && (_type_of(call) === "object" || typeof call === "function")) {
+    return call;
+  }
+  return _assert_this_initialized(self);
 }
 function _set_prototype_of(o, p) {
-  return _set_prototype_of = Object.setPrototypeOf || function (o2, p2) {
-    return o2.__proto__ = p2, o2;
-  }, _set_prototype_of(o, p);
+  _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o2, p2) {
+    o2.__proto__ = p2;
+    return o2;
+  };
+  return _set_prototype_of(o, p);
 }
 function _type_of(obj) {
   "@swc/helpers - typeof";
 
-  return obj && typeof Symbol < "u" && obj.constructor === Symbol ? "symbol" : typeof obj;
+  return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 }
 function _wrap_native_super(Class) {
-  var _cache = typeof Map == "function" ? /* @__PURE__ */new Map() : void 0;
-  return _wrap_native_super = function (Class2) {
+  var _cache = typeof Map === "function" ? /* @__PURE__ */new Map() : void 0;
+  _wrap_native_super = function wrapNativeSuper(Class2) {
     if (Class2 === null || !_is_native_function(Class2)) return Class2;
-    if (typeof Class2 != "function") throw new TypeError("Super expression must either be null or a function");
-    if (typeof _cache < "u") {
+    if (typeof Class2 !== "function") {
+      throw new TypeError("Super expression must either be null or a function");
+    }
+    if (typeof _cache !== "undefined") {
       if (_cache.has(Class2)) return _cache.get(Class2);
       _cache.set(Class2, Wrapper);
     }
     function Wrapper() {
       return _construct(Class2, arguments, _get_prototype_of(this).constructor);
     }
-    return Wrapper.prototype = Object.create(Class2.prototype, {
+    Wrapper.prototype = Object.create(Class2.prototype, {
       constructor: {
         value: Wrapper,
-        enumerable: !1,
-        writable: !0,
-        configurable: !0
+        enumerable: false,
+        writable: true,
+        configurable: true
       }
-    }), _set_prototype_of(Wrapper, Class2);
-  }, _wrap_native_super(Class);
+    });
+    return _set_prototype_of(Wrapper, Class2);
+  };
+  return _wrap_native_super(Class);
 }
 function _is_native_reflect_construct() {
   try {
     var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
-  } catch {}
+  } catch (_) {}
   return (_is_native_reflect_construct = function () {
     return !!result;
   })();
@@ -97,28 +125,42 @@ var Bail = /* @__PURE__ */function (Error1) {
 
   _inherits(Bail2, Error1);
   function Bail2() {
-    return _class_call_check(this, Bail2), _call_super(this, Bail2, arguments);
+    _class_call_check(this, Bail2);
+    return _call_super(this, Bail2, arguments);
   }
   return Bail2;
 }(_wrap_native_super(Error));
 function bailIfUnchanged(obj1, obj2) {
-  if (JSON.stringify(obj1) === JSON.stringify(obj2)) throw new Bail();
+  if (JSON.stringify(obj1) === JSON.stringify(obj2)) {
+    throw new Bail();
+  }
 }
 function bailIfExists(haystack, needle) {
-  if (haystack.includes(needle)) throw new Bail();
+  if (haystack.includes(needle)) {
+    throw new Bail();
+  }
 }
 async function applyBuiltInPatches(options, extraPatches) {
   var all = [...builtInDepPatches];
   if (extraPatches) {
     var _loop = function (key2) {
-      var extraPatchFiles = extraPatches[key2],
-        existing = all.find(function (x) {
-          return x.module === key2;
-        });
-      if (existing) for (var patchKey in extraPatchFiles) existing.patchFiles[patchKey] && console.warn("Warning: Overwriting One built-in patch with user patch", key2, patchKey), existing.patchFiles[patchKey] = extraPatchFiles[patchKey];else all.push({
-        module: key2,
-        patchFiles: extraPatchFiles
+      var extraPatchFiles = extraPatches[key2];
+      var existing = all.find(function (x) {
+        return x.module === key2;
       });
+      if (existing) {
+        for (var patchKey in extraPatchFiles) {
+          if (existing.patchFiles[patchKey]) {
+            console.warn(`Warning: Overwriting One built-in patch with user patch`, key2, patchKey);
+          }
+          existing.patchFiles[patchKey] = extraPatchFiles[patchKey];
+        }
+      } else {
+        all.push({
+          module: key2,
+          patchFiles: extraPatchFiles
+        });
+      }
     };
     for (var key in extraPatches) _loop(key);
   }
@@ -133,7 +175,7 @@ function getOriginalPath(fullPath) {
 async function readPatchStats(nodeModulesDir) {
   try {
     return await FSExtra.readJSON(join(nodeModulesDir, STATS_FILE));
-  } catch {
+  } catch (unused) {
     return {};
   }
 }
@@ -145,66 +187,78 @@ function moduleToPnpmStorePattern(moduleName) {
 }
 async function applyDependencyPatches(patches) {
   var {
-      root = process.cwd()
-    } = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {},
-    patchModuleNames = [...new Set(patches.map(function (p) {
-      return p.module;
-    }))],
-    nodeModulesDirs = findNodeModules({
-      cwd: root
-    }).flatMap(function (relativePath) {
-      var dir = join(root, relativePath),
-        dirs = [dir],
-        pnpmBase = join(dir, ".pnpm");
-      if (!FSExtra.existsSync(pnpmBase)) return dirs;
-      var pnpmHoistedDir = join(pnpmBase, "node_modules");
-      FSExtra.existsSync(pnpmHoistedDir) && dirs.push(pnpmHoistedDir);
-      var _iteratorNormalCompletion2 = !0,
-        _didIteratorError2 = !1,
-        _iteratorError2 = void 0;
-      try {
-        for (var _iterator2 = patchModuleNames[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = !0) {
-          var moduleName = _step2.value,
-            storePattern = moduleToPnpmStorePattern(moduleName),
-            storeMatches = Glob.sync(`${storePattern}@*/node_modules`, {
-              cwd: pnpmBase,
-              onlyDirectories: !0
-            }),
-            _iteratorNormalCompletion1 = !0,
-            _didIteratorError1 = !1,
-            _iteratorError1 = void 0;
+    root = process.cwd()
+  } = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+  var patchModuleNames = [...new Set(patches.map(function (p) {
+    return p.module;
+  }))];
+  var nodeModulesDirs = findNodeModules({
+    cwd: root
+  }).flatMap(function (relativePath) {
+    var dir = join(root, relativePath);
+    var dirs = [dir];
+    var pnpmBase = join(dir, ".pnpm");
+    if (!FSExtra.existsSync(pnpmBase)) return dirs;
+    var pnpmHoistedDir = join(pnpmBase, "node_modules");
+    if (FSExtra.existsSync(pnpmHoistedDir)) {
+      dirs.push(pnpmHoistedDir);
+    }
+    var _iteratorNormalCompletion2 = true,
+      _didIteratorError2 = false,
+      _iteratorError2 = void 0;
+    try {
+      for (var _iterator2 = patchModuleNames[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+        var moduleName = _step2.value;
+        var storePattern = moduleToPnpmStorePattern(moduleName);
+        var storeMatches = Glob.sync(`${storePattern}@*/node_modules`, {
+          cwd: pnpmBase,
+          onlyDirectories: true
+        });
+        var _iteratorNormalCompletion1 = true,
+          _didIteratorError1 = false,
+          _iteratorError1 = void 0;
+        try {
+          for (var _iterator1 = storeMatches[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+            var match = _step1.value;
+            dirs.push(join(pnpmBase, match));
+          }
+        } catch (err) {
+          _didIteratorError1 = true;
+          _iteratorError1 = err;
+        } finally {
           try {
-            for (var _iterator1 = storeMatches[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = !0) {
-              var match = _step1.value;
-              dirs.push(join(pnpmBase, match));
+            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+              _iterator1.return();
             }
-          } catch (err) {
-            _didIteratorError1 = !0, _iteratorError1 = err;
           } finally {
-            try {
-              !_iteratorNormalCompletion1 && _iterator1.return != null && _iterator1.return();
-            } finally {
-              if (_didIteratorError1) throw _iteratorError1;
+            if (_didIteratorError1) {
+              throw _iteratorError1;
             }
           }
         }
-      } catch (err) {
-        _didIteratorError2 = !0, _iteratorError2 = err;
+      }
+    } catch (err) {
+      _didIteratorError2 = true;
+      _iteratorError2 = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+          _iterator2.return();
+        }
       } finally {
-        try {
-          !_iteratorNormalCompletion2 && _iterator2.return != null && _iterator2.return();
-        } finally {
-          if (_didIteratorError2) throw _iteratorError2;
+        if (_didIteratorError2) {
+          throw _iteratorError2;
         }
       }
-      return dirs;
-    }),
-    results = /* @__PURE__ */new Map(),
-    transformWarnedModules = /* @__PURE__ */new Set(),
-    patchedRealPaths = /* @__PURE__ */new Set();
+    }
+    return dirs;
+  });
+  var results = /* @__PURE__ */new Map();
+  var transformWarnedModules = /* @__PURE__ */new Set();
+  var patchedRealPaths = /* @__PURE__ */new Set();
   await Promise.all(nodeModulesDirs.map(async function (nodeModulesDir) {
-    var patchStats = await readPatchStats(nodeModulesDir),
-      statsChanged = !1;
+    var patchStats = await readPatchStats(nodeModulesDir);
+    var statsChanged = false;
     await Promise.all(patches.map(async function (patch) {
       try {
         var nodeModuleDir = join(nodeModulesDir, patch.module);
@@ -212,26 +266,27 @@ async function applyDependencyPatches(patches) {
         var realModuleDir;
         try {
           realModuleDir = realpathSync(nodeModuleDir);
-        } catch {
+        } catch (unused) {
           return;
         }
-        var patchIdx = patches.indexOf(patch),
-          dedupKey = `${patchIdx}\0${realModuleDir}`;
+        var patchIdx = patches.indexOf(patch);
+        var dedupKey = `${patchIdx}\0${realModuleDir}`;
         if (patchedRealPaths.has(dedupKey)) return;
         patchedRealPaths.add(dedupKey);
         var version = patch.patchFiles.version;
-        if (typeof version == "string") {
+        if (typeof version === "string") {
           var pkgJSON = await FSExtra.readJSON(join(nodeModuleDir, "package.json"));
           if (!semver.satisfies(pkgJSON.version, version)) return;
         }
         var filePatches = [];
-        for (var file in patch.patchFiles) if (file !== "version") {
-          var filesToApply = file.includes("*") ? globDir(nodeModuleDir, file) : [file],
-            _iteratorNormalCompletion2 = !0,
-            _didIteratorError2 = !1,
+        for (var file in patch.patchFiles) {
+          if (file === "version") continue;
+          var filesToApply = file.includes("*") ? globDir(nodeModuleDir, file) : [file];
+          var _iteratorNormalCompletion2 = true,
+            _didIteratorError2 = false,
             _iteratorError2 = void 0;
           try {
-            for (var _iterator2 = filesToApply[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = !0) {
+            for (var _iterator2 = filesToApply[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
               var relativePath = _step2.value;
               filePatches.push({
                 relativePath,
@@ -239,53 +294,61 @@ async function applyDependencyPatches(patches) {
               });
             }
           } catch (err) {
-            _didIteratorError2 = !0, _iteratorError2 = err;
+            _didIteratorError2 = true;
+            _iteratorError2 = err;
           } finally {
             try {
-              !_iteratorNormalCompletion2 && _iterator2.return != null && _iterator2.return();
+              if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+                _iterator2.return();
+              }
             } finally {
-              if (_didIteratorError2) throw _iteratorError2;
+              if (_didIteratorError2) {
+                throw _iteratorError2;
+              }
             }
           }
         }
         var fileStatsResults = await Promise.all(filePatches.map(async function (param) {
-            var {
-                relativePath: relativePath2
-              } = param,
-              fullPath = join(nodeModuleDir, relativePath2);
-            try {
-              var stat = await FSExtra.stat(fullPath);
-              return {
-                relativePath: relativePath2,
-                fullPath,
-                stat,
-                exists: !0
-              };
-            } catch {
-              return {
-                relativePath: relativePath2,
-                fullPath,
-                stat: null,
-                exists: !1
-              };
-            }
-          })),
-          filesToProcess = fileStatsResults.filter(function (param) {
-            var {
+          var {
+            relativePath: relativePath2
+          } = param;
+          var fullPath = join(nodeModuleDir, relativePath2);
+          try {
+            var stat = await FSExtra.stat(fullPath);
+            return {
+              relativePath: relativePath2,
               fullPath,
               stat,
-              exists
-            } = param;
-            if (!exists || !stat) return !1;
-            if (process.env.VXRN_FORCE_PATCH) return !0;
-            var cached = patchStats[fullPath];
-            return cached ? stat.size !== cached.size || stat.mtimeMs !== cached.mtimeMs : !0;
-          });
+              exists: true
+            };
+          } catch (unused) {
+            return {
+              relativePath: relativePath2,
+              fullPath,
+              stat: null,
+              exists: false
+            };
+          }
+        }));
+        var filesToProcess = fileStatsResults.filter(function (param) {
+          var {
+            fullPath,
+            stat,
+            exists
+          } = param;
+          if (!exists || !stat) return false;
+          if (process.env.VXRN_FORCE_PATCH) return true;
+          var cached = patchStats[fullPath];
+          if (!cached) return true;
+          return stat.size !== cached.size || stat.mtimeMs !== cached.mtimeMs;
+        });
         if (filesToProcess.length === 0) {
-          results.has(patch.module) || results.set(patch.module, "ok");
+          if (!results.has(patch.module)) {
+            results.set(patch.module, "ok");
+          }
           return;
         }
-        var didApplyPatch = !1;
+        var didApplyPatch = false;
         await Promise.all(filesToProcess.map(async function (param) {
           var {
             relativePath: relativePath2,
@@ -293,49 +356,71 @@ async function applyDependencyPatches(patches) {
           } = param;
           try {
             var patchDef = filePatches.find(function (p) {
-                return p.relativePath === relativePath2;
-              }).patchDefinition,
-              originalPath = getOriginalPath(fullPath),
-              [targetContent, originalContent] = await Promise.all([FSExtra.readFile(fullPath, "utf-8"), FSExtra.readFile(originalPath, "utf-8").catch(function () {
-                return null;
-              })]),
-              sourceContent = originalContent ?? targetContent,
-              patchedContent = null;
-            if (typeof patchDef == "string") patchedContent = patchDef;else if (Array.isArray(patchDef)) try {
-              var contents = sourceContent,
-                _iteratorNormalCompletion3 = !0,
-                _didIteratorError3 = !1,
-                _iteratorError3 = void 0;
+              return p.relativePath === relativePath2;
+            }).patchDefinition;
+            var originalPath = getOriginalPath(fullPath);
+            var [targetContent, originalContent] = await Promise.all([FSExtra.readFile(fullPath, "utf-8"), FSExtra.readFile(originalPath, "utf-8").catch(function () {
+              return null;
+            })]);
+            var sourceContent = originalContent !== null && originalContent !== void 0 ? originalContent : targetContent;
+            var patchedContent = null;
+            if (typeof patchDef === "string") {
+              patchedContent = patchDef;
+            } else if (Array.isArray(patchDef)) {
               try {
-                for (var _iterator3 = patchDef[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = !0) {
-                  var strategy = _step3.value;
-                  if (strategy === "flow" && (contents = await transformFlowBabel(contents)), strategy === "swc" || strategy === "jsx") {
-                    var _this;
-                    contents = ((_this = await transformSWC(fullPath, contents, {
-                      mode: "build",
-                      environment: "ios",
-                      forceJSX: strategy === "jsx",
-                      noHMR: !0,
-                      fixNonTypeSpecificImports: !0
-                    })) === null || _this === void 0 ? void 0 : _this.code) || contents;
-                  }
-                }
-              } catch (err) {
-                _didIteratorError3 = !0, _iteratorError3 = err;
-              } finally {
+                var contents = sourceContent;
+                var _iteratorNormalCompletion3 = true,
+                  _didIteratorError3 = false,
+                  _iteratorError3 = void 0;
                 try {
-                  !_iteratorNormalCompletion3 && _iterator3.return != null && _iterator3.return();
+                  for (var _iterator3 = patchDef[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+                    var strategy = _step3.value;
+                    if (strategy === "flow") {
+                      contents = await transformFlowBabel(contents);
+                    }
+                    if (strategy === "swc" || strategy === "jsx") {
+                      var _this;
+                      contents = ((_this = await transformSWC(fullPath, contents, {
+                        mode: "build",
+                        environment: "ios",
+                        forceJSX: strategy === "jsx",
+                        noHMR: true,
+                        fixNonTypeSpecificImports: true
+                      })) === null || _this === void 0 ? void 0 : _this.code) || contents;
+                    }
+                  }
+                } catch (err) {
+                  _didIteratorError3 = true;
+                  _iteratorError3 = err;
                 } finally {
-                  if (_didIteratorError3) throw _iteratorError3;
+                  try {
+                    if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
+                      _iterator3.return();
+                    }
+                  } finally {
+                    if (_didIteratorError3) {
+                      throw _iteratorError3;
+                    }
+                  }
+                }
+                if (contents !== sourceContent) {
+                  patchedContent = contents;
                 }
+              } catch (transformErr) {
+                if (!transformWarnedModules.has(patch.module)) {
+                  transformWarnedModules.add(patch.module);
+                  console.warn(`  \u26A0 Patch transform failed for ${patch.module} (likely Node version compat), skipping non-critical patch`);
+                  if (process.env.DEBUG) {
+                    console.warn(transformErr);
+                  }
+                }
+                return;
               }
-              contents !== sourceContent && (patchedContent = contents);
-            } catch (transformErr) {
-              transformWarnedModules.has(patch.module) || (transformWarnedModules.add(patch.module), console.warn(`  \u26A0 Patch transform failed for ${patch.module} (likely Node version compat), skipping non-critical patch`), process.env.DEBUG && console.warn(transformErr));
-              return;
             } else {
               var out = await patchDef(sourceContent);
-              typeof out == "string" && out !== sourceContent && (patchedContent = out);
+              if (typeof out === "string" && out !== sourceContent) {
+                patchedContent = out;
+              }
             }
             if (patchedContent !== null) {
               if (targetContent === patchedContent) {
@@ -343,7 +428,8 @@ async function applyDependencyPatches(patches) {
                 patchStats[fullPath] = {
                   size: stat.size,
                   mtimeMs: stat.mtimeMs
-                }, statsChanged = !0;
+                };
+                statsChanged = true;
                 return;
               }
               await Promise.all([originalContent === null && atomicWriteFile(originalPath, sourceContent), atomicWriteFile(fullPath, patchedContent)]);
@@ -351,45 +437,70 @@ async function applyDependencyPatches(patches) {
               patchStats[fullPath] = {
                 size: stat1.size,
                 mtimeMs: stat1.mtimeMs
-              }, statsChanged = !0, didApplyPatch = !0, process.env.DEBUG && console.info(`  - Applied patch to ${patch.module}: ${relativePath2}`);
+              };
+              statsChanged = true;
+              didApplyPatch = true;
+              if (process.env.DEBUG) {
+                console.info(`  - Applied patch to ${patch.module}: ${relativePath2}`);
+              }
             } else {
               var stat2 = await FSExtra.stat(fullPath);
               patchStats[fullPath] = {
                 size: stat2.size,
                 mtimeMs: stat2.mtimeMs
-              }, statsChanged = !0;
+              };
+              statsChanged = true;
             }
           } catch (err) {
             if (_instanceof(err, Bail)) return;
             throw err;
           }
-        })), didApplyPatch ? results.set(patch.module, "applied") : results.has(patch.module) || results.set(patch.module, "ok");
+        }));
+        if (didApplyPatch) {
+          results.set(patch.module, "applied");
+        } else if (!results.has(patch.module)) {
+          results.set(patch.module, "ok");
+        }
       } catch (err) {
-        console.error("\u{1F6A8} Error applying patch to", patch.module), console.error(err);
+        console.error(`\u{1F6A8} Error applying patch to`, patch.module);
+        console.error(err);
       }
-    })), statsChanged && (await writePatchStats(nodeModulesDir, patchStats));
+    }));
+    if (statsChanged) {
+      await writePatchStats(nodeModulesDir, patchStats);
+    }
   }));
-  var _iteratorNormalCompletion = !0,
-    _didIteratorError = !1,
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
     _iteratorError = void 0;
   try {
-    for (var _iterator = results[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) {
+    for (var _iterator = results[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
       var [module, result] = _step.value;
-      result === "applied" ? console.info(` \u{1FA79} ${module}`) : result === "ok" && process.env.VXRN_FORCE_PATCH && console.info(` \u2713 ${module}`);
+      if (result === "applied") {
+        console.info(` \u{1FA79} ${module}`);
+      } else if (result === "ok" && process.env.VXRN_FORCE_PATCH) {
+        console.info(` \u2713 ${module}`);
+      }
     }
   } catch (err) {
-    _didIteratorError = !0, _iteratorError = err;
+    _didIteratorError = true;
+    _iteratorError = err;
   } finally {
     try {
-      !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
     } finally {
-      if (_didIteratorError) throw _iteratorError;
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
     }
   }
 }
 async function atomicWriteFile(filePath, contents) {
   var tempPath = filePath + ".vxrn.tmp." + process.pid + "." + Date.now();
-  await FSExtra.writeFile(tempPath, contents), await rename(tempPath, filePath);
+  await FSExtra.writeFile(tempPath, contents);
+  await rename(tempPath, filePath);
 }
 export { applyBuiltInPatches, applyDependencyPatches, bailIfExists, bailIfUnchanged, moduleToPnpmStorePattern };
 //# sourceMappingURL=patches.native.js.map