@hanzlaa/rcode 3.4.5 → 3.4.6

package/dist/rcode.js

@@ -12093,302 +12093,289 @@ var require_semver2 = __commonJS({
   }
 });
 
-// node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/diff/base.js
+// node_modules/.pnpm/diff@8.0.4/node_modules/diff/libcjs/diff/base.js
 var require_base = __commonJS({
-  "node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/diff/base.js"(exports2) {
+  "node_modules/.pnpm/diff@8.0.4/node_modules/diff/libcjs/diff/base.js"(exports2) {
     "use strict";
-    Object.defineProperty(exports2, "__esModule", {
-      value: true
-    });
-    exports2["default"] = Diff;
-    function Diff() {
-    }
-    Diff.prototype = {
-      /*istanbul ignore start*/
-      /*istanbul ignore end*/
-      diff: function diff(oldString, newString) {
-        var _options$timeout;
-        var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
-        var callback = options.callback;
-        if (typeof options === "function") {
-          callback = options;
-          options = {};
-        }
-        var self = this;
-        function done(value) {
-          value = self.postProcess(value, options);
-          if (callback) {
-            setTimeout(function() {
-              callback(value);
-            }, 0);
-            return true;
-          } else {
-            return value;
-          }
-        }
-        oldString = this.castInput(oldString, options);
-        newString = this.castInput(newString, options);
-        oldString = this.removeEmpty(this.tokenize(oldString, options));
-        newString = this.removeEmpty(this.tokenize(newString, options));
-        var newLen = newString.length, oldLen = oldString.length;
-        var editLength = 1;
-        var maxEditLength = newLen + oldLen;
-        if (options.maxEditLength != null) {
-          maxEditLength = Math.min(maxEditLength, options.maxEditLength);
-        }
-        var maxExecutionTime = (
-          /*istanbul ignore start*/
-          (_options$timeout = /*istanbul ignore end*/
-          options.timeout) !== null && _options$timeout !== void 0 ? _options$timeout : Infinity
-        );
-        var abortAfterTimestamp = Date.now() + maxExecutionTime;
-        var bestPath = [{
-          oldPos: -1,
-          lastComponent: void 0
-        }];
-        var newPos = this.extractCommon(bestPath[0], newString, oldString, 0, options);
-        if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
-          return done(buildValues(self, bestPath[0].lastComponent, newString, oldString, self.useLongestToken));
-        }
-        var minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
-        function execEditLength() {
-          for (var diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
-            var basePath = (
-              /*istanbul ignore start*/
-              void 0
-            );
-            var removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
-            if (removePath) {
-              bestPath[diagonalPath - 1] = void 0;
-            }
-            var canAdd = false;
-            if (addPath) {
-              var addPathNewPos = addPath.oldPos - diagonalPath;
-              canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
-            }
-            var canRemove = removePath && removePath.oldPos + 1 < oldLen;
-            if (!canAdd && !canRemove) {
-              bestPath[diagonalPath] = void 0;
-              continue;
-            }
-            if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) {
-              basePath = self.addToPath(addPath, true, false, 0, options);
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var Diff = (
+      /** @class */
+      (function() {
+        function Diff2() {
+        }
+        Diff2.prototype.diff = function(oldStr, newStr, options) {
+          if (options === void 0) {
+            options = {};
+          }
+          var callback;
+          if (typeof options === "function") {
+            callback = options;
+            options = {};
+          } else if ("callback" in options) {
+            callback = options.callback;
+          }
+          var oldString = this.castInput(oldStr, options);
+          var newString = this.castInput(newStr, options);
+          var oldTokens = this.removeEmpty(this.tokenize(oldString, options));
+          var newTokens = this.removeEmpty(this.tokenize(newString, options));
+          return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);
+        };
+        Diff2.prototype.diffWithOptionsObj = function(oldTokens, newTokens, options, callback) {
+          var _this = this;
+          var _a;
+          var done = function(value) {
+            value = _this.postProcess(value, options);
+            if (callback) {
+              setTimeout(function() {
+                callback(value);
+              }, 0);
+              return void 0;
             } else {
-              basePath = self.addToPath(removePath, false, true, 1, options);
+              return value;
             }
-            newPos = self.extractCommon(basePath, newString, oldString, diagonalPath, options);
-            if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
-              return done(buildValues(self, basePath.lastComponent, newString, oldString, self.useLongestToken));
-            } else {
-              bestPath[diagonalPath] = basePath;
-              if (basePath.oldPos + 1 >= oldLen) {
-                maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
+          };
+          var newLen = newTokens.length, oldLen = oldTokens.length;
+          var editLength = 1;
+          var maxEditLength = newLen + oldLen;
+          if (options.maxEditLength != null) {
+            maxEditLength = Math.min(maxEditLength, options.maxEditLength);
+          }
+          var maxExecutionTime = (_a = options.timeout) !== null && _a !== void 0 ? _a : Infinity;
+          var abortAfterTimestamp = Date.now() + maxExecutionTime;
+          var bestPath = [{ oldPos: -1, lastComponent: void 0 }];
+          var newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);
+          if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+            return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
+          }
+          var minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
+          var execEditLength = function() {
+            for (var diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
+              var basePath = void 0;
+              var removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
+              if (removePath) {
+                bestPath[diagonalPath - 1] = void 0;
               }
-              if (newPos + 1 >= newLen) {
-                minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
+              var canAdd = false;
+              if (addPath) {
+                var addPathNewPos = addPath.oldPos - diagonalPath;
+                canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
               }
-            }
-          }
-          editLength++;
-        }
-        if (callback) {
-          (function exec() {
-            setTimeout(function() {
-              if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
-                return callback();
+              var canRemove = removePath && removePath.oldPos + 1 < oldLen;
+              if (!canAdd && !canRemove) {
+                bestPath[diagonalPath] = void 0;
+                continue;
               }
-              if (!execEditLength()) {
-                exec();
+              if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) {
+                basePath = _this.addToPath(addPath, true, false, 0, options);
+              } else {
+                basePath = _this.addToPath(removePath, false, true, 1, options);
+              }
+              newPos = _this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options);
+              if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+                return done(_this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;
+              } else {
+                bestPath[diagonalPath] = basePath;
+                if (basePath.oldPos + 1 >= oldLen) {
+                  maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
+                }
+                if (newPos + 1 >= newLen) {
+                  minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
+                }
               }
-            }, 0);
-          })();
-        } else {
-          while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
-            var ret = execEditLength();
-            if (ret) {
-              return ret;
-            }
-          }
-        }
-      },
-      /*istanbul ignore start*/
-      /*istanbul ignore end*/
-      addToPath: function addToPath(path2, added, removed, oldPosInc, options) {
-        var last = path2.lastComponent;
-        if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
-          return {
-            oldPos: path2.oldPos + oldPosInc,
-            lastComponent: {
-              count: last.count + 1,
-              added,
-              removed,
-              previousComponent: last.previousComponent
             }
+            editLength++;
           };
-        } else {
-          return {
-            oldPos: path2.oldPos + oldPosInc,
-            lastComponent: {
-              count: 1,
-              added,
-              removed,
-              previousComponent: last
+          if (callback) {
+            (function exec() {
+              setTimeout(function() {
+                if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
+                  return callback(void 0);
+                }
+                if (!execEditLength()) {
+                  exec();
+                }
+              }, 0);
+            })();
+          } else {
+            while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
+              var ret = execEditLength();
+              if (ret) {
+                return ret;
+              }
             }
-          };
-        }
-      },
-      /*istanbul ignore start*/
-      /*istanbul ignore end*/
-      extractCommon: function extractCommon(basePath, newString, oldString, diagonalPath, options) {
-        var newLen = newString.length, oldLen = oldString.length, oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
-        while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldString[oldPos + 1], newString[newPos + 1], options)) {
-          newPos++;
-          oldPos++;
-          commonCount++;
-          if (options.oneChangePerToken) {
-            basePath.lastComponent = {
-              count: 1,
-              previousComponent: basePath.lastComponent,
-              added: false,
-              removed: false
+          }
+        };
+        Diff2.prototype.addToPath = function(path2, added, removed, oldPosInc, options) {
+          var last = path2.lastComponent;
+          if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
+            return {
+              oldPos: path2.oldPos + oldPosInc,
+              lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
+            };
+          } else {
+            return {
+              oldPos: path2.oldPos + oldPosInc,
+              lastComponent: { count: 1, added, removed, previousComponent: last }
             };
           }
-        }
-        if (commonCount && !options.oneChangePerToken) {
-          basePath.lastComponent = {
-            count: commonCount,
-            previousComponent: basePath.lastComponent,
-            added: false,
-            removed: false
-          };
-        }
-        basePath.oldPos = oldPos;
-        return newPos;
-      },
-      /*istanbul ignore start*/
-      /*istanbul ignore end*/
-      equals: function equals(left, right, options) {
-        if (options.comparator) {
-          return options.comparator(left, right);
-        } else {
-          return left === right || options.ignoreCase && left.toLowerCase() === right.toLowerCase();
-        }
-      },
-      /*istanbul ignore start*/
-      /*istanbul ignore end*/
-      removeEmpty: function removeEmpty(array) {
-        var ret = [];
-        for (var i = 0; i < array.length; i++) {
-          if (array[i]) {
-            ret.push(array[i]);
+        };
+        Diff2.prototype.extractCommon = function(basePath, newTokens, oldTokens, diagonalPath, options) {
+          var newLen = newTokens.length, oldLen = oldTokens.length;
+          var oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
+          while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options)) {
+            newPos++;
+            oldPos++;
+            commonCount++;
+            if (options.oneChangePerToken) {
+              basePath.lastComponent = { count: 1, previousComponent: basePath.lastComponent, added: false, removed: false };
+            }
           }
-        }
-        return ret;
-      },
-      /*istanbul ignore start*/
-      /*istanbul ignore end*/
-      castInput: function castInput(value) {
-        return value;
-      },
-      /*istanbul ignore start*/
-      /*istanbul ignore end*/
-      tokenize: function tokenize(value) {
-        return Array.from(value);
-      },
-      /*istanbul ignore start*/
-      /*istanbul ignore end*/
-      join: function join(chars) {
-        return chars.join("");
-      },
-      /*istanbul ignore start*/
-      /*istanbul ignore end*/
-      postProcess: function postProcess(changeObjects) {
-        return changeObjects;
-      }
-    };
-    function buildValues(diff, lastComponent, newString, oldString, useLongestToken) {
-      var components = [];
-      var nextComponent;
-      while (lastComponent) {
-        components.push(lastComponent);
-        nextComponent = lastComponent.previousComponent;
-        delete lastComponent.previousComponent;
-        lastComponent = nextComponent;
-      }
-      components.reverse();
-      var componentPos = 0, componentLen = components.length, newPos = 0, oldPos = 0;
-      for (; componentPos < componentLen; componentPos++) {
-        var component = components[componentPos];
-        if (!component.removed) {
-          if (!component.added && useLongestToken) {
-            var value = newString.slice(newPos, newPos + component.count);
-            value = value.map(function(value2, i) {
-              var oldValue = oldString[oldPos + i];
-              return oldValue.length > value2.length ? oldValue : value2;
-            });
-            component.value = diff.join(value);
+          if (commonCount && !options.oneChangePerToken) {
+            basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: false, removed: false };
+          }
+          basePath.oldPos = oldPos;
+          return newPos;
+        };
+        Diff2.prototype.equals = function(left, right, options) {
+          if (options.comparator) {
+            return options.comparator(left, right);
           } else {
-            component.value = diff.join(newString.slice(newPos, newPos + component.count));
+            return left === right || !!options.ignoreCase && left.toLowerCase() === right.toLowerCase();
           }
-          newPos += component.count;
-          if (!component.added) {
-            oldPos += component.count;
+        };
+        Diff2.prototype.removeEmpty = function(array) {
+          var ret = [];
+          for (var i = 0; i < array.length; i++) {
+            if (array[i]) {
+              ret.push(array[i]);
+            }
           }
-        } else {
-          component.value = diff.join(oldString.slice(oldPos, oldPos + component.count));
-          oldPos += component.count;
-        }
-      }
-      return components;
-    }
+          return ret;
+        };
+        Diff2.prototype.castInput = function(value, options) {
+          return value;
+        };
+        Diff2.prototype.tokenize = function(value, options) {
+          return Array.from(value);
+        };
+        Diff2.prototype.join = function(chars) {
+          return chars.join("");
+        };
+        Diff2.prototype.postProcess = function(changeObjects, options) {
+          return changeObjects;
+        };
+        Object.defineProperty(Diff2.prototype, "useLongestToken", {
+          get: function() {
+            return false;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        Diff2.prototype.buildValues = function(lastComponent, newTokens, oldTokens) {
+          var components = [];
+          var nextComponent;
+          while (lastComponent) {
+            components.push(lastComponent);
+            nextComponent = lastComponent.previousComponent;
+            delete lastComponent.previousComponent;
+            lastComponent = nextComponent;
+          }
+          components.reverse();
+          var componentLen = components.length;
+          var componentPos = 0, newPos = 0, oldPos = 0;
+          for (; componentPos < componentLen; componentPos++) {
+            var component = components[componentPos];
+            if (!component.removed) {
+              if (!component.added && this.useLongestToken) {
+                var value = newTokens.slice(newPos, newPos + component.count);
+                value = value.map(function(value2, i) {
+                  var oldValue = oldTokens[oldPos + i];
+                  return oldValue.length > value2.length ? oldValue : value2;
+                });
+                component.value = this.join(value);
+              } else {
+                component.value = this.join(newTokens.slice(newPos, newPos + component.count));
+              }
+              newPos += component.count;
+              if (!component.added) {
+                oldPos += component.count;
+              }
+            } else {
+              component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
+              oldPos += component.count;
+            }
+          }
+          return components;
+        };
+        return Diff2;
+      })()
+    );
+    exports2.default = Diff;
   }
 });
 
-// node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/diff/character.js
+// node_modules/.pnpm/diff@8.0.4/node_modules/diff/libcjs/diff/character.js
 var require_character = __commonJS({
-  "node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/diff/character.js"(exports2) {
+  "node_modules/.pnpm/diff@8.0.4/node_modules/diff/libcjs/diff/character.js"(exports2) {
     "use strict";
-    Object.defineProperty(exports2, "__esModule", {
-      value: true
-    });
+    var __extends = exports2 && exports2.__extends || /* @__PURE__ */ (function() {
+      var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+          d2.__proto__ = b2;
+        } || function(d2, b2) {
+          for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
+        };
+        return extendStatics(d, b);
+      };
+      return function(d, b) {
+        if (typeof b !== "function" && b !== null)
+          throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() {
+          this.constructor = d;
+        }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+      };
+    })();
+    Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.characterDiff = void 0;
     exports2.diffChars = diffChars;
-    var _base = _interopRequireDefault(require_base());
-    function _interopRequireDefault(obj) {
-      return obj && obj.__esModule ? obj : { "default": obj };
-    }
-    var characterDiff = (
-      /*istanbul ignore start*/
-      exports2.characterDiff = /*istanbul ignore end*/
-      new /*istanbul ignore start*/
-      _base[
-        /*istanbul ignore start*/
-        "default"
-        /*istanbul ignore end*/
-      ]()
+    var base_js_1 = require_base();
+    var CharacterDiff = (
+      /** @class */
+      (function(_super) {
+        __extends(CharacterDiff2, _super);
+        function CharacterDiff2() {
+          return _super !== null && _super.apply(this, arguments) || this;
+        }
+        return CharacterDiff2;
+      })(base_js_1.default)
     );
+    exports2.characterDiff = new CharacterDiff();
     function diffChars(oldStr, newStr, options) {
-      return characterDiff.diff(oldStr, newStr, options);
+      return exports2.characterDiff.diff(oldStr, newStr, options);
     }
   }
 });
 
