@kubohiroya/turbowarp-plus-editor-git 0.0.0-stage → 0.8.0

package/dist/scratch-block-diff-renderer-xS8OYsRl.js

@@ -0,0 +1,1830 @@
+import { n as init_objectSpread2, t as _objectSpread2 } from "./objectSpread2-Dkd68nJH.js";
+import { a as createTwoFilesPatch, i as isAssetName, n as assetsDirectoryParts, o as hasOnlyUnixLineEndings, r as folderSettingsLimit, s as hasOnlyWinLineEndings, t as assetLimit } from "./project-asset-paths-KV715791.js";
+import React, { useEffect, useMemo, useRef, useState } from "react";
+// 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");
+}
+// \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-assets.ts
+var imageTypes = {
+	svg: "image/svg+xml",
+	png: "image/png",
+	jpg: "image/jpeg",
+	jpeg: "image/jpeg",
+	gif: "image/gif",
+	bmp: "image/bmp",
+	webp: "image/webp"
+};
+/** The costume a sprite shows, or the backdrop the stage shows, when the project data names an image file for it. */
+function currentCostume(target) {
+	const { costumes, currentCostume: index } = target;
+	if (!Array.isArray(costumes)) return null;
+	const costume = costumes[typeof index === "number" && Number.isInteger(index) && index >= 0 ? index : 0];
+	if (!isRecord(costume)) return null;
+	const md5ext = typeof costume.md5ext === "string" ? costume.md5ext : typeof costume.assetId === "string" && typeof costume.dataFormat === "string" ? costume.assetId + "." + costume.dataFormat : "";
+	const match = /^[0-9A-Za-z_-]{1,128}\.([0-9A-Za-z]{1,8})$/.exec(md5ext);
+	const type = match ? imageTypes[match[1].toLowerCase()] : void 0;
+	if (!type) return null;
+	return {
+		name: typeof costume.name === "string" ? costume.name : "",
+		md5ext,
+		type
+	};
+}
+var reads = /* @__PURE__ */ new WeakMap();
+function readAsset(loadAsset, version, md5ext) {
+	let cache = reads.get(loadAsset);
+	if (!cache) reads.set(loadAsset, cache = /* @__PURE__ */ new Map());
+	const key = version + ":" + md5ext;
+	let read = cache.get(key);
+	if (!read) {
+		read = loadAsset({
+			version,
+			md5ext,
+			signal: new AbortController().signal
+		}).catch(() => null);
+		cache.set(key, read);
+	}
+	return read;
+}
+/** Loads the current costume of one version of a target as an object URL for an image, or `null` while it is unavailable. */
+function useCostumeImage(target, version, loadAsset) {
+	const costume = target && loadAsset ? currentCostume(target) : null;
+	const key = costume ? version + ":" + costume.md5ext : "";
+	const [image, setImage] = useState();
+	useEffect(() => {
+		if (!costume || !loadAsset) return;
+		let active = true;
+		let url;
+		readAsset(loadAsset, version, costume.md5ext).then((blob) => {
+			if (!blob || !active) return;
+			url = URL.createObjectURL(new Blob([blob], { type: costume.type }));
+			setImage({
+				key,
+				url
+			});
+		});
+		return () => {
+			active = false;
+			if (url) URL.revokeObjectURL(url);
+		};
+	}, [key, loadAsset]);
+	return (image === null || image === void 0 ? void 0 : image.key) === key ? image.url : null;
+}
+// src/block-diff-preview.tsx
+init_objectSpread2();
+function createPreviewSync() {
+	const members = /* @__PURE__ */ new Map();
+	let linked = true;
+	let moving = false;
+	const align = () => {
+		if (!linked || !members.size) return;
+		const views = [...members.keys()];
+		const fit = {
+			scale: Math.min(...views.map((view) => view.fit.scale)),
+			height: Math.max(...views.map((view) => view.fit.height))
+		};
+		for (const view of views) view.layout(fit);
+	};
+	return {
+		add(view) {
+			const stop = view.onChange(() => {
+				if (!linked || moving) return;
+				moving = true;
+				try {
+					const viewport = view.viewport();
+					for (const other of members.keys()) if (other !== view) other.setViewport(viewport);
+				} finally {
+					moving = false;
+				}
+			});
+			members.set(view, stop);
+			align();
+			return () => {
+				stop();
+				members.delete(view);
+			};
+		},
+		setLinked(value) {
+			if (linked === value) return;
+			linked = value;
+			align();
+		}
+	};
+}
+var linkLabels = {
+	en: "Move both versions together",
+	ja: "変更前と変更後を連動して動かす"
+};
+/** One sync group per comparison, with the checkbox that links or unlinks its previews. */
+function usePreviewSync(locale) {
+	const sync = useMemo(createPreviewSync, []);
+	const [linked, setLinked] = useState(true);
+	useEffect(() => sync.setLinked(linked), [sync, linked]);
+	return {
+		sync,
+		toggle: /* @__PURE__ */ React.createElement("label", { className: "twgit-block-diff-link" }, /* @__PURE__ */ React.createElement("input", {
+			type: "checkbox",
+			checked: linked,
+			onChange: (event) => setLinked(event.currentTarget.checked)
+		}), " ", locale.startsWith("ja") ? linkLabels.ja : linkLabels.en)
+	};
+}
+var rendering = (result) => typeof result === "function" ? { release: result } : {
+	release: result && (() => result.dispose()),
+	view: result === null || result === void 0 ? void 0 : result.view
+};
+function BlockPreview({ side, title, parts, marks, renderBlock, withContext, labels, onLocate, locationStatus, version, loadAsset, sync }) {
+	const host = useRef(null);
+	const watermark = useRef(null);
+	const [status, setStatus] = useState("loading");
+	const thumbnail = !!(side && version && loadAsset && currentCostume(side.target));
+	const image = useCostumeImage(thumbnail ? side.target : void 0, version !== null && version !== void 0 ? version : "after", loadAsset);
+	useEffect(() => {
+		if (!side || !host.current) return;
+		const container = host.current;
+		const abort = new AbortController();
+		let dispose;
+		setStatus("loading");
+		Promise.resolve().then(() => {
+			var _watermark$current;
+			return renderBlock(_objectSpread2(_objectSpread2({}, side), {}, {
+				container,
+				withContext,
+				parts,
+				marks,
+				signal: abort.signal,
+				watermark: thumbnail ? (_watermark$current = watermark.current) !== null && _watermark$current !== void 0 ? _watermark$current : void 0 : void 0
+			}));
+		}).then((result) => {
+			const { release, view } = rendering(result);
+			if (abort.signal.aborted) {
+				release === null || release === void 0 || release();
+				return;
+			}
+			const leave = view && (sync === null || sync === void 0 ? void 0 : sync.add(view));
+			dispose = () => {
+				leave === null || leave === void 0 || leave();
+				release === null || release === void 0 || release();
+			};
+			setStatus("ready");
+		}, () => {
+			if (!abort.signal.aborted) setStatus("failed");
+		});
+		return () => {
+			abort.abort();
+			dispose === null || dispose === void 0 || dispose();
+		};
+	}, [
+		side,
+		renderBlock,
+		withContext,
+		parts,
+		marks,
+		sync,
+		thumbnail
+	]);
+	return /* @__PURE__ */ React.createElement("div", { className: "twgit-block-diff-side" }, /* @__PURE__ */ React.createElement("h4", null, title), !side && /* @__PURE__ */ React.createElement("p", null, labels.absent), side && status === "loading" && /* @__PURE__ */ React.createElement("p", { role: "status" }, labels.loading), side && status === "failed" && /* @__PURE__ */ React.createElement("p", { role: "status" }, labels.unavailable), side && /* @__PURE__ */ React.createElement("div", {
+		ref: host,
+		className: "twgit-block-diff-preview"
+	}, thumbnail && /* @__PURE__ */ React.createElement("div", {
+		ref: watermark,
+		className: "twgit-block-diff-watermark",
+		"data-dockview-costume-thumbnail": ""
+	}, image && /* @__PURE__ */ React.createElement("img", {
+		src: image,
+		alt: ""
+	}))), side && onLocate && /* @__PURE__ */ React.createElement("button", {
+		type: "button",
+		"aria-label": `${title} · ${labels.locate}`,
+		onClick: onLocate
+	}, labels.locate), locationStatus && /* @__PURE__ */ React.createElement("p", { role: "status" }, labels[locationStatus]));
+}
+// src/project-source-review-model.ts
+init_objectSpread2();
+function scriptRoots(target) {
+	const roots = /* @__PURE__ */ new Map();
+	if (!target) return roots;
+	for (const id of Object.keys(target.blocks)) {
+		var _roots$get;
+		if (roots.has(id)) continue;
+		const chain = /* @__PURE__ */ new Set();
+		let current = id;
+		while (!roots.has(current) && !chain.has(current)) {
+			chain.add(current);
+			const block = target.blocks[current];
+			if (!isRecord(block) || typeof block.parent !== "string" || !Object.hasOwn(target.blocks, block.parent)) break;
+			current = block.parent;
+		}
+		const root = (_roots$get = roots.get(current)) !== null && _roots$get !== void 0 ? _roots$get : current;
+		for (const block of chain) roots.set(block, root);
+	}
+	return roots;
+}
+function groupScripts(before, after, changes) {
+	const roots = {
+		before: scriptRoots(before),
+		after: scriptRoots(after)
+	};
+	const parents = /* @__PURE__ */ new Map();
+	function groupOf(key) {
+		let parent = key;
+		while (parents.has(parent)) parent = parents.get(parent);
+		for (let current = key; current !== parent;) {
+			const next = parents.get(current);
+			parents.set(current, parent);
+			current = next;
+		}
+		return parent;
+	}
+	for (const [id, oldRoot] of roots.before) {
+		const newRoot = roots.after.get(id);
+		if (newRoot === void 0) continue;
+		const a = groupOf("before:" + oldRoot), b = groupOf("after:" + newRoot);
+		if (a !== b) parents.set(b, a);
+	}
+	const groups = /* @__PURE__ */ new Map();
+	const sides = /* @__PURE__ */ new Map();
+	for (const version of ["before", "after"]) {
+		const target = version === "before" ? before : after;
+		if (!target) continue;
+		for (const root of new Set(roots[version].values())) {
+			var _groups$get;
+			const key = version + ":" + root;
+			const id = groupOf(key);
+			const group = (_groups$get = groups.get(id)) !== null && _groups$get !== void 0 ? _groups$get : {
+				id,
+				before: [],
+				after: []
+			};
+			const side = {
+				target,
+				id: root,
+				marks: []
+			};
+			group[version].push(side);
+			groups.set(id, group);
+			sides.set(key, side);
+		}
+	}
+	const affected = /* @__PURE__ */ new Set();
+	for (const change of changes) for (const version of ["before", "after"]) {
+		var _sides$get;
+		const block = change[version];
+		if (!block) continue;
+		const key = version + ":" + roots[version].get(block.id);
+		(_sides$get = sides.get(key)) === null || _sides$get === void 0 || _sides$get.marks.push({
+			id: block.id,
+			kind: change.kind,
+			parts: change.parts
+		});
+		affected.add(groupOf(key));
+	}
+	return [...affected].map((id) => groups.get(id));
+}
+function changedProperties(before, after, except) {
+	return [.../* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)])].filter((key) => key !== except && !equal(before[key], after[key]));
+}
+function compareProjectForReview(before, after) {
+	const { changes } = compareProjectBlocks(before, after);
+	const byTarget = /* @__PURE__ */ new Map();
+	for (const change of changes) {
+		var _change$after;
+		const key = targetKey(((_change$after = change.after) !== null && _change$after !== void 0 ? _change$after : change.before).target);
+		const existing = byTarget.get(key);
+		if (existing) existing.push(change);
+		else byTarget.set(key, [change]);
+	}
+	const oldTargets = new Map(before.targets.map((target) => [targetKey(target), target]));
+	const newTargets = new Map(after.targets.map((target) => [targetKey(target), target]));
+	const targets = [];
+	for (const key of /* @__PURE__ */ new Set([...oldTargets.keys(), ...newTargets.keys()])) {
+		const a = oldTargets.get(key), b = newTargets.get(key);
+		const edits = byTarget.get(key);
+		const scripts = edits ? groupScripts(a, b, edits) : [];
+		const properties = changedProperties(_objectSpread2({}, a), _objectSpread2({}, b), "blocks");
+		if (scripts.length || properties.length) {
+			const { name, isStage } = b !== null && b !== void 0 ? b : a;
+			targets.push({
+				name,
+				isStage,
+				scripts,
+				properties,
+				before: a,
+				after: b
+			});
+		}
+	}
+	return {
+		targets,
+		properties: changedProperties(before, after, "targets")
+	};
+}
+// src/project-source-review.tsx
+var ja = {
+	review: "変更レビュー",
+	fullDescription: "PR 本文を表示",
+	checks: "確認してほしいこと",
+	files: "変更ファイル",
+	targets: "影響するステージ・スプライト",
+	scripts: "コードの変更",
+	scriptCount: (count) => `コードの変更 · ${count} か所`,
+	reviewed: "確認済み",
+	before: "変更前",
+	after: "変更後",
+	updated: "変更",
+	added: "追加",
+	removed: "削除",
+	reorganized: "再編",
+	absent: "この版にはこのコードがありません",
+	loading: "コードを描画中…",
+	unavailable: "このコードを描画できません。",
+	related: "関連ファイル",
+	properties: "コード以外の変更",
+	invalid: "この作品の差分を読み込めません。",
+	flag: "緑の旗が押されたとき",
+	broadcast: "を受け取ったとき",
+	key: "キーが押されたとき",
+	click: "このスプライトが押されたとき",
+	script: "コード",
+	noChanges: "作品に内容の変更はありません。",
+	comparison: "作品の変更",
+	unreadable: "作品データとして読み込めないため、テキストの差分を表示します。"
+};
+var en = {
+	review: "Change review",
+	fullDescription: "Show full PR description",
+	checks: "Review checklist",
+	files: "Changed files",
+	targets: "Affected stages and sprites",
+	scripts: "Code changes",
+	scriptCount: (count) => `Code changes · ${count}`,
+	reviewed: "Reviewed",
+	before: "Before",
+	after: "After",
+	updated: "Changed",
+	added: "Added",
+	removed: "Removed",
+	reorganized: "Reorganized",
+	absent: "No code in this version",
+	loading: "Rendering code…",
+	unavailable: "This code could not be rendered.",
+	related: "Related file",
+	properties: "Changes outside the code",
+	invalid: "This project diff could not be read.",
+	flag: "When green flag clicked",
+	broadcast: "received",
+	key: "When key pressed",
+	click: "When this sprite clicked",
+	script: "Code",
+	noChanges: "No changes to the project contents.",
+	comparison: "Project changes",
+	unreadable: "This file could not be read as project data, so its text diff is shown."
+};
+var properties = /* @__PURE__ */ new Map([
+	["variables", ["変数", "Variables"]],
+	["lists", ["リスト", "Lists"]],
+	["broadcasts", ["メッセージ", "Broadcast messages"]],
+	["costumes", ["コスチューム・背景", "Costumes and backdrops"]],
+	["sounds", ["音", "Sounds"]],
+	["comments", ["コメント", "Comments"]],
+	["monitors", ["モニター", "Monitors"]],
+	["extensions", ["拡張機能", "Extensions"]],
+	["x", ["X 座標", "X position"]],
+	["y", ["Y 座標", "Y position"]],
+	["visible", ["表示状態", "Visibility"]],
+	["direction", ["向き", "Direction"]],
+	["size", ["大きさ", "Size"]],
+	["currentCostume", ["表示するコスチューム", "Selected costume"]]
+]);
+function scriptTitle(side, labels) {
+	const block = side.target.blocks[side.id];
+	if (!isRecord(block)) return labels.script;
+	if (block.opcode === "event_whenflagclicked") return labels.flag;
+	if (block.opcode === "event_whenthisspriteclicked") return labels.click;
+	if (block.opcode === "event_whenkeypressed") return labels.key;
+	if (block.opcode === "event_whenbroadcastreceived") {
+		const field = isRecord(block.fields) ? block.fields.BROADCAST_OPTION : void 0;
+		const message = Array.isArray(field) && typeof field[0] === "string" ? field[0] : "";
+		if (message) return labels === ja ? `「${message}」${labels.broadcast}` : `“${message}” ${labels.broadcast}`;
+	}
+	return typeof block.opcode === "string" ? block.opcode : labels.script;
+}
+function ScriptComparison({ script, labels, reviewed = false, setReviewed, renderBlock, loadAsset }) {
+	const [open, setOpen] = useState(false);
+	const { sync, toggle } = usePreviewSync(labels === ja ? "ja" : "en");
+	const status = !script.before.length ? "added" : !script.after.length ? "removed" : script.before.length !== 1 || script.after.length !== 1 ? "reorganized" : "updated";
+	const beforeTitle = script.before[0] && scriptTitle(script.before[0], labels);
+	const afterTitle = script.after[0] && scriptTitle(script.after[0], labels);
+	const title = beforeTitle && afterTitle && beforeTitle !== afterTitle ? beforeTitle + " → " + afterTitle : afterTitle !== null && afterTitle !== void 0 ? afterTitle : beforeTitle;
+	return /* @__PURE__ */ React.createElement("details", {
+		className: "twgit-review-script",
+		onToggle: (event) => setOpen(event.currentTarget.open)
+	}, /* @__PURE__ */ React.createElement("summary", null, /* @__PURE__ */ React.createElement("span", { className: "twgit-review-status" }, labels[status]), /* @__PURE__ */ React.createElement("strong", null, title), status === "reorganized" && /* @__PURE__ */ React.createElement("small", null, script.before.length, " → ", script.after.length), reviewed && /* @__PURE__ */ React.createElement("small", null, labels.reviewed)), open && /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement("div", { className: "twgit-block-diff-sides" }, ["before", "after"].map((version) => /* @__PURE__ */ React.createElement("div", { key: version }, script[version].length ? script[version].map((side, index, sides) => /* @__PURE__ */ React.createElement(BlockPreview, {
+		key: side.id,
+		side,
+		title: sides.length > 1 ? `${labels[version]} ${index + 1}` : labels[version],
+		marks: side.marks,
+		renderBlock,
+		withContext: true,
+		labels,
+		version,
+		loadAsset,
+		sync
+	})) : /* @__PURE__ */ React.createElement(BlockPreview, {
+		title: labels[version],
+		renderBlock,
+		withContext: true,
+		labels
+	})))), toggle, setReviewed && /* @__PURE__ */ React.createElement("label", { className: "twgit-review-checked" }, /* @__PURE__ */ React.createElement("input", {
+		type: "checkbox",
+		checked: reviewed,
+		onChange: (event) => setReviewed(event.currentTarget.checked)
+	}), " ", labels.reviewed)));
+}
+function propertyNames(keys, labels) {
+	return keys.map((key) => {
+		var _properties$get, _properties$get2;
+		return (_properties$get = (_properties$get2 = properties.get(key)) === null || _properties$get2 === void 0 ? void 0 : _properties$get2[labels === ja ? 0 : 1]) !== null && _properties$get !== void 0 ? _properties$get : key;
+	}).join(" · ");
+}
+/**
+* The current costume (the backdrop for the stage) of each version of a target that has one. A changed costume shows
+* before → after. Nothing is shown until an image is read, so the heading falls back to the name alone.
+*/
+function TargetThumbnails({ target, labels, loadAsset }) {
+	const images = {
+		before: useCostumeImage(target.before, "before", loadAsset),
+		after: useCostumeImage(target.after, "after", loadAsset)
+	};
+	const costumes = {
+		before: target.before && currentCostume(target.before),
+		after: target.after && currentCostume(target.after)
+	};
+	const changed = !!costumes.before && !!costumes.after && costumes.before.md5ext !== costumes.after.md5ext;
+	const shown = (changed ? ["before", "after"] : [images.after ? "after" : "before"]).filter((version) => images[version]);
+	if (!shown.length) return null;
+	return /* @__PURE__ */ React.createElement("span", { className: "twgit-review-thumbnails" }, shown.map((version, index) => {
+		var _costumes$version, _costumes$version$nam, _costumes$version2;
+		return /* @__PURE__ */ React.createElement(React.Fragment, { key: version }, index > 0 && /* @__PURE__ */ React.createElement("span", { "aria-hidden": "true" }, "→"), /* @__PURE__ */ React.createElement("img", {
+			src: images[version],
+			title: ((_costumes$version = costumes[version]) === null || _costumes$version === void 0 ? void 0 : _costumes$version.name) || void 0,
+			alt: changed ? `${labels[version]}: ${(_costumes$version$nam = (_costumes$version2 = costumes[version]) === null || _costumes$version2 === void 0 ? void 0 : _costumes$version2.name) !== null && _costumes$version$nam !== void 0 ? _costumes$version$nam : ""}` : ""
+		}));
+	}));
+}
+/** Lists the changed stages and sprites of one project file, each with its code comparisons. */
+function ComparisonTargets({ comparison, labels, renderBlock, loadAsset, review }) {
+	return /* @__PURE__ */ React.createElement(React.Fragment, null, comparison.properties.length > 0 && /* @__PURE__ */ React.createElement("p", null, labels.properties, " · ", propertyNames(comparison.properties, labels)), !comparison.targets.length && !comparison.properties.length && /* @__PURE__ */ React.createElement("p", null, labels.noChanges), comparison.targets.map((target) => /* @__PURE__ */ React.createElement("section", {
+		className: "twgit-review-target",
+		key: JSON.stringify([target.isStage, target.name])
+	}, /* @__PURE__ */ React.createElement("h5", null, /* @__PURE__ */ React.createElement(TargetThumbnails, {
+		target,
+		labels,
+		loadAsset
+	}), target.name, target.scripts.length > 0 && /* @__PURE__ */ React.createElement("small", null, labels.scriptCount(target.scripts.length))), target.properties.length > 0 && /* @__PURE__ */ React.createElement("p", null, labels.properties, " · ", propertyNames(target.properties, labels)), target.scripts.map((script) => {
+		const key = JSON.stringify([
+			review === null || review === void 0 ? void 0 : review.file,
+			target.isStage,
+			target.name,
+			script.id
+		]);
+		return /* @__PURE__ */ React.createElement(ScriptComparison, {
+			key,
+			script,
+			labels,
+			renderBlock,
+			loadAsset,
+			reviewed: review === null || review === void 0 ? void 0 : review.keys.has(key),
+			setReviewed: review && ((value) => review.set(key, value))
+		});
+	}))));
+}
+var countScripts = (comparison) => comparison.targets.reduce((count, target) => count + target.scripts.length, 0);
+/** Compares two versions of a project.source.json by stage, sprite and code, as the pull request review does. */
+function ProjectSourceComparison({ before, after, renderBlock, locale = "en", fallback, loadAsset }) {
+	const labels = locale.startsWith("ja") ? ja : en;
+	const comparison = useMemo(() => {
+		try {
+			return compareProjectForReview(parseProjectSource(before), parseProjectSource(after));
+		} catch (_unused) {
+			return null;
+		}
+	}, [before, after]);
+	if (!comparison) return fallback === void 0 ? /* @__PURE__ */ React.createElement("p", { role: "alert" }, labels.invalid) : /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement("p", {
+		role: "alert",
+		className: "twgit-review-unreadable"
+	}, labels.unreadable), fallback);
+	return /* @__PURE__ */ React.createElement("section", {
+		className: "twgit-block-diff twgit-review twgit-review-comparison",
+		"aria-label": labels.comparison
+	}, /* @__PURE__ */ React.createElement("header", { className: "twgit-review-overview" }, /* @__PURE__ */ React.createElement("dl", null, /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement("dt", null, labels.targets), /* @__PURE__ */ React.createElement("dd", null, comparison.targets.length)), /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement("dt", null, labels.scripts), /* @__PURE__ */ React.createElement("dd", null, countScripts(comparison))))), /* @__PURE__ */ React.createElement(ComparisonTargets, {
+		comparison,
+		labels,
+		renderBlock,
+		loadAsset
+	}));
+}
+function ProjectSourceReview({ title, description, verification, files, renderBlock, locale = "en" }) {
+	const labels = locale.startsWith("ja") ? ja : en;
+	const entries = useMemo(() => files.map((file) => {
+		if (!("patch" in file)) return { file };
+		try {
+			const projects = readProjectSourceDiff(file.patch, file.beforeSource);
+			return {
+				file,
+				comparison: projects ? compareProjectForReview(...projects) : {
+					targets: [],
+					properties: []
+				}
+			};
+		} catch (_unused2) {
+			return {
+				file,
+				invalid: true
+			};
+		}
+	}), [files]);
+	const [checked, setChecked] = useState();
+	const reviewed = (checked === null || checked === void 0 ? void 0 : checked.entries) === entries ? checked.keys : /* @__PURE__ */ new Set();
+	const setReviewed = (key, value) => setChecked((previous) => {
+		const keys = new Set((previous === null || previous === void 0 ? void 0 : previous.entries) === entries ? previous.keys : []);
+		if (value) keys.add(key);
+		else keys.delete(key);
+		return {
+			entries,
+			keys
+		};
+	});
+	const targets = entries.reduce((total, entry) => {
+		var _entry$comparison$tar, _entry$comparison;
+		return total + ((_entry$comparison$tar = (_entry$comparison = entry.comparison) === null || _entry$comparison === void 0 ? void 0 : _entry$comparison.targets.length) !== null && _entry$comparison$tar !== void 0 ? _entry$comparison$tar : 0);
+	}, 0);
+	const scripts = entries.reduce((total, entry) => total + (entry.comparison ? countScripts(entry.comparison) : 0), 0);
+	const body = description === null || description === void 0 ? void 0 : description.trim();
+	const longBody = !!body && body.length > 420;
+	const excerpt = longBody ? body.slice(0, 250).trimEnd() + "…" : body;
+	return /* @__PURE__ */ React.createElement("section", {
+		className: "twgit-block-diff twgit-review",
+		"aria-label": labels.review
+	}, /* @__PURE__ */ React.createElement("header", { className: "twgit-review-overview" }, /* @__PURE__ */ React.createElement("p", null, labels.review), /* @__PURE__ */ React.createElement("h2", null, title), excerpt && /* @__PURE__ */ React.createElement("p", { className: "twgit-review-description" }, excerpt), /* @__PURE__ */ React.createElement("dl", null, /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement("dt", null, labels.files), /* @__PURE__ */ React.createElement("dd", null, entries.length)), /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement("dt", null, labels.targets), /* @__PURE__ */ React.createElement("dd", null, targets)), /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement("dt", null, labels.scripts), /* @__PURE__ */ React.createElement("dd", null, scripts)), scripts > 0 && /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement("dt", null, labels.reviewed), /* @__PURE__ */ React.createElement("dd", null, reviewed.size, " / ", scripts))), longBody && /* @__PURE__ */ React.createElement("details", { className: "twgit-review-body" }, /* @__PURE__ */ React.createElement("summary", null, labels.fullDescription), /* @__PURE__ */ React.createElement("p", { className: "twgit-review-description" }, body)), !!(verification === null || verification === void 0 ? void 0 : verification.length) && /* @__PURE__ */ React.createElement("div", { className: "twgit-review-checklist" }, /* @__PURE__ */ React.createElement("h3", null, labels.checks), /* @__PURE__ */ React.createElement("ul", null, verification.map((item, index) => /* @__PURE__ */ React.createElement("li", { key: index }, item))))), /* @__PURE__ */ React.createElement("h3", { className: "twgit-review-files-title" }, labels.files), entries.map(({ file, comparison, invalid }) => /* @__PURE__ */ React.createElement("section", {
+		key: file.path,
+		className: "twgit-review-file"
+	}, /* @__PURE__ */ React.createElement("header", null, /* @__PURE__ */ React.createElement("h4", null, file.previousPath ? file.previousPath + " → " + file.path : file.path), file.summary && /* @__PURE__ */ React.createElement("p", null, file.summary)), "status" in file && /* @__PURE__ */ React.createElement("p", null, labels.related, " · ", labels[file.status]), (invalid || file.unavailable) && /* @__PURE__ */ React.createElement("p", { role: "alert" }, labels.invalid), comparison && /* @__PURE__ */ React.createElement(ComparisonTargets, {
+		comparison,
+		labels,
+		renderBlock,
+		loadAsset: "loadAsset" in file ? file.loadAsset : void 0,
+		review: {
+			file: file.path,
+			keys: reviewed,
+			set: setReviewed
+		}
+	}))));
+}
+// src/github-pull-requests.ts
+init_objectSpread2();
+var PullRequestError = class extends Error {
+	constructor(code) {
+		super(code);
+		this.code = code;
+	}
+};
+var repositoryName = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/;
+var validRepository = (value) => typeof value === "string" && repositoryName.test(value) && value.split("/").every((segment) => segment !== "." && segment !== "..");
+var isSha = (value) => typeof value === "string" && /^[a-f0-9]{40}$/i.test(value);
+function gitHubRepositoryFromOrigin(origin) {
+	var _origin$trim$match;
+	const name = origin === null || origin === void 0 || (_origin$trim$match = origin.trim().match(/^(?:https:\/\/github\.com\/|ssh:\/\/git@github\.com\/|git@github\.com:)([^/?#]+\/[^/?#]+)\/?$/i)) === null || _origin$trim$match === void 0 ? void 0 : _origin$trim$match[1];
+	const repository = name === null || name === void 0 ? void 0 : name.replace(/\.git$/i, "");
+	return validRepository(repository) ? repository : null;
+}
+function repoPath(repository) {
+	return "/repos/" + repository.split("/").map(encodeURIComponent).join("/");
+}
+var invalidResponse = () => new PullRequestError("failed");
+var emptyProject = "{\"targets\":[]}\n";
+var sourceLimit = 1048576;
+async function readBody(response, limit, chunk) {
+	if (Number(response.headers.get("Content-Length")) > limit || !response.body) throw invalidResponse();
+	const reader = response.body.getReader();
+	let length = 0;
+	try {
+		for (;;) {
+			const { done, value } = await reader.read();
+			if (done) return;
+			length += value.byteLength;
+			if (length > limit) throw invalidResponse();
+			chunk(value);
+		}
+	} catch (error) {
+		reader.cancel().catch(() => {});
+		throw error;
+	}
+}
+async function readText(response, limit) {
+	const decoder = new TextDecoder("utf-8", { fatal: true });
+	const chunks = [];
+	await readBody(response, limit, (value) => chunks.push(decoder.decode(value, { stream: true })));
+	return chunks.join("") + decoder.decode();
+}
+function readSummary(value) {
+	if (!isRecord(value) || !Number.isSafeInteger(value.number) || Number(value.number) < 1 || typeof value.title !== "string") throw invalidResponse();
+	return {
+		number: Number(value.number),
+		title: value.title
+	};
+}
+function readRevision(value) {
+	if (!isRecord(value) || !isSha(value.sha) || typeof value.ref !== "string") throw invalidResponse();
+	const repository = isRecord(value.repo) ? value.repo.full_name : null;
+	if (repository !== null && !validRepository(repository)) throw invalidResponse();
+	return {
+		sha: value.sha,
+		ref: value.ref,
+		repository
+	};
+}
+function readPullRequest(value) {
+	const summary = readSummary(value);
+	if (!isRecord(value) || value.state !== "open" && value.state !== "closed" || !Number.isSafeInteger(value.changed_files) || Number(value.changed_files) < 0) throw invalidResponse();
+	const author = isRecord(value.user) && typeof value.user.login === "string" ? value.user.login : void 0;
+	const description = typeof value.body_text === "string" ? value.body_text : typeof value.body === "string" ? value.body : "";
+	const state = value.merged_at ? "merged" : value.draft ? "draft" : value.state;
+	return _objectSpread2(_objectSpread2({}, summary), {}, {
+		author,
+		description,
+		base: readRevision(value.base),
+		head: readRevision(value.head),
+		state,
+		changedFiles: Number(value.changed_files)
+	});
+}
+function readFile(value) {
+	if (!isRecord(value) || typeof value.filename !== "string" || typeof value.status !== "string") throw invalidResponse();
+	return {
+		path: value.filename,
+		previous: typeof value.previous_filename === "string" ? value.previous_filename : void 0,
+		status: value.status
+	};
+}
+function contentPath(path) {
+	const parts = path.split("/");
+	if (parts.some((part) => !part || part === "." || part === "..")) throw invalidResponse();
+	return parts.map(encodeURIComponent).join("/");
+}
+/**
+* Reads the assets of both versions of a project file from raw.githubusercontent.com, which does not count against the
+* API rate limit. Each version's sb3-source.json names its assets directory. Every read is capped, honors both its own
+* signal and the pull request's, and resolves `null` on any failure.
+*/
+function rawAssetLoader(versions, send, review) {
+	const directories = /* @__PURE__ */ new Map();
+	const get = (url, signal) => send(url, {
+		credentials: "omit",
+		redirect: "error",
+		signal
+	});
+	const folderUrl = ({ repository, sha, path }) => "https://raw.githubusercontent.com/" + repository.split("/").map(encodeURIComponent).join("/") + "/" + sha + "/" + contentPath(path).split("/").slice(0, -1).map((part) => part + "/").join("");
+	const readDirectory = async (folder, signal) => {
+		let settings = null;
+		try {
+			var _response$body;
+			const response = await get(folder + "sb3-source.json", signal);
+			if (response.ok) settings = await readText(response, folderSettingsLimit);
+			else (_response$body = response.body) === null || _response$body === void 0 || _response$body.cancel().catch(() => {});
+		} catch (error) {
+			if (signal.aborted) throw error;
+		}
+		return assetsDirectoryParts(settings);
+	};
+	return async ({ version, md5ext, signal: own }) => {
+		const location = versions[version];
+		if (!location || !isAssetName(md5ext)) return null;
+		try {
+			const signal = AbortSignal.any([own, review]);
+			if (signal.aborted) return null;
+			const folder = folderUrl(location);
+			let directory = directories.get(version);
+			if (!directory) {
+				directory = readDirectory(folder, signal);
+				directories.set(version, directory);
+				const pending = directory;
+				pending.catch(() => {
+					if (directories.get(version) === pending) directories.delete(version);
+				});
+			}
+			const parts = await directory;
+			if (!parts || signal.aborted) return null;
+			const response = await get(folder + parts.map(encodeURIComponent).join("/") + "/" + md5ext, signal);
+			if (!response.ok) {
+				var _response$body2;
+				(_response$body2 = response.body) === null || _response$body2 === void 0 || _response$body2.cancel().catch(() => {});
+				return null;
+			}
+			const chunks = [];
+			await readBody(response, assetLimit, (value) => chunks.push(value));
+			return signal.aborted ? null : new Blob(chunks);
+		} catch (_unused) {
+			return null;
+		}
+	};
+}
+function createGitHubPullRequests(repository, send = fetch) {
+	if (!validRepository(repository)) throw invalidResponse();
+	const api = "https://api.github.com";
+	const repo = repoPath(repository);
+	const request = async (path, signal, accept = "application/vnd.github+json") => {
+		const response = await send(api + path, {
+			headers: { Accept: accept },
+			credentials: "omit",
+			redirect: "error",
+			signal
+		});
+		if (!response.ok) {
+			if (response.status === 429 || response.status === 403 && (response.headers.get("X-RateLimit-Remaining") === "0" || response.headers.has("Retry-After"))) throw new PullRequestError("rateLimit");
+			if (response.status === 404 || response.status === 403) throw new PullRequestError("unavailable");
+			throw invalidResponse();
+		}
+		return response;
+	};
+	const json = async (path, signal, accept) => JSON.parse(await readText(await request(path, signal, accept), 12 * sourceLimit));
+	const metadata = async (number, signal) => readPullRequest(await json(repo + "/pulls/" + number, signal, "application/vnd.github.text+json"));
+	const source = async (name, path, revision, signal) => readText(await request(repoPath(name) + "/contents/" + contentPath(path) + "?ref=" + revision, signal, "application/vnd.github.raw+json"), sourceLimit);
+	return {
+		async list(page, signal) {
+			const result = await json(repo + "/pulls?state=all&sort=updated&per_page=20&page=" + page, signal);
+			if (!Array.isArray(result)) throw invalidResponse();
+			return {
+				items: result.map(readSummary),
+				more: result.length === 20
+			};
+		},
+		async load(number, signal) {
+			if (!Number.isSafeInteger(number) || number < 1) throw invalidResponse();
+			const pr = await metadata(number, signal);
+			if (pr.number !== number) throw invalidResponse();
+			if (pr.changedFiles > 3e3) throw new PullRequestError("tooManyFiles");
+			const records = [];
+			for (let page = 1; page <= Math.ceil(pr.changedFiles / 100); page++) {
+				const result = await json(repo + "/pulls/" + number + "/files?per_page=100&page=" + page, signal);
+				if (!Array.isArray(result)) throw invalidResponse();
+				records.push(...result.map(readFile));
+			}
+			const current = await metadata(number, signal);
+			if (current.base.sha !== pr.base.sha || current.head.sha !== pr.head.sha || current.changedFiles !== pr.changedFiles || records.length !== pr.changedFiles) throw new PullRequestError("changed");
+			let base;
+			if (records.some((file) => file.path.split("/").pop() === "project.source.json" && file.status !== "added" && file.status !== "copied")) try {
+				const comparison = await json(repo + "/compare/" + pr.base.sha + "..." + pr.head.sha + "?per_page=1", signal);
+				const merge = isRecord(comparison) ? comparison.merge_base_commit : null;
+				if (isRecord(merge) && isSha(merge.sha)) base = merge.sha;
+			} catch (error) {
+				if (signal.aborted) throw error;
+			}
+			const files = [];
+			for (const file of records) {
+				const status = file.status === "removed" ? "removed" : file.status === "added" || file.status === "copied" ? "added" : "updated";
+				const related = {
+					path: file.path,
+					status,
+					previousPath: file.previous
+				};
+				if (file.path.split("/").pop() !== "project.source.json") {
+					files.push(related);
+					continue;
+				}
+				try {
+					var _file$previous, _pr$head$repository, _file$previous2, _pr$head$repository2;
+					if (status !== "added" && !base) throw invalidResponse();
+					const [before, after] = await Promise.all([status === "added" ? emptyProject : source(repository, (_file$previous = file.previous) !== null && _file$previous !== void 0 ? _file$previous : file.path, base, signal), status === "removed" ? emptyProject : source((_pr$head$repository = pr.head.repository) !== null && _pr$head$repository !== void 0 ? _pr$head$repository : repository, file.path, pr.head.sha, signal)]);
+					const loadAsset = rawAssetLoader({
+						before: status === "added" ? null : {
+							repository,
+							sha: base,
+							path: (_file$previous2 = file.previous) !== null && _file$previous2 !== void 0 ? _file$previous2 : file.path
+						},
+						after: status === "removed" ? null : {
+							repository: (_pr$head$repository2 = pr.head.repository) !== null && _pr$head$repository2 !== void 0 ? _pr$head$repository2 : repository,
+							sha: pr.head.sha,
+							path: file.path
+						}
+					}, send, signal);
+					files.push({
+						path: file.path,
+						previousPath: file.previous,
+						patch: createProjectSourceDiff(before, after),
+						loadAsset
+					});
+				} catch (error) {
+					if (signal.aborted) throw error;
+					files.push(_objectSpread2(_objectSpread2({}, related), {}, { unavailable: true }));
+				}
+			}
+			return _objectSpread2(_objectSpread2({}, pr), {}, {
+				files,
+				url: "https://github.com/" + repository + "/pull/" + number
+			});
+		}
+	};
+}
+// src/block-diff-location.ts
+function markBlockLocation(block, parts) {
+	const root = block.getSvgRoot();
+	if (!root) return;
+	root.classList.add("twgit-changed-block");
+	const marked = /* @__PURE__ */ new Set();
+	for (const { kind, name } of parts) {
+		var _block$getInputTarget, _block$getField;
+		const part = kind === "input" ? (_block$getInputTarget = block.getInputTargetBlock) === null || _block$getInputTarget === void 0 ? void 0 : _block$getInputTarget.call(block, name) : (_block$getField = block.getField) === null || _block$getField === void 0 ? void 0 : _block$getField.call(block, name);
+		const element = part === null || part === void 0 ? void 0 : part.getSvgRoot();
+		if (!element || element === root || marked.has(element)) continue;
+		element.classList.add("twgit-changed-block-part");
+		marked.add(element);
+	}
+	return () => {
+		root.classList.remove("twgit-changed-block");
+		for (const element of marked) element.classList.remove("twgit-changed-block-part");
+	};
+}
+/** Resolve the matching project revision and target in the host before navigating its workspace. */
+function createScratchBlocksDiffLocator(resolveWorkspace) {
+	return async (location) => {
+		const workspace = await resolveWorkspace(location);
+		if (!workspace || location.signal.aborted) return false;
+		const block = workspace.getBlockById(location.id);
+		const expected = location.target.blocks[location.id];
+		if (!block || isRecord(expected) && typeof expected.opcode === "string" && block.type !== expected.opcode) return false;
+		const clear = markBlockLocation(block, location.parts);
+		if (!clear) return false;
+		try {
+			workspace.centerOnBlock(location.id);
+		} catch (error) {
+			clear();
+			throw error;
+		}
+		if (location.signal.aborted) {
+			clear();
+			return false;
+		}
+		location.signal.addEventListener("abort", clear, { once: true });
+		return true;
+	};
+}
+// src/scratch-block-diff-renderer.ts
+init_objectSpread2();
+function scriptRoot({ target, id }) {
+	const visited = /* @__PURE__ */ new Set();
+	for (;;) {
+		const block = target.blocks[id];
+		if (!isRecord(block) || typeof block.parent !== "string" || !Object.hasOwn(target.blocks, block.parent)) return id;
+		if (visited.has(id)) throw new Error("Cyclic block parents.");
+		visited.add(id);
+		id = block.parent;
+	}
+}
+function safeMutation(value, root, depth = 0) {
+	if (!isRecord(value) || depth > 32 || value.tagName !== (root ? "mutation" : "arg") || !Array.isArray(value.children)) return false;
+	return Object.entries(value).every(([key, item]) => key === "children" || /^[a-zA-Z][\w-]*$/.test(key) && [
+		"string",
+		"number",
+		"boolean"
+	].includes(typeof item)) && value.children.every((child) => safeMutation(child, false, depth + 1));
+}
+function selectBlocks({ target, id }, root, withContext) {
+	const selected = Object.create(null);
+	const visiting = /* @__PURE__ */ new Set();
+	let blockCount = 0;
+	function visit(blockId, followNext, depth) {
+		if (visiting.has(blockId) || depth > 128) throw new Error("Block preview exceeds its graph limit.");
+		if (Object.hasOwn(selected, blockId) || !Object.hasOwn(target.blocks, blockId)) return;
+		if (++blockCount > 800) throw new Error("Block preview exceeds its graph limit.");
+		if (blockId === "__proto__") throw new Error("Invalid block ID.");
+		const data = target.blocks[blockId];
+		if (Array.isArray(data)) {
+			selected[blockId] = data.length > 3 ? [
+				...data.slice(0, 3),
+				20,
+				20
+			] : [...data];
+			return;
+		}
+		if (!isRecord(data) || typeof data.opcode !== "string") throw new Error("Invalid Scratch block.");
+		const block = structuredClone(data);
+		if (block.mutation && !safeMutation(block.mutation, true)) throw new Error("Unsupported block mutation.");
+		block.x = 20;
+		block.y = 20;
+		block.topLevel = blockId === root;
+		if (blockId === root) block.shadow = false;
+		delete block.comment;
+		if (!followNext) block.next = null;
+		selected[blockId] = block;
+		visiting.add(blockId);
+		if (isRecord(block.inputs)) for (const [name, input] of Object.entries(block.inputs)) {
+			if (!withContext && /^SUBSTACK\d*$/.test(name)) {
+				delete block.inputs[name];
+				continue;
+			}
+			if (!Array.isArray(input)) continue;
+			for (const child of input.slice(1, 3)) if (typeof child === "string") visit(child, withContext, depth + 1);
+		}
+		if (typeof block.next === "string") visit(block.next, true, depth + 1);
+		visiting.delete(blockId);
+	}
+	visit(root, withContext, 0);
+	if (!Object.hasOwn(selected, id)) throw new Error("The changed block is not reachable.");
+	return selected;
+}
+var placeholderPrefix = "twgit_review_placeholder_";
+var placeholderSerial = 0;
+function statementInput(element) {
+	var _element$getAttribute;
+	return element.localName === "statement" || /^SUBSTACK\d*$/.test((_element$getAttribute = element.getAttribute("name")) !== null && _element$getAttribute !== void 0 ? _element$getAttribute : "");
+}
+function placeholderDefinition(element, opcode, type, blockly, locale) {
+	const args = [{
+		type: "field_label",
+		text: (locale.startsWith("ja") ? "未登録: " : "Unregistered: ") + opcode.slice(0, 120)
+	}];
+	const branches = [];
+	for (const child of Array.from(element.children)) {
+		const name = child.getAttribute("name");
+		if (!name) continue;
+		if (child.localName === "field") args.push({
+			type: "field_input",
+			name,
+			text: ""
+		});
+		else if (statementInput(child)) branches.push(name);
+		else if (child.localName === "value") args.push({
+			type: "input_value",
+			name
+		});
+	}
+	const parent = element.parentElement;
+	const reporter = (parent === null || parent === void 0 ? void 0 : parent.localName) === "value" && !statementInput(parent);
+	const definition = _objectSpread2({
+		type,
+		message0: args.map((_, index) => "%" + (index + 1)).join(" "),
+		args0: args,
+		inputsInline: true,
+		colour: "#687488",
+		colourSecondary: "#566274",
+		colourTertiary: "#4b5564"
+	}, reporter ? {
+		output: null,
+		outputShape: blockly.OUTPUT_SHAPE_ROUND
+	} : {
+		previousStatement: null,
+		nextStatement: null
+	});
+	for (const [index, name] of branches.entries()) {
+		definition["message" + (index + 1)] = "%1";
+		definition["args" + (index + 1)] = [{
+			type: "input_statement",
+			name
+		}];
+	}
+	return definition;
+}
+var defaultScale = .675;
+var padding = 16;
+var minHeight = 160;
+var maxHeight = 420;
+/**
+* Sizes a preview frame to its blocks and reports scrolling and zooming, so both versions can move together.
+* The frame keeps a gutter on the right for the zoom buttons, and for the minimap and thumbnail when present.
+*/
+function createView(workspace, blockly, surface, frame, startScale, navigation) {
+	var _bounds$x, _bounds$y, _workspace$translate, _surface$ownerDocumen;
+	const bounds = workspace.getBlocksBoundingBox();
+	const left = (_bounds$x = bounds.x) !== null && _bounds$x !== void 0 ? _bounds$x : 0, top = (_bounds$y = bounds.y) !== null && _bounds$y !== void 0 ? _bounds$y : 0;
+	const gutter = navigation ? 150 : 56;
+	const width = frame.clientWidth || 400;
+	const scale = Math.max(.25, Math.min(startScale, (width - padding - gutter) / Math.max(1, bounds.width), 388 / Math.max(1, bounds.height)));
+	const fit = {
+		scale,
+		height: Math.min(maxHeight, Math.max(minHeight, Math.ceil(bounds.height * scale + 32)))
+	};
+	const listeners = /* @__PURE__ */ new Set();
+	const translate = (_workspace$translate = workspace.translate) === null || _workspace$translate === void 0 ? void 0 : _workspace$translate.bind(workspace);
+	let quiet = false;
+	if (translate) workspace.translate = (x, y) => {
+		translate(x, y);
+		if (!quiet) for (const listener of listeners) listener();
+	};
+	const setViewport = ({ scale, x, y }) => {
+		if (!translate) return;
+		quiet = true;
+		try {
+			var _workspace$getMetrics, _metrics$absoluteLeft, _metrics$absoluteTop, _workspace$scrollbar;
+			workspace.scale = scale;
+			workspace.scrollX = x;
+			workspace.scrollY = y;
+			const metrics = (_workspace$getMetrics = workspace.getMetrics) === null || _workspace$getMetrics === void 0 ? void 0 : _workspace$getMetrics.call(workspace);
+			translate(x + ((_metrics$absoluteLeft = metrics === null || metrics === void 0 ? void 0 : metrics.absoluteLeft) !== null && _metrics$absoluteLeft !== void 0 ? _metrics$absoluteLeft : 0), y + ((_metrics$absoluteTop = metrics === null || metrics === void 0 ? void 0 : metrics.absoluteTop) !== null && _metrics$absoluteTop !== void 0 ? _metrics$absoluteTop : 0));
+			(_workspace$scrollbar = workspace.scrollbar) === null || _workspace$scrollbar === void 0 || _workspace$scrollbar.resize();
+		} finally {
+			quiet = false;
+		}
+	};
+	const layout = ({ scale, height }) => {
+		frame.style.height = height + "px";
+		blockly.svgResize(workspace);
+		setViewport({
+			scale,
+			x: padding - left * scale,
+			y: padding - top * scale
+		});
+	};
+	layout(fit);
+	const resize = new ((_surface$ownerDocumen = surface.ownerDocument.defaultView) !== null && _surface$ownerDocumen !== void 0 ? _surface$ownerDocumen : globalThis).ResizeObserver(() => blockly.svgResize(workspace));
+	resize.observe(surface);
+	const wheel = (event) => {
+		if (!event.ctrlKey) event.stopPropagation();
+	};
+	surface.addEventListener("wheel", wheel, { capture: true });
+	return {
+		api: {
+			fit,
+			layout,
+			setViewport,
+			viewport: () => {
+				var _workspace$scale, _workspace$scrollX, _workspace$scrollY;
+				return {
+					scale: (_workspace$scale = workspace.scale) !== null && _workspace$scale !== void 0 ? _workspace$scale : fit.scale,
+					x: (_workspace$scrollX = workspace.scrollX) !== null && _workspace$scrollX !== void 0 ? _workspace$scrollX : 0,
+					y: (_workspace$scrollY = workspace.scrollY) !== null && _workspace$scrollY !== void 0 ? _workspace$scrollY : 0
+				};
+			},
+			onChange(listener) {
+				listeners.add(listener);
+				return () => listeners.delete(listener);
+			}
+		},
+		dispose() {
+			frame.style.removeProperty("height");
+			listeners.clear();
+			resize.disconnect();
+			surface.removeEventListener("wheel", wheel, { capture: true });
+			if (translate) workspace.translate = translate;
+		}
+	};
+}
+/** Use the host's Scratch VM serializer and Scratch Blocks definitions in an isolated workspace. */
+function createScratchBlocksDiffRenderer(options) {
+	return async ({ container, target, id, withContext, parts = [], marks, signal, watermark }) => {
+		var _Object$values$find;
+		const blockly = await options.getBlockly();
+		if (signal.aborted) return;
+		const root = withContext ? scriptRoot({
+			target,
+			id
+		}) : id;
+		const selected = selectBlocks({
+			target,
+			id
+		}, root, withContext);
+		const compactRoot = Array.isArray(selected[root]);
+		const blocks = options.deserializeBlocks(selected);
+		const serializedRoot = compactRoot ? (_Object$values$find = Object.values(blocks).find((block) => block.topLevel)) === null || _Object$values$find === void 0 ? void 0 : _Object$values$find.id : root;
+		if (!serializedRoot) throw new Error("Missing Scratch block.");
+		const vmBlocks = options.createBlockContainer();
+		for (const block of Object.values(blocks)) vmBlocks.createBlock(block, true);
+		const xml = vmBlocks.blockToXML(serializedRoot);
+		if (!xml) throw new Error("Missing Scratch block XML.");
+		const dom = blockly.Xml.textToDom("<xml>" + xml + "</xml>");
+		const main = blockly.getMainWorkspace();
+		const surface = container.ownerDocument.createElement("div");
+		surface.className = "twgit-block-diff-surface";
+		container.append(surface);
+		let workspace;
+		let view;
+		let navigation;
+		const cleanups = [];
+		const placeholders = [];
+		const dispose = () => {
+			const active = blockly.getMainWorkspace();
+			for (const cleanup of cleanups.splice(0)) cleanup();
+			blockly.Events.disable();
+			try {
+				navigation === null || navigation === void 0 || navigation.dispose();
+				workspace === null || workspace === void 0 || workspace.dispose();
+			} finally {
+				if (active === workspace) blockly.mainWorkspace = main;
+				for (const type of placeholders) delete blockly.Blocks[type];
+				blockly.Events.enable();
+				surface.remove();
+			}
+		};
+		blockly.Events.disable();
+		try {
+			var _main$options$zoomOpt, _main$options, _main$options2, _options$attachNaviga;
+			for (const element of Array.from(dom.querySelectorAll("block,shadow"))) {
+				var _element$getAttribute2, _options$locale;
+				const opcode = (_element$getAttribute2 = element.getAttribute("type")) !== null && _element$getAttribute2 !== void 0 ? _element$getAttribute2 : "";
+				if (!opcode.startsWith(placeholderPrefix) && Object.hasOwn(blockly.Blocks, opcode)) continue;
+				if (!options.showUnregisteredBlocks || !blockly.defineBlocksWithJsonArray) throw new Error("Unregistered Scratch block.");
+				let alias;
+				do
+					alias = placeholderPrefix + ++placeholderSerial;
+				while (Object.hasOwn(blockly.Blocks, alias));
+				placeholders.push(alias);
+				blockly.defineBlocksWithJsonArray([placeholderDefinition(element, opcode, alias, blockly, (_options$locale = options.locale) !== null && _options$locale !== void 0 ? _options$locale : container.ownerDocument.documentElement.lang)]);
+				element.setAttribute("type", alias);
+			}
+			const startScale = (_main$options$zoomOpt = main === null || main === void 0 || (_main$options = main.options) === null || _main$options === void 0 || (_main$options = _main$options.zoomOptions) === null || _main$options === void 0 ? void 0 : _main$options.startScale) !== null && _main$options$zoomOpt !== void 0 ? _main$options$zoomOpt : defaultScale;
+			workspace = blockly.inject(surface, {
+				readOnly: true,
+				sounds: false,
+				media: main === null || main === void 0 || (_main$options2 = main.options) === null || _main$options2 === void 0 ? void 0 : _main$options2.pathToMedia,
+				scrollbars: true,
+				zoom: {
+					controls: true,
+					wheel: true,
+					startScale,
+					maxScale: 4,
+					minScale: .25,
+					scaleSpeed: 1.2
+				}
+			});
+			workspace.markFocused = () => {};
+			blockly.Xml.domToWorkspace(dom, workspace);
+			if (marks) for (const mark of marks) {
+				var _changed$getSvgRoot;
+				const changed = workspace.getBlockById(mark.id === root ? serializedRoot : mark.id);
+				if (!changed) continue;
+				(_changed$getSvgRoot = changed.getSvgRoot()) === null || _changed$getSvgRoot === void 0 || _changed$getSvgRoot.classList.add("twgit-block-diff-" + mark.kind);
+				markBlockLocation(changed, mark.parts);
+			}
+			else {
+				const changed = workspace.getBlockById(id === root ? serializedRoot : id);
+				if (changed) markBlockLocation(changed, parts);
+			}
+			view = createView(workspace, blockly, surface, container, startScale, !!options.attachNavigation);
+			cleanups.push(view.dispose);
+			navigation = (_options$attachNaviga = options.attachNavigation) === null || _options$attachNaviga === void 0 ? void 0 : _options$attachNaviga.call(options, workspace, blockly, watermark);
+			if (navigation && watermark) {
+				watermark.dataset.navigation = "";
+				cleanups.push(() => delete watermark.dataset.navigation);
+			}
+		} catch (error) {
+			dispose();
+			throw error;
+		} finally {
+			blockly.mainWorkspace = main;
+			blockly.Events.enable();
+		}
+		return {
+			dispose,
+			view: view.api
+		};
+	};
+}
+export { gitHubRepositoryFromOrigin as a, BlockPreview as c, currentCostume as d, compareProjectBlocks as f, createGitHubPullRequests as i, createPreviewSync as l, readProjectSourceDiff as m, createScratchBlocksDiffLocator as n, ProjectSourceComparison as o, createProjectSourceDiff as p, PullRequestError as r, ProjectSourceReview as s, createScratchBlocksDiffRenderer as t, usePreviewSync as u };