@kubohiroya/turbowarp-plus-editor-git 0.16.1 → 0.17.0

package/dist/{project-asset-paths-KV715791.js → project-asset-paths-nL5sV35A.js}

@@ -1,3 +1,4 @@
+import { n as init_objectSpread2, t as _objectSpread2 } from "./objectSpread2-Dkd68nJH.js";
 // node_modules/diff/libesm/diff/base.js
 var Diff = class {
 	diff(oldStr, newStr, options = {}) {
@@ -518,6 +519,518 @@ var ArrayDiff = class extends Diff {
 	}
 };
 new ArrayDiff();
+// node_modules/diff/libesm/patch/line-endings.js
+function unixToWin(patch) {
+	if (Array.isArray(patch)) return patch.map((p) => unixToWin(p));
+	return Object.assign(Object.assign({}, patch), { hunks: patch.hunks.map((hunk) => Object.assign(Object.assign({}, hunk), { lines: hunk.lines.map((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((p) => winToUnix(p));
+	return Object.assign(Object.assign({}, patch), { hunks: patch.hunks.map((hunk) => Object.assign(Object.assign({}, hunk), { lines: hunk.lines.map((line) => 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((index) => index.hunks.some((hunk) => hunk.lines.some((line) => !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((index) => index.hunks.some((hunk) => hunk.lines.some((line) => line.endsWith("\r")))) && patch.every((index) => index.hunks.every((hunk) => hunk.lines.every((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/diff/libesm/patch/parse.js
+/**
+* Parses a unified diff format patch into a structured patch object.
+*
+* `parsePatch` has some understanding of Git's particular dialect of unified diff format.
+* When parsing a Git patch, each index in the result may contain additional
+* fields (`isRename`, `isBinary`, etc) not included in the data structure returned by
+* `structuredPatch`; see the `StructuredPatch` interface for a full list.
+*
+* @return a JSON object representation of the patch, suitable for use with the `applyPatch`
+* method. This parses to the same structure returned by `structuredPatch`, except that
+* `oldFileName` and `newFileName` may be `undefined` if the patch doesn't contain enough
+* information to determine them (e.g. a hunk-only patch with no file headers).
+*/
+function parsePatch(uniDiff) {
+	const diffstr = uniDiff.split(/\n/), list = [];
+	let i = 0;
+	function isGitDiffHeader(line) {
+		return /^diff --git /.test(line);
+	}
+	function isDiffHeader(line) {
+		return isGitDiffHeader(line) || /^Index:\s/.test(line) || /^diff(?: -r \w+)+\s/.test(line);
+	}
+	function isFileHeader(line) {
+		return /^(---|\+\+\+)\s/.test(line);
+	}
+	function isHunkHeader(line) {
+		return /^@@\s/.test(line);
+	}
+	function parseIndex() {
+		var _a;
+		const index = {};
+		index.hunks = [];
+		list.push(index);
+		let seenDiffHeader = false;
+		while (i < diffstr.length) {
+			const line = diffstr[i];
+			if (isFileHeader(line) || isHunkHeader(line)) break;
+			if (isGitDiffHeader(line)) {
+				if (seenDiffHeader) return;
+				seenDiffHeader = true;
+				index.isGit = true;
+				const paths = parseGitDiffHeader(line);
+				if (paths) {
+					index.oldFileName = paths.oldFileName;
+					index.newFileName = paths.newFileName;
+				}
+				i++;
+				while (i < diffstr.length) {
+					const extLine = diffstr[i];
+					if (isFileHeader(extLine) || isHunkHeader(extLine) || isDiffHeader(extLine)) break;
+					const renameFromMatch = /^rename from (.*)/.exec(extLine);
+					if (renameFromMatch) {
+						index.oldFileName = "a/" + unquoteIfQuoted(renameFromMatch[1]);
+						index.isRename = true;
+					}
+					const renameToMatch = /^rename to (.*)/.exec(extLine);
+					if (renameToMatch) {
+						index.newFileName = "b/" + unquoteIfQuoted(renameToMatch[1]);
+						index.isRename = true;
+					}
+					const copyFromMatch = /^copy from (.*)/.exec(extLine);
+					if (copyFromMatch) {
+						index.oldFileName = "a/" + unquoteIfQuoted(copyFromMatch[1]);
+						index.isCopy = true;
+					}
+					const copyToMatch = /^copy to (.*)/.exec(extLine);
+					if (copyToMatch) {
+						index.newFileName = "b/" + unquoteIfQuoted(copyToMatch[1]);
+						index.isCopy = true;
+					}
+					const newFileModeMatch = /^new file mode (\d+)/.exec(extLine);
+					if (newFileModeMatch) {
+						index.isCreate = true;
+						index.newMode = newFileModeMatch[1];
+					}
+					const deletedFileModeMatch = /^deleted file mode (\d+)/.exec(extLine);
+					if (deletedFileModeMatch) {
+						index.isDelete = true;
+						index.oldMode = deletedFileModeMatch[1];
+					}
+					const oldModeMatch = /^old mode (\d+)/.exec(extLine);
+					if (oldModeMatch) index.oldMode = oldModeMatch[1];
+					const newModeMatch = /^new mode (\d+)/.exec(extLine);
+					if (newModeMatch) index.newMode = newModeMatch[1];
+					if (/^Binary files /.test(extLine)) index.isBinary = true;
+					i++;
+				}
+				continue;
+			} else if (isDiffHeader(line)) {
+				if (seenDiffHeader) return;
+				seenDiffHeader = true;
+				const headerMatch = /^(?:Index:|diff(?: -r \w+)+)\s+/.exec(line);
+				if (headerMatch) index.index = line.substring(headerMatch[0].length).trim();
+			}
+			i++;
+		}
+		parseFileHeader(index);
+		parseFileHeader(index);
+		if (index.oldFileName === void 0 !== (index.newFileName === void 0)) throw new Error("Missing " + (index.oldFileName !== void 0 ? "\"+++ ...\"" : "\"--- ...\"") + " file header for " + ((_a = index.oldFileName) !== null && _a !== void 0 ? _a : index.newFileName));
+		while (i < diffstr.length) {
+			const line = diffstr[i];
+			if (isDiffHeader(line) || isFileHeader(line) || /^===================================================================/.test(line)) break;
+			else if (isHunkHeader(line)) index.hunks.push(parseHunk());
+			else i++;
+		}
+	}
+	/**
+	* Parses the old and new filenames from a `diff --git` header line.
+	*
+	* The format is:
+	*     diff --git a/<old-path> b/<new-path>
+	*
+	* When filenames contain special characters (including newlines, tabs,
+	* backslashes, or double quotes), Git quotes them with C-style escaping:
+	*     diff --git "a/file\twith\ttabs.txt" "b/file\twith\ttabs.txt"
+	*
+	* When filenames don't contain special characters and the old and new names
+	* are the same, we can unambiguously split on ` b/` by finding where the
+	* two halves (including their a/ and b/ prefixes) yield matching bare names.
+	*
+	* A pathological case exists in which we cannot reliably determine the paths
+	* from the `diff --git` header. This case is when the following are true:
+	* - the old and new file paths differ
+	* - they are both unquoted (i.e. contain no special characters)
+	* - at least one of the underlying file paths includes the substring ` b/`
+	* In this scenario, we do not know which occurrence of ` b/` indicates the
+	* start of the new file path, so the header is inherently ambiguous. We thus
+	* select a possible interpretation arbitrarily and return that.
+	*
+	* Fortunately, this ambiguity should never matter, because in any patch
+	* genuinely output by Git in which this pathological scenario occurs, there
+	* must also be `rename from`/`rename to` or `copy from`/`copy to` extended
+	* headers present below the `diff --git` header. `parseIndex` will parse
+	* THOSE headers, from which we CAN unambiguously determine the filenames,
+	* and will discard the result returned by this function.
+	*
+	* Returns null if the header can't be parsed at all — e.g. a quoted filename
+	* has an unterminated quote, or if the unquoted header doesn't match the
+	* expected `a/... b/...` format. In that case, the caller (parseIndex)
+	* skips setting oldFileName/newFileName from this header, but they may
+	* still be set later from `---`/`+++` lines or `rename from`/`rename to`
+	* extended headers; if none of those are present either, they'll remain
+	* undefined in the output.
+	*/
+	function parseGitDiffHeader(line) {
+		const rest = line.substring(11);
+		if (rest.startsWith("\"")) {
+			const oldPath = parseQuotedFileName(rest);
+			if (oldPath === null) return null;
+			const afterOld = rest.substring(oldPath.rawLength + 1);
+			let newFileName;
+			if (afterOld.startsWith("\"")) {
+				const newPath = parseQuotedFileName(afterOld);
+				if (newPath === null) return null;
+				newFileName = newPath.fileName;
+			} else newFileName = afterOld;
+			return {
+				oldFileName: oldPath.fileName,
+				newFileName
+			};
+		}
+		const quoteIdx = rest.indexOf("\"");
+		if (quoteIdx > 0) {
+			const oldFileName = rest.substring(0, quoteIdx - 1);
+			const newPath = parseQuotedFileName(rest.substring(quoteIdx));
+			if (newPath === null) return null;
+			return {
+				oldFileName,
+				newFileName: newPath.fileName
+			};
+		}
+		if (rest.startsWith("a/")) {
+			const splits = [];
+			let idx = 0;
+			while (true) {
+				idx = rest.indexOf(" b/", idx + 1);
+				if (idx === -1) break;
+				splits.push(idx);
+			}
+			if (splits.length > 0) {
+				const mid = splits[Math.floor(splits.length / 2)];
+				return {
+					oldFileName: rest.substring(0, mid),
+					newFileName: rest.substring(mid + 1)
+				};
+			}
+		}
+		return null;
+	}
+	/**
+	* If `s` starts with a double quote, unquotes it using C-style escape
+	* rules (as used by Git). Otherwise returns `s` as-is.
+	*/
+	function unquoteIfQuoted(s) {
+		if (s.startsWith("\"")) {
+			const parsed = parseQuotedFileName(s);
+			if (parsed) return parsed.fileName;
+		}
+		return s;
+	}
+	/**
+	* Parses a C-style quoted filename as used by Git or GNU `diff -u`.
+	* Returns the unescaped filename and the raw length consumed (including quotes).
+	*/
+	function parseQuotedFileName(s) {
+		if (!s.startsWith("\"")) return null;
+		let result = "";
+		let j = 1;
+		while (j < s.length) {
+			if (s[j] === "\"") return {
+				fileName: result,
+				rawLength: j + 1
+			};
+			if (s[j] === "\\" && j + 1 < s.length) {
+				j++;
+				switch (s[j]) {
+					case "a":
+						result += "\x07";
+						break;
+					case "b":
+						result += "\b";
+						break;
+					case "f":
+						result += "\f";
+						break;
+					case "n":
+						result += "\n";
+						break;
+					case "r":
+						result += "\r";
+						break;
+					case "t":
+						result += "	";
+						break;
+					case "v":
+						result += "\v";
+						break;
+					case "\\":
+						result += "\\";
+						break;
+					case "\"":
+						result += "\"";
+						break;
+					case "0":
+					case "1":
+					case "2":
+					case "3":
+					case "4":
+					case "5":
+					case "6":
+					case "7": {
+						if (j + 2 >= s.length || s[j + 1] < "0" || s[j + 1] > "7" || s[j + 2] < "0" || s[j + 2] > "7") return null;
+						const bytes = [parseInt(s.substring(j, j + 3), 8)];
+						j += 3;
+						while (s[j] === "\\" && s[j + 1] >= "0" && s[j + 1] <= "7") {
+							if (j + 3 >= s.length || s[j + 2] < "0" || s[j + 2] > "7" || s[j + 3] < "0" || s[j + 3] > "7") return null;
+							bytes.push(parseInt(s.substring(j + 1, j + 4), 8));
+							j += 4;
+						}
+						result += new TextDecoder("utf-8").decode(new Uint8Array(bytes));
+						continue;
+					}
+					default: return null;
+				}
+			} else result += s[j];
+			j++;
+		}
+		return null;
+	}
+	function parseFileHeader(index) {
+		const fileHeaderMatch = /^(---|\+\+\+)\s+/.exec(diffstr[i]);
+		if (fileHeaderMatch) {
+			const prefix = fileHeaderMatch[1], data = diffstr[i].substring(3).trim().split("	", 2), header = (data[1] || "").trim();
+			let fileName = data[0];
+			if (fileName.startsWith("\"")) fileName = unquoteIfQuoted(fileName);
+			else fileName = fileName.replace(/\\\\/g, "\\");
+			if (prefix === "---") {
+				index.oldFileName = fileName;
+				index.oldHeader = header;
+			} else {
+				index.newFileName = fileName;
+				index.newHeader = header;
+			}
+			i++;
+		}
+	}
+	function parseHunk() {
+		var _a;
+		const chunkHeaderIndex = i, chunkHeader = diffstr[i++].split(/@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+		const 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;
+		let addCount = 0, removeCount = 0;
+		for (; i < diffstr.length && (removeCount < hunk.oldLines || addCount < hunk.newLines || ((_a = diffstr[i]) === null || _a === void 0 ? void 0 : _a.startsWith("\\"))); i++) {
+			const 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(`Hunk at line ${chunkHeaderIndex + 1} contained invalid line ${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));
+		if (i < diffstr.length && diffstr[i] && /^[+ -]/.test(diffstr[i]) && !isFileHeader(diffstr[i])) throw new Error("Hunk at line " + (chunkHeaderIndex + 1) + " has more lines than expected (expected " + hunk.oldLines + " old lines and " + hunk.newLines + " new lines)");
+		return hunk;
+	}
+	while (i < diffstr.length) parseIndex();
+	return list;
+}
+// node_modules/diff/libesm/util/distance-iterator.js
+function distance_iterator_default(start, minLine, maxLine) {
+	let wantForward = true, backwardExhausted = false, forwardExhausted = false, localOffset = 1;
+	return function iterator() {
+		if (wantForward && !forwardExhausted) {
+			if (backwardExhausted) localOffset++;
+			else wantForward = false;
+			if (start + localOffset <= maxLine) return start + localOffset;
+			forwardExhausted = true;
+		}
+		if (!backwardExhausted) {
+			if (!forwardExhausted) wantForward = true;
+			if (minLine <= start - localOffset) return start - localOffset++;
+			backwardExhausted = true;
+			return iterator();
+		}
+	};
+}
+// node_modules/diff/libesm/patch/apply.js
+/**
+* attempts to apply a unified diff patch.
+*
+* Hunks are applied first to last.
+* `applyPatch` first tries to apply the first hunk at the line number specified in the hunk header, and with all context lines matching exactly.
+* If that fails, it tries scanning backwards and forwards, one line at a time, to find a place to apply the hunk where the context lines match exactly.
+* If that still fails, and `fuzzFactor` is greater than zero, it increments the maximum number of mismatches (missing, extra, or changed context lines) that there can be between the hunk context and a region where we are trying to apply the patch such that the hunk will still be considered to match.
+* Regardless of `fuzzFactor`, lines to be deleted in the hunk *must* be present for a hunk to match, and the context lines *immediately* before and after an insertion must match exactly.
+*
+* Once a hunk is successfully fitted, the process begins again with the next hunk.
+* Regardless of `fuzzFactor`, later hunks must be applied later in the file than earlier hunks.
+*
+* If a hunk cannot be successfully fitted *anywhere* with fewer than `fuzzFactor` mismatches, `applyPatch` fails and returns `false`.
+*
+* If a hunk is successfully fitted but not at the line number specified by the hunk header, all subsequent hunks have their target line number adjusted accordingly.
+* (e.g. if the first hunk is applied 10 lines below where the hunk header said it should fit, `applyPatch` will *start* looking for somewhere to apply the second hunk 10 lines below where its hunk header says it goes.)
+*
+* If the patch was applied successfully, returns a string containing the patched text.
+* If the patch could not be applied (because some hunks in the patch couldn't be fitted to the text in `source`), `applyPatch` returns false.
+*
+* @param patch a string diff or the output from the `parsePatch` or `structuredPatch` methods.
+*/
+function applyPatch(source, patch, options = {}) {
+	let patches;
+	if (typeof patch === "string") patches = 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.autoConvertLineEndings || options.autoConvertLineEndings == null) {
+		if (hasOnlyWinLineEndings(source) && isUnix(patch)) patch = unixToWin(patch);
+		else if (hasOnlyUnixLineEndings(source) && isWin(patch)) patch = winToUnix(patch);
+	}
+	const lines = source.split("\n"), hunks = patch.hunks, compareLine = options.compareLine || ((lineNumber, line, operation, patchContent) => line === patchContent), fuzzFactor = options.fuzzFactor || 0;
+	let minLine = 0;
+	if (fuzzFactor < 0 || !Number.isInteger(fuzzFactor)) throw new Error("fuzzFactor must be a non-negative integer");
+	if (!hunks.length) return source;
+	let prevLine = "", removeEOFNL = false, addEOFNL = false;
+	for (let i = 0; i < hunks[hunks.length - 1].lines.length; i++) {
+		const line = hunks[hunks.length - 1].lines[i];
+		if (line[0] == "\\") {
+			if (prevLine[0] == "+") removeEOFNL = true;
+			else if (prevLine[0] == "-") addEOFNL = true;
+		}
+		prevLine = line;
+	}
+	if (removeEOFNL) {
+		if (addEOFNL) {
+			if (!fuzzFactor && lines[lines.length - 1] == "") return false;
+		} else if (lines[lines.length - 1] == "") lines.pop();
+		else if (!fuzzFactor) return false;
+	} else if (addEOFNL) {
+		if (lines[lines.length - 1] != "") lines.push("");
+		else if (!fuzzFactor) return false;
+	}
+	/**
+	* Checks if the hunk can be made to fit at the provided location with at most `maxErrors`
+	* insertions, substitutions, or deletions, while ensuring also that:
+	* - lines deleted in the hunk match exactly, and
+	* - wherever an insertion operation or block of insertion operations appears in the hunk, the
+	*   immediately preceding and following lines of context match exactly
+	*
+	* `toPos` should be set such that lines[toPos] is meant to match hunkLines[0].
+	*
+	* If the hunk can be applied, returns an object with properties `oldLineLastI` and
+	* `replacementLines`. Otherwise, returns null.
+	*/
+	function applyHunk(hunkLines, toPos, maxErrors, hunkLinesI = 0, lastContextLineMatched = true, patchedLines = [], patchedLinesLength = 0) {
+		let nConsecutiveOldContextLines = 0;
+		let nextContextLineMustMatch = false;
+		for (; hunkLinesI < hunkLines.length; hunkLinesI++) {
+			const hunkLine = hunkLines[hunkLinesI], operation = hunkLine.length > 0 ? hunkLine[0] : " ", content = hunkLine.length > 0 ? hunkLine.substr(1) : hunkLine;
+			if (operation === "-") {
+				if (compareLine(toPos + 1, lines[toPos], operation, content)) {
+					toPos++;
+					nConsecutiveOldContextLines = 0;
+				} else {
+					if (!maxErrors || lines[toPos] == null) return null;
+					patchedLines[patchedLinesLength] = lines[toPos];
+					return applyHunk(hunkLines, toPos + 1, maxErrors - 1, hunkLinesI, false, patchedLines, patchedLinesLength + 1);
+				}
+			}
+			if (operation === "+") {
+				if (!lastContextLineMatched) return null;
+				patchedLines[patchedLinesLength] = content;
+				patchedLinesLength++;
+				nConsecutiveOldContextLines = 0;
+				nextContextLineMustMatch = true;
+			}
+			if (operation === " ") {
+				nConsecutiveOldContextLines++;
+				patchedLines[patchedLinesLength] = lines[toPos];
+				if (compareLine(toPos + 1, lines[toPos], operation, content)) {
+					patchedLinesLength++;
+					lastContextLineMatched = true;
+					nextContextLineMustMatch = false;
+					toPos++;
+				} else {
+					if (nextContextLineMustMatch || !maxErrors) return null;
+					return lines[toPos] && (applyHunk(hunkLines, toPos + 1, maxErrors - 1, hunkLinesI + 1, false, patchedLines, patchedLinesLength + 1) || applyHunk(hunkLines, toPos + 1, maxErrors - 1, hunkLinesI, false, patchedLines, patchedLinesLength + 1)) || applyHunk(hunkLines, toPos, maxErrors - 1, hunkLinesI + 1, false, patchedLines, patchedLinesLength);
+				}
+			}
+		}
+		patchedLinesLength -= nConsecutiveOldContextLines;
+		toPos -= nConsecutiveOldContextLines;
+		patchedLines.length = patchedLinesLength;
+		return {
+			patchedLines,
+			oldLineLastI: toPos - 1
+		};
+	}
+	const resultLines = [];
+	let prevHunkOffset = 0;
+	for (let i = 0; i < hunks.length; i++) {
+		const hunk = hunks[i];
+		let hunkResult;
+		const maxLine = lines.length - hunk.oldLines + fuzzFactor;
+		let toPos;
+		for (let maxErrors = 0; maxErrors <= fuzzFactor; maxErrors++) {
+			toPos = hunk.oldStart + prevHunkOffset - 1;
+			const iterator = distance_iterator_default(toPos, minLine, maxLine);
+			for (; toPos !== void 0; toPos = iterator()) {
+				hunkResult = applyHunk(hunk.lines, toPos, maxErrors);
+				if (hunkResult) break;
+			}
+			if (hunkResult) break;
+		}
+		if (!hunkResult) return false;
+		for (let i = minLine; i < toPos; i++) resultLines.push(lines[i]);
+		for (let i = 0; i < hunkResult.patchedLines.length; i++) {
+			const line = hunkResult.patchedLines[i];
+			resultLines.push(line);
+		}
+		minLine = hunkResult.oldLineLastI + 1;
+		prevHunkOffset = toPos + 1 - hunk.oldStart;
+	}
+	for (let i = minLine; i < lines.length; i++) resultLines.push(lines[i]);
+	return resultLines.join("\n");
+}
 // node_modules/diff/libesm/patch/create.js
 /**
 * Returns true if the filename contains characters that require C-style
@@ -736,6 +1249,145 @@ function splitLines(text) {
 	else result.push(result.pop().slice(0, -1));
 	return result;
 }
+// \0@oxc-project+runtime@0.156.0/helpers/esm/objectWithoutPropertiesLoose.js
+init_objectSpread2();
+function _objectWithoutPropertiesLoose(r, e) {
+	if (null == r) return {};
+	var t = {};
+	for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+		if (e.includes(n)) continue;
+		t[n] = r[n];
+	}
+	return t;
+}
+// \0@oxc-project+runtime@0.156.0/helpers/esm/objectWithoutProperties.js
+function _objectWithoutProperties(e, t) {
+	if (null == e) return {};
+	var o, r, i = _objectWithoutPropertiesLoose(e, t);
+	if (Object.getOwnPropertySymbols) {
+		var s = Object.getOwnPropertySymbols(e);
+		for (r = 0; r < s.length; r++) o = s[r], t.includes(o) || {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
+	}
+	return i;
+}
+// src/project-source-patch.ts
+var _excluded = ["blocks"];
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function readProject(source) {
+	const project = JSON.parse(source);
+	if (!isRecord(project) || !Array.isArray(project.targets) || !project.targets.every((target) => isRecord(target) && typeof target.name === "string" && typeof target.isStage === "boolean" && (target.blocks === void 0 || isRecord(target.blocks)))) throw new Error("Expected a project.source.json with Scratch targets and blocks.");
+	const parsed = project;
+	return _objectSpread2(_objectSpread2({}, parsed), {}, { targets: parsed.targets.map((target) => {
+		var _target$blocks;
+		return _objectSpread2(_objectSpread2({}, target), {}, { blocks: (_target$blocks = target.blocks) !== null && _target$blocks !== void 0 ? _target$blocks : {} });
+	}) });
+}
+/** Reads one version of a project.source.json. `null` stands for a version in which the file does not exist. */
+function parseProjectSource(source) {
+	return source === null ? { targets: [] } : readProject(source);
+}
+/** Keep the original lines and include enough context to render both sides from the patch alone. */
+function createProjectSourceDiff(before, after) {
+	readProject(before);
+	readProject(after);
+	const patch = createTwoFilesPatch("a/project.source.json", "b/project.source.json", before, after, void 0, void 0, {
+		context: Infinity,
+		timeout: 1e3
+	});
+	if (patch === void 0) throw new Error("Project source diff exceeded its time limit.");
+	return "diff --git a/project.source.json b/project.source.json\n" + patch.replace(/^=+\n/, "");
+}
+function readProjectSourceDiff(patch, beforeSource) {
+	const [file, extra] = parsePatch(patch);
+	if (!file || extra || !file.oldFileName || !file.newFileName) throw new Error("Expected a single unified text diff.");
+	if (beforeSource !== void 0) {
+		const before = readProject(beforeSource);
+		const after = applyPatch(beforeSource, file);
+		if (after === false) throw new Error("The original project does not match this diff.");
+		return [before, readProject(after)];
+	}
+	if (!file.hunks.length) return null;
+	const before = [], after = [];
+	for (const hunk of file.hunks) {
+		if (hunk.oldStart !== before.length + 1 || hunk.newStart !== after.length + 1) throw new Error("The diff omits project context.");
+		for (const line of hunk.lines) {
+			if (line.startsWith(" ") || line.startsWith("-")) before.push(line.slice(1));
+			if (line.startsWith(" ") || line.startsWith("+")) after.push(line.slice(1));
+		}
+	}
+	return [readProject(before.join("\n")), readProject(after.join("\n"))];
+}
+function equal(a, b) {
+	if (a === b) return true;
+	if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((value, i) => equal(value, b[i]));
+	if (!isRecord(a) || !isRecord(b)) return false;
+	const keys = Object.keys(a);
+	return keys.length === Object.keys(b).length && keys.every((key) => Object.hasOwn(b, key) && equal(a[key], b[key]));
+}
+var targetKey = (target) => target.isStage ? "stage" : "sprite:" + target.name;
+function changedParts(before, after) {
+	if (!isRecord(before) || !isRecord(after)) return [];
+	const result = [];
+	const visibleInput = (input) => {
+		var _input$;
+		return Array.isArray(input) ? (_input$ = input[1]) !== null && _input$ !== void 0 ? _input$ : input[2] : input;
+	};
+	for (const group of ["inputs", "fields"]) {
+		const oldGroup = isRecord(before[group]) ? before[group] : {};
+		const newGroup = isRecord(after[group]) ? after[group] : {};
+		for (const name of /* @__PURE__ */ new Set([...Object.keys(oldGroup), ...Object.keys(newGroup)])) {
+			const a = oldGroup[name], b = newGroup[name];
+			if (group === "inputs" ? !equal(visibleInput(a), visibleInput(b)) : !equal(a, b)) result.push({
+				kind: group === "inputs" ? "input" : "field",
+				name
+			});
+		}
+	}
+	return result;
+}
+function compareProjectBlocks(before, after) {
+	const oldTargets = new Map(before.targets.map((target) => [targetKey(target), target]));
+	const newTargets = new Map(after.targets.map((target) => [targetKey(target), target]));
+	const changes = [];
+	let unchanged = 0;
+	for (const key of /* @__PURE__ */ new Set([...oldTargets.keys(), ...newTargets.keys()])) {
+		var _oldTarget$blocks, _newTarget$blocks;
+		const oldTarget = oldTargets.get(key), newTarget = newTargets.get(key);
+		const oldBlocks = (_oldTarget$blocks = oldTarget === null || oldTarget === void 0 ? void 0 : oldTarget.blocks) !== null && _oldTarget$blocks !== void 0 ? _oldTarget$blocks : {}, newBlocks = (_newTarget$blocks = newTarget === null || newTarget === void 0 ? void 0 : newTarget.blocks) !== null && _newTarget$blocks !== void 0 ? _newTarget$blocks : {};
+		for (const id of /* @__PURE__ */ new Set([...Object.keys(oldBlocks), ...Object.keys(newBlocks)])) {
+			const hadBlock = Object.hasOwn(oldBlocks, id), hasBlock = Object.hasOwn(newBlocks, id);
+			const a = oldBlocks[id], b = newBlocks[id];
+			if (hadBlock && hasBlock && equal(a, b)) {
+				unchanged++;
+				continue;
+			}
+			const fields = isRecord(a) && isRecord(b) ? [.../* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)])].filter((field) => !equal(a[field], b[field])) : [];
+			changes.push({
+				key: JSON.stringify([key, id]),
+				before: hadBlock && oldTarget ? {
+					target: oldTarget,
+					id
+				} : void 0,
+				after: hasBlock && newTarget ? {
+					target: newTarget,
+					id
+				} : void 0,
+				kind: !hadBlock ? "added" : !hasBlock ? "removed" : "updated",
+				fields,
+				parts: changedParts(a, b)
+			});
+		}
+	}
+	const withoutBlocks = (project) => _objectSpread2(_objectSpread2({}, project), {}, { targets: project.targets.map((_ref) => {
+		let { blocks: _ } = _ref;
+		return _objectWithoutProperties(_ref, _excluded);
+	}) });
+	return {
+		changes,
+		unchanged,
+		otherChanges: !equal(withoutBlocks(before), withoutBlocks(after))
+	};
+}
 // src/project-asset-paths.ts
 /** The largest asset a thumbnail reads. */
 var assetLimit = 10485760;
@@ -758,4 +1410,4 @@ function assetsDirectoryParts(settings) {
 	const parts = value.split("/");
 	return parts.every((part) => part && part !== "." && part !== ".." && part.toLowerCase() !== ".git" && !/[\\\0-\x1f\x7f]/.test(part)) ? parts : null;
 }
-export { createTwoFilesPatch as a, isAssetName as i, assetsDirectoryParts as n, hasOnlyUnixLineEndings as o, folderSettingsLimit as r, hasOnlyWinLineEndings as s, assetLimit as t };
+export { compareProjectBlocks as a, isRecord as c, targetKey as d, createTwoFilesPatch as f, isAssetName as i, parseProjectSource as l, assetsDirectoryParts as n, createProjectSourceDiff as o, folderSettingsLimit as r, equal as s, assetLimit as t, readProjectSourceDiff as u };