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

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

@@ -0,0 +1,1464 @@
+import { n as init_objectSpread2, t as _objectSpread2 } from "./objectSpread2-Dkd68nJH.js";
+import { n as hasOnlyUnixLineEndings, r as hasOnlyWinLineEndings, t as createTwoFilesPatch } from "./libesm-OWRWzmu_.js";
+import React, { useEffect, useMemo, useRef, useState } from "react";
+// src/block-diff-preview.tsx
+init_objectSpread2();
+function BlockPreview({ side, title, parts, marks, renderBlock, withContext, labels, onLocate, locationStatus }) {
+	const host = useRef(null);
+	const [status, setStatus] = useState("loading");
+	useEffect(() => {
+		if (!side || !host.current) return;
+		const container = host.current;
+		const abort = new AbortController();
+		let dispose;
+		setStatus("loading");
+		Promise.resolve().then(() => renderBlock(_objectSpread2(_objectSpread2({}, side), {}, {
+			container,
+			withContext,
+			parts,
+			marks,
+			signal: abort.signal
+		}))).then((cleanup) => {
+			if (abort.signal.aborted) cleanup === null || cleanup === void 0 || cleanup();
+			else {
+				dispose = cleanup;
+				setStatus("ready");
+			}
+		}, () => {
+			if (!abort.signal.aborted) setStatus("failed");
+		});
+		return () => {
+			abort.abort();
+			dispose === null || dispose === void 0 || dispose();
+		};
+	}, [
+		side,
+		renderBlock,
+		withContext,
+		parts,
+		marks
+	]);
+	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), /* @__PURE__ */ React.createElement("div", {
+		ref: host,
+		className: "twgit-block-diff-preview"
+	}), 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]));
+}
+// 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
+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
+init_objectSpread2();
+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-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
+			});
+		}
+	}
+	return {
+		targets,
+		properties: changedProperties(before, after, "targets")
+	};
+}
+// src/project-source-review.tsx
+var ja = {
+	review: "変更レビュー",
+	fullDescription: "PR 本文を表示",
+	checks: "確認してほしいこと",
+	files: "変更ファイル",
+	targets: "影響するステージ・スプライト",
+	scripts: "スクリプトの比較",
+	reviewed: "確認済み",
+	reviewedScripts: "スクリプト確認済み",
+	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: "Script comparisons",
+	reviewed: "Reviewed",
+	reviewedScripts: "Reviewed scripts",
+	before: "Before",
+	after: "After",
+	updated: "Changed",
+	added: "Added",
+	removed: "Removed",
+	reorganized: "Reorganized",
+	absent: "No script in this version",
+	loading: "Rendering script…",
+	unavailable: "This script 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: "Script",
+	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 }) {
+	const [open, setOpen] = useState(false);
+	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
+	})) : /* @__PURE__ */ React.createElement(BlockPreview, {
+		title: labels[version],
+		renderBlock,
+		withContext: true,
+		labels
+	})))), 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(" · ");
+}
+/** Lists the changed stages and sprites of one project file, each with its script comparisons. */
+function ComparisonTargets({ comparison, labels, renderBlock, 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, target.name, target.scripts.length > 0 && /* @__PURE__ */ React.createElement("small", null, labels.scripts, " · ", 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,
+			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 script, as the pull request review does. */
+function ProjectSourceComparison({ before, after, renderBlock, locale = "en", fallback }) {
+	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
+	}));
+}
+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.reviewedScripts), /* @__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,
+		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 readText(response, limit) {
+	if (Number(response.headers.get("Content-Length")) > limit || !response.body) throw invalidResponse();
+	const reader = response.body.getReader();
+	const decoder = new TextDecoder("utf-8", { fatal: true });
+	const chunks = [];
+	let length = 0;
+	try {
+		for (;;) {
+			const { done, value } = await reader.read();
+			if (done) return chunks.join("") + decoder.decode();
+			length += value.byteLength;
+			if (length > limit) throw invalidResponse();
+			chunks.push(decoder.decode(value, { stream: true }));
+		}
+	} catch (error) {
+		reader.cancel().catch(() => {});
+		throw error;
+	}
+}
+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("/");
+}
+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;
+					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)]);
+					files.push({
+						path: file.path,
+						previousPath: file.previous,
+						patch: createProjectSourceDiff(before, after)
+					});
+				} 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;
+}
+/** 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 }) => {
+		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;
+		const placeholders = [];
+		const dispose = () => {
+			const active = blockly.getMainWorkspace();
+			blockly.Events.disable();
+			try {
+				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;
+			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);
+			}
+			workspace = blockly.inject(surface, {
+				readOnly: true,
+				sounds: false,
+				media: main === null || main === void 0 || (_main$options = main.options) === null || _main$options === void 0 ? void 0 : _main$options.pathToMedia
+			});
+			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);
+			}
+			const bounds = workspace.getBlocksBoundingBox();
+			surface.style.width = Math.max(100, Math.ceil(bounds.width) + 48) + "px";
+			surface.style.height = Math.max(64, Math.ceil(bounds.height) + 48) + "px";
+			blockly.svgResize(workspace);
+		} catch (error) {
+			dispose();
+			throw error;
+		} finally {
+			blockly.mainWorkspace = main;
+			blockly.Events.enable();
+		}
+		return dispose;
+	};
+}
+export { gitHubRepositoryFromOrigin as a, compareProjectBlocks as c, BlockPreview as d, createGitHubPullRequests as i, createProjectSourceDiff as l, createScratchBlocksDiffLocator as n, ProjectSourceComparison as o, PullRequestError as r, ProjectSourceReview as s, createScratchBlocksDiffRenderer as t, readProjectSourceDiff as u };