@eggjs/mock 6.0.6 → 6.1.0-beta.10

package/dist/node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/patch/line-endings.js

@@ -0,0 +1,137 @@
+import { __commonJS } from "../../../../../../../_virtual/rolldown_runtime.js";
+
+//#region ../../node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/patch/line-endings.js
+var require_line_endings = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/patch/line-endings.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.isUnix = isUnix;
+	exports.isWin = isWin;
+	exports.unixToWin = unixToWin;
+	exports.winToUnix = winToUnix;
+	function _typeof(o) {
+		"@babel/helpers - typeof";
+		return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
+			return typeof o$1;
+		} : function(o$1) {
+			return o$1 && "function" == typeof Symbol && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
+		}, _typeof(o);
+	}
+	function ownKeys(e, r) {
+		var t = Object.keys(e);
+		if (Object.getOwnPropertySymbols) {
+			var o = Object.getOwnPropertySymbols(e);
+			r && (o = o.filter(function(r$1) {
+				return Object.getOwnPropertyDescriptor(e, r$1).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), !0).forEach(function(r$1) {
+				_defineProperty(e, r$1, t[r$1]);
+			}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r$1) {
+				Object.defineProperty(e, r$1, Object.getOwnPropertyDescriptor(t, r$1));
+			});
+		}
+		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);
+	}
+	/*istanbul ignore end*/
+	function unixToWin(patch) {
+		if (Array.isArray(patch)) return patch.map(unixToWin);
+		return _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 line.startsWith("\\") || line.endsWith("\r") || (_hunk$lines = hunk.lines[i + 1]) !== null && _hunk$lines !== void 0 && _hunk$lines.startsWith("\\") ? line : line + "\r";
+			}) });
+		}) });
+	}
+	function winToUnix(patch) {
+		if (Array.isArray(patch)) return patch.map(winToUnix);
+		return _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 line.endsWith("\r") ? line.substring(0, line.length - 1) : line;
+			}) });
+		}) });
+	}
+	/**
+	* Returns true if the patch consistently uses Unix line endings (or only involves one line and has
+	* no line endings).
+	*/
+	function isUnix(patch) {
+		if (!Array.isArray(patch)) patch = [patch];
+		return !patch.some(function(index) {
+			return index.hunks.some(function(hunk) {
+				return hunk.lines.some(function(line) {
+					return !line.startsWith("\\") && line.endsWith("\r");
+				});
+			});
+		});
+	}
+	/**
+	* Returns true if the patch uses Windows line endings and only Windows line endings.
+	*/
+	function isWin(patch) {
+		if (!Array.isArray(patch)) patch = [patch];
+		return patch.some(function(index) {
+			return index.hunks.some(function(hunk) {
+				return hunk.lines.some(function(line) {
+					return line.endsWith("\r");
+				});
+			});
+		}) && patch.every(function(index) {
+			return index.hunks.every(function(hunk) {
+				return hunk.lines.every(function(line, i) {
+					var _hunk$lines2;
+					return line.startsWith("\\") || line.endsWith("\r") || ((_hunk$lines2 = hunk.lines[i + 1]) === null || _hunk$lines2 === void 0 ? void 0 : _hunk$lines2.startsWith("\\"));
+				});
+			});
+		});
+	}
+}) });
+
+//#endregion
+export default require_line_endings();
+
+export { require_line_endings };

package/dist/node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/patch/merge.js