-// node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/util/string.js
+// node_modules/.pnpm/diff@8.0.4/node_modules/diff/libcjs/util/string.js
 var require_string2 = __commonJS({
-  "node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/util/string.js"(exports2) {
+  "node_modules/.pnpm/diff@8.0.4/node_modules/diff/libcjs/util/string.js"(exports2) {
     "use strict";
-    Object.defineProperty(exports2, "__esModule", {
-      value: true
-    });
-    exports2.hasOnlyUnixLineEndings = hasOnlyUnixLineEndings;
-    exports2.hasOnlyWinLineEndings = hasOnlyWinLineEndings;
+    Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.longestCommonPrefix = longestCommonPrefix;
     exports2.longestCommonSuffix = longestCommonSuffix;
-    exports2.maximumOverlap = maximumOverlap;
-    exports2.removePrefix = removePrefix;
-    exports2.removeSuffix = removeSuffix;
     exports2.replacePrefix = replacePrefix;
     exports2.replaceSuffix = replaceSuffix;
+    exports2.removePrefix = removePrefix;
+    exports2.removeSuffix = removeSuffix;
+    exports2.maximumOverlap = maximumOverlap;
+    exports2.hasOnlyWinLineEndings = hasOnlyWinLineEndings;
+    exports2.hasOnlyUnixLineEndings = hasOnlyUnixLineEndings;
+    exports2.segment = segment;
+    exports2.trailingWs = trailingWs;
+    exports2.leadingWs = leadingWs;
+    exports2.leadingAndTrailingWs = leadingAndTrailingWs;
     function longestCommonPrefix(str1, str2) {
       var i;
       for (i = 0; i < str1.length && i < str2.length; i++) {
@@ -12412,14 +12399,7 @@ var require_string2 = __commonJS({
     }
     function replacePrefix(string, oldPrefix, newPrefix) {
       if (string.slice(0, oldPrefix.length) != oldPrefix) {
-        throw Error(
-          /*istanbul ignore start*/
-          "string ".concat(
-            /*istanbul ignore end*/
-            JSON.stringify(string),
-            " doesn't start with prefix "
-          ).concat(JSON.stringify(oldPrefix), "; this is a bug")
-        );
+        throw Error("string ".concat(JSON.stringify(string), " doesn't start with prefix ").concat(JSON.stringify(oldPrefix), "; this is a bug"));
       }
       return newPrefix + string.slice(oldPrefix.length);
     }
@@ -12428,14 +12408,7 @@ var require_string2 = __commonJS({
         return string + newSuffix;
       }
       if (string.slice(-oldSuffix.length) != oldSuffix) {
-        throw Error(
-          /*istanbul ignore start*/
-          "string ".concat(
-            /*istanbul ignore end*/
-            JSON.stringify(string),
-            " doesn't end with suffix "
-          ).concat(JSON.stringify(oldSuffix), "; this is a bug")
-        );
+        throw Error("string ".concat(JSON.stringify(string), " doesn't end with suffix ").concat(JSON.stringify(oldSuffix), "; this is a bug"));
       }
       return string.slice(0, -oldSuffix.length) + newSuffix;
     }
@@ -12490,293 +12463,259 @@ var require_string2 = __commonJS({
     function hasOnlyUnixLineEndings(string) {
       return !string.includes("\r\n") && string.includes("\n");
     }
+    function segment(string, segmenter) {
+      var parts = [];
+      for (var _i = 0, _a = Array.from(segmenter.segment(string)); _i < _a.length; _i++) {
+        var segmentObj = _a[_i];
+        var segment_1 = segmentObj.segment;
+        if (parts.length && /\s/.test(parts[parts.length - 1]) && /\s/.test(segment_1)) {
+          parts[parts.length - 1] += segment_1;
+        } else {
+          parts.push(segment_1);
+        }
+      }
+      return parts;
+    }
+    function trailingWs(string, segmenter) {
+      if (segmenter) {
+        return leadingAndTrailingWs(string, segmenter)[1];
+      }
+      var i;
+      for (i = string.length - 1; i >= 0; i--) {
+        if (!string[i].match(/\s/)) {
+          break;
+        }
+      }
+      return string.substring(i + 1);
+    }
+    function leadingWs(string, segmenter) {
+      if (segmenter) {
+        return leadingAndTrailingWs(string, segmenter)[0];
+      }
+      var match = string.match(/^\s*/);
+      return match ? match[0] : "";
+    }
+    function leadingAndTrailingWs(string, segmenter) {
+      if (!segmenter) {
+        return [leadingWs(string), trailingWs(string)];
+      }
+      if (segmenter.resolvedOptions().granularity != "word") {
+        throw new Error('The segmenter passed must have a granularity of "word"');
+      }
+      var segments = segment(string, segmenter);
+      var firstSeg = segments[0];
+      var lastSeg = segments[segments.length - 1];
+      var head = /\s/.test(firstSeg) ? firstSeg : "";
+      var tail = /\s/.test(lastSeg) ? lastSeg : "";
+      return [head, tail];
+    }
   }
 });
 
-// node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/diff/word.js
+// node_modules/.pnpm/diff@8.0.4/node_modules/diff/libcjs/diff/word.js
 var require_word = __commonJS({
-  "node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/diff/word.js"(exports2) {
+  "node_modules/.pnpm/diff@8.0.4/node_modules/diff/libcjs/diff/word.js"(exports2) {
     "use strict";
-    Object.defineProperty(exports2, "__esModule", {
-      value: true
-    });
+    var __extends = exports2 && exports2.__extends || /* @__PURE__ */ (function() {
+      var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+          d2.__proto__ = b2;
+        } || function(d2, b2) {
+          for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
+        };
+        return extendStatics(d, b);
+      };
+      return function(d, b) {
+        if (typeof b !== "function" && b !== null)
+          throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() {
+          this.constructor = d;
+        }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+      };
+    })();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.wordsWithSpaceDiff = exports2.wordDiff = void 0;
     exports2.diffWords = diffWords;
     exports2.diffWordsWithSpace = diffWordsWithSpace;
-    exports2.wordWithSpaceDiff = exports2.wordDiff = void 0;
-    var _base = _interopRequireDefault(require_base());
-    var _string = require_string2();
-    function _interopRequireDefault(obj) {
-      return obj && obj.__esModule ? obj : { "default": obj };
-    }
-    var extendedWordChars = "a-zA-Z0-9_\\u{C0}-\\u{FF}\\u{D8}-\\u{F6}\\u{F8}-\\u{2C6}\\u{2C8}-\\u{2D7}\\u{2DE}-\\u{2FF}\\u{1E00}-\\u{1EFF}";
-    var tokenizeIncludingWhitespace = new RegExp(
-      /*istanbul ignore start*/
-      "[".concat(
-        /*istanbul ignore end*/
-        extendedWordChars,
-        "]+|\\s+|[^"
-      ).concat(extendedWordChars, "]"),
-      "ug"
-    );
-    var wordDiff = (
-      /*istanbul ignore start*/
-      exports2.wordDiff = /*istanbul ignore end*/
-      new /*istanbul ignore start*/
-      _base[
-        /*istanbul ignore start*/
-        "default"
-        /*istanbul ignore end*/
-      ]()
-    );
-    wordDiff.equals = function(left, right, options) {
-      if (options.ignoreCase) {
-        left = left.toLowerCase();
-        right = right.toLowerCase();
-      }
-      return left.trim() === right.trim();
-    };
-    wordDiff.tokenize = function(value) {
-      var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
-      var parts;
-      if (options.intlSegmenter) {
-        if (options.intlSegmenter.resolvedOptions().granularity != "word") {
-          throw new Error('The segmenter passed must have a granularity of "word"');
-        }
-        parts = Array.from(options.intlSegmenter.segment(value), function(segment) {
-          return (
-            /*istanbul ignore end*/
-            segment.segment
-          );
-        });
-      } else {
-        parts = value.match(tokenizeIncludingWhitespace) || [];
-      }
-      var tokens = [];
-      var prevPart = null;
-      parts.forEach(function(part) {
-        if (/\s/.test(part)) {
-          if (prevPart == null) {
-            tokens.push(part);
-          } else {
-            tokens.push(tokens.pop() + part);
-          }
-        } else if (/\s/.test(prevPart)) {
-          if (tokens[tokens.length - 1] == prevPart) {
-            tokens.push(tokens.pop() + part);
+    var base_js_1 = require_base();
+    var string_js_1 = require_string2();
+    var extendedWordChars = "a-zA-Z0-9_\\u{AD}\\u{C0}-\\u{D6}\\u{D8}-\\u{F6}\\u{F8}-\\u{2C6}\\u{2C8}-\\u{2D7}\\u{2DE}-\\u{2FF}\\u{1E00}-\\u{1EFF}";
+    var tokenizeIncludingWhitespace = new RegExp("[".concat(extendedWordChars, "]+|\\s+|[^").concat(extendedWordChars, "]"), "ug");
+    var WordDiff = (
+      /** @class */
+      (function(_super) {
+        __extends(WordDiff2, _super);
+        function WordDiff2() {
+          return _super !== null && _super.apply(this, arguments) || this;
+        }
+        WordDiff2.prototype.equals = function(left, right, options) {
+          if (options.ignoreCase) {
+            left = left.toLowerCase();
+            right = right.toLowerCase();
+          }
+          return left.trim() === right.trim();
+        };
+        WordDiff2.prototype.tokenize = function(value, options) {
+          if (options === void 0) {
+            options = {};
+          }
+          var parts;
+          if (options.intlSegmenter) {
+            var segmenter = options.intlSegmenter;
+            if (segmenter.resolvedOptions().granularity != "word") {
+              throw new Error('The segmenter passed must have a granularity of "word"');
+            }
+            parts = (0, string_js_1.segment)(value, segmenter);
           } else {
-            tokens.push(prevPart + part);
-          }
-        } else {
-          tokens.push(part);
-        }
-        prevPart = part;
-      });
-      return tokens;
-    };
-    wordDiff.join = function(tokens) {
-      return tokens.map(function(token, i) {
-        if (i == 0) {
-          return token;
-        } else {
-          return token.replace(/^\s+/, "");
-        }
-      }).join("");
-    };
-    wordDiff.postProcess = function(changes, options) {
-      if (!changes || options.oneChangePerToken) {
-        return changes;
-      }
-      var lastKeep = null;
-      var insertion = null;
-      var deletion = null;
-      changes.forEach(function(change) {
-        if (change.added) {
-          insertion = change;
-        } else if (change.removed) {
-          deletion = change;
-        } else {
+            parts = value.match(tokenizeIncludingWhitespace) || [];
+          }
+          var tokens = [];
+          var prevPart = null;
+          parts.forEach(function(part) {
+            if (/\s/.test(part)) {
+              if (prevPart == null) {
+                tokens.push(part);
+              } else {
+                tokens.push(tokens.pop() + part);
+              }
+            } else if (prevPart != null && /\s/.test(prevPart)) {
+              if (tokens[tokens.length - 1] == prevPart) {
+                tokens.push(tokens.pop() + part);
+              } else {
+                tokens.push(prevPart + part);
+              }
+            } else {
+              tokens.push(part);
+            }
+            prevPart = part;
+          });
+          return tokens;
+        };
+        WordDiff2.prototype.join = function(tokens) {
+          return tokens.map(function(token, i) {
+            if (i == 0) {
+              return token;
+            } else {
+              return token.replace(/^\s+/, "");
+            }
+          }).join("");
+        };
+        WordDiff2.prototype.postProcess = function(changes, options) {
+          if (!changes || options.oneChangePerToken) {
+            return changes;
+          }
+          var lastKeep = null;
+          var insertion = null;
+          var deletion = null;
+          changes.forEach(function(change) {
+            if (change.added) {
+              insertion = change;
+            } else if (change.removed) {
+              deletion = change;
+            } else {
+              if (insertion || deletion) {
+                dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, change, options.intlSegmenter);
+              }
+              lastKeep = change;
+              insertion = null;
+              deletion = null;
+            }
+          });
           if (insertion || deletion) {
-            dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, change);
+            dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, null, options.intlSegmenter);
           }
-          lastKeep = change;
-          insertion = null;
-          deletion = null;
-        }
-      });
-      if (insertion || deletion) {
-        dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, null);
-      }
-      return changes;
-    };
+          return changes;
+        };
+        return WordDiff2;
+      })(base_js_1.default)
+    );
+    exports2.wordDiff = new WordDiff();
     function diffWords(oldStr, newStr, options) {
-      if (
-        /*istanbul ignore start*/
-        /*istanbul ignore end*/
-        (options === null || options === void 0 ? void 0 : options.ignoreWhitespace) != null && !options.ignoreWhitespace
-      ) {
+      if ((options === null || options === void 0 ? void 0 : options.ignoreWhitespace) != null && !options.ignoreWhitespace) {
         return diffWordsWithSpace(oldStr, newStr, options);
       }
-      return wordDiff.diff(oldStr, newStr, options);
+      return exports2.wordDiff.diff(oldStr, newStr, options);
     }
-    function dedupeWhitespaceInChangeObjects(startKeep, deletion, insertion, endKeep) {
+    function dedupeWhitespaceInChangeObjects(startKeep, deletion, insertion, endKeep, segmenter) {
       if (deletion && insertion) {
-        var oldWsPrefix = deletion.value.match(/^\s*/)[0];
-        var oldWsSuffix = deletion.value.match(/\s*$/)[0];
-        var newWsPrefix = insertion.value.match(/^\s*/)[0];
-        var newWsSuffix = insertion.value.match(/\s*$/)[0];
+        var _a = (0, string_js_1.leadingAndTrailingWs)(deletion.value, segmenter), oldWsPrefix = _a[0], oldWsSuffix = _a[1];
+        var _b = (0, string_js_1.leadingAndTrailingWs)(insertion.value, segmenter), newWsPrefix = _b[0], newWsSuffix = _b[1];
         if (startKeep) {
-          var commonWsPrefix = (
-            /*istanbul ignore start*/
-            (0, /*istanbul ignore end*/
-            /*istanbul ignore start*/
-            _string.longestCommonPrefix)(oldWsPrefix, newWsPrefix)
-          );
-          startKeep.value = /*istanbul ignore start*/
-          (0, /*istanbul ignore end*/
-          /*istanbul ignore start*/
-          _string.replaceSuffix)(startKeep.value, newWsPrefix, commonWsPrefix);
-          deletion.value = /*istanbul ignore start*/
-          (0, /*istanbul ignore end*/
-          /*istanbul ignore start*/
-          _string.removePrefix)(deletion.value, commonWsPrefix);
-          insertion.value = /*istanbul ignore start*/
-          (0, /*istanbul ignore end*/
-          /*istanbul ignore start*/
-          _string.removePrefix)(insertion.value, commonWsPrefix);
+          var commonWsPrefix = (0, string_js_1.longestCommonPrefix)(oldWsPrefix, newWsPrefix);
+          startKeep.value = (0, string_js_1.replaceSuffix)(startKeep.value, newWsPrefix, commonWsPrefix);
+          deletion.value = (0, string_js_1.removePrefix)(deletion.value, commonWsPrefix);
+          insertion.value = (0, string_js_1.removePrefix)(insertion.value, commonWsPrefix);
         }
         if (endKeep) {
-          var commonWsSuffix = (
-            /*istanbul ignore start*/
-            (0, /*istanbul ignore end*/
-            /*istanbul ignore start*/
-            _string.longestCommonSuffix)(oldWsSuffix, newWsSuffix)
-          );
-          endKeep.value = /*istanbul ignore start*/
-          (0, /*istanbul ignore end*/
-          /*istanbul ignore start*/
-          _string.replacePrefix)(endKeep.value, newWsSuffix, commonWsSuffix);
-          deletion.value = /*istanbul ignore start*/
-          (0, /*istanbul ignore end*/
-          /*istanbul ignore start*/
-          _string.removeSuffix)(deletion.value, commonWsSuffix);
-          insertion.value = /*istanbul ignore start*/
-          (0, /*istanbul ignore end*/
-          /*istanbul ignore start*/
-          _string.removeSuffix)(insertion.value, commonWsSuffix);
+          var commonWsSuffix = (0, string_js_1.longestCommonSuffix)(oldWsSuffix, newWsSuffix);
+          endKeep.value = (0, string_js_1.replacePrefix)(endKeep.value, newWsSuffix, commonWsSuffix);
+          deletion.value = (0, string_js_1.removeSuffix)(deletion.value, commonWsSuffix);
+          insertion.value = (0, string_js_1.removeSuffix)(insertion.value, commonWsSuffix);
         }
       } else if (insertion) {
         if (startKeep) {
-          insertion.value = insertion.value.replace(/^\s*/, "");
+          var ws = (0, string_js_1.leadingWs)(insertion.value, segmenter);
+          insertion.value = insertion.value.substring(ws.length);
         }
         if (endKeep) {
-          endKeep.value = endKeep.value.replace(/^\s*/, "");
+          var ws = (0, string_js_1.leadingWs)(endKeep.value, segmenter);
+          endKeep.value = endKeep.value.substring(ws.length);
         }
       } else if (startKeep && endKeep) {
-        var newWsFull = endKeep.value.match(/^\s*/)[0], delWsStart = deletion.value.match(/^\s*/)[0], delWsEnd = deletion.value.match(/\s*$/)[0];
-        var newWsStart = (
-          /*istanbul ignore start*/
-          (0, /*istanbul ignore end*/
-          /*istanbul ignore start*/
-          _string.longestCommonPrefix)(newWsFull, delWsStart)
-        );
-        deletion.value = /*istanbul ignore start*/
-        (0, /*istanbul ignore end*/
-        /*istanbul ignore start*/
-        _string.removePrefix)(deletion.value, newWsStart);
-        var newWsEnd = (
-          /*istanbul ignore start*/
-          (0, /*istanbul ignore end*/
-          /*istanbul ignore start*/
-          _string.longestCommonSuffix)(
-            /*istanbul ignore start*/
-            (0, /*istanbul ignore end*/
-            /*istanbul ignore start*/
-            _string.removePrefix)(newWsFull, newWsStart),
-            delWsEnd
-          )
-        );
-        deletion.value = /*istanbul ignore start*/
-        (0, /*istanbul ignore end*/
-        /*istanbul ignore start*/
-        _string.removeSuffix)(deletion.value, newWsEnd);
-        endKeep.value = /*istanbul ignore start*/
-        (0, /*istanbul ignore end*/
-        /*istanbul ignore start*/
-        _string.replacePrefix)(endKeep.value, newWsFull, newWsEnd);
-        startKeep.value = /*istanbul ignore start*/
-        (0, /*istanbul ignore end*/
-        /*istanbul ignore start*/
-        _string.replaceSuffix)(startKeep.value, newWsFull, newWsFull.slice(0, newWsFull.length - newWsEnd.length));
+        var newWsFull = (0, string_js_1.leadingWs)(endKeep.value, segmenter), _c = (0, string_js_1.leadingAndTrailingWs)(deletion.value, segmenter), delWsStart = _c[0], delWsEnd = _c[1];
+        var newWsStart = (0, string_js_1.longestCommonPrefix)(newWsFull, delWsStart);
+        deletion.value = (0, string_js_1.removePrefix)(deletion.value, newWsStart);
+        var newWsEnd = (0, string_js_1.longestCommonSuffix)((0, string_js_1.removePrefix)(newWsFull, newWsStart), delWsEnd);
+        deletion.value = (0, string_js_1.removeSuffix)(deletion.value, newWsEnd);
+        endKeep.value = (0, string_js_1.replacePrefix)(endKeep.value, newWsFull, newWsEnd);
+        startKeep.value = (0, string_js_1.replaceSuffix)(startKeep.value, newWsFull, newWsFull.slice(0, newWsFull.length - newWsEnd.length));
       } else if (endKeep) {
-        var endKeepWsPrefix = endKeep.value.match(/^\s*/)[0];
-        var deletionWsSuffix = deletion.value.match(/\s*$/)[0];
-        var overlap = (
-          /*istanbul ignore start*/
-          (0, /*istanbul ignore end*/
-          /*istanbul ignore start*/
-          _string.maximumOverlap)(deletionWsSuffix, endKeepWsPrefix)
-        );
-        deletion.value = /*istanbul ignore start*/
-        (0, /*istanbul ignore end*/
-        /*istanbul ignore start*/
-        _string.removeSuffix)(deletion.value, overlap);
+        var endKeepWsPrefix = (0, string_js_1.leadingWs)(endKeep.value, segmenter);
+        var deletionWsSuffix = (0, string_js_1.trailingWs)(deletion.value, segmenter);
+        var overlap = (0, string_js_1.maximumOverlap)(deletionWsSuffix, endKeepWsPrefix);
+        deletion.value = (0, string_js_1.removeSuffix)(deletion.value, overlap);
       } else if (startKeep) {
-        var startKeepWsSuffix = startKeep.value.match(/\s*$/)[0];
-        var deletionWsPrefix = deletion.value.match(/^\s*/)[0];
-        var _overlap = (
-          /*istanbul ignore start*/
-          (0, /*istanbul ignore end*/
-          /*istanbul ignore start*/
-          _string.maximumOverlap)(startKeepWsSuffix, deletionWsPrefix)
-        );
-        deletion.value = /*istanbul ignore start*/
-        (0, /*istanbul ignore end*/
-        /*istanbul ignore start*/
-        _string.removePrefix)(deletion.value, _overlap);
-      }
-    }
-    var wordWithSpaceDiff = (
-      /*istanbul ignore start*/
-      exports2.wordWithSpaceDiff = /*istanbul ignore end*/
-      new /*istanbul ignore start*/
-      _base[
-        /*istanbul ignore start*/
-        "default"
-        /*istanbul ignore end*/
-      ]()
+        var startKeepWsSuffix = (0, string_js_1.trailingWs)(startKeep.value, segmenter);
+        var deletionWsPrefix = (0, string_js_1.leadingWs)(deletion.value, segmenter);
+        var overlap = (0, string_js_1.maximumOverlap)(startKeepWsSuffix, deletionWsPrefix);
+        deletion.value = (0, string_js_1.removePrefix)(deletion.value, overlap);
+      }
+    }
+    var WordsWithSpaceDiff = (
+      /** @class */
+      (function(_super) {
+        __extends(WordsWithSpaceDiff2, _super);
+        function WordsWithSpaceDiff2() {
+          return _super !== null && _super.apply(this, arguments) || this;
+        }
+        WordsWithSpaceDiff2.prototype.tokenize = function(value) {
+          var regex = new RegExp("(\\r?\\n)|[".concat(extendedWordChars, "]+|[^\\S\\n\\r]+|[^").concat(extendedWordChars, "]"), "ug");
+          return value.match(regex) || [];
+        };
+        return WordsWithSpaceDiff2;
+      })(base_js_1.default)
     );
-    wordWithSpaceDiff.tokenize = function(value) {
-      var regex = new RegExp(
-        /*istanbul ignore start*/
-        "(\\r?\\n)|[".concat(
-          /*istanbul ignore end*/
-          extendedWordChars,
-          "]+|[^\\S\\n\\r]+|[^"
-        ).concat(extendedWordChars, "]"),
-        "ug"
-      );
-      return value.match(regex) || [];
-    };
+    exports2.wordsWithSpaceDiff = new WordsWithSpaceDiff();
     function diffWordsWithSpace(oldStr, newStr, options) {
-      return wordWithSpaceDiff.diff(oldStr, newStr, options);
+      return exports2.wordsWithSpaceDiff.diff(oldStr, newStr, options);
     }
   }
 });
 
-// node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/util/params.js
+// node_modules/.pnpm/diff@8.0.4/node_modules/diff/libcjs/util/params.js
 var require_params = __commonJS({
-  "node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/util/params.js"(exports2) {
+  "node_modules/.pnpm/diff@8.0.4/node_modules/diff/libcjs/util/params.js"(exports2) {
     "use strict";
-    Object.defineProperty(exports2, "__esModule", {
-      value: true
-    });
+    Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.generateOptions = generateOptions;
     function generateOptions(options, defaults) {
       if (typeof options === "function") {
         defaults.callback = options;
       } else if (options) {
         for (var name in options) {
-          if (options.hasOwnProperty(name)) {
+          if (Object.prototype.hasOwnProperty.call(options, name)) {
             defaults[name] = options[name];
           }
         }
@@ -12786,32 +12725,75 @@ var require_params = __commonJS({
   }
 });
 
-// node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/diff/line.js
+// node_modules/.pnpm/diff@8.0.4/node_modules/diff/libcjs/diff/line.js
 var require_line = __commonJS({
-  "node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/diff/line.js"(exports2) {
+  "node_modules/.pnpm/diff@8.0.4/node_modules/diff/libcjs/diff/line.js"(exports2) {
     "use strict";
-    Object.defineProperty(exports2, "__esModule", {
-      value: true
-    });
+    var __extends = exports2 && exports2.__extends || /* @__PURE__ */ (function() {
+      var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+          d2.__proto__ = b2;
+        } || function(d2, b2) {
+          for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
+        };
+        return extendStatics(d, b);
+      };
+      return function(d, b) {
+        if (typeof b !== "function" && b !== null)
+          throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() {
+          this.constructor = d;
+        }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+      };
+    })();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.lineDiff = void 0;
     exports2.diffLines = diffLines;
     exports2.diffTrimmedLines = diffTrimmedLines;
-    exports2.lineDiff = void 0;
-    var _base = _interopRequireDefault(require_base());
-    var _params = require_params();
-    function _interopRequireDefault(obj) {
-      return obj && obj.__esModule ? obj : { "default": obj };
-    }
-    var lineDiff = (
-      /*istanbul ignore start*/
-      exports2.lineDiff = /*istanbul ignore end*/
-      new /*istanbul ignore start*/
-      _base[
-        /*istanbul ignore start*/
-        "default"
-        /*istanbul ignore end*/
-      ]()
+    exports2.tokenize = tokenize;
+    var base_js_1 = require_base();
+    var params_js_1 = require_params();
+    var LineDiff = (
+      /** @class */
+      (function(_super) {
+        __extends(LineDiff2, _super);
+        function LineDiff2() {
+          var _this = _super !== null && _super.apply(this, arguments) || this;
+          _this.tokenize = tokenize;
+          return _this;
+        }
+        LineDiff2.prototype.equals = function(left, right, options) {
+          if (options.ignoreWhitespace) {
+            if (!options.newlineIsToken || !left.includes("\n")) {
+              left = left.trim();
+            }
+            if (!options.newlineIsToken || !right.includes("\n")) {
+              right = right.trim();
+            }
+          } else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
+            if (left.endsWith("\n")) {
+              left = left.slice(0, -1);
+            }
+            if (right.endsWith("\n")) {
+              right = right.slice(0, -1);
+            }
+          }
+          return _super.prototype.equals.call(this, left, right, options);
+        };
+        return LineDiff2;
+      })(base_js_1.default)
     );
-    lineDiff.tokenize = function(value, options) {
+    exports2.lineDiff = new LineDiff();
+    function diffLines(oldStr, newStr, options) {
+      return exports2.lineDiff.diff(oldStr, newStr, options);
+    }
+    function diffTrimmedLines(oldStr, newStr, options) {
+      options = (0, params_js_1.generateOptions)(options, { ignoreWhitespace: true });
+      return exports2.lineDiff.diff(oldStr, newStr, options);
+    }
+    function tokenize(value, options) {
       if (options.stripTrailingCr) {
         value = value.replace(/\r\n/g, "\n");
       }
@@ -12828,179 +12810,191 @@ var require_line = __commonJS({
         }
       }
       return retLines;
-    };
-    lineDiff.equals = function(left, right, options) {
-      if (options.ignoreWhitespace) {
-        if (!options.newlineIsToken || !left.includes("\n")) {
-          left = left.trim();
-        }
-        if (!options.newlineIsToken || !right.includes("\n")) {
-          right = right.trim();
-        }
-      } else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
-        if (left.endsWith("\n")) {
-          left = left.slice(0, -1);
-        }
-        if (right.endsWith("\n")) {
-          right = right.slice(0, -1);
-        }
-      }
-      return (
-        /*istanbul ignore start*/
-        _base[
-          /*istanbul ignore start*/
-          "default"
-          /*istanbul ignore end*/
-        ].prototype.equals.call(this, left, right, options)
-      );
-    };
-    function diffLines(oldStr, newStr, callback) {
-      return lineDiff.diff(oldStr, newStr, callback);
-    }
-    function diffTrimmedLines(oldStr, newStr, callback) {
-      var options = (
-        /*istanbul ignore start*/
-        (0, /*istanbul ignore end*/
-        /*istanbul ignore start*/
-        _params.generateOptions)(callback, {
-          ignoreWhitespace: true
-        })
-      );
-      return lineDiff.diff(oldStr, newStr, options);
     }
   }
 });
 
-// node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/diff/sentence.js
+// node_modules/.pnpm/diff@8.0.4/node_modules/diff/libcjs/diff/sentence.js
 var require_sentence = __commonJS({
-  "node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/diff/sentence.js"(exports2) {
+  "node_modules/.pnpm/diff@8.0.4/node_modules/diff/libcjs/diff/sentence.js"(exports2) {
     "use strict";
-    Object.defineProperty(exports2, "__esModule", {
-      value: true
-    });
-    exports2.diffSentences = diffSentences;
+    var __extends = exports2 && exports2.__extends || /* @__PURE__ */ (function() {
+      var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+          d2.__proto__ = b2;
+        } || function(d2, b2) {
+          for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
+        };
+        return extendStatics(d, b);
+      };
+      return function(d, b) {
+        if (typeof b !== "function" && b !== null)
+          throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() {
+          this.constructor = d;
+        }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+      };
+    })();
+    Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.sentenceDiff = void 0;
-    var _base = _interopRequireDefault(require_base());
-    function _interopRequireDefault(obj) {
-      return obj && obj.__esModule ? obj : { "default": obj };
-    }
-    var sentenceDiff = (
-      /*istanbul ignore start*/
-      exports2.sentenceDiff = /*istanbul ignore end*/
-      new /*istanbul ignore start*/
-      _base[
-        /*istanbul ignore start*/
-        "default"
-        /*istanbul ignore end*/
-      ]()
+    exports2.diffSentences = diffSentences;
+    var base_js_1 = require_base();
+    function isSentenceEndPunct(char) {
+      return char == "." || char == "!" || char == "?";
+    }
+    var SentenceDiff = (
+      /** @class */
+      (function(_super) {
+        __extends(SentenceDiff2, _super);
+        function SentenceDiff2() {
+          return _super !== null && _super.apply(this, arguments) || this;
+        }
+        SentenceDiff2.prototype.tokenize = function(value) {
+          var _a;
+          var result = [];
+          var tokenStartI = 0;
+          for (var i = 0; i < value.length; i++) {
+            if (i == value.length - 1) {
+              result.push(value.slice(tokenStartI));
+              break;
+            }
+            if (isSentenceEndPunct(value[i]) && value[i + 1].match(/\s/)) {
+              result.push(value.slice(tokenStartI, i + 1));
+              i = tokenStartI = i + 1;
+              while ((_a = value[i + 1]) === null || _a === void 0 ? void 0 : _a.match(/\s/)) {
+                i++;
+              }
+              result.push(value.slice(tokenStartI, i + 1));
+              tokenStartI = i + 1;
+            }
+          }
+          return result;
+        };
+        return SentenceDiff2;
+      })(base_js_1.default)
     );
-    sentenceDiff.tokenize = function(value) {
-      return value.split(/(\S.+?[.!?])(?=\s+|$)/);
-    };
-    function diffSentences(oldStr, newStr, callback) {
-      return sentenceDiff.diff(oldStr, newStr, callback);
+    exports2.sentenceDiff = new SentenceDiff();
+    function diffSentences(oldStr, newStr, options) {
+      return exports2.sentenceDiff.diff(oldStr, newStr, options);
     }
   }
 });
 
-// node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/diff/css.js
+// node_modules/.pnpm/diff@8.0.4/node_modules/diff/libcjs/diff/css.js
 var require_css = __commonJS({
-  "node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/diff/css.js"(exports2) {
+  "node_modules/.pnpm/diff@8.0.4/node_modules/diff/libcjs/diff/css.js"(exports2) {
     "use strict";
-    Object.defineProperty(exports2, "__esModule", {
-      value: true
-    });
+    var __extends = exports2 && exports2.__extends || /* @__PURE__ */ (function() {
+      var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+          d2.__proto__ = b2;
+        } || function(d2, b2) {
+          for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
+        };
+        return extendStatics(d, b);
+      };
+      return function(d, b) {
+        if (typeof b !== "function" && b !== null)
+          throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() {
+          this.constructor = d;
+        }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+      };
+    })();
+    Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.cssDiff = void 0;
     exports2.diffCss = diffCss;
-    var _base = _interopRequireDefault(require_base());
-    function _interopRequireDefault(obj) {
-      return obj && obj.__esModule ? obj : { "default": obj };
-    }
-    var cssDiff = (
-      /*istanbul ignore start*/
-      exports2.cssDiff = /*istanbul ignore end*/
-      new /*istanbul ignore start*/
-      _base[
-        /*istanbul ignore start*/
-        "default"
-        /*istanbul ignore end*/
-      ]()
+    var base_js_1 = require_base();
+    var CssDiff = (
+      /** @class */
+      (function(_super) {
+        __extends(CssDiff2, _super);
+        function CssDiff2() {
+          return _super !== null && _super.apply(this, arguments) || this;
+        }
+        CssDiff2.prototype.tokenize = function(value) {
+          return value.split(/([{}:;,]|\s+)/);
+        };
+        return CssDiff2;
+      })(base_js_1.default)
     );
-    cssDiff.tokenize = function(value) {
-      return value.split(/([{}:;,]|\s+)/);
-    };
-    function diffCss(oldStr, newStr, callback) {
-      return cssDiff.diff(oldStr, newStr, callback);
+    exports2.cssDiff = new CssDiff();
+    function diffCss(oldStr, newStr, options) {
+      return exports2.cssDiff.diff(oldStr, newStr, options);
     }
   }
 });
 
-// node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/diff/json.js
+// node_modules/.pnpm/diff@8.0.4/node_modules/diff/libcjs/diff/json.js
 var require_json = __commonJS({
-  "node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/diff/json.js"(exports2) {
+  "node_modules/.pnpm/diff@8.0.4/node_modules/diff/libcjs/diff/json.js"(exports2) {
     "use strict";
-    Object.defineProperty(exports2, "__esModule", {
-      value: true
-    });
-    exports2.canonicalize = canonicalize;
-    exports2.diffJson = diffJson;
+    var __extends = exports2 && exports2.__extends || /* @__PURE__ */ (function() {
+      var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+          d2.__proto__ = b2;
+        } || function(d2, b2) {
+          for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
+        };
+        return extendStatics(d, b);
+      };
+      return function(d, b) {
+        if (typeof b !== "function" && b !== null)
+          throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() {
+          this.constructor = d;
+        }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+      };
+    })();
+    Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.jsonDiff = void 0;
-    var _base = _interopRequireDefault(require_base());
-    var _line = require_line();
-    function _interopRequireDefault(obj) {
-      return obj && obj.__esModule ? obj : { "default": obj };
-    }
-    function _typeof(o) {
-      "@babel/helpers - typeof";
-      return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
-        return typeof o2;
-      } : function(o2) {
-        return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
-      }, _typeof(o);
-    }
-    var jsonDiff = (
-      /*istanbul ignore start*/
-      exports2.jsonDiff = /*istanbul ignore end*/
-      new /*istanbul ignore start*/
-      _base[
-        /*istanbul ignore start*/
-        "default"
-        /*istanbul ignore end*/
-      ]()
+    exports2.diffJson = diffJson;
+    exports2.canonicalize = canonicalize;
+    var base_js_1 = require_base();
+    var line_js_1 = require_line();
+    var JsonDiff = (
+      /** @class */
+      (function(_super) {
+        __extends(JsonDiff2, _super);
+        function JsonDiff2() {
+          var _this = _super !== null && _super.apply(this, arguments) || this;
+          _this.tokenize = line_js_1.tokenize;
+          return _this;
+        }
+        Object.defineProperty(JsonDiff2.prototype, "useLongestToken", {
+          get: function() {
+            return true;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        JsonDiff2.prototype.castInput = function(value, options) {
+          var undefinedReplacement = options.undefinedReplacement, _a = options.stringifyReplacer, stringifyReplacer = _a === void 0 ? function(k, v) {
+            return typeof v === "undefined" ? undefinedReplacement : v;
+          } : _a;
+          return typeof value === "string" ? value : JSON.stringify(canonicalize(value, null, null, stringifyReplacer), null, "  ");
+        };
+        JsonDiff2.prototype.equals = function(left, right, options) {
+          return _super.prototype.equals.call(this, left.replace(/,([\r\n])/g, "$1"), right.replace(/,([\r\n])/g, "$1"), options);
+        };
+        return JsonDiff2;
+      })(base_js_1.default)
     );
-    jsonDiff.useLongestToken = true;
-    jsonDiff.tokenize = /*istanbul ignore start*/
-    _line.lineDiff.tokenize;
-    jsonDiff.castInput = function(value, options) {
-      var undefinedReplacement = options.undefinedReplacement, _options$stringifyRep = (
-        /*istanbul ignore end*/
-        options.stringifyReplacer
-      ), stringifyReplacer = _options$stringifyRep === void 0 ? function(k, v) {
-        return (
-          /*istanbul ignore end*/
-          typeof v === "undefined" ? undefinedReplacement : v
-        );
-      } : _options$stringifyRep;
-      return typeof value === "string" ? value : JSON.stringify(canonicalize(value, null, null, stringifyReplacer), stringifyReplacer, "  ");
-    };
-    jsonDiff.equals = function(left, right, options) {
-      return (
-        /*istanbul ignore start*/
-        _base[
-          /*istanbul ignore start*/
-          "default"
-          /*istanbul ignore end*/
-        ].prototype.equals.call(jsonDiff, left.replace(/,([\r\n])/g, "$1"), right.replace(/,([\r\n])/g, "$1"), options)
-      );
-    };
-    function diffJson(oldObj, newObj, options) {
-      return jsonDiff.diff(oldObj, newObj, options);
+    exports2.jsonDiff = new JsonDiff();
+    function diffJson(oldStr, newStr, options) {
+      return exports2.jsonDiff.diff(oldStr, newStr, options);
     }
     function canonicalize(obj, stack, replacementStack, replacer, key) {
       stack = stack || [];
       replacementStack = replacementStack || [];
       if (replacer) {
-        obj = replacer(key, obj);
+        obj = replacer(key === void 0 ? "" : key, obj);
       }
       var i;
       for (i = 0; i < stack.length; i += 1) {
@@ -13014,7 +13008,7 @@ var require_json = __commonJS({
         canonicalizedObj = new Array(obj.length);
         replacementStack.push(canonicalizedObj);
         for (i = 0; i < obj.length; i += 1) {
-          canonicalizedObj[i] = canonicalize(obj[i], stack, replacementStack, replacer, key);
+          canonicalizedObj[i] = canonicalize(obj[i], stack, replacementStack, replacer, String(i));
         }
         stack.pop();
         replacementStack.pop();
@@ -13023,26 +13017,21 @@ var require_json = __commonJS({
       if (obj && obj.toJSON) {
         obj = obj.toJSON();
       }
-      if (
-        /*istanbul ignore start*/
-        _typeof(
-          /*istanbul ignore end*/
-          obj
-        ) === "object" && obj !== null
-      ) {
+      if (typeof obj === "object" && obj !== null) {
         stack.push(obj);
         canonicalizedObj = {};
         replacementStack.push(canonicalizedObj);
-        var sortedKeys = [], _key;
-        for (_key in obj) {
-          if (Object.prototype.hasOwnProperty.call(obj, _key)) {
-            sortedKeys.push(_key);
+        var sortedKeys = [];
+        var key_1;
+        for (key_1 in obj) {
+          if (Object.prototype.hasOwnProperty.call(obj, key_1)) {
+            sortedKeys.push(key_1);
           }
         }
         sortedKeys.sort();
         for (i = 0; i < sortedKeys.length; i += 1) {
-          _key = sortedKeys[i];
-          canonicalizedObj[_key] = canonicalize(obj[_key], stack, replacementStack, replacer, _key);
+          key_1 = sortedKeys[i];
+          canonicalizedObj[key_1] = canonicalize(obj[key_1], stack, replacementStack, replacer, key_1);
         }
         stack.pop();
         replacementStack.pop();
@@ -13054,183 +13043,114 @@ var require_json = __commonJS({
   }
 });
 
-// node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/diff/array.js
+// node_modules/.pnpm/diff@8.0.4/node_modules/diff/libcjs/diff/array.js
 var require_array2 = __commonJS({
-  "node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/diff/array.js"(exports2) {
+  "node_modules/.pnpm/diff@8.0.4/node_modules/diff/libcjs/diff/array.js"(exports2) {
     "use strict";
-    Object.defineProperty(exports2, "__esModule", {
-      value: true
-    });
+    var __extends = exports2 && exports2.__extends || /* @__PURE__ */ (function() {
+      var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+          d2.__proto__ = b2;
+        } || function(d2, b2) {
+          for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
+        };
+        return extendStatics(d, b);
+      };
+      return function(d, b) {
+        if (typeof b !== "function" && b !== null)
+          throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() {
+          this.constructor = d;
+        }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+      };
+    })();
+    Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.arrayDiff = void 0;
     exports2.diffArrays = diffArrays;
-    var _base = _interopRequireDefault(require_base());
-    function _interopRequireDefault(obj) {
-      return obj && obj.__esModule ? obj : { "default": obj };
-    }
-    var arrayDiff = (
-      /*istanbul ignore start*/
-      exports2.arrayDiff = /*istanbul ignore end*/
-      new /*istanbul ignore start*/
-      _base[
-        /*istanbul ignore start*/
-        "default"
-        /*istanbul ignore end*/
-      ]()
+    var base_js_1 = require_base();
+    var ArrayDiff = (
+      /** @class */
+      (function(_super) {
+        __extends(ArrayDiff2, _super);
+        function ArrayDiff2() {
+          return _super !== null && _super.apply(this, arguments) || this;
+        }
+        ArrayDiff2.prototype.tokenize = function(value) {
+          return value.slice();
+        };
+        ArrayDiff2.prototype.join = function(value) {
+          return value;
+        };
+        ArrayDiff2.prototype.removeEmpty = function(value) {
+          return value;
+        };
+        return ArrayDiff2;
+      })(base_js_1.default)
     );
-    arrayDiff.tokenize = function(value) {
-      return value.slice();
-    };
-    arrayDiff.join = arrayDiff.removeEmpty = function(value) {
-      return value;
-    };
-    function diffArrays(oldArr, newArr, callback) {
-      return arrayDiff.diff(oldArr, newArr, callback);
+    exports2.arrayDiff = new ArrayDiff();
+    function diffArrays(oldArr, newArr, options) {
+      return exports2.arrayDiff.diff(oldArr, newArr, options);
     }
   }
 });
 
-// node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/patch/line-endings.js
+// node_modules/.pnpm/diff@8.0.4/node_modules/diff/libcjs/patch/line-endings.js
 var require_line_endings = __commonJS({
-  "node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/patch/line-endings.js"(exports2) {
+  "node_modules/.pnpm/diff@8.0.4/node_modules/diff/libcjs/patch/line-endings.js"(exports2) {
     "use strict";
-    Object.defineProperty(exports2, "__esModule", {
-      value: true
-    });
-    exports2.isUnix = isUnix;
-    exports2.isWin = isWin;
+    var __assign = exports2 && exports2.__assign || function() {
+      __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+          s = arguments[i];
+          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+            t[p] = s[p];
+        }
+        return t;
+      };
+      return __assign.apply(this, arguments);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.unixToWin = unixToWin;
     exports2.winToUnix = winToUnix;
-    function _typeof(o) {
-      "@babel/helpers - typeof";
-      return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
-        return typeof o2;
-      } : function(o2) {
-        return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
-      }, _typeof(o);
-    }
-    function ownKeys(e, r) {
-      var t = Object.keys(e);
-      if (Object.getOwnPropertySymbols) {
-        var o = Object.getOwnPropertySymbols(e);
-        r && (o = o.filter(function(r2) {
-          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
-        })), t.push.apply(t, o);
-      }
-      return t;
-    }
-    function _objectSpread(e) {
-      for (var r = 1; r < arguments.length; r++) {
-        var t = null != arguments[r] ? arguments[r] : {};
-        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
-          _defineProperty(e, r2, t[r2]);
-        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
-          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
-        });
-      }
-      return e;
-    }
-    function _defineProperty(obj, key, value) {
-      key = _toPropertyKey(key);
-      if (key in obj) {
-        Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
-      } else {
-        obj[key] = value;
-      }
-      return obj;
-    }
-    function _toPropertyKey(t) {
-      var i = _toPrimitive(t, "string");
-      return "symbol" == _typeof(i) ? i : i + "";
-    }
-    function _toPrimitive(t, r) {
-      if ("object" != _typeof(t) || !t) return t;
-      var e = t[Symbol.toPrimitive];
-      if (void 0 !== e) {
-        var i = e.call(t, r || "default");
-        if ("object" != _typeof(i)) return i;
-        throw new TypeError("@@toPrimitive must return a primitive value.");
-      }
-      return ("string" === r ? String : Number)(t);
-    }
+    exports2.isUnix = isUnix;
+    exports2.isWin = isWin;
     function unixToWin(patch) {
       if (Array.isArray(patch)) {
-        return patch.map(unixToWin);
-      }
-      return (
-        /*istanbul ignore start*/
-        _objectSpread(_objectSpread(
-          {},
-          /*istanbul ignore end*/
-          patch
-        ), {}, {
-          hunks: patch.hunks.map(function(hunk) {
-            return _objectSpread(_objectSpread(
-              {},
-              /*istanbul ignore end*/
-              hunk
-            ), {}, {
-              lines: hunk.lines.map(function(line, i) {
-                var _hunk$lines;
-                return (
-                  /*istanbul ignore end*/
-                  line.startsWith("\\") || line.endsWith("\r") || /*istanbul ignore start*/
-                  (_hunk$lines = /*istanbul ignore end*/
-                  hunk.lines[i + 1]) !== null && _hunk$lines !== void 0 && /*istanbul ignore start*/
-                  _hunk$lines.startsWith("\\") ? line : line + "\r"
-                );
-              })
-            });
-          })
-        })
-      );
+        return patch.map(function(p) {
+          return unixToWin(p);
+        });
+      }
+      return __assign(__assign({}, patch), { hunks: patch.hunks.map(function(hunk) {
+        return __assign(__assign({}, hunk), { lines: hunk.lines.map(function(line, i) {
+          var _a;
+          return line.startsWith("\\") || line.endsWith("\r") || ((_a = hunk.lines[i + 1]) === null || _a === void 0 ? void 0 : _a.startsWith("\\")) ? line : line + "\r";
+        }) });
+      }) });
     }
     function winToUnix(patch) {
       if (Array.isArray(patch)) {
-        return patch.map(winToUnix);
-      }
-      return (
-        /*istanbul ignore start*/
-        _objectSpread(_objectSpread(
-          {},
-          /*istanbul ignore end*/
-          patch
-        ), {}, {
-          hunks: patch.hunks.map(function(hunk) {
-            return _objectSpread(_objectSpread(
-              {},
-              /*istanbul ignore end*/
-              hunk
-            ), {}, {
-              lines: hunk.lines.map(function(line) {
-                return (
-                  /*istanbul ignore end*/
-                  line.endsWith("\r") ? line.substring(0, line.length - 1) : line
-                );
-              })
-            });
-          })
-        })
-      );
+        return patch.map(function(p) {
+          return winToUnix(p);
+        });
+      }
+      return __assign(__assign({}, patch), { hunks: patch.hunks.map(function(hunk) {
+        return __assign(__assign({}, hunk), { lines: hunk.lines.map(function(line) {
+          return line.endsWith("\r") ? line.substring(0, line.length - 1) : line;
+        }) });
+      }) });
     }
     function isUnix(patch) {
       if (!Array.isArray(patch)) {
         patch = [patch];
       }
       return !patch.some(function(index) {
-        return (
-          /*istanbul ignore end*/
-          index.hunks.some(function(hunk) {
-            return (
-              /*istanbul ignore end*/
-              hunk.lines.some(function(line) {
-                return (
-                  /*istanbul ignore end*/
-                  !line.startsWith("\\") && line.endsWith("\r")
-                );
-              })
-            );
-          })
-        );
+        return index.hunks.some(function(hunk) {
+          return hunk.lines.some(function(line) {
+            return !line.startsWith("\\") && line.endsWith("\r");
+          });
+        });
       });
     }
     function isWin(patch) {
@@ -13238,67 +13158,43 @@ var require_line_endings = __commonJS({
         patch = [patch];
       }
       return patch.some(function(index) {
-        return (
-          /*istanbul ignore end*/
-          index.hunks.some(function(hunk) {
-            return (
-              /*istanbul ignore end*/
-              hunk.lines.some(function(line) {
-                return (
-                  /*istanbul ignore end*/
-                  line.endsWith("\r")
-                );
-              })
-            );
-          })
-        );
+        return index.hunks.some(function(hunk) {
+          return hunk.lines.some(function(line) {
+            return line.endsWith("\r");
+          });
+        });
       }) && patch.every(function(index) {
-        return (
-          /*istanbul ignore end*/
-          index.hunks.every(function(hunk) {
-            return (
-              /*istanbul ignore end*/
-              hunk.lines.every(function(line, i) {
-                var _hunk$lines2;
-                return (
-                  /*istanbul ignore end*/
-                  line.startsWith("\\") || line.endsWith("\r") || /*istanbul ignore start*/
-                  ((_hunk$lines2 = /*istanbul ignore end*/
-                  hunk.lines[i + 1]) === null || _hunk$lines2 === void 0 ? void 0 : (
-                    /*istanbul ignore start*/
-                    _hunk$lines2.startsWith("\\")
-                  ))
-                );
-              })
-            );
-          })
-        );
+        return index.hunks.every(function(hunk) {
+          return hunk.lines.every(function(line, i) {
+            var _a;
+            return line.startsWith("\\") || line.endsWith("\r") || ((_a = hunk.lines[i + 1]) === null || _a === void 0 ? void 0 : _a.startsWith("\\"));
+          });
+        });
       });
     }
   }
 });
 
-// node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/patch/parse.js
+// node_modules/.pnpm/diff@8.0.4/node_modules/diff/libcjs/patch/parse.js
 var require_parse4 = __commonJS({
-  "node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/patch/parse.js"(exports2) {
+  "node_modules/.pnpm/diff@8.0.4/node_modules/diff/libcjs/patch/parse.js"(exports2) {
     "use strict";
-    Object.defineProperty(exports2, "__esModule", {
-      value: true
-    });
+    Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.parsePatch = parsePatch;
     function parsePatch(uniDiff) {
-      var diffstr = uniDiff.split(/\n/), list = [], i = 0;
+      var diffstr = uniDiff.split(/\n/), list = [];
+      var i = 0;
       function parseIndex() {
         var index = {};
         list.push(index);
         while (i < diffstr.length) {
           var line = diffstr[i];
-          if (/^(\-\-\-|\+\+\+|@@)\s/.test(line)) {
+          if (/^(---|\+\+\+|@@)\s/.test(line)) {
             break;
           }
-          var header = /^(?:Index:|diff(?: -r \w+)+)\s+(.+?)\s*$/.exec(line);
-          if (header) {
-            index.index = header[1];
+          var headerMatch = /^(?:Index:|diff(?: -r \w+)+)\s+/.exec(line);
+          if (headerMatch) {
+            index.index = line.substring(headerMatch[0].length).trim();
           }
           i++;
         }
@@ -13306,33 +13202,38 @@ var require_parse4 = __commonJS({
         parseFileHeader(index);
         index.hunks = [];
         while (i < diffstr.length) {
-          var _line = diffstr[i];
-          if (/^(Index:\s|diff\s|\-\-\-\s|\+\+\+\s|===================================================================)/.test(_line)) {
+          var line = diffstr[i];
+          if (/^(Index:\s|diff\s|---\s|\+\+\+\s|===================================================================)/.test(line)) {
             break;
-          } else if (/^@@/.test(_line)) {
+          } else if (/^@@/.test(line)) {
             index.hunks.push(parseHunk());
-          } else if (_line) {
-            throw new Error("Unknown line " + (i + 1) + " " + JSON.stringify(_line));
+          } else if (line) {
+            throw new Error("Unknown line " + (i + 1) + " " + JSON.stringify(line));
           } else {
             i++;
           }
         }
       }
       function parseFileHeader(index) {
-        var fileHeader = /^(---|\+\+\+)\s+(.*)\r?$/.exec(diffstr[i]);
-        if (fileHeader) {
-          var keyPrefix = fileHeader[1] === "---" ? "old" : "new";
-          var data = fileHeader[2].split("	", 2);
+        var fileHeaderMatch = /^(---|\+\+\+)\s+/.exec(diffstr[i]);
+        if (fileHeaderMatch) {
+          var prefix = fileHeaderMatch[1], data = diffstr[i].substring(3).trim().split("	", 2), header = (data[1] || "").trim();
           var fileName = data[0].replace(/\\\\/g, "\\");
-          if (/^".*"$/.test(fileName)) {
+          if (fileName.startsWith('"') && fileName.endsWith('"')) {
             fileName = fileName.substr(1, fileName.length - 2);
           }
-          index[keyPrefix + "FileName"] = fileName;
-          index[keyPrefix + "Header"] = (data[1] || "").trim();
+          if (prefix === "---") {
+            index.oldFileName = fileName;
+            index.oldHeader = header;
+          } else {
+            index.newFileName = fileName;
+            index.newHeader = header;
+          }
           i++;
         }
       }
       function parseHunk() {
+        var _a;
         var chunkHeaderIndex = i, chunkHeaderLine = diffstr[i++], chunkHeader = chunkHeaderLine.split(/@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
         var hunk = {
           oldStart: +chunkHeader[1],
@@ -13348,11 +13249,7 @@ var require_parse4 = __commonJS({
           hunk.newStart += 1;
         }
         var addCount = 0, removeCount = 0;
-        for (; i < diffstr.length && (removeCount < hunk.oldLines || addCount < hunk.newLines || /*istanbul ignore start*/
-        (_diffstr$i = /*istanbul ignore end*/
-        diffstr[i]) !== null && _diffstr$i !== void 0 && /*istanbul ignore start*/
-        _diffstr$i.startsWith("\\")); i++) {
-          var _diffstr$i;
+        for (; i < diffstr.length && (removeCount < hunk.oldLines || addCount < hunk.newLines || ((_a = diffstr[i]) === null || _a === void 0 ? void 0 : _a.startsWith("\\"))); i++) {
           var operation = diffstr[i].length == 0 && i != diffstr.length - 1 ? " " : diffstr[i][0];
           if (operation === "+" || operation === "-" || operation === " " || operation === "\\") {
             hunk.lines.push(diffstr[i]);
@@ -13365,14 +13262,7 @@ var require_parse4 = __commonJS({
               removeCount++;
             }
           } else {
-            throw new Error(
-              /*istanbul ignore start*/
-              "Hunk at line ".concat(
-                /*istanbul ignore end*/
-                chunkHeaderIndex + 1,
-                " contained invalid line "
-              ).concat(diffstr[i])
-            );
+            throw new Error("Hunk at line ".concat(chunkHeaderIndex + 1, " contained invalid line ").concat(diffstr[i]));
           }
         }
         if (!addCount && hunk.newLines === 1) {
@@ -13397,15 +13287,13 @@ var require_parse4 = __commonJS({
   }
 });
 
-// node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/util/distance-iterator.js
+// node_modules/.pnpm/diff@8.0.4/node_modules/diff/libcjs/util/distance-iterator.js
 var require_distance_iterator = __commonJS({
-  "node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/util/distance-iterator.js"(exports2) {
+  "node_modules/.pnpm/diff@8.0.4/node_modules/diff/libcjs/util/distance-iterator.js"(exports2) {
     "use strict";
-    Object.defineProperty(exports2, "__esModule", {
-      value: true
-    });
-    exports2["default"] = _default;
-    function _default(start, minLine, maxLine) {
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.default = default_1;
+    function default_1(start, minLine, maxLine) {
       var wantForward = true, backwardExhausted = false, forwardExhausted = false, localOffset = 1;
       return function iterator() {
         if (wantForward && !forwardExhausted) {
@@ -13429,76 +13317,55 @@ var require_distance_iterator = __commonJS({
           backwardExhausted = true;
           return iterator();
         }
+        return void 0;
       };
     }
   }
 });
 
-// node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/patch/apply.js
+// node_modules/.pnpm/diff@8.0.4/node_modules/diff/libcjs/patch/apply.js
 var require_apply = __commonJS({
-  "node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/patch/apply.js"(exports2) {
+  "node_modules/.pnpm/diff@8.0.4/node_modules/diff/libcjs/patch/apply.js"(exports2) {
     "use strict";
-    Object.defineProperty(exports2, "__esModule", {
-      value: true
-    });
+    Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.applyPatch = applyPatch;
     exports2.applyPatches = applyPatches;
-    var _string = require_string2();
-    var _lineEndings = require_line_endings();
-    var _parse = require_parse4();
-    var _distanceIterator = _interopRequireDefault(require_distance_iterator());
-    function _interopRequireDefault(obj) {
-      return obj && obj.__esModule ? obj : { "default": obj };
-    }
-    function applyPatch(source, uniDiff) {
-      var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
-      if (typeof uniDiff === "string") {
-        uniDiff = /*istanbul ignore start*/
-        (0, /*istanbul ignore end*/
-        /*istanbul ignore start*/
-        _parse.parsePatch)(uniDiff);
-      }
-      if (Array.isArray(uniDiff)) {
-        if (uniDiff.length > 1) {
-          throw new Error("applyPatch only works with a single input.");
-        }
-        uniDiff = uniDiff[0];
+    var string_js_1 = require_string2();
+    var line_endings_js_1 = require_line_endings();
+    var parse_js_1 = require_parse4();
+    var distance_iterator_js_1 = require_distance_iterator();
+    function applyPatch(source, patch, options) {
+      if (options === void 0) {
+        options = {};
+      }
+      var patches;
+      if (typeof patch === "string") {
+        patches = (0, parse_js_1.parsePatch)(patch);
+      } else if (Array.isArray(patch)) {
+        patches = patch;
+      } else {
+        patches = [patch];
+      }
+      if (patches.length > 1) {
+        throw new Error("applyPatch only works with a single input.");
+      }
+      return applyStructuredPatch(source, patches[0], options);
+    }
+    function applyStructuredPatch(source, patch, options) {
+      if (options === void 0) {
+        options = {};
       }
       if (options.autoConvertLineEndings || options.autoConvertLineEndings == null) {
-        if (
-          /*istanbul ignore start*/
-          (0, /*istanbul ignore end*/
-          /*istanbul ignore start*/
-          _string.hasOnlyWinLineEndings)(source) && /*istanbul ignore start*/
-          (0, /*istanbul ignore end*/
-          /*istanbul ignore start*/
-          _lineEndings.isUnix)(uniDiff)
-        ) {
-          uniDiff = /*istanbul ignore start*/
-          (0, /*istanbul ignore end*/
-          /*istanbul ignore start*/
-          _lineEndings.unixToWin)(uniDiff);
-        } else if (
-          /*istanbul ignore start*/
-          (0, /*istanbul ignore end*/
-          /*istanbul ignore start*/
-          _string.hasOnlyUnixLineEndings)(source) && /*istanbul ignore start*/
-          (0, /*istanbul ignore end*/
-          /*istanbul ignore start*/
-          _lineEndings.isWin)(uniDiff)
-        ) {
-          uniDiff = /*istanbul ignore start*/
-          (0, /*istanbul ignore end*/
-          /*istanbul ignore start*/
-          _lineEndings.winToUnix)(uniDiff);
-        }
-      }
-      var lines = source.split("\n"), hunks = uniDiff.hunks, compareLine = options.compareLine || function(lineNumber, line2, operation, patchContent) {
-        return (
-          /*istanbul ignore end*/
-          line2 === patchContent
-        );
-      }, fuzzFactor = options.fuzzFactor || 0, minLine = 0;
+        if ((0, string_js_1.hasOnlyWinLineEndings)(source) && (0, line_endings_js_1.isUnix)(patch)) {
+          patch = (0, line_endings_js_1.unixToWin)(patch);
+        } else if ((0, string_js_1.hasOnlyUnixLineEndings)(source) && (0, line_endings_js_1.isWin)(patch)) {
+          patch = (0, line_endings_js_1.winToUnix)(patch);
+        }
+      }
+      var lines = source.split("\n"), hunks = patch.hunks, compareLine = options.compareLine || (function(lineNumber, line2, operation, patchContent) {
+        return line2 === patchContent;
+      }), fuzzFactor = options.fuzzFactor || 0;
+      var minLine = 0;
       if (fuzzFactor < 0 || !Number.isInteger(fuzzFactor)) {
         throw new Error("fuzzFactor must be a non-negative integer");
       }
@@ -13534,11 +13401,19 @@ var require_apply = __commonJS({
           return false;
         }
       }
-      function applyHunk(hunkLines, toPos2, maxErrors2) {
-        var hunkLinesI = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 0;
-        var lastContextLineMatched = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : true;
-        var patchedLines = arguments.length > 5 && arguments[5] !== void 0 ? arguments[5] : [];
-        var patchedLinesLength = arguments.length > 6 && arguments[6] !== void 0 ? arguments[6] : 0;
+      function applyHunk(hunkLines, toPos2, maxErrors2, hunkLinesI, lastContextLineMatched, patchedLines, patchedLinesLength) {
+        if (hunkLinesI === void 0) {
+          hunkLinesI = 0;
+        }
+        if (lastContextLineMatched === void 0) {
+          lastContextLineMatched = true;
+        }
+        if (patchedLines === void 0) {
+          patchedLines = [];
+        }
+        if (patchedLinesLength === void 0) {
+          patchedLinesLength = 0;
+        }
         var nConsecutiveOldContextLines = 0;
         var nextContextLineMustMatch = false;
         for (; hunkLinesI < hunkLines.length; hunkLinesI++) {
@@ -13590,29 +13465,14 @@ var require_apply = __commonJS({
       }
       var resultLines = [];
       var prevHunkOffset = 0;
-      for (var _i = 0; _i < hunks.length; _i++) {
-        var hunk = hunks[_i];
-        var hunkResult = (
-          /*istanbul ignore start*/
-          void 0
-        );
+      for (var i = 0; i < hunks.length; i++) {
+        var hunk = hunks[i];
+        var hunkResult = void 0;
         var maxLine = lines.length - hunk.oldLines + fuzzFactor;
-        var toPos = (
-          /*istanbul ignore start*/
-          void 0
-        );
+        var toPos = void 0;
         for (var maxErrors = 0; maxErrors <= fuzzFactor; maxErrors++) {
           toPos = hunk.oldStart + prevHunkOffset - 1;
-          var iterator = (
-            /*istanbul ignore start*/
-            (0, /*istanbul ignore end*/
-            /*istanbul ignore start*/
-            _distanceIterator[
-              /*istanbul ignore start*/
-              "default"
-              /*istanbul ignore end*/
-            ])(toPos, minLine, maxLine)
-          );
+          var iterator = (0, distance_iterator_js_1.default)(toPos, minLine, maxLine);
           for (; toPos !== void 0; toPos = iterator()) {
             hunkResult = applyHunk(hunk.lines, toPos, maxErrors);
             if (hunkResult) {
@@ -13626,31 +13486,26 @@ var require_apply = __commonJS({
         if (!hunkResult) {
           return false;
         }
-        for (var _i2 = minLine; _i2 < toPos; _i2++) {
-          resultLines.push(lines[_i2]);
+        for (var i_1 = minLine; i_1 < toPos; i_1++) {
+          resultLines.push(lines[i_1]);
         }
-        for (var _i3 = 0; _i3 < hunkResult.patchedLines.length; _i3++) {
-          var _line = hunkResult.patchedLines[_i3];
-          resultLines.push(_line);
+        for (var i_2 = 0; i_2 < hunkResult.patchedLines.length; i_2++) {
+          var line = hunkResult.patchedLines[i_2];
+          resultLines.push(line);
         }
         minLine = hunkResult.oldLineLastI + 1;
         prevHunkOffset = toPos + 1 - hunk.oldStart;
       }
-      for (var _i4 = minLine; _i4 < lines.length; _i4++) {
-        resultLines.push(lines[_i4]);
+      for (var i = minLine; i < lines.length; i++) {
+        resultLines.push(lines[i]);
       }
       return resultLines.join("\n");
     }
     function applyPatches(uniDiff, options) {
-      if (typeof uniDiff === "string") {
-        uniDiff = /*istanbul ignore start*/
-        (0, /*istanbul ignore end*/
-        /*istanbul ignore start*/
-        _parse.parsePatch)(uniDiff);
-      }
+      var spDiff = typeof uniDiff === "string" ? (0, parse_js_1.parsePatch)(uniDiff) : uniDiff;
       var currentIndex = 0;
       function processIndex() {
-        var index = uniDiff[currentIndex++];
+        var index = spDiff[currentIndex++];
         if (!index) {
           return options.complete();
         }
@@ -13672,182 +13527,142 @@ var require_apply = __commonJS({
   }
 });
 
-// node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/patch/create.js
-var require_create = __commonJS({
-  "node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/patch/create.js"(exports2) {
+// node_modules/.pnpm/diff@8.0.4/node_modules/diff/libcjs/patch/reverse.js
+var require_reverse = __commonJS({
+  "node_modules/.pnpm/diff@8.0.4/node_modules/diff/libcjs/patch/reverse.js"(exports2) {
     "use strict";
-    Object.defineProperty(exports2, "__esModule", {
-      value: true
-    });
-    exports2.createPatch = createPatch;
-    exports2.createTwoFilesPatch = createTwoFilesPatch;
-    exports2.formatPatch = formatPatch;
-    exports2.structuredPatch = structuredPatch;
-    var _line = require_line();
-    function _typeof(o) {
-      "@babel/helpers - typeof";
-      return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
-        return typeof o2;
-      } : function(o2) {
-        return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
-      }, _typeof(o);
-    }
-    function _toConsumableArray(arr) {
-      return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
-    }
-    function _nonIterableSpread() {
-      throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-    }
-    function _unsupportedIterableToArray(o, minLen) {
-      if (!o) return;
-      if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-      var n = Object.prototype.toString.call(o).slice(8, -1);
-      if (n === "Object" && o.constructor) n = o.constructor.name;
-      if (n === "Map" || n === "Set") return Array.from(o);
-      if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
-    }
-    function _iterableToArray(iter) {
-      if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
-    }
-    function _arrayWithoutHoles(arr) {
-      if (Array.isArray(arr)) return _arrayLikeToArray(arr);
-    }
-    function _arrayLikeToArray(arr, len) {
-      if (len == null || len > arr.length) len = arr.length;
-      for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
-      return arr2;
-    }
-    function ownKeys(e, r) {
-      var t = Object.keys(e);
-      if (Object.getOwnPropertySymbols) {
-        var o = Object.getOwnPropertySymbols(e);
-        r && (o = o.filter(function(r2) {
-          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
-        })), t.push.apply(t, o);
-      }
-      return t;
-    }
-    function _objectSpread(e) {
-      for (var r = 1; r < arguments.length; r++) {
-        var t = null != arguments[r] ? arguments[r] : {};
-        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
-          _defineProperty(e, r2, t[r2]);
-        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
-          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
-        });
-      }
-      return e;
-    }
-    function _defineProperty(obj, key, value) {
-      key = _toPropertyKey(key);
-      if (key in obj) {
-        Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
-      } else {
-        obj[key] = value;
-      }
-      return obj;
-    }
-    function _toPropertyKey(t) {
-      var i = _toPrimitive(t, "string");
-      return "symbol" == _typeof(i) ? i : i + "";
-    }
-    function _toPrimitive(t, r) {
-      if ("object" != _typeof(t) || !t) return t;
-      var e = t[Symbol.toPrimitive];
-      if (void 0 !== e) {
-        var i = e.call(t, r || "default");
-        if ("object" != _typeof(i)) return i;
-        throw new TypeError("@@toPrimitive must return a primitive value.");
+    var __assign = exports2 && exports2.__assign || function() {
+      __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+          s = arguments[i];
+          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+            t[p] = s[p];
+        }
+        return t;
+      };
+      return __assign.apply(this, arguments);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.reversePatch = reversePatch;
+    function reversePatch(structuredPatch) {
+      if (Array.isArray(structuredPatch)) {
+        return structuredPatch.map(function(patch) {
+          return reversePatch(patch);
+        }).reverse();
       }
-      return ("string" === r ? String : Number)(t);
+      return __assign(__assign({}, structuredPatch), { oldFileName: structuredPatch.newFileName, oldHeader: structuredPatch.newHeader, newFileName: structuredPatch.oldFileName, newHeader: structuredPatch.oldHeader, hunks: structuredPatch.hunks.map(function(hunk) {
+        return {
+          oldLines: hunk.newLines,
+          oldStart: hunk.newStart,
+          newLines: hunk.oldLines,
+          newStart: hunk.oldStart,
+          lines: hunk.lines.map(function(l) {
+            if (l.startsWith("-")) {
+              return "+".concat(l.slice(1));
+            }
+            if (l.startsWith("+")) {
+              return "-".concat(l.slice(1));
+            }
+            return l;
+          })
+        };
+      }) });
     }
+  }
+});
+
+// node_modules/.pnpm/diff@8.0.4/node_modules/diff/libcjs/patch/create.js
+var require_create = __commonJS({
+  "node_modules/.pnpm/diff@8.0.4/node_modules/diff/libcjs/patch/create.js"(exports2) {
+    "use strict";
+    var __assign = exports2 && exports2.__assign || function() {
+      __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+          s = arguments[i];
+          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+            t[p] = s[p];
+        }
+        return t;
+      };
+      return __assign.apply(this, arguments);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.OMIT_HEADERS = exports2.FILE_HEADERS_ONLY = exports2.INCLUDE_HEADERS = void 0;
+    exports2.structuredPatch = structuredPatch;
+    exports2.formatPatch = formatPatch;
+    exports2.createTwoFilesPatch = createTwoFilesPatch;
+    exports2.createPatch = createPatch;
+    var line_js_1 = require_line();
+    exports2.INCLUDE_HEADERS = {
+      includeIndex: true,
+      includeUnderline: true,
+      includeFileHeaders: true
+    };
+    exports2.FILE_HEADERS_ONLY = {
+      includeIndex: false,
+      includeUnderline: false,
+      includeFileHeaders: true
+    };
+    exports2.OMIT_HEADERS = {
+      includeIndex: false,
+      includeUnderline: false,
+      includeFileHeaders: false
+    };
     function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
+      var optionsObj;
       if (!options) {
-        options = {};
-      }
-      if (typeof options === "function") {
-        options = {
-          callback: options
-        };
+        optionsObj = {};
+      } else if (typeof options === "function") {
+        optionsObj = { callback: options };
+      } else {
+        optionsObj = options;
       }
-      if (typeof options.context === "undefined") {
-        options.context = 4;
+      if (typeof optionsObj.context === "undefined") {
+        optionsObj.context = 4;
       }
-      if (options.newlineIsToken) {
+      var context = optionsObj.context;
+      if (optionsObj.newlineIsToken) {
         throw new Error("newlineIsToken may not be used with patch-generation functions, only with diffing functions");
       }
-      if (!options.callback) {
-        return diffLinesResultToPatch(
-          /*istanbul ignore start*/
-          (0, /*istanbul ignore end*/
-          /*istanbul ignore start*/
-          _line.diffLines)(oldStr, newStr, options)
-        );
+      if (!optionsObj.callback) {
+        return diffLinesResultToPatch((0, line_js_1.diffLines)(oldStr, newStr, optionsObj));
       } else {
-        var _options = (
-          /*istanbul ignore end*/
-          options
-        ), _callback = _options.callback;
-        (0, /*istanbul ignore end*/
-        /*istanbul ignore start*/
-        _line.diffLines)(
-          oldStr,
-          newStr,
-          /*istanbul ignore start*/
-          _objectSpread(_objectSpread(
-            {},
-            /*istanbul ignore end*/
-            options
-          ), {}, {
-            callback: function callback(diff) {
-              var patch = diffLinesResultToPatch(diff);
-              _callback(patch);
-            }
-          })
-        );
+        var callback_1 = optionsObj.callback;
+        (0, line_js_1.diffLines)(oldStr, newStr, __assign(__assign({}, optionsObj), { callback: function(diff) {
+          var patch = diffLinesResultToPatch(diff);
+          callback_1(patch);
+        } }));
       }
       function diffLinesResultToPatch(diff) {
         if (!diff) {
           return;
         }
-        diff.push({
-          value: "",
-          lines: []
-        });
-        function contextLines(lines) {
-          return lines.map(function(entry) {
+        diff.push({ value: "", lines: [] });
+        function contextLines(lines2) {
+          return lines2.map(function(entry) {
             return " " + entry;
           });
         }
         var hunks = [];
         var oldRangeStart = 0, newRangeStart = 0, curRange = [], oldLine = 1, newLine = 1;
-        var _loop = function _loop2() {
+        for (var i = 0; i < diff.length; i++) {
           var current = diff[i], lines = current.lines || splitLines(current.value);
           current.lines = lines;
           if (current.added || current.removed) {
-            var _curRange;
             if (!oldRangeStart) {
               var prev = diff[i - 1];
               oldRangeStart = oldLine;
               newRangeStart = newLine;
               if (prev) {
-                curRange = options.context > 0 ? contextLines(prev.lines.slice(-options.context)) : [];
+                curRange = context > 0 ? contextLines(prev.lines.slice(-context)) : [];
                 oldRangeStart -= curRange.length;
                 newRangeStart -= curRange.length;
               }
             }
-            (_curRange = /*istanbul ignore end*/
-            curRange).push.apply(
-              /*istanbul ignore start*/
-              _curRange,
-              /*istanbul ignore start*/
-              _toConsumableArray(
-                /*istanbul ignore end*/
-                lines.map(function(entry) {
-                  return (current.added ? "+" : "-") + entry;
-                })
-              )
-            );
+            for (var _i = 0, lines_1 = lines; _i < lines_1.length; _i++) {
+              var line = lines_1[_i];
+              curRange.push((current.added ? "+" : "-") + line);
+            }
             if (current.added) {
               newLine += lines.length;
             } else {
@@ -13855,39 +13670,25 @@ var require_create = __commonJS({
             }
           } else {
             if (oldRangeStart) {
-              if (lines.length <= options.context * 2 && i < diff.length - 2) {
-                var _curRange2;
-                (_curRange2 = /*istanbul ignore end*/
-                curRange).push.apply(
-                  /*istanbul ignore start*/
-                  _curRange2,
-                  /*istanbul ignore start*/
-                  _toConsumableArray(
-                    /*istanbul ignore end*/
-                    contextLines(lines)
-                  )
-                );
+              if (lines.length <= context * 2 && i < diff.length - 2) {
+                for (var _a = 0, _b = contextLines(lines); _a < _b.length; _a++) {
+                  var line = _b[_a];
+                  curRange.push(line);
+                }
               } else {
-                var _curRange3;
-                var contextSize = Math.min(lines.length, options.context);
-                (_curRange3 = /*istanbul ignore end*/
-                curRange).push.apply(
-                  /*istanbul ignore start*/
-                  _curRange3,
-                  /*istanbul ignore start*/
-                  _toConsumableArray(
-                    /*istanbul ignore end*/
-                    contextLines(lines.slice(0, contextSize))
-                  )
-                );
-                var _hunk = {
+                var contextSize = Math.min(lines.length, context);
+                for (var _c = 0, _d = contextLines(lines.slice(0, contextSize)); _c < _d.length; _c++) {
+                  var line = _d[_c];
+                  curRange.push(line);
+                }
+                var hunk = {
                   oldStart: oldRangeStart,
                   oldLines: oldLine - oldRangeStart + contextSize,
                   newStart: newRangeStart,
                   newLines: newLine - newRangeStart + contextSize,
                   lines: curRange
                 };
-                hunks.push(_hunk);
+                hunks.push(hunk);
                 oldRangeStart = 0;
                 newRangeStart = 0;
                 curRange = [];
@@ -13896,30 +13697,15 @@ var require_create = __commonJS({
             oldLine += lines.length;
             newLine += lines.length;
           }
-        };
-        for (var i = 0; i < diff.length; i++) {
-          _loop();
         }
-        for (
-          var _i = 0, _hunks = (
-            /*istanbul ignore end*/
-            hunks
-          );
-          /*istanbul ignore start*/
-          _i < _hunks.length;
-          /*istanbul ignore start*/
-          _i++
-        ) {
-          var hunk = (
-            /*istanbul ignore start*/
-            _hunks[_i]
-          );
-          for (var _i2 = 0; _i2 < hunk.lines.length; _i2++) {
-            if (hunk.lines[_i2].endsWith("\n")) {
-              hunk.lines[_i2] = hunk.lines[_i2].slice(0, -1);
+        for (var _e = 0, hunks_1 = hunks; _e < hunks_1.length; _e++) {
+          var hunk = hunks_1[_e];
+          for (var i = 0; i < hunk.lines.length; i++) {
+            if (hunk.lines[i].endsWith("\n")) {
+              hunk.lines[i] = hunk.lines[i].slice(0, -1);
             } else {
-              hunk.lines.splice(_i2 + 1, 0, "\");
-              _i2++;
+              hunk.lines.splice(i + 1, 0, "\");
+              i++;
             }
           }
         }
@@ -13932,19 +13718,31 @@ var require_create = __commonJS({
         };
       }
     }
-    function formatPatch(diff) {
-      if (Array.isArray(diff)) {
-        return diff.map(formatPatch).join("\n");
+    function formatPatch(patch, headerOptions) {
+      if (!headerOptions) {
+        headerOptions = exports2.INCLUDE_HEADERS;
+      }
+      if (Array.isArray(patch)) {
+        if (patch.length > 1 && !headerOptions.includeFileHeaders) {
+          throw new Error("Cannot omit file headers on a multi-file patch. (The result would be unparseable; how would a tool trying to apply the patch know which changes are to which file?)");
+        }
+        return patch.map(function(p) {
+          return formatPatch(p, headerOptions);
+        }).join("\n");
       }
       var ret = [];
-      if (diff.oldFileName == diff.newFileName) {
-        ret.push("Index: " + diff.oldFileName);
-      }
-      ret.push("===================================================================");
-      ret.push("--- " + diff.oldFileName + (typeof diff.oldHeader === "undefined" ? "" : "	" + diff.oldHeader));
-      ret.push("+++ " + diff.newFileName + (typeof diff.newHeader === "undefined" ? "" : "	" + diff.newHeader));
-      for (var i = 0; i < diff.hunks.length; i++) {
-        var hunk = diff.hunks[i];
+      if (headerOptions.includeIndex && patch.oldFileName == patch.newFileName) {
+        ret.push("Index: " + patch.oldFileName);
+      }
+      if (headerOptions.includeUnderline) {
+        ret.push("===================================================================");
+      }
+      if (headerOptions.includeFileHeaders) {
+        ret.push("--- " + patch.oldFileName + (typeof patch.oldHeader === "undefined" ? "" : "	" + patch.oldHeader));
+        ret.push("+++ " + patch.newFileName + (typeof patch.newHeader === "undefined" ? "" : "	" + patch.newHeader));
+      }
+      for (var i = 0; i < patch.hunks.length; i++) {
+        var hunk = patch.hunks[i];
         if (hunk.oldLines === 0) {
           hunk.oldStart -= 1;
         }
@@ -13952,53 +13750,32 @@ var require_create = __commonJS({
           hunk.newStart -= 1;
         }
         ret.push("@@ -" + hunk.oldStart + "," + hunk.oldLines + " +" + hunk.newStart + "," + hunk.newLines + " @@");
-        ret.push.apply(ret, hunk.lines);
+        for (var _i = 0, _a = hunk.lines; _i < _a.length; _i++) {
+          var line = _a[_i];
+          ret.push(line);
+        }
       }
       return ret.join("\n") + "\n";
     }
     function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
-      var _options2;
       if (typeof options === "function") {
-        options = {
-          callback: options
-        };
+        options = { callback: options };
       }
-      if (!/*istanbul ignore start*/
-      ((_options2 = /*istanbul ignore end*/
-      options) !== null && _options2 !== void 0 && /*istanbul ignore start*/
-      _options2.callback)) {
+      if (!(options === null || options === void 0 ? void 0 : options.callback)) {
         var patchObj = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options);
         if (!patchObj) {
           return;
         }
-        return formatPatch(patchObj);
+        return formatPatch(patchObj, options === null || options === void 0 ? void 0 : options.headerOptions);
       } else {
-        var _options3 = (
-          /*istanbul ignore end*/
-          options
-        ), _callback2 = _options3.callback;
-        structuredPatch(
-          oldFileName,
-          newFileName,
-          oldStr,
-          newStr,
-          oldHeader,
-          newHeader,
-          /*istanbul ignore start*/
-          _objectSpread(_objectSpread(
-            {},
-            /*istanbul ignore end*/
-            options
-          ), {}, {
-            callback: function callback(patchObj2) {
-              if (!patchObj2) {
-                _callback2();
-              } else {
-                _callback2(formatPatch(patchObj2));
-              }
-            }
-          })
-        );
+        var callback_2 = options.callback;
+        structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, __assign(__assign({}, options), { callback: function(patchObj2) {
+          if (!patchObj2) {
+            callback_2(void 0);
+          } else {
+            callback_2(formatPatch(patchObj2, options.headerOptions));
+          }
+        } }));
       }
     }
     function createPatch(fileName, oldStr, newStr, oldHeader, newHeader, options) {
@@ -14007,10 +13784,7 @@ var require_create = __commonJS({
     function splitLines(text) {
       var hasTrailingNl = text.endsWith("\n");
       var result = text.split("\n").map(function(line) {
-        return (
-          /*istanbul ignore end*/
-          line + "\n"
-        );
+        return line + "\n";
       });
       if (hasTrailingNl) {
         result.pop();
@@ -14022,576 +13796,15 @@ var require_create = __commonJS({
   }
 });
 
-// node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/util/array.js
-var require_array3 = __commonJS({
-  "node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/util/array.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", {
-      value: true
-    });
-    exports2.arrayEqual = arrayEqual;
-    exports2.arrayStartsWith = arrayStartsWith;
-    function arrayEqual(a, b) {
-      if (a.length !== b.length) {
-        return false;
-      }
-      return arrayStartsWith(a, b);
-    }
-    function arrayStartsWith(array, start) {
-      if (start.length > array.length) {
-        return false;
-      }
-      for (var i = 0; i < start.length; i++) {
-        if (start[i] !== array[i]) {
-          return false;
-        }
-      }
-      return true;
-    }
-  }
-});
-
-// node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/patch/merge.js
-var require_merge = __commonJS({
-  "node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/patch/merge.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", {
-      value: true
-    });
-    exports2.calcLineCount = calcLineCount;
-    exports2.merge = merge;
-    var _create = require_create();
-    var _parse = require_parse4();
-    var _array = require_array3();
-    function _toConsumableArray(arr) {
-      return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
-    }
-    function _nonIterableSpread() {
-      throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-    }
-    function _unsupportedIterableToArray(o, minLen) {
-      if (!o) return;
-      if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-      var n = Object.prototype.toString.call(o).slice(8, -1);
-      if (n === "Object" && o.constructor) n = o.constructor.name;
-      if (n === "Map" || n === "Set") return Array.from(o);
-      if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
-    }
-    function _iterableToArray(iter) {
-      if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
-    }
-    function _arrayWithoutHoles(arr) {
-      if (Array.isArray(arr)) return _arrayLikeToArray(arr);
-    }
-    function _arrayLikeToArray(arr, len) {
-      if (len == null || len > arr.length) len = arr.length;
-      for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
-      return arr2;
-    }
-    function calcLineCount(hunk) {
-      var _calcOldNewLineCount = (
-        /*istanbul ignore end*/
-        calcOldNewLineCount(hunk.lines)
-      ), oldLines = _calcOldNewLineCount.oldLines, newLines = _calcOldNewLineCount.newLines;
-      if (oldLines !== void 0) {
-        hunk.oldLines = oldLines;
-      } else {
-        delete hunk.oldLines;
-      }
-      if (newLines !== void 0) {
-        hunk.newLines = newLines;
-      } else {
-        delete hunk.newLines;
-      }
-    }
-    function merge(mine, theirs, base) {
-      mine = loadPatch(mine, base);
-      theirs = loadPatch(theirs, base);
-      var ret = {};
-      if (mine.index || theirs.index) {
-        ret.index = mine.index || theirs.index;
-      }
-      if (mine.newFileName || theirs.newFileName) {
-        if (!fileNameChanged(mine)) {
-          ret.oldFileName = theirs.oldFileName || mine.oldFileName;
-          ret.newFileName = theirs.newFileName || mine.newFileName;
-          ret.oldHeader = theirs.oldHeader || mine.oldHeader;
-          ret.newHeader = theirs.newHeader || mine.newHeader;
-        } else if (!fileNameChanged(theirs)) {
-          ret.oldFileName = mine.oldFileName;
-          ret.newFileName = mine.newFileName;
-          ret.oldHeader = mine.oldHeader;
-          ret.newHeader = mine.newHeader;
-        } else {
-          ret.oldFileName = selectField(ret, mine.oldFileName, theirs.oldFileName);
-          ret.newFileName = selectField(ret, mine.newFileName, theirs.newFileName);
-          ret.oldHeader = selectField(ret, mine.oldHeader, theirs.oldHeader);
-          ret.newHeader = selectField(ret, mine.newHeader, theirs.newHeader);
-        }
-      }
-      ret.hunks = [];
-      var mineIndex = 0, theirsIndex = 0, mineOffset = 0, theirsOffset = 0;
-      while (mineIndex < mine.hunks.length || theirsIndex < theirs.hunks.length) {
-        var mineCurrent = mine.hunks[mineIndex] || {
-          oldStart: Infinity
-        }, theirsCurrent = theirs.hunks[theirsIndex] || {
-          oldStart: Infinity
-        };
-        if (hunkBefore(mineCurrent, theirsCurrent)) {
-          ret.hunks.push(cloneHunk(mineCurrent, mineOffset));
-          mineIndex++;
-          theirsOffset += mineCurrent.newLines - mineCurrent.oldLines;
-        } else if (hunkBefore(theirsCurrent, mineCurrent)) {
-          ret.hunks.push(cloneHunk(theirsCurrent, theirsOffset));
-          theirsIndex++;
-          mineOffset += theirsCurrent.newLines - theirsCurrent.oldLines;
-        } else {
-          var mergedHunk = {
-            oldStart: Math.min(mineCurrent.oldStart, theirsCurrent.oldStart),
-            oldLines: 0,
-            newStart: Math.min(mineCurrent.newStart + mineOffset, theirsCurrent.oldStart + theirsOffset),
-            newLines: 0,
-            lines: []
-          };
-          mergeLines(mergedHunk, mineCurrent.oldStart, mineCurrent.lines, theirsCurrent.oldStart, theirsCurrent.lines);
-          theirsIndex++;
-          mineIndex++;
-          ret.hunks.push(mergedHunk);
-        }
-      }
-      return ret;
-    }
-    function loadPatch(param, base) {
-      if (typeof param === "string") {
-        if (/^@@/m.test(param) || /^Index:/m.test(param)) {
-          return (
-            /*istanbul ignore start*/
-            (0, /*istanbul ignore end*/
-            /*istanbul ignore start*/
-            _parse.parsePatch)(param)[0]
-          );
-        }
-        if (!base) {
-          throw new Error("Must provide a base reference or pass in a patch");
-        }
-        return (
-          /*istanbul ignore start*/
-          (0, /*istanbul ignore end*/
-          /*istanbul ignore start*/
-          _create.structuredPatch)(void 0, void 0, base, param)
-        );
-      }
-      return param;
-    }
-    function fileNameChanged(patch) {
-      return patch.newFileName && patch.newFileName !== patch.oldFileName;
-    }
-    function selectField(index, mine, theirs) {
-      if (mine === theirs) {
-        return mine;
-      } else {
-        index.conflict = true;
-        return {
-          mine,
-          theirs
-        };
-      }
-    }
-    function hunkBefore(test, check) {
-      return test.oldStart < check.oldStart && test.oldStart + test.oldLines < check.oldStart;
-    }
-    function cloneHunk(hunk, offset) {
-      return {
-        oldStart: hunk.oldStart,
-        oldLines: hunk.oldLines,
-        newStart: hunk.newStart + offset,
-        newLines: hunk.newLines,
-        lines: hunk.lines
-      };
-    }
-    function mergeLines(hunk, mineOffset, mineLines, theirOffset, theirLines) {
-      var mine = {
-        offset: mineOffset,
-        lines: mineLines,
-        index: 0
-      }, their = {
-        offset: theirOffset,
-        lines: theirLines,
-        index: 0
-      };
-      insertLeading(hunk, mine, their);
-      insertLeading(hunk, their, mine);
-      while (mine.index < mine.lines.length && their.index < their.lines.length) {
-        var mineCurrent = mine.lines[mine.index], theirCurrent = their.lines[their.index];
-        if ((mineCurrent[0] === "-" || mineCurrent[0] === "+") && (theirCurrent[0] === "-" || theirCurrent[0] === "+")) {
-          mutualChange(hunk, mine, their);
-        } else if (mineCurrent[0] === "+" && theirCurrent[0] === " ") {
-          var _hunk$lines;
-          (_hunk$lines = /*istanbul ignore end*/
-          hunk.lines).push.apply(
-            /*istanbul ignore start*/
-            _hunk$lines,
-            /*istanbul ignore start*/
-            _toConsumableArray(
-              /*istanbul ignore end*/
-              collectChange(mine)
-            )
-          );
-        } else if (theirCurrent[0] === "+" && mineCurrent[0] === " ") {
-          var _hunk$lines2;
-          (_hunk$lines2 = /*istanbul ignore end*/
-          hunk.lines).push.apply(
-            /*istanbul ignore start*/
-            _hunk$lines2,
-            /*istanbul ignore start*/
-            _toConsumableArray(
-              /*istanbul ignore end*/
-              collectChange(their)
-            )
-          );
-        } else if (mineCurrent[0] === "-" && theirCurrent[0] === " ") {
-          removal(hunk, mine, their);
-        } else if (theirCurrent[0] === "-" && mineCurrent[0] === " ") {
-          removal(hunk, their, mine, true);
-        } else if (mineCurrent === theirCurrent) {
-          hunk.lines.push(mineCurrent);
-          mine.index++;
-          their.index++;
-        } else {
-          conflict(hunk, collectChange(mine), collectChange(their));
-        }
-      }
-      insertTrailing(hunk, mine);
-      insertTrailing(hunk, their);
-      calcLineCount(hunk);
-    }
-    function mutualChange(hunk, mine, their) {
-      var myChanges = collectChange(mine), theirChanges = collectChange(their);
-      if (allRemoves(myChanges) && allRemoves(theirChanges)) {
-        if (
-          /*istanbul ignore start*/
-          (0, /*istanbul ignore end*/
-          /*istanbul ignore start*/
-          _array.arrayStartsWith)(myChanges, theirChanges) && skipRemoveSuperset(their, myChanges, myChanges.length - theirChanges.length)
-        ) {
-          var _hunk$lines3;
-          (_hunk$lines3 = /*istanbul ignore end*/
-          hunk.lines).push.apply(
-            /*istanbul ignore start*/
-            _hunk$lines3,
-            /*istanbul ignore start*/
-            _toConsumableArray(
-              /*istanbul ignore end*/
-              myChanges
-            )
-          );
-          return;
-        } else if (
-          /*istanbul ignore start*/
-          (0, /*istanbul ignore end*/
-          /*istanbul ignore start*/
-          _array.arrayStartsWith)(theirChanges, myChanges) && skipRemoveSuperset(mine, theirChanges, theirChanges.length - myChanges.length)
-        ) {
-          var _hunk$lines4;
-          (_hunk$lines4 = /*istanbul ignore end*/
-          hunk.lines).push.apply(
-            /*istanbul ignore start*/
-            _hunk$lines4,
-            /*istanbul ignore start*/
-            _toConsumableArray(
-              /*istanbul ignore end*/
-              theirChanges
-            )
-          );
-          return;
-        }
-      } else if (
-        /*istanbul ignore start*/
-        (0, /*istanbul ignore end*/
-        /*istanbul ignore start*/
-        _array.arrayEqual)(myChanges, theirChanges)
-      ) {
-        var _hunk$lines5;
-        (_hunk$lines5 = /*istanbul ignore end*/
-        hunk.lines).push.apply(
-          /*istanbul ignore start*/
-          _hunk$lines5,
-          /*istanbul ignore start*/
-          _toConsumableArray(
-            /*istanbul ignore end*/
-            myChanges
-          )
-        );
-        return;
-      }
-      conflict(hunk, myChanges, theirChanges);
-    }
-    function removal(hunk, mine, their, swap) {
-      var myChanges = collectChange(mine), theirChanges = collectContext(their, myChanges);
-      if (theirChanges.merged) {
-        var _hunk$lines6;
-        (_hunk$lines6 = /*istanbul ignore end*/
-        hunk.lines).push.apply(
-          /*istanbul ignore start*/
-          _hunk$lines6,
-          /*istanbul ignore start*/
-          _toConsumableArray(
-            /*istanbul ignore end*/
-            theirChanges.merged
-          )
-        );
-      } else {
-        conflict(hunk, swap ? theirChanges : myChanges, swap ? myChanges : theirChanges);
-      }
-    }
-    function conflict(hunk, mine, their) {
-      hunk.conflict = true;
-      hunk.lines.push({
-        conflict: true,
-        mine,
-        theirs: their
-      });
-    }
-    function insertLeading(hunk, insert, their) {
-      while (insert.offset < their.offset && insert.index < insert.lines.length) {
-        var line = insert.lines[insert.index++];
-        hunk.lines.push(line);
-        insert.offset++;
-      }
-    }
-    function insertTrailing(hunk, insert) {
-      while (insert.index < insert.lines.length) {
-        var line = insert.lines[insert.index++];
-        hunk.lines.push(line);
-      }
-    }
-    function collectChange(state) {
-      var ret = [], operation = state.lines[state.index][0];
-      while (state.index < state.lines.length) {
-        var line = state.lines[state.index];
-        if (operation === "-" && line[0] === "+") {
-          operation = "+";
-        }
-        if (operation === line[0]) {
-          ret.push(line);
-          state.index++;
-        } else {
-          break;
-        }
-      }
-      return ret;
-    }
-    function collectContext(state, matchChanges) {
-      var changes = [], merged = [], matchIndex = 0, contextChanges = false, conflicted = false;
-      while (matchIndex < matchChanges.length && state.index < state.lines.length) {
-        var change = state.lines[state.index], match = matchChanges[matchIndex];
-        if (match[0] === "+") {
-          break;
-        }
-        contextChanges = contextChanges || change[0] !== " ";
-        merged.push(match);
-        matchIndex++;
-        if (change[0] === "+") {
-          conflicted = true;
-          while (change[0] === "+") {
-            changes.push(change);
-            change = state.lines[++state.index];
-          }
-        }
-        if (match.substr(1) === change.substr(1)) {
-          changes.push(change);
-          state.index++;
-        } else {
-          conflicted = true;
-        }
-      }
-      if ((matchChanges[matchIndex] || "")[0] === "+" && contextChanges) {
-        conflicted = true;
-      }
-      if (conflicted) {
-        return changes;
-      }
-      while (matchIndex < matchChanges.length) {
-        merged.push(matchChanges[matchIndex++]);
-      }
-      return {
-        merged,
-        changes
-      };
-    }
-    function allRemoves(changes) {
-      return changes.reduce(function(prev, change) {
-        return prev && change[0] === "-";
-      }, true);
-    }
-    function skipRemoveSuperset(state, removeChanges, delta) {
-      for (var i = 0; i < delta; i++) {
-        var changeContent = removeChanges[removeChanges.length - delta + i].substr(1);
-        if (state.lines[state.index + i] !== " " + changeContent) {
-          return false;
-        }
-      }
-      state.index += delta;
-      return true;
-    }
-    function calcOldNewLineCount(lines) {
-      var oldLines = 0;
-      var newLines = 0;
-      lines.forEach(function(line) {
-        if (typeof line !== "string") {
-          var myCount = calcOldNewLineCount(line.mine);
-          var theirCount = calcOldNewLineCount(line.theirs);
-          if (oldLines !== void 0) {
-            if (myCount.oldLines === theirCount.oldLines) {
-              oldLines += myCount.oldLines;
-            } else {
-              oldLines = void 0;
-            }
-          }
-          if (newLines !== void 0) {
-            if (myCount.newLines === theirCount.newLines) {
-              newLines += myCount.newLines;
-            } else {
-              newLines = void 0;
-            }
-          }
-        } else {
-          if (newLines !== void 0 && (line[0] === "+" || line[0] === " ")) {
-            newLines++;
-          }
-          if (oldLines !== void 0 && (line[0] === "-" || line[0] === " ")) {
-            oldLines++;
-          }
-        }
-      });
-      return {
-        oldLines,
-        newLines
-      };
-    }
-  }
-});
-
-// node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/patch/reverse.js
-var require_reverse = __commonJS({
-  "node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/patch/reverse.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", {
-      value: true
-    });
-    exports2.reversePatch = reversePatch;
-    function _typeof(o) {
-      "@babel/helpers - typeof";
-      return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
-        return typeof o2;
-      } : function(o2) {
-        return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
-      }, _typeof(o);
-    }
-    function ownKeys(e, r) {
-      var t = Object.keys(e);
-      if (Object.getOwnPropertySymbols) {
-        var o = Object.getOwnPropertySymbols(e);
-        r && (o = o.filter(function(r2) {
-          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
-        })), t.push.apply(t, o);
-      }
-      return t;
-    }
-    function _objectSpread(e) {
-      for (var r = 1; r < arguments.length; r++) {
-        var t = null != arguments[r] ? arguments[r] : {};
-        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
-          _defineProperty(e, r2, t[r2]);
-        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
-          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
-        });
-      }
-      return e;
-    }
-    function _defineProperty(obj, key, value) {
-      key = _toPropertyKey(key);
-      if (key in obj) {
-        Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
-      } else {
-        obj[key] = value;
-      }
-      return obj;
-    }
-    function _toPropertyKey(t) {
-      var i = _toPrimitive(t, "string");
-      return "symbol" == _typeof(i) ? i : i + "";
-    }
-    function _toPrimitive(t, r) {
-      if ("object" != _typeof(t) || !t) return t;
-      var e = t[Symbol.toPrimitive];
-      if (void 0 !== e) {
-        var i = e.call(t, r || "default");
-        if ("object" != _typeof(i)) return i;
-        throw new TypeError("@@toPrimitive must return a primitive value.");
-      }
-      return ("string" === r ? String : Number)(t);
-    }
-    function reversePatch(structuredPatch) {
-      if (Array.isArray(structuredPatch)) {
-        return structuredPatch.map(reversePatch).reverse();
-      }
-      return (
-        /*istanbul ignore start*/
-        _objectSpread(_objectSpread(
-          {},
-          /*istanbul ignore end*/
-          structuredPatch
-        ), {}, {
-          oldFileName: structuredPatch.newFileName,
-          oldHeader: structuredPatch.newHeader,
-          newFileName: structuredPatch.oldFileName,
-          newHeader: structuredPatch.oldHeader,
-          hunks: structuredPatch.hunks.map(function(hunk) {
-            return {
-              oldLines: hunk.newLines,
-              oldStart: hunk.newStart,
-              newLines: hunk.oldLines,
-              newStart: hunk.oldStart,
-              lines: hunk.lines.map(function(l) {
-                if (l.startsWith("-")) {
-                  return (
-                    /*istanbul ignore start*/
-                    "+".concat(
-                      /*istanbul ignore end*/
-                      l.slice(1)
-                    )
-                  );
-                }
-                if (l.startsWith("+")) {
-                  return (
-                    /*istanbul ignore start*/
-                    "-".concat(
-                      /*istanbul ignore end*/
-                      l.slice(1)
-                    )
-                  );
-                }
-                return l;
-              })
-            };
-          })
-        })
-      );
-    }
-  }
-});
-
-// node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/convert/dmp.js
+// node_modules/.pnpm/diff@8.0.4/node_modules/diff/libcjs/convert/dmp.js
 var require_dmp = __commonJS({
-  "node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/convert/dmp.js"(exports2) {
+  "node_modules/.pnpm/diff@8.0.4/node_modules/diff/libcjs/convert/dmp.js"(exports2) {
     "use strict";
-    Object.defineProperty(exports2, "__esModule", {
-      value: true
-    });
+    Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.convertChangesToDMP = convertChangesToDMP;
     function convertChangesToDMP(changes) {
-      var ret = [], change, operation;
+      var ret = [];
+      var change, operation;
       for (var i = 0; i < changes.length; i++) {
         change = changes[i];
         if (change.added) {
@@ -14608,13 +13821,11 @@ var require_dmp = __commonJS({
   }
 });
 
-// node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/convert/xml.js
+// node_modules/.pnpm/diff@8.0.4/node_modules/diff/libcjs/convert/xml.js
 var require_xml = __commonJS({
-  "node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/convert/xml.js"(exports2) {
+  "node_modules/.pnpm/diff@8.0.4/node_modules/diff/libcjs/convert/xml.js"(exports2) {
     "use strict";
-    Object.defineProperty(exports2, "__esModule", {
-      value: true
-    });
+    Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.convertChangesToXML = convertChangesToXML;
     function convertChangesToXML(changes) {
       var ret = [];
@@ -14645,163 +13856,120 @@ var require_xml = __commonJS({
   }
 });
 
-// node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/index.js
-var require_lib = __commonJS({
-  "node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/index.js"(exports2) {
+// node_modules/.pnpm/diff@8.0.4/node_modules/diff/libcjs/index.js
+var require_libcjs = __commonJS({
+  "node_modules/.pnpm/diff@8.0.4/node_modules/diff/libcjs/index.js"(exports2) {
     "use strict";
-    Object.defineProperty(exports2, "__esModule", {
-      value: true
-    });
-    Object.defineProperty(exports2, "Diff", {
-      enumerable: true,
-      get: function get() {
-        return _base["default"];
-      }
-    });
-    Object.defineProperty(exports2, "applyPatch", {
-      enumerable: true,
-      get: function get() {
-        return _apply.applyPatch;
-      }
-    });
-    Object.defineProperty(exports2, "applyPatches", {
-      enumerable: true,
-      get: function get() {
-        return _apply.applyPatches;
-      }
-    });
-    Object.defineProperty(exports2, "canonicalize", {
-      enumerable: true,
-      get: function get() {
-        return _json.canonicalize;
-      }
-    });
-    Object.defineProperty(exports2, "convertChangesToDMP", {
-      enumerable: true,
-      get: function get() {
-        return _dmp.convertChangesToDMP;
-      }
-    });
-    Object.defineProperty(exports2, "convertChangesToXML", {
-      enumerable: true,
-      get: function get() {
-        return _xml.convertChangesToXML;
-      }
-    });
-    Object.defineProperty(exports2, "createPatch", {
-      enumerable: true,
-      get: function get() {
-        return _create.createPatch;
-      }
-    });
-    Object.defineProperty(exports2, "createTwoFilesPatch", {
-      enumerable: true,
-      get: function get() {
-        return _create.createTwoFilesPatch;
-      }
-    });
-    Object.defineProperty(exports2, "diffArrays", {
-      enumerable: true,
-      get: function get() {
-        return _array.diffArrays;
-      }
-    });
-    Object.defineProperty(exports2, "diffChars", {
-      enumerable: true,
-      get: function get() {
-        return _character.diffChars;
-      }
-    });
-    Object.defineProperty(exports2, "diffCss", {
-      enumerable: true,
-      get: function get() {
-        return _css.diffCss;
-      }
-    });
-    Object.defineProperty(exports2, "diffJson", {
-      enumerable: true,
-      get: function get() {
-        return _json.diffJson;
-      }
-    });
-    Object.defineProperty(exports2, "diffLines", {
-      enumerable: true,
-      get: function get() {
-        return _line.diffLines;
-      }
-    });
-    Object.defineProperty(exports2, "diffSentences", {
-      enumerable: true,
-      get: function get() {
-        return _sentence.diffSentences;
-      }
-    });
-    Object.defineProperty(exports2, "diffTrimmedLines", {
-      enumerable: true,
-      get: function get() {
-        return _line.diffTrimmedLines;
-      }
-    });
-    Object.defineProperty(exports2, "diffWords", {
-      enumerable: true,
-      get: function get() {
-        return _word.diffWords;
-      }
-    });
-    Object.defineProperty(exports2, "diffWordsWithSpace", {
-      enumerable: true,
-      get: function get() {
-        return _word.diffWordsWithSpace;
-      }
-    });
-    Object.defineProperty(exports2, "formatPatch", {
-      enumerable: true,
-      get: function get() {
-        return _create.formatPatch;
-      }
-    });
-    Object.defineProperty(exports2, "merge", {
-      enumerable: true,
-      get: function get() {
-        return _merge.merge;
-      }
-    });
-    Object.defineProperty(exports2, "parsePatch", {
-      enumerable: true,
-      get: function get() {
-        return _parse.parsePatch;
-      }
-    });
-    Object.defineProperty(exports2, "reversePatch", {
-      enumerable: true,
-      get: function get() {
-        return _reverse.reversePatch;
-      }
-    });
-    Object.defineProperty(exports2, "structuredPatch", {
-      enumerable: true,
-      get: function get() {
-        return _create.structuredPatch;
-      }
-    });
-    var _base = _interopRequireDefault(require_base());
-    var _character = require_character();
-    var _word = require_word();
-    var _line = require_line();
-    var _sentence = require_sentence();
-    var _css = require_css();
-    var _json = require_json();
-    var _array = require_array2();
-    var _apply = require_apply();
-    var _parse = require_parse4();
-    var _merge = require_merge();
-    var _reverse = require_reverse();
-    var _create = require_create();
-    var _dmp = require_dmp();
-    var _xml = require_xml();
-    function _interopRequireDefault(obj) {
-      return obj && obj.__esModule ? obj : { "default": obj };
-    }
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.canonicalize = exports2.convertChangesToXML = exports2.convertChangesToDMP = exports2.reversePatch = exports2.parsePatch = exports2.applyPatches = exports2.applyPatch = exports2.OMIT_HEADERS = exports2.FILE_HEADERS_ONLY = exports2.INCLUDE_HEADERS = exports2.formatPatch = exports2.createPatch = exports2.createTwoFilesPatch = exports2.structuredPatch = exports2.arrayDiff = exports2.diffArrays = exports2.jsonDiff = exports2.diffJson = exports2.cssDiff = exports2.diffCss = exports2.sentenceDiff = exports2.diffSentences = exports2.diffTrimmedLines = exports2.lineDiff = exports2.diffLines = exports2.wordsWithSpaceDiff = exports2.diffWordsWithSpace = exports2.wordDiff = exports2.diffWords = exports2.characterDiff = exports2.diffChars = exports2.Diff = void 0;
+    var base_js_1 = require_base();
+    exports2.Diff = base_js_1.default;
+    var character_js_1 = require_character();
+    Object.defineProperty(exports2, "diffChars", { enumerable: true, get: function() {
+      return character_js_1.diffChars;
+    } });
+    Object.defineProperty(exports2, "characterDiff", { enumerable: true, get: function() {
+      return character_js_1.characterDiff;
+    } });
+    var word_js_1 = require_word();
+    Object.defineProperty(exports2, "diffWords", { enumerable: true, get: function() {
+      return word_js_1.diffWords;
+    } });
+    Object.defineProperty(exports2, "diffWordsWithSpace", { enumerable: true, get: function() {
+      return word_js_1.diffWordsWithSpace;
+    } });
+    Object.defineProperty(exports2, "wordDiff", { enumerable: true, get: function() {
+      return word_js_1.wordDiff;
+    } });
+    Object.defineProperty(exports2, "wordsWithSpaceDiff", { enumerable: true, get: function() {
+      return word_js_1.wordsWithSpaceDiff;
+    } });
+    var line_js_1 = require_line();
+    Object.defineProperty(exports2, "diffLines", { enumerable: true, get: function() {
+      return line_js_1.diffLines;
+    } });
+    Object.defineProperty(exports2, "diffTrimmedLines", { enumerable: true, get: function() {
+      return line_js_1.diffTrimmedLines;
+    } });
+    Object.defineProperty(exports2, "lineDiff", { enumerable: true, get: function() {
+      return line_js_1.lineDiff;
+    } });
+    var sentence_js_1 = require_sentence();
+    Object.defineProperty(exports2, "diffSentences", { enumerable: true, get: function() {
+      return sentence_js_1.diffSentences;
+    } });
+    Object.defineProperty(exports2, "sentenceDiff", { enumerable: true, get: function() {
+      return sentence_js_1.sentenceDiff;
+    } });
+    var css_js_1 = require_css();
+    Object.defineProperty(exports2, "diffCss", { enumerable: true, get: function() {
+      return css_js_1.diffCss;
+    } });
+    Object.defineProperty(exports2, "cssDiff", { enumerable: true, get: function() {
+      return css_js_1.cssDiff;
+    } });
+    var json_js_1 = require_json();
+    Object.defineProperty(exports2, "diffJson", { enumerable: true, get: function() {
+      return json_js_1.diffJson;
+    } });
+    Object.defineProperty(exports2, "canonicalize", { enumerable: true, get: function() {
+      return json_js_1.canonicalize;
+    } });
+    Object.defineProperty(exports2, "jsonDiff", { enumerable: true, get: function() {
+      return json_js_1.jsonDiff;
+    } });
+    var array_js_1 = require_array2();
+    Object.defineProperty(exports2, "diffArrays", { enumerable: true, get: function() {
+      return array_js_1.diffArrays;
+    } });
+    Object.defineProperty(exports2, "arrayDiff", { enumerable: true, get: function() {
+      return array_js_1.arrayDiff;
+    } });
+    var apply_js_1 = require_apply();
+    Object.defineProperty(exports2, "applyPatch", { enumerable: true, get: function() {
+      return apply_js_1.applyPatch;
+    } });
+    Object.defineProperty(exports2, "applyPatches", { enumerable: true, get: function() {
+      return apply_js_1.applyPatches;
+    } });
+    var parse_js_1 = require_parse4();
+    Object.defineProperty(exports2, "parsePatch", { enumerable: true, get: function() {
+      return parse_js_1.parsePatch;
+    } });
+    var reverse_js_1 = require_reverse();
+    Object.defineProperty(exports2, "reversePatch", { enumerable: true, get: function() {
+      return reverse_js_1.reversePatch;
+    } });
+    var create_js_1 = require_create();
+    Object.defineProperty(exports2, "structuredPatch", { enumerable: true, get: function() {
+      return create_js_1.structuredPatch;
+    } });
+    Object.defineProperty(exports2, "createTwoFilesPatch", { enumerable: true, get: function() {
+      return create_js_1.createTwoFilesPatch;
+    } });
+    Object.defineProperty(exports2, "createPatch", { enumerable: true, get: function() {
+      return create_js_1.createPatch;
+    } });
+    Object.defineProperty(exports2, "formatPatch", { enumerable: true, get: function() {
+      return create_js_1.formatPatch;
+    } });
+    Object.defineProperty(exports2, "INCLUDE_HEADERS", { enumerable: true, get: function() {
+      return create_js_1.INCLUDE_HEADERS;
+    } });
+    Object.defineProperty(exports2, "FILE_HEADERS_ONLY", { enumerable: true, get: function() {
+      return create_js_1.FILE_HEADERS_ONLY;
+    } });
+    Object.defineProperty(exports2, "OMIT_HEADERS", { enumerable: true, get: function() {
+      return create_js_1.OMIT_HEADERS;
+    } });
+    var dmp_js_1 = require_dmp();
+    Object.defineProperty(exports2, "convertChangesToDMP", { enumerable: true, get: function() {
+      return dmp_js_1.convertChangesToDMP;
+    } });
+    var xml_js_1 = require_xml();
+    Object.defineProperty(exports2, "convertChangesToXML", { enumerable: true, get: function() {
+      return xml_js_1.convertChangesToXML;
+    } });
   }
 });
 
@@ -15783,7 +14951,7 @@ var require_install = __commonJS({
     var fg = require_out4();
     var { z } = require_zod();
     var semver = require_semver2();
-    var { createTwoFilesPatch } = require_lib();
+    var { createTwoFilesPatch } = require_libcjs();
     var clack = require_dist3();
     var ok = (s) => pc.green("\u2713") + " " + s;
     var fail = (s) => pc.red("\u2717") + " " + s;
@@ -15849,7 +15017,10 @@ var require_install = __commonJS({
         // #252 — skip update-notifier check
         noUpdateCheck: false,
         // #381 — skip backup tarball on --force-overwrite (CI escape hatch)
-        noBackup: false
+        noBackup: false,
+        // #199 — git pre-commit hook. null = install if .git/ present (default).
+        // Set false by --no-git-hooks, true by --git-hooks.
+        gitHooks: null
       };
       const positional = [];
       for (let i = 0; i < argv.length; i++) {
@@ -15875,6 +15046,8 @@ var require_install = __commonJS({
         else if (arg === "--accept-all") opts.acceptAll = true;
         else if (arg === "--no-update-check") opts.noUpdateCheck = true;
         else if (arg === "--no-backup") opts.noBackup = true;
+        else if (arg === "--no-git-hooks") opts.gitHooks = false;
+        else if (arg === "--git-hooks") opts.gitHooks = true;
         else if (!arg.startsWith("--")) positional.push(arg);
       }
       if (positional[0]) {
@@ -16048,7 +15221,7 @@ Installs (IDE-specific):
         case "claude":
           return {
             agentsDir: path2.join(target, ".claude", "agents"),
-            commandsDir: path2.join(target, ".claude", "commands", "rihal"),
+            commandsDir: path2.join(target, ".claude", "commands"),
             workflowsDir: path2.join(target, ".rihal", "workflows"),
             referencesDir: path2.join(target, ".rihal", "references"),
             binDir: path2.join(target, ".rihal", "bin")
@@ -16299,6 +15472,67 @@ Say "plan a sprint" or run \`/rihal-sprint-planning\` to break Phase 01 into sto
         return { action: "skipped-error", error: err.message };
       }
     }
+    function ensureRcodePreCommitHook(target, options = {}) {
+      if (options.gitHooks === false) return { action: "skipped-flag" };
+      const gitDir = path2.join(target, ".git");
+      if (!fs2.existsSync(gitDir) || !fs2.statSync(gitDir).isDirectory()) {
+        return { action: "skipped-no-git" };
+      }
+      const BEGIN = "# ===== rcode-managed pre-commit block =====";
+      const END = "# ===== end rcode pre-commit block =====";
+      const BLOCK = [
+        "",
+        BEGIN,
+        "# Auto-syncs .rihal/state.json when planning files change.",
+        "# Added by rcode install \u2014 safe to re-run (idempotent).",
+        'if git diff --cached --name-only | grep -qE "^\\.planning/|^\\.rihal/brain/sources\\.yaml$"; then',
+        "  if [ -x .rihal/bin/rihal-tools.cjs ]; then",
+        "    node .rihal/bin/rihal-tools.cjs state sync --from-disk > /dev/null 2>&1 || true",
+        "    git add .rihal/state.json 2>/dev/null || true",
+        "  fi",
+        "fi",
+        END,
+        ""
+      ].join("\n");
+      const hooksDir = path2.join(gitDir, "hooks");
+      const hookPath = path2.join(hooksDir, "pre-commit");
+      try {
+        let spliceBlock2 = function(text, newBlock) {
+          const start = text.indexOf(BEGIN);
+          if (start < 0) return null;
+          const endIdx = text.indexOf(END, start);
+          if (endIdx < 0) return null;
+          let sliceStart = start;
+          if (sliceStart > 0 && text[sliceStart - 1] === "\n") sliceStart -= 1;
+          let sliceEnd = endIdx + END.length;
+          if (text[sliceEnd] === "\n") sliceEnd += 1;
+          return text.slice(0, sliceStart) + newBlock + text.slice(sliceEnd);
+        };
+        var spliceBlock = spliceBlock2;
+        fs2.mkdirSync(hooksDir, { recursive: true });
+        if (!fs2.existsSync(hookPath)) {
+          fs2.writeFileSync(hookPath, `#!/bin/sh
+${BLOCK}`);
+          fs2.chmodSync(hookPath, 493);
+          return { action: "created" };
+        }
+        const existing = fs2.readFileSync(hookPath, "utf8");
+        if (existing.includes(BEGIN)) {
+          const rewritten = spliceBlock2(existing, BLOCK);
+          if (rewritten !== null && rewritten !== existing) {
+            fs2.writeFileSync(hookPath, rewritten);
+            fs2.chmodSync(hookPath, 493);
+            return { action: "updated" };
+          }
+          return { action: "already-present" };
+        }
+        fs2.writeFileSync(hookPath, existing + BLOCK);
+        fs2.chmodSync(hookPath, 493);
+        return { action: "appended" };
+      } catch (err) {
+        return { action: "skipped-error", error: err.message };
+      }
+    }
     function installBrainScaffold(packageRoot, target) {
       const srcDir = path2.join(packageRoot, "rihal", "brain");
       const destDir = path2.join(target, ".rihal", "brain");
@@ -16433,7 +15667,8 @@ Say "plan a sprint" or run \`/rihal-sprint-planning\` to break Phase 01 into sto
       for (const f of walkFiles(path2.join(SOURCE_ROOT, "commands"))) {
         const rel = path2.relative(path2.join(SOURCE_ROOT, "commands"), f);
         const ext = ide === "cursor" ? ".mdc" : ".md";
-        const outName = path2.basename(f, ".md") + ext;
+        const baseName = path2.basename(f, ".md");
+        const outName = ide === "claude" ? `rihal-${baseName}${ext}` : baseName + ext;
         plan.push({ src: f, rel: path2.join(relCommands, path2.dirname(rel), outName), ide, cursor: ide === "cursor" });
       }
       const agentRulesDir = path2.join(target, ".rihal", "agents-rules");
@@ -16490,7 +15725,7 @@ Say "plan a sprint" or run \`/rihal-sprint-planning\` to break Phase 01 into sto
         }
         for (const a of mod.agents) allowed.add(path2.join(".claude", "agents", a));
         for (const w of mod.workflows) allowed.add(path2.join(".rihal", "workflows", w));
-        for (const c of mod.commands) allowed.add(path2.join(".claude", "commands", "rihal", c));
+        for (const c of mod.commands) allowed.add(path2.join(".claude", "commands", `rihal-${c}`));
         for (const r of mod.references) allowed.add(path2.join(".rihal", "references", r));
       }
       return plan.filter((entry) => {
@@ -17051,6 +16286,7 @@ Say "plan a sprint" or run \`/rihal-sprint-planning\` to break Phase 01 into sto
       const starterSeeded = seedStarterPlanning(opts.target, opts.projectName);
       installBrainScaffold(PACKAGE_ROOT2, opts.target);
       const gitignoreReport = ensureRcodeGitignore(opts.target, { commitPlanning: opts.commitPlanning });
+      const hookReport = ensureRcodePreCommitHook(opts.target, { gitHooks: opts.gitHooks });
       let brainReport = null;
       try {
         const { execFileSync } = require("child_process");
@@ -17091,6 +16327,18 @@ Say "plan a sprint" or run \`/rihal-sprint-planning\` to break Phase 01 into sto
         }[gitignoreReport.action] || ".gitignore unchanged";
         console.log("  " + dim(gitMsg));
       }
+      if (hookReport) {
+        const hookMsg = {
+          "created": "pre-commit hook installed (.git/hooks/pre-commit)",
+          "appended": "pre-commit hook updated \u2014 rcode block appended",
+          "already-present": "pre-commit hook rcode block already present",
+          "updated": "pre-commit hook rcode block refreshed",
+          "skipped-flag": "pre-commit hook skipped (--no-git-hooks)",
+          "skipped-no-git": "pre-commit hook skipped (no .git/ directory)",
+          "skipped-error": `pre-commit hook skipped (${hookReport.error})`
+        }[hookReport.action] || "pre-commit hook unchanged";
+        console.log("  " + dim(hookMsg));
+      }
       if (skipped > 0) console.log("  " + dim(`${skipped} files skipped (unchanged)`));
       if (preserved > 0 && opts.nonDestructive) {
         console.log("");
@@ -17121,7 +16369,11 @@ Say "plan a sprint" or run \`/rihal-sprint-planning\` to break Phase 01 into sto
           agentCount = fs2.readdirSync(agentsDir).filter((f) => (f.startsWith("rihal-") || f.startsWith("rcode-")) && (f.endsWith(".md") || f.endsWith(".mdc"))).length;
         }
         if (fs2.existsSync(commandsDir)) {
-          commandCount = fs2.readdirSync(commandsDir).filter((f) => f.endsWith(".md") || f.endsWith(".mdc")).length;
+          commandCount = fs2.readdirSync(commandsDir).filter((f) => f.startsWith("rihal-") && (f.endsWith(".md") || f.endsWith(".mdc"))).length;
+        }
+        const legacyColonDir = path2.join(opts.target, ".claude", "commands", "rihal");
+        if (primaryIde === "claude" && fs2.existsSync(legacyColonDir)) {
+          fs2.rmSync(legacyColonDir, { recursive: true, force: true });
         }
       } catch {
       }
@@ -18553,6 +17805,11 @@ var require_uninstall = __commonJS({
         console.log(`\u2139  .rihal/ state was preserved. /rihal-init will detect this on reinstall.`);
         console.log(`   For a fully clean slate next time, use: rcode uninstall --purge`);
       }
+      console.log();
+      console.log(`\u{1F4A1} IDE reload required:`);
+      console.log(`   VS Code / Cursor: Cmd+Shift+P \u2192 "Developer: Reload Window"`);
+      console.log(`   If commands still appear after reload, check ~/.claude/commands/ for`);
+      console.log(`   any globally-installed rihal-* items (rcode does not touch global installs).`);
       console.log(`
 To reinstall later:`);
       console.log(`   rcode install`);