@@ -0,0 +1,367 @@
+import { __commonJS } from "../../../../../../../_virtual/rolldown_runtime.js";
+import { require_parse } from "./parse.js";
+import { require_create } from "./create.js";
+import { require_array } from "../util/array.js";
+
+//#region ../../node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/patch/merge.js
+var require_merge = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/patch/merge.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.calcLineCount = calcLineCount;
+	exports.merge = merge;
+	/*istanbul ignore end*/
+	var _create = require_create();
+	var _parse = require_parse();
+	var _array = require_array();
+	/*istanbul ignore start*/ 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;
+	}
+	/*istanbul ignore end*/
+	function calcLineCount(hunk) {
+		var _calcOldNewLineCount = 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 (0, _parse.parsePatch)(param)[0];
+			if (!base) throw new Error("Must provide a base reference or pass in a patch");
+			return (0, _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] === " ") {
+				/*istanbul ignore start*/
+				var _hunk$lines;
+				/*istanbul ignore end*/
+				/*istanbul ignore start*/
+				/*istanbul ignore end*/
+				/*istanbul ignore start*/
+				(_hunk$lines = hunk.lines).push.apply(
+					/*istanbul ignore start*/
+					_hunk$lines,
+					/*istanbul ignore start*/
+					_toConsumableArray(
+						/*istanbul ignore end*/
+						collectChange(mine)
+					)
+				);
+			} else if (theirCurrent[0] === "+" && mineCurrent[0] === " ") {
+				/*istanbul ignore start*/
+				var _hunk$lines2;
+				/*istanbul ignore end*/
+				/*istanbul ignore start*/
+				/*istanbul ignore end*/
+				/*istanbul ignore start*/
+				(_hunk$lines2 = 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 ((0, _array.arrayStartsWith)(myChanges, theirChanges) && skipRemoveSuperset(their, myChanges, myChanges.length - theirChanges.length)) {
+				/*istanbul ignore start*/
+				var _hunk$lines3;
+				/*istanbul ignore end*/
+				/*istanbul ignore start*/
+				/*istanbul ignore end*/
+				/*istanbul ignore start*/
+				(_hunk$lines3 = hunk.lines).push.apply(
+					/*istanbul ignore start*/
+					_hunk$lines3,
+					/*istanbul ignore start*/
+					_toConsumableArray(
+						/*istanbul ignore end*/
+						myChanges
+					)
+				);
+				return;
+			} else if ((0, _array.arrayStartsWith)(theirChanges, myChanges) && skipRemoveSuperset(mine, theirChanges, theirChanges.length - myChanges.length)) {
+				/*istanbul ignore start*/
+				var _hunk$lines4;
+				/*istanbul ignore end*/
+				/*istanbul ignore start*/
+				/*istanbul ignore end*/
+				/*istanbul ignore start*/
+				(_hunk$lines4 = hunk.lines).push.apply(
+					/*istanbul ignore start*/
+					_hunk$lines4,
+					/*istanbul ignore start*/
+					_toConsumableArray(
+						/*istanbul ignore end*/
+						theirChanges
+					)
+				);
+				return;
+			}
+		} else if ((0, _array.arrayEqual)(myChanges, theirChanges)) {
+			/*istanbul ignore start*/
+			var _hunk$lines5;
+			/*istanbul ignore end*/
+			/*istanbul ignore start*/
+			/*istanbul ignore end*/
+			/*istanbul ignore start*/
+			(_hunk$lines5 = 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) {
+			/*istanbul ignore start*/
+			var _hunk$lines6;
+			/*istanbul ignore end*/
+			/*istanbul ignore start*/
+			/*istanbul ignore end*/
+			/*istanbul ignore start*/
+			(_hunk$lines6 = 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
+		};
+	}
+}) });
+
+//#endregion
+export default require_merge();
+
+export { require_merge };

package/dist/node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/patch/parse.js

@@ -0,0 +1,91 @@
+import { __commonJS } from "../../../../../../../_virtual/rolldown_runtime.js";
+
+//#region ../../node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/patch/parse.js
+var require_parse = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/patch/parse.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.parsePatch = parsePatch;
+	/*istanbul ignore end*/
+	function parsePatch(uniDiff) {
+		var diffstr = uniDiff.split(/\n/), list = [], i = 0;
+		function parseIndex() {
+			var index = {};
+			list.push(index);
+			while (i < diffstr.length) {
+				var line = diffstr[i];
+				if (/^(\-\-\-|\+\+\+|@@)\s/.test(line)) break;
+				var header = /^(?:Index:|diff(?: -r \w+)+)\s+(.+?)\s*$/.exec(line);
+				if (header) index.index = header[1];
+				i++;
+			}
+			parseFileHeader(index);
+			parseFileHeader(index);
+			index.hunks = [];
+			while (i < diffstr.length) {
+				var _line = diffstr[i];
+				if (/^(Index:\s|diff\s|\-\-\-\s|\+\+\+\s|===================================================================)/.test(_line)) break;
+				else if (/^@@/.test(_line)) index.hunks.push(parseHunk());
+				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 fileName = data[0].replace(/\\\\/g, "\\");
+				if (/^".*"$/.test(fileName)) fileName = fileName.substr(1, fileName.length - 2);
+				index[keyPrefix + "FileName"] = fileName;
+				index[keyPrefix + "Header"] = (data[1] || "").trim();
+				i++;
+			}
+		}
+		function parseHunk() {
+			var chunkHeaderIndex = i, chunkHeaderLine = diffstr[i++], chunkHeader = chunkHeaderLine.split(/@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+			var hunk = {
+				oldStart: +chunkHeader[1],
+				oldLines: typeof chunkHeader[2] === "undefined" ? 1 : +chunkHeader[2],
+				newStart: +chunkHeader[3],
+				newLines: typeof chunkHeader[4] === "undefined" ? 1 : +chunkHeader[4],
+				lines: []
+			};
+			if (hunk.oldLines === 0) hunk.oldStart += 1;
+			if (hunk.newLines === 0) hunk.newStart += 1;
+			var addCount = 0, removeCount = 0;
+			for (; i < diffstr.length && (removeCount < hunk.oldLines || addCount < hunk.newLines || (_diffstr$i = diffstr[i]) !== null && _diffstr$i !== void 0 && _diffstr$i.startsWith("\\")); i++) {
+				/*istanbul ignore start*/
+				var _diffstr$i;
+				/*istanbul ignore end*/
+				var operation = diffstr[i].length == 0 && i != diffstr.length - 1 ? " " : diffstr[i][0];
+				if (operation === "+" || operation === "-" || operation === " " || operation === "\\") {
+					hunk.lines.push(diffstr[i]);
+					if (operation === "+") addCount++;
+					else if (operation === "-") removeCount++;
+					else if (operation === " ") {
+						addCount++;
+						removeCount++;
+					}
+				} else throw new Error(
+					/*istanbul ignore start*/
+					"Hunk at line ".concat(
+						/*istanbul ignore end*/
+						chunkHeaderIndex + 1,
+						" contained invalid line "
+					).concat(diffstr[i])
+				);
+			}
+			if (!addCount && hunk.newLines === 1) hunk.newLines = 0;
+			if (!removeCount && hunk.oldLines === 1) hunk.oldLines = 0;
+			if (addCount !== hunk.newLines) throw new Error("Added line count did not match for hunk at line " + (chunkHeaderIndex + 1));
+			if (removeCount !== hunk.oldLines) throw new Error("Removed line count did not match for hunk at line " + (chunkHeaderIndex + 1));
+			return hunk;
+		}
+		while (i < diffstr.length) parseIndex();
+		return list;
+	}
+}) });
+
+//#endregion
+export default require_parse();
+
+export { require_parse };

package/dist/node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/patch/reverse.js

@@ -0,0 +1,99 @@
+import { __commonJS } from "../../../../../../../_virtual/rolldown_runtime.js";
+
+//#region ../../node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/patch/reverse.js
+var require_reverse = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/patch/reverse.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.reversePatch = reversePatch;
+	function _typeof(o) {
+		"@babel/helpers - typeof";
+		return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
+			return typeof o$1;
+		} : function(o$1) {
+			return o$1 && "function" == typeof Symbol && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
+		}, _typeof(o);
+	}
+	function ownKeys(e, r) {
+		var t = Object.keys(e);
+		if (Object.getOwnPropertySymbols) {
+			var o = Object.getOwnPropertySymbols(e);
+			r && (o = o.filter(function(r$1) {
+				return Object.getOwnPropertyDescriptor(e, r$1).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), !0).forEach(function(r$1) {
+				_defineProperty(e, r$1, t[r$1]);
+			}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r$1) {
+				Object.defineProperty(e, r$1, Object.getOwnPropertyDescriptor(t, r$1));
+			});
+		}
+		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);
+	}
+	/*istanbul ignore end*/
+	function reversePatch(structuredPatch) {
+		if (Array.isArray(structuredPatch)) return structuredPatch.map(reversePatch).reverse();
+		return _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 "+".concat(
+							/*istanbul ignore end*/
+							l.slice(1)
+						);
+						if (l.startsWith("+")) return "-".concat(
+							/*istanbul ignore end*/
+							l.slice(1)
+						);
+						return l;
+					})
+				};
+			})
+		});
+	}
+}) });
+
+//#endregion
+export default require_reverse();
+
+export { require_reverse };