@dev.fast/whiteboard 0.0.0-stage → 0.2.1-preview.20261005.98

package/dist/src-CmdiBL20.js

@@ -0,0 +1,3676 @@
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import path from "node:path";
+import { tmpdir } from "node:os";
+import { execFile, execFileSync, spawn } from "node:child_process";
+import { promisify } from "node:util";
+import "node:timers/promises";
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
+//#endregion
+//#region ../../node_modules/protocols/lib/index.js
+var require_lib$4 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* protocols
+	* Returns the protocols of an input url.
+	*
+	* @name protocols
+	* @function
+	* @param {String|URL} input The input url (string or `URL` instance)
+	* @param {Boolean|Number} first If `true`, the first protocol will be returned. If number, it will represent the zero-based index of the protocols array.
+	* @return {Array|String} The array of protocols or the specified protocol.
+	*/
+	module.exports = function protocols(input, first) {
+		if (first === true) first = 0;
+		var prots = "";
+		if (typeof input === "string") try {
+			prots = new URL(input).protocol;
+		} catch (e) {}
+		else if (input && input.constructor === URL) prots = input.protocol;
+		var splits = prots.split(/\:|\+/).filter(Boolean);
+		if (typeof first === "number") return splits[first];
+		return splits;
+	};
+}));
+//#endregion
+//#region ../../node_modules/parse-path/lib/index.js
+var require_lib$3 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var protocols = require_lib$4();
+	/**
+	* parsePath
+	* Parses the input url.
+	*
+	* @name parsePath
+	* @function
+	* @param {String} url The input url.
+	* @return {Object} An object containing the following fields:
+	*
+	*    - `protocols` (Array): An array with the url protocols (usually it has one element).
+	*    - `protocol` (String): The first protocol or `"file"`.
+	*    - `port` (String): The domain port (default: `""`).
+	*    - `resource` (String): The url domain/hostname.
+	*    - `host` (String): The url domain (including subdomain and port).
+	*    - `user` (String): The authentication user (default: `""`).
+	*    - `password` (String): The authentication password (default: `""`).
+	*    - `pathname` (String): The url pathname.
+	*    - `hash` (String): The url hash.
+	*    - `search` (String): The url querystring value (excluding `?`).
+	*    - `href` (String): The normalized input url.
+	*    - `query` (Object): The url querystring, parsed as object.
+	*    - `parse_failed` (Boolean): Whether the parsing failed or not.
+	*/
+	function parsePath(url) {
+		var output = {
+			protocols: [],
+			protocol: null,
+			port: null,
+			resource: "",
+			host: "",
+			user: "",
+			password: "",
+			pathname: "",
+			hash: "",
+			search: "",
+			href: url,
+			query: {},
+			parse_failed: false
+		};
+		try {
+			var parsed = new URL(url);
+			output.protocols = protocols(parsed);
+			output.protocol = output.protocols[0];
+			output.port = parsed.port;
+			output.resource = parsed.hostname;
+			output.host = parsed.host;
+			output.user = parsed.username || "";
+			output.password = parsed.password || "";
+			output.pathname = parsed.pathname;
+			output.hash = parsed.hash.slice(1);
+			output.search = parsed.search.slice(1);
+			output.href = parsed.href;
+			output.query = Object.fromEntries(parsed.searchParams);
+		} catch (e) {
+			output.protocols = ["file"];
+			output.protocol = output.protocols[0];
+			output.port = "";
+			output.resource = "";
+			output.user = "";
+			output.pathname = "";
+			output.hash = "";
+			output.search = "";
+			output.href = url;
+			output.query = {};
+			output.parse_failed = true;
+		}
+		return output;
+	}
+	module.exports = parsePath;
+}));
+//#endregion
+//#region ../../node_modules/parse-url/dist/index.js
+var require_dist = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var require$$1 = require_lib$3();
+	function _interopDefaultLegacy(e) {
+		return e && typeof e === "object" && "default" in e ? e : { "default": e };
+	}
+	var require$$1__default = /*#__PURE__*/ _interopDefaultLegacy(require$$1);
+	function getAugmentedNamespace(n) {
+		if (n.__esModule) return n;
+		var f = n.default;
+		if (typeof f == "function") {
+			var a = function a() {
+				if (this instanceof a) {
+					var args = [null];
+					args.push.apply(args, arguments);
+					return new (Function.bind.apply(f, args))();
+				}
+				return f.apply(this, arguments);
+			};
+			a.prototype = f.prototype;
+		} else a = {};
+		Object.defineProperty(a, "__esModule", { value: true });
+		Object.keys(n).forEach(function(k) {
+			var d = Object.getOwnPropertyDescriptor(n, k);
+			Object.defineProperty(a, k, d.get ? d : {
+				enumerable: true,
+				get: function() {
+					return n[k];
+				}
+			});
+		});
+		return a;
+	}
+	var src = {};
+	const DATA_URL_DEFAULT_MIME_TYPE = "text/plain";
+	const DATA_URL_DEFAULT_CHARSET = "us-ascii";
+	const testParameter = (name, filters) => filters.some((filter) => filter instanceof RegExp ? filter.test(name) : filter === name);
+	const normalizeDataURL = (urlString, { stripHash }) => {
+		const match = /^data:(?<type>[^,]*?),(?<data>[^#]*?)(?:#(?<hash>.*))?$/.exec(urlString);
+		if (!match) throw new Error(`Invalid URL: ${urlString}`);
+		let { type, data, hash } = match.groups;
+		const mediaType = type.split(";");
+		hash = stripHash ? "" : hash;
+		let isBase64 = false;
+		if (mediaType[mediaType.length - 1] === "base64") {
+			mediaType.pop();
+			isBase64 = true;
+		}
+		const mimeType = (mediaType.shift() || "").toLowerCase();
+		const normalizedMediaType = [...mediaType.map((attribute) => {
+			let [key, value = ""] = attribute.split("=").map((string) => string.trim());
+			if (key === "charset") {
+				value = value.toLowerCase();
+				if (value === DATA_URL_DEFAULT_CHARSET) return "";
+			}
+			return `${key}${value ? `=${value}` : ""}`;
+		}).filter(Boolean)];
+		if (isBase64) normalizedMediaType.push("base64");
+		if (normalizedMediaType.length > 0 || mimeType && mimeType !== DATA_URL_DEFAULT_MIME_TYPE) normalizedMediaType.unshift(mimeType);
+		return `data:${normalizedMediaType.join(";")},${isBase64 ? data.trim() : data}${hash ? `#${hash}` : ""}`;
+	};
+	function normalizeUrl(urlString, options) {
+		options = {
+			defaultProtocol: "http:",
+			normalizeProtocol: true,
+			forceHttp: false,
+			forceHttps: false,
+			stripAuthentication: true,
+			stripHash: false,
+			stripTextFragment: true,
+			stripWWW: true,
+			removeQueryParameters: [/^utm_\w+/i],
+			removeTrailingSlash: true,
+			removeSingleSlash: true,
+			removeDirectoryIndex: false,
+			sortQueryParameters: true,
+			...options
+		};
+		urlString = urlString.trim();
+		if (/^data:/i.test(urlString)) return normalizeDataURL(urlString, options);
+		if (/^view-source:/i.test(urlString)) throw new Error("`view-source:` is not supported as it is a non-standard protocol");
+		const hasRelativeProtocol = urlString.startsWith("//");
+		if (!(!hasRelativeProtocol && /^\.*\//.test(urlString))) urlString = urlString.replace(/^(?!(?:\w+:)?\/\/)|^\/\//, options.defaultProtocol);
+		const urlObject = new URL(urlString);
+		if (options.forceHttp && options.forceHttps) throw new Error("The `forceHttp` and `forceHttps` options cannot be used together");
+		if (options.forceHttp && urlObject.protocol === "https:") urlObject.protocol = "http:";
+		if (options.forceHttps && urlObject.protocol === "http:") urlObject.protocol = "https:";
+		if (options.stripAuthentication) {
+			urlObject.username = "";
+			urlObject.password = "";
+		}
+		if (options.stripHash) urlObject.hash = "";
+		else if (options.stripTextFragment) urlObject.hash = urlObject.hash.replace(/#?:~:text.*?$/i, "");
+		if (urlObject.pathname) {
+			const protocolRegex = /\b[a-z][a-z\d+\-.]{1,50}:\/\//g;
+			let lastIndex = 0;
+			let result = "";
+			for (;;) {
+				const match = protocolRegex.exec(urlObject.pathname);
+				if (!match) break;
+				const protocol = match[0];
+				const protocolAtIndex = match.index;
+				const intermediate = urlObject.pathname.slice(lastIndex, protocolAtIndex);
+				result += intermediate.replace(/\/{2,}/g, "/");
+				result += protocol;
+				lastIndex = protocolAtIndex + protocol.length;
+			}
+			const remnant = urlObject.pathname.slice(lastIndex, urlObject.pathname.length);
+			result += remnant.replace(/\/{2,}/g, "/");
+			urlObject.pathname = result;
+		}
+		if (urlObject.pathname) try {
+			urlObject.pathname = decodeURI(urlObject.pathname);
+		} catch {}
+		if (options.removeDirectoryIndex === true) options.removeDirectoryIndex = [/^index\.[a-z]+$/];
+		if (Array.isArray(options.removeDirectoryIndex) && options.removeDirectoryIndex.length > 0) {
+			let pathComponents = urlObject.pathname.split("/");
+			const lastComponent = pathComponents[pathComponents.length - 1];
+			if (testParameter(lastComponent, options.removeDirectoryIndex)) {
+				pathComponents = pathComponents.slice(0, -1);
+				urlObject.pathname = pathComponents.slice(1).join("/") + "/";
+			}
+		}
+		if (urlObject.hostname) {
+			urlObject.hostname = urlObject.hostname.replace(/\.$/, "");
+			if (options.stripWWW && /^www\.(?!www\.)[a-z\-\d]{1,63}\.[a-z.\-\d]{2,63}$/.test(urlObject.hostname)) urlObject.hostname = urlObject.hostname.replace(/^www\./, "");
+		}
+		if (Array.isArray(options.removeQueryParameters)) {
+			for (const key of [...urlObject.searchParams.keys()]) if (testParameter(key, options.removeQueryParameters)) urlObject.searchParams.delete(key);
+		}
+		if (options.removeQueryParameters === true) urlObject.search = "";
+		if (options.sortQueryParameters) {
+			urlObject.searchParams.sort();
+			try {
+				urlObject.search = decodeURIComponent(urlObject.search);
+			} catch {}
+		}
+		if (options.removeTrailingSlash) urlObject.pathname = urlObject.pathname.replace(/\/$/, "");
+		const oldUrlString = urlString;
+		urlString = urlObject.toString();
+		if (!options.removeSingleSlash && urlObject.pathname === "/" && !oldUrlString.endsWith("/") && urlObject.hash === "") urlString = urlString.replace(/\/$/, "");
+		if ((options.removeTrailingSlash || urlObject.pathname === "/") && urlObject.hash === "" && options.removeSingleSlash) urlString = urlString.replace(/\/$/, "");
+		if (hasRelativeProtocol && !options.normalizeProtocol) urlString = urlString.replace(/^http:\/\//, "//");
+		if (options.stripProtocol) urlString = urlString.replace(/^(?:https?:)?\/\//, "");
+		return urlString;
+	}
+	var require$$0 = /*@__PURE__*/ getAugmentedNamespace(/* @__PURE__ */ Object.freeze({
+		__proto__: null,
+		"default": normalizeUrl
+	}));
+	Object.defineProperty(src, "__esModule", { value: true });
+	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function(obj) {
+		return typeof obj;
+	} : function(obj) {
+		return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+	};
+	var _normalizeUrl2 = _interopRequireDefault(require$$0);
+	var _parsePath = require$$1__default["default"];
+	var _parsePath2 = _interopRequireDefault(_parsePath);
+	function _interopRequireDefault(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	/**
+	* parseUrl
+	* Parses the input url.
+	*
+	* **Note**: This *throws* if invalid urls are provided.
+	*
+	* @name parseUrl
+	* @function
+	* @param {String} url The input url.
+	* @param {Boolean|Object} normalize Whether to normalize the url or not.
+	*                         Default is `false`. If `true`, the url will
+	*                         be normalized. If an object, it will be the
+	*                         options object sent to [`normalize-url`](https://github.com/sindresorhus/normalize-url).
+	*
+	*                         For SSH urls, normalize won't work.
+	*
+	* @return {Object} An object containing the following fields:
+	*
+	*    - `protocols` (Array): An array with the url protocols (usually it has one element).
+	*    - `protocol` (String): The first protocol, `"ssh"` (if the url is a ssh url) or `"file"`.
+	*    - `port` (null|Number): The domain port.
+	*    - `resource` (String): The url domain (including subdomains).
+	*    - `host` (String):  The fully qualified domain name of a network host, or its IP address.
+	*    - `user` (String): The authentication user (usually for ssh urls).
+	*    - `pathname` (String): The url pathname.
+	*    - `hash` (String): The url hash.
+	*    - `search` (String): The url querystring value.
+	*    - `href` (String): The input url.
+	*    - `query` (Object): The url querystring, parsed as object.
+	*    - `parse_failed` (Boolean): Whether the parsing failed or not.
+	*/
+	var parseUrl = function parseUrl(url) {
+		var normalize = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
+		/**
+		* ([a-zA-Z_][a-zA-Z0-9_-]{0,31}) Try to match the user
+		* ([\w\.\-@]+) Match the host/resource
+		* (([\~,\.\w,\-,\_,\/,\s]|%[0-9A-Fa-f]{2})+?(?:\.git|\/)?) Match the path, allowing spaces/white 
+		*/
+		var GIT_RE = /^(?:([a-zA-Z_][a-zA-Z0-9_-]{0,31})@|https?:\/\/)([\w\.\-@]+)[\/:](([\~,\.\w,\-,\_,\/,\s]|%[0-9A-Fa-f]{2})+?(?:\.git|\/)?)$/;
+		var throwErr = function throwErr(msg) {
+			var err = new Error(msg);
+			err.subject_url = url;
+			throw err;
+		};
+		if (typeof url !== "string" || !url.trim()) throwErr("Invalid url.");
+		if (url.length > parseUrl.MAX_INPUT_LENGTH) throwErr("Input exceeds maximum length. If needed, change the value of parseUrl.MAX_INPUT_LENGTH.");
+		if (normalize) {
+			if ((typeof normalize === "undefined" ? "undefined" : _typeof(normalize)) !== "object") normalize = { stripHash: false };
+			url = (0, _normalizeUrl2.default)(url, normalize);
+		}
+		var parsed = (0, _parsePath2.default)(url);
+		if (parsed.parse_failed) {
+			var matched = parsed.href.match(GIT_RE);
+			if (matched) {
+				parsed.protocols = ["ssh"];
+				parsed.protocol = "ssh";
+				parsed.resource = matched[2];
+				parsed.host = matched[2];
+				parsed.user = matched[1];
+				parsed.pathname = "/" + matched[3];
+				parsed.parse_failed = false;
+			} else throwErr("URL parsing failed.");
+		}
+		return parsed;
+	};
+	parseUrl.MAX_INPUT_LENGTH = 2048;
+	module.exports = src.default = parseUrl;
+}));
+//#endregion
+//#region ../../node_modules/is-ssh/lib/index.js
+var require_lib$2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var protocols = require_lib$4();
+	/**
+	* isSsh
+	* Checks if an input value is a ssh url or not.
+	*
+	* @name isSsh
+	* @function
+	* @param {String|Array} input The input url or an array of protocols.
+	* @return {Boolean} `true` if the input is a ssh url, `false` otherwise.
+	*/
+	function isSsh(input) {
+		if (Array.isArray(input)) return input.indexOf("ssh") !== -1 || input.indexOf("rsync") !== -1;
+		if (typeof input !== "string") return false;
+		var prots = protocols(input);
+		input = input.substring(input.indexOf("://") + 3);
+		if (isSsh(prots)) return true;
+		var urlPortPattern = /* @__PURE__ */ new RegExp(".([a-zA-Z\\d]+):(\\d+)/");
+		return !input.match(urlPortPattern) && input.indexOf("@") < input.indexOf(":");
+	}
+	module.exports = isSsh;
+}));
+//#endregion
+//#region ../../node_modules/git-up/lib/index.js
+var require_lib$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const parseUrl = require_dist();
+	const isSsh = require_lib$2();
+	/**
+	* gitUp
+	* Parses the input url.
+	*
+	* @name gitUp
+	* @function
+	* @param {String} input The input url.
+	* @return {Object} An object containing the following fields:
+	*
+	*  - `protocols` (Array): An array with the url protocols (usually it has one element).
+	*  - `port` (String): The domain port.
+	*  - `resource` (String): The url domain (including subdomains).
+	*  - `user` (String): The authentication user (usually for ssh urls).
+	*  - `pathname` (String): The url pathname.
+	*  - `hash` (String): The url hash.
+	*  - `search` (String): The url querystring value.
+	*  - `href` (String): The input url.
+	*  - `protocol` (String): The git url protocol.
+	*  - `token` (String): The oauth token (could appear in the https urls).
+	*/
+	function gitUp(input) {
+		let output = parseUrl(input);
+		output.token = "";
+		if (output.password === "x-oauth-basic") output.token = output.user;
+		else if (output.user === "x-token-auth") output.token = output.password;
+		if (isSsh(output.protocols) || output.protocols.length === 0 && isSsh(input)) output.protocol = "ssh";
+		else if (output.protocols.length) output.protocol = output.protocols[0];
+		else {
+			output.protocol = "file";
+			output.protocols = ["file"];
+		}
+		output.href = output.href.replace(/\/$/, "");
+		return output;
+	}
+	module.exports = gitUp;
+}));
+/*!
+* buildToken
+* Builds OAuth token prefix (helper function)
+*
+* @name buildToken
+* @function
+* @param {GitUrl} obj The parsed Git url object.
+* @return {String} token prefix
+*/
+//#endregion
+//#region ../local-vcs/src/exec.ts
+var import_lib = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var gitUp = require_lib$1();
+	/**
+	* gitUrlParse
+	* Parses a Git url.
+	*
+	* @name gitUrlParse
+	* @function
+	* @param {String} url The Git url to parse.
+	* @param {Array} refs An array of strings representing the refs. This is
+	*  helpful in the context of the URLs that contain branches with slashes.
+	*  If user wants to identify the branch, he should pass all branch names
+	*  of the project as part of refs parameter
+	* @return {GitUrl} The `GitUrl` object containing:
+	*
+	*  - `protocols` (Array): An array with the url protocols (usually it has one element).
+	*  - `port` (String): The domain port.
+	*  - `resource` (String): The url domain (including subdomains).
+	*  - `user` (String): The authentication user (usually for ssh urls).
+	*  - `pathname` (String): The url pathname.
+	*  - `hash` (String): The url hash.
+	*  - `search` (String): The url querystring value.
+	*  - `href` (String): The input url.
+	*  - `protocol` (String): The git url protocol.
+	*  - `token` (String): The oauth token (could appear in the https urls).
+	*  - `source` (String): The Git provider (e.g. `"github.com"`).
+	*  - `owner` (String): The repository owner.
+	*  - `name` (String): The repository name.
+	*  - `ref` (String): The repository ref (e.g., "master" or "dev").
+	*  - `filepath` (String): A filepath relative to the repository root.
+	*  - `filepathtype` (String): The type of filepath in the url ("blob" or "tree").
+	*  - `full_name` (String): The owner and name values in the `owner/name` format.
+	*  - `toString` (Function): A function to stringify the parsed url into another url type.
+	*  - `organization` (String): The organization the owner belongs to. This is CloudForge specific.
+	*  - `git_suffix` (Boolean): Whether to add the `.git` suffix or not.
+	*
+	*/
+	function gitUrlParse(url, refs) {
+		refs = refs || [];
+		if (typeof url !== "string") throw new Error("The url must be a string.");
+		if (!refs.every(function(item) {
+			return typeof item === "string";
+		})) throw new Error("The refs should contain only strings");
+		if (/^([a-z\d-]{1,39})\/([-\.\w]{1,100})$/i.test(url)) url = "https://github.com/" + url;
+		var urlInfo = gitUp(url), sourceParts = urlInfo.resource.split("."), splits = null;
+		urlInfo.toString = function(type) {
+			return gitUrlParse.stringify(this, type);
+		};
+		urlInfo.source = sourceParts.length > 2 ? sourceParts.slice(1 - sourceParts.length).join(".") : urlInfo.source = urlInfo.resource;
+		urlInfo.git_suffix = /\.git$/.test(urlInfo.pathname);
+		urlInfo.name = decodeURIComponent((urlInfo.pathname || urlInfo.href).replace(/(^\/)|(\/$)/g, "").replace(/\.git$/, ""));
+		urlInfo.owner = decodeURIComponent(urlInfo.user);
+		switch (urlInfo.source) {
+			case "git.cloudforge.com":
+				urlInfo.owner = urlInfo.user;
+				urlInfo.organization = sourceParts[0];
+				urlInfo.source = "cloudforge.com";
+				break;
+			case "visualstudio.com": if (urlInfo.resource === "vs-ssh.visualstudio.com") {
+				splits = urlInfo.name.split("/");
+				if (splits.length === 4) {
+					urlInfo.organization = splits[1];
+					urlInfo.owner = splits[2];
+					urlInfo.name = splits[3];
+					urlInfo.full_name = splits[2] + "/" + splits[3];
+				}
+				break;
+			} else {
+				splits = urlInfo.name.split("/");
+				if (splits.length === 2) {
+					urlInfo.owner = splits[1];
+					urlInfo.name = splits[1];
+					urlInfo.full_name = "_git/" + urlInfo.name;
+				} else if (splits.length === 3) {
+					urlInfo.name = splits[2];
+					if (splits[0] === "DefaultCollection") {
+						urlInfo.owner = splits[2];
+						urlInfo.organization = splits[0];
+						urlInfo.full_name = urlInfo.organization + "/_git/" + urlInfo.name;
+					} else {
+						urlInfo.owner = splits[0];
+						urlInfo.full_name = urlInfo.owner + "/_git/" + urlInfo.name;
+					}
+				} else if (splits.length === 4) {
+					urlInfo.organization = splits[0];
+					urlInfo.owner = splits[1];
+					urlInfo.name = splits[3];
+					urlInfo.full_name = urlInfo.organization + "/" + urlInfo.owner + "/_git/" + urlInfo.name;
+				}
+				break;
+			}
+			case "dev.azure.com":
+			case "azure.com": if (urlInfo.resource === "ssh.dev.azure.com") {
+				splits = urlInfo.name.split("/");
+				if (splits.length === 4) {
+					urlInfo.organization = splits[1];
+					urlInfo.owner = splits[2];
+					urlInfo.name = splits[3];
+				}
+				break;
+			} else {
+				splits = urlInfo.name.split("/");
+				if (splits.length === 5) {
+					urlInfo.organization = splits[0];
+					urlInfo.owner = splits[1];
+					urlInfo.name = splits[4];
+					urlInfo.full_name = "_git/" + urlInfo.name;
+				} else if (splits.length === 3) {
+					urlInfo.name = splits[2];
+					if (splits[0] === "DefaultCollection") {
+						urlInfo.owner = splits[2];
+						urlInfo.organization = splits[0];
+						urlInfo.full_name = urlInfo.organization + "/_git/" + urlInfo.name;
+					} else {
+						urlInfo.owner = splits[0];
+						urlInfo.full_name = urlInfo.owner + "/_git/" + urlInfo.name;
+					}
+				} else if (splits.length === 4) {
+					urlInfo.organization = splits[0];
+					urlInfo.owner = splits[1];
+					urlInfo.name = splits[3];
+					urlInfo.full_name = urlInfo.organization + "/" + urlInfo.owner + "/_git/" + urlInfo.name;
+				}
+				if (urlInfo.query && urlInfo.query["path"]) urlInfo.filepath = urlInfo.query["path"].replace(/^\/+/g, "");
+				if (urlInfo.query && urlInfo.query["version"]) urlInfo.ref = urlInfo.query["version"].replace(/^GB/, "");
+				break;
+			}
+			default:
+				splits = urlInfo.name.split("/");
+				var nameIndex = splits.length - 1;
+				if (splits.length >= 2) {
+					var dashIndex = splits.indexOf("-", 2);
+					var blobIndex = splits.indexOf("blob", 2);
+					var treeIndex = splits.indexOf("tree", 2);
+					var commitIndex = splits.indexOf("commit", 2);
+					var issuesIndex = splits.indexOf("issues", 2);
+					var srcIndex = splits.indexOf("src", 2);
+					var rawIndex = splits.indexOf("raw", 2);
+					var editIndex = splits.indexOf("edit", 2);
+					nameIndex = dashIndex > 0 ? dashIndex - 1 : blobIndex > 0 && treeIndex > 0 ? Math.min(blobIndex - 1, treeIndex - 1) : blobIndex > 0 ? blobIndex - 1 : issuesIndex > 0 ? issuesIndex - 1 : treeIndex > 0 ? treeIndex - 1 : commitIndex > 0 ? commitIndex - 1 : srcIndex > 0 ? srcIndex - 1 : rawIndex > 0 ? rawIndex - 1 : editIndex > 0 ? editIndex - 1 : nameIndex;
+					urlInfo.owner = splits.slice(0, nameIndex).join("/");
+					urlInfo.name = splits[nameIndex];
+					if (commitIndex && issuesIndex < 0) urlInfo.commit = splits[nameIndex + 2];
+				}
+				urlInfo.ref = "";
+				urlInfo.filepathtype = "";
+				urlInfo.filepath = "";
+				var offsetNameIndex = splits.length > nameIndex && splits[nameIndex + 1] === "-" ? nameIndex + 1 : nameIndex;
+				if (splits.length > offsetNameIndex + 2 && [
+					"raw",
+					"src",
+					"blob",
+					"tree",
+					"edit"
+				].indexOf(splits[offsetNameIndex + 1]) >= 0) {
+					urlInfo.filepathtype = splits[offsetNameIndex + 1];
+					urlInfo.ref = splits[offsetNameIndex + 2];
+					if (splits.length > offsetNameIndex + 3) urlInfo.filepath = splits.slice(offsetNameIndex + 3).join("/");
+				}
+				urlInfo.organization = urlInfo.owner;
+		}
+		if (!urlInfo.full_name) {
+			urlInfo.full_name = urlInfo.owner;
+			if (urlInfo.name) {
+				urlInfo.full_name && (urlInfo.full_name += "/");
+				urlInfo.full_name += urlInfo.name;
+			}
+		}
+		if (urlInfo.owner.startsWith("scm/")) {
+			urlInfo.source = "bitbucket-server";
+			urlInfo.owner = urlInfo.owner.replace("scm/", "");
+			urlInfo.organization = urlInfo.owner;
+			urlInfo.full_name = urlInfo.owner + "/" + urlInfo.name;
+		}
+		var matches = /(projects|users)\/(.*?)\/repos\/(.*?)((\/.*$)|$)/.exec(urlInfo.pathname);
+		if (matches != null) {
+			urlInfo.source = "bitbucket-server";
+			if (matches[1] === "users") urlInfo.owner = "~" + matches[2];
+			else urlInfo.owner = matches[2];
+			urlInfo.organization = urlInfo.owner;
+			urlInfo.name = matches[3];
+			splits = matches[4].split("/");
+			if (splits.length > 1) {
+				if (["raw", "browse"].indexOf(splits[1]) >= 0) {
+					urlInfo.filepathtype = splits[1];
+					if (splits.length > 2) urlInfo.filepath = splits.slice(2).join("/");
+				} else if (splits[1] === "commits" && splits.length > 2) urlInfo.commit = splits[2];
+			}
+			urlInfo.full_name = urlInfo.owner + "/" + urlInfo.name;
+			if (urlInfo.query.at) urlInfo.ref = urlInfo.query.at;
+			else urlInfo.ref = "";
+		}
+		if (refs.length !== 0 && urlInfo.ref) {
+			urlInfo.ref = findLongestMatchingSubstring(urlInfo.href, refs) || urlInfo.ref;
+			urlInfo.filepath = urlInfo.href.split(urlInfo.ref + "/")[1];
+		}
+		return urlInfo;
+	}
+	/**
+	* stringify
+	* Stringifies a `GitUrl` object.
+	*
+	* @name stringify
+	* @function
+	* @param {GitUrl} obj The parsed Git url object.
+	* @param {String} type The type of the stringified url (default `obj.protocol`).
+	* @return {String} The stringified url.
+	*/
+	gitUrlParse.stringify = function(obj, type) {
+		type = type || (obj.protocols && obj.protocols.length ? obj.protocols.join("+") : obj.protocol);
+		var port = obj.port ? ":" + obj.port : "";
+		var user = obj.user || "git";
+		var maybeGitSuffix = obj.git_suffix ? ".git" : "";
+		switch (type) {
+			case "ssh": if (port) return "ssh://" + user + "@" + obj.resource + port + "/" + obj.full_name + maybeGitSuffix;
+			else return user + "@" + obj.resource + ":" + obj.full_name + maybeGitSuffix;
+			case "git+ssh":
+			case "ssh+git":
+			case "ftp":
+			case "ftps": return type + "://" + user + "@" + obj.resource + port + "/" + obj.full_name + maybeGitSuffix;
+			case "http":
+			case "https":
+				var auth = obj.token ? buildToken(obj) : obj.user && (obj.protocols.includes("http") || obj.protocols.includes("https")) ? obj.user + "@" : "";
+				return type + "://" + auth + obj.resource + port + "/" + buildPath(obj) + maybeGitSuffix;
+			default: return obj.href;
+		}
+	};
+	function buildToken(obj) {
+		switch (obj.source) {
+			case "bitbucket.org": return "x-token-auth:" + obj.token + "@";
+			default: return obj.token + "@";
+		}
+	}
+	function buildPath(obj) {
+		switch (obj.source) {
+			case "bitbucket-server": return "scm/" + obj.full_name;
+			default: return obj.full_name.split("/").map(function(x) {
+				return encodeURIComponent(x);
+			}).join("/");
+		}
+	}
+	function findLongestMatchingSubstring(string, array) {
+		var longestMatch = "";
+		array.forEach(function(item) {
+			if (string.includes(item) && item.length > longestMatch.length) longestMatch = item;
+		});
+		return longestMatch;
+	}
+	module.exports = gitUrlParse;
+})))(), 1);
+let observer = null;
+function setLocalVcsCommandObserver(next) {
+	observer = next;
+}
+const execFilePromise = promisify(execFile);
+async function execFileAsync(file, args, options = {}) {
+	const finish = observer?.start({
+		file,
+		args,
+		cwd: options.cwd === void 0 ? void 0 : String(options.cwd)
+	});
+	try {
+		const result = await execFilePromise(file, args, {
+			...options,
+			encoding: options.encoding ?? "utf8"
+		});
+		finish?.({ ok: true });
+		return {
+			stdout: String(result.stdout),
+			stderr: String(result.stderr)
+		};
+	} catch (error) {
+		finish?.({ ok: false });
+		throw error;
+	}
+}
+function execFileSyncObserved(file, args, options) {
+	const finish = observer?.start({
+		file,
+		args,
+		cwd: options.cwd === void 0 ? void 0 : String(options.cwd)
+	});
+	try {
+		const output = execFileSync(file, args, options);
+		finish?.({ ok: true });
+		return String(output);
+	} catch (error) {
+		finish?.({ ok: false });
+		throw error;
+	}
+}
+/** Long-lived child; the observer sees one spawn, completed once the process is up. */
+function spawnObserved(file, args, options) {
+	const finish = observer?.start({
+		file,
+		args,
+		cwd: options.cwd === void 0 ? void 0 : String(options.cwd)
+	});
+	try {
+		const child = spawn(file, args, options);
+		let finished = false;
+		const complete = (ok) => {
+			if (finished) return;
+			finished = true;
+			finish?.({ ok });
+		};
+		child.once("spawn", () => complete(true));
+		child.once("error", () => complete(false));
+		return child;
+	} catch (error) {
+		finish?.({ ok: false });
+		throw error;
+	}
+}
+//#endregion
+//#region ../local-vcs/src/blob-batch-reader.ts
+const DEFAULT_IDLE_TIMEOUT_MS = 3e4;
+const DEFAULT_MAX_BLOB_BYTES = 10485760;
+const headerPattern = /^[0-9a-f]+ ([a-z]+) (\d+)$/;
+const KILL_TIMEOUT_MS = 2e3;
+const newline = 10;
+const NOTHING = { found: "nothing" };
+/** Not a cache: every read reaches git. Starts on first read, retires when idle, respawns after a crash. */
+var BlobBatchReader = class {
+	input;
+	session = null;
+	objectStoreArgs = null;
+	starting = null;
+	idleTimer = null;
+	closed = false;
+	constructor(input) {
+		this.input = input;
+	}
+	get pid() {
+		return this.session?.child.pid;
+	}
+	processExit() {
+		return this.session?.exit ?? Promise.resolve();
+	}
+	async read(commit, relativePath) {
+		const answer = await this.readObject(commit, relativePath);
+		return answer.found === "blob" ? answer.blob : null;
+	}
+	async readObject(commit, relativePath) {
+		const request = `${commit}:${relativePath}`;
+		if (this.closed || request.includes("\n")) return NOTHING;
+		const session = await this.start();
+		if (!session) return NOTHING;
+		const answer = new Promise((resolve, reject) => {
+			session.pending.push({
+				resolve,
+				reject
+			});
+			session.writes = session.writes.then(() => this.write(session, `${request}\n`));
+		});
+		session.tail = answer.catch(() => null);
+		this.holdEventLoop(session);
+		this.armIdleTimer(session);
+		return answer;
+	}
+	async close() {
+		this.closed = true;
+		this.clearIdleTimer();
+		await this.starting?.catch(() => null);
+		const session = this.session;
+		if (!session) return;
+		await session.writes.catch(() => null);
+		await session.tail;
+		this.setEventLoopHold(session, true);
+		this.retire(session);
+		await this.awaitExit(session);
+	}
+	async awaitExit(session) {
+		let timer;
+		const expired = new Promise((resolve) => {
+			timer = setTimeout(() => resolve("expired"), KILL_TIMEOUT_MS);
+			timer.unref();
+		});
+		const outcome = await Promise.race([session.exit.then(() => "exited"), expired]);
+		clearTimeout(timer);
+		if (outcome === "exited") return;
+		session.child.kill("SIGKILL");
+		await session.exit;
+	}
+	start() {
+		if (this.session) return Promise.resolve(this.session);
+		this.starting ??= this.spawn().finally(() => {
+			this.starting = null;
+		});
+		return this.starting;
+	}
+	async spawn() {
+		const args = this.objectStoreArgs ?? await this.input.objectStoreArgs().catch(() => null);
+		if (!args) return null;
+		this.objectStoreArgs = args;
+		const child = spawnObserved("git", [
+			...args,
+			"cat-file",
+			"--batch"
+		], {
+			stdio: [
+				"pipe",
+				"pipe",
+				"ignore"
+			],
+			env: this.input.env
+		});
+		const session = {
+			child,
+			pending: [],
+			buffered: Buffer.alloc(0),
+			expected: null,
+			collected: null,
+			writes: Promise.resolve(),
+			tail: Promise.resolve(),
+			exit: new Promise((resolve) => {
+				child.once("close", () => resolve());
+			})
+		};
+		child.stdin.on("error", () => {});
+		child.stdout.on("data", (chunk) => this.consume(session, chunk));
+		child.once("error", (cause) => this.fail(session, "git cat-file --batch could not start.", cause));
+		child.once("exit", () => this.fail(session, "git cat-file --batch stopped before answering."));
+		this.session = session;
+		this.armIdleTimer(session);
+		return session;
+	}
+	consume(session, chunk) {
+		session.buffered = session.buffered.length > 0 ? Buffer.concat([session.buffered, chunk]) : chunk;
+		for (;;) {
+			if (session.expected === null) {
+				const end = session.buffered.indexOf(newline);
+				if (end < 0) break;
+				const header = session.buffered.subarray(0, end).toString("utf8");
+				session.buffered = session.buffered.subarray(end + 1);
+				const answer = headerPattern.exec(header);
+				if (!answer) {
+					this.settle(session, NOTHING);
+					continue;
+				}
+				const size = Number(answer[2]);
+				session.expected = size + 1;
+				session.collected = answer[1] === "blob" && size <= this.maxBlobBytes ? [] : null;
+			}
+			const take = Math.min(session.buffered.length, session.expected);
+			session.collected?.push(session.buffered.subarray(0, take));
+			session.buffered = session.buffered.subarray(take);
+			session.expected -= take;
+			if (session.expected > 0) break;
+			const collected = session.collected;
+			session.expected = null;
+			session.collected = null;
+			this.settle(session, collected ? {
+				found: "blob",
+				blob: Buffer.concat(collected).subarray(0, -1)
+			} : { found: "other" });
+		}
+		this.armIdleTimer(session);
+	}
+	settle(session, value) {
+		session.pending.shift()?.resolve(value);
+		this.holdEventLoop(session);
+	}
+	/** Hold the loop only while a read is pending or a close is in progress. */
+	holdEventLoop(session) {
+		this.setEventLoopHold(session, session.pending.length > 0 || this.closed);
+	}
+	setEventLoopHold(session, hold) {
+		for (const handle of [
+			session.child,
+			session.child.stdin,
+			session.child.stdout
+		]) if (hold) handle.ref();
+		else handle.unref();
+	}
+	fail(session, message, cause) {
+		if (this.session === session) {
+			this.session = null;
+			this.clearIdleTimer();
+		}
+		for (const read of session.pending.splice(0)) read.reject(cause ? new Error(message, { cause }) : new Error(message));
+		this.holdEventLoop(session);
+	}
+	write(session, request) {
+		const stdin = session.child.stdin;
+		if (!stdin.writable) return Promise.resolve();
+		return new Promise((resolve) => {
+			if (stdin.write(request)) {
+				resolve();
+				return;
+			}
+			const proceed = () => {
+				stdin.off("drain", proceed);
+				resolve();
+			};
+			stdin.once("drain", proceed);
+			session.exit.then(proceed);
+		});
+	}
+	get maxBlobBytes() {
+		return this.input.maxBlobBytes ?? DEFAULT_MAX_BLOB_BYTES;
+	}
+	armIdleTimer(session) {
+		if (this.session !== session) return;
+		this.clearIdleTimer();
+		this.idleTimer = setTimeout(() => {
+			this.idleTimer = null;
+			if (session.pending.length > 0) {
+				this.armIdleTimer(session);
+				return;
+			}
+			this.retire(session);
+		}, this.input.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS);
+		this.idleTimer.unref();
+	}
+	clearIdleTimer() {
+		if (!this.idleTimer) return;
+		clearTimeout(this.idleTimer);
+		this.idleTimer = null;
+	}
+	/** Null the session before killing so its exit rejects nothing. */
+	retire(session) {
+		if (this.session === session) {
+			this.session = null;
+			this.clearIdleTimer();
+		}
+		session.child.kill();
+	}
+};
+//#endregion
+//#region ../local-vcs/src/windows-path.ts
+/**
+* A Windows process keeps the PATH it launched with, so Git installed while
+* Whiteboard runs is only in the saved system and user PATH. Merge those (and
+* Git for Windows' usual location) into this process. Returns whether PATH
+* gained any entries.
+*/
+function refreshWindowsPath() {
+	if (process.platform !== "win32") return false;
+	const current = (process.env.PATH ?? "").split(";").filter(Boolean);
+	const known = new Set(current.map(normalizeEntry));
+	const added = [];
+	const candidates = [
+		...savedPath("HKLM\\SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment"),
+		...savedPath("HKCU\\Environment"),
+		path.join(process.env.ProgramFiles ?? "C:\\Program Files", "Git", "cmd")
+	];
+	for (const entry of candidates) {
+		const key = normalizeEntry(entry);
+		if (known.has(key) || !fs.existsSync(entry)) continue;
+		known.add(key);
+		added.push(entry);
+	}
+	if (added.length === 0) return false;
+	process.env.PATH = [...current, ...added].join(";");
+	return true;
+}
+function savedPath(key) {
+	let output;
+	try {
+		output = execFileSync("reg.exe", [
+			"query",
+			key,
+			"/v",
+			"Path"
+		], {
+			encoding: "utf8",
+			windowsHide: true
+		});
+	} catch {
+		return [];
+	}
+	return (output.match(/^\s*Path\s+REG_\w+\s*(.*)$/im)?.[1] ?? "").split(";").map((entry) => entry.trim().replace(/%([^%]+)%/g, (whole, name) => process.env[name] ?? whole)).filter(Boolean);
+}
+function normalizeEntry(entry) {
+	return path.win32.resolve(entry).toLowerCase();
+}
+//#endregion
+//#region ../local-vcs/src/vcs.ts
+const LOCAL_GIT_ENV_KEYS = [
+	"GIT_ALTERNATE_OBJECT_DIRECTORIES",
+	"GIT_COMMON_DIR",
+	"GIT_CONFIG",
+	"GIT_CONFIG_COUNT",
+	"GIT_CONFIG_PARAMETERS",
+	"GIT_DIR",
+	"GIT_GRAFT_FILE",
+	"GIT_IMPLICIT_WORK_TREE",
+	"GIT_INDEX_FILE",
+	"GIT_INTERNAL_SUPER_PREFIX",
+	"GIT_NO_REPLACE_OBJECTS",
+	"GIT_OBJECT_DIRECTORY",
+	"GIT_PREFIX",
+	"GIT_QUARANTINE_PATH",
+	"GIT_REPLACE_REF_BASE",
+	"GIT_SHALLOW_FILE",
+	"GIT_WORK_TREE"
+];
+/** Neither git nor jj could be started, so no folder can be recognized as a repository. */
+var LocalVcsToolsMissingError = class extends Error {
+	constructor() {
+		super(process.platform === "win32" ? "Git isn't installed or isn't on PATH. Install Git for Windows, then try again." : "Git isn't installed or isn't on PATH. Install Git, then try again.");
+		this.name = "LocalVcsToolsMissingError";
+	}
+};
+async function detectLocalVcs(rootPath) {
+	const detected = await detectLocalVcsOnce(rootPath);
+	if (detected !== TOOLS_MISSING) return detected;
+	if (refreshWindowsPath()) {
+		const retried = await detectLocalVcsOnce(rootPath);
+		if (retried !== TOOLS_MISSING) return retried;
+	}
+	throw new LocalVcsToolsMissingError();
+}
+const TOOLS_MISSING = Symbol("tools missing");
+async function detectLocalVcsOnce(rootPath) {
+	const resolvedRootPath = canonicalPath(rootPath);
+	let missing = 0;
+	const notStarted = (error) => {
+		if (error.code === "ENOENT") missing++;
+		return null;
+	};
+	const jjRoot = await commandOutput("jj", [
+		"-R",
+		resolvedRootPath,
+		"root",
+		"--ignore-working-copy"
+	], { cwd: resolvedRootPath }).catch(notStarted);
+	if (jjRoot && isInsideDirectory(resolvedRootPath, canonicalPath(jjRoot))) return createLocalVcs("jj", canonicalPath(jjRoot));
+	const gitRoot = await commandOutput("git", [
+		"-C",
+		resolvedRootPath,
+		"rev-parse",
+		"--show-toplevel"
+	], { cwd: resolvedRootPath }).catch(notStarted);
+	if (gitRoot) return createLocalVcs("git", canonicalPath(gitRoot));
+	return missing === 2 && fs.existsSync(resolvedRootPath) ? TOOLS_MISSING : null;
+}
+/** Skip detection when the caller already holds a handle for this root. */
+async function knownOrDetectedVcs(rootPath, kind) {
+	return kind ? createLocalVcs(kind, rootPath) : detectLocalVcs(rootPath);
+}
+/**
+* Resolve the repository's shared git directory ($GIT_COMMON_DIR) so all
+* worktrees agree on one object database and one refs namespace. Follows the
+* same jj-first preference as detectLocalVcs: a non-colocated jj workspace
+* nested inside another git repo must resolve to its jj backing store
+* (`jj git root`), not the OUTER repo's git dir via plain git. Colocated jj
+* repos have a real .git and resolve to it through either path.
+*/
+async function gitCommonDir(rootPath) {
+	const key = path.resolve(rootPath);
+	return await commandOutput("jj", [
+		"git",
+		"root",
+		"--ignore-working-copy"
+	], { cwd: key }).catch(() => null) || await commandOutput("git", [
+		"-C",
+		key,
+		"rev-parse",
+		"--path-format=absolute",
+		"--git-common-dir"
+	], { cwd: key }).catch(() => null) || null;
+}
+function gitCommonDirSync(rootPath) {
+	const key = path.resolve(rootPath);
+	return commandOutputSync("jj", [
+		"git",
+		"root",
+		"--ignore-working-copy"
+	], { cwd: key }) || commandOutputSync("git", [
+		"-C",
+		key,
+		"rev-parse",
+		"--path-format=absolute",
+		"--git-common-dir"
+	], { cwd: key }) || null;
+}
+/**
+* Resolve the repository identity through its jj-first shared Git directory.
+* Remote lookup must never rely on Git's cwd walk: a non-colocated jj
+* workspace may be nested inside an unrelated Git repository.
+*/
+async function resolveRepoContext(rootPath) {
+	const commonDir = await gitCommonDir(path.resolve(rootPath));
+	if (!commonDir) return null;
+	const [originUrl, resolvedOriginUrl] = await Promise.all([commandOutput("git", [
+		"--git-dir",
+		commonDir,
+		"config",
+		"--get",
+		"remote.origin.url"
+	]).catch(() => null), commandOutput("git", [
+		"--git-dir",
+		commonDir,
+		"remote",
+		"get-url",
+		"origin"
+	]).catch(() => null)]);
+	return {
+		commonDir,
+		originUrl: originUrl || null,
+		githubSlug: (resolvedOriginUrl ? parseGitRemoteSlug(resolvedOriginUrl) : null) ?? (originUrl ? parseGitRemoteSlug(originUrl) : null)
+	};
+}
+function resolveRepoContextSync(rootPath) {
+	const commonDir = gitCommonDirSync(path.resolve(rootPath));
+	if (!commonDir) return null;
+	const originUrl = commandOutputSync("git", [
+		"--git-dir",
+		commonDir,
+		"config",
+		"--get",
+		"remote.origin.url"
+	]) || null;
+	const resolvedOriginUrl = commandOutputSync("git", [
+		"--git-dir",
+		commonDir,
+		"remote",
+		"get-url",
+		"origin"
+	]) || null;
+	return {
+		commonDir,
+		originUrl,
+		githubSlug: (resolvedOriginUrl ? parseGitRemoteSlug(resolvedOriginUrl) : null) ?? (originUrl ? parseGitRemoteSlug(originUrl) : null)
+	};
+}
+/** git argv for the object store: a jj workspace reads through its backing store. */
+async function objectStoreArgs(input) {
+	if (input.kind === "git") return ["-C", input.rootPath];
+	const gitDir = await gitCommonDir(input.rootPath);
+	return gitDir ? ["--git-dir", gitDir] : ["-C", input.rootPath];
+}
+function createBlobBatchReader(input) {
+	return new BlobBatchReader({
+		objectStoreArgs: () => objectStoreArgs(input),
+		env: localGitEnvironment(),
+		idleTimeoutMs: input.idleTimeoutMs
+	});
+}
+/** Git argv prefix that pins a command to the repo's shared git dir. */
+async function gitArgs(rootPath, args) {
+	const gitDir = await gitCommonDir(rootPath);
+	if (!gitDir) throw new Error(`No git repository found at ${rootPath}`);
+	return [
+		"--git-dir",
+		gitDir,
+		...args
+	];
+}
+/** Run git against the repo's shared git dir, optionally tolerating failure. */
+async function git(rootPath, args, options = {}) {
+	try {
+		const { stdout, stderr } = await execFileAsync("git", await gitArgs(rootPath, args), {
+			maxBuffer: 67108864,
+			signal: options.signal
+		});
+		return {
+			ok: true,
+			stdout,
+			stderr
+		};
+	} catch (error) {
+		if (options.allowFailure) {
+			const err = error;
+			return {
+				ok: false,
+				stdout: err.stdout ?? "",
+				stderr: err.stderr ?? String(error)
+			};
+		}
+		throw error;
+	}
+}
+/**
+* Run git from a working directory, as `git -C <cwd>` does. Unlike `git()`,
+* which pins the shared git dir, this resolves HEAD, the index, and local
+* config for the worktree that owns `cwd`.
+*/
+async function gitAt(cwd, args, options = {}) {
+	try {
+		const { stdout, stderr } = await execFileAsync("git", [
+			"-C",
+			cwd,
+			...args
+		], {
+			maxBuffer: 67108864,
+			signal: options.signal,
+			env: options.env,
+			timeout: options.timeout
+		});
+		return {
+			ok: true,
+			stdout,
+			stderr
+		};
+	} catch (error) {
+		if (options.allowFailure) {
+			const err = error;
+			return {
+				ok: false,
+				stdout: err.stdout ?? "",
+				stderr: err.stderr ?? String(error)
+			};
+		}
+		throw error;
+	}
+}
+function createLocalVcs(kind, rootPath) {
+	return {
+		kind,
+		rootPath,
+		currentHead: () => currentHeadForKind(rootPath, kind),
+		resolveRevision: (revision) => resolveRevisionForKind(rootPath, revision, kind),
+		defaultBranch: () => defaultBranchForKind(rootPath, kind),
+		mergeBase: (baseRef, headRef) => mergeBaseForKind({
+			rootPath,
+			baseRef,
+			headRef,
+			kind
+		}),
+		listTrackedFiles: (revision) => Promise.resolve(listTrackedFilesForKind({
+			rootPath,
+			ref: revision,
+			kind
+		})),
+		readFileAtRef: (ref, relativePath) => Promise.resolve(readFileAtRevisionForKind({
+			rootPath,
+			ref,
+			relativePath,
+			kind
+		})?.source ?? null),
+		diff: (input) => diffForKind({
+			rootPath,
+			baseRef: input.base,
+			headRef: input.head,
+			contextLines: input.contextLines,
+			paths: input.paths,
+			kind
+		}),
+		diffNameStatus: async (input) => toNameStatusEntries(await diffNameStatusForKind({
+			rootPath,
+			baseRef: input.base,
+			headRef: input.head,
+			mergeBase: input.mergeBase,
+			kind
+		})),
+		diffFileSummaries: (input) => diffFileSummariesForKind({
+			rootPath,
+			baseRef: input.base,
+			headRef: input.head,
+			paths: input.paths,
+			kind
+		}),
+		githubRemoteSlug: () => githubRemoteSlug(rootPath)
+	};
+}
+/**
+* Whether a revision carries unresolved jj conflicts. jj materializes
+* conflict markers into the git export of such commits, so a downstream git
+* checkout would silently contain marker text instead of code. Returns null
+* when the repository is not jj (git commits cannot be conflicted) or when
+* jj cannot answer — callers must only act on a definite true.
+*/
+async function jjRevisionIsConflicted(rootPath, revision) {
+	if ((await detectLocalVcs(rootPath))?.kind !== "jj") return null;
+	try {
+		const { stdout } = await execFileAsync("jj", [
+			"log",
+			"-r",
+			revision,
+			"--no-graph",
+			"-T",
+			"if(conflict, \"true\", \"false\")",
+			"--ignore-working-copy"
+		], { cwd: rootPath });
+		const value = stdout.trim();
+		return value === "true" ? true : value === "false" ? false : null;
+	} catch {
+		return null;
+	}
+}
+async function resolveRevision(rootPath, revision) {
+	const vcs = await detectLocalVcs(rootPath);
+	if (!vcs) return null;
+	return vcs.resolveRevision(revision);
+}
+async function currentHeadForKind(rootPath, kind) {
+	return resolveRevisionForKind(rootPath, kind === "jj" ? "@" : "HEAD", kind);
+}
+async function resolveRevisionForKind(rootPath, revision, kind) {
+	const commit = await resolveRevisionCommitByPreference(rootPath, revision, kind);
+	return commit ? { commit } : null;
+}
+/**
+* The default branch as a re-resolvable NAME (e.g. "origin/main" or "main"),
+* or null when no candidate resolves. Callers that must store a base ref a
+* later update can re-derive from should prefer this over the resolved
+* commit, which freezes the fork point forever.
+*/
+async function defaultBranchForKind(rootPath, kind) {
+	const candidates = await defaultBranchCandidates(rootPath);
+	for (const candidate of candidates) {
+		const commit = await resolveRevisionCommitByPreference(rootPath, candidate, kind);
+		if (commit) return {
+			ref: candidate,
+			commit
+		};
+	}
+	return null;
+}
+async function mergeBaseForKind(input) {
+	const commit = await mergeBaseByPreference(input.rootPath, input.baseRef, input.headRef, input.kind);
+	return commit ? { commit } : null;
+}
+async function listTrackedFilesAtCommit(input) {
+	if (input.kind === "jj") {
+		const output = await commandOutput("jj", [
+			"-R",
+			input.rootPath,
+			"file",
+			"list",
+			"--ignore-working-copy",
+			"-r",
+			input.commit
+		], { cwd: input.rootPath }).catch(() => null);
+		if (output !== null) return splitLines(output);
+		if (!await canUseGitFallback(input.rootPath, input.kind)) return [];
+	}
+	const output = await commandOutput("git", [
+		"-C",
+		input.rootPath,
+		"ls-tree",
+		"-r",
+		"-z",
+		"--name-only",
+		input.commit
+	], { cwd: input.rootPath }).catch(() => null);
+	return output === null ? [] : output.split("\0").filter(Boolean);
+}
+function listTrackedFilesForKind(input) {
+	if (input.kind === "jj") {
+		const args = [
+			"-R",
+			input.rootPath,
+			"file",
+			"list",
+			"--ignore-working-copy"
+		];
+		if (input.ref) args.push("-r", input.ref);
+		const output = commandOutputSync("jj", args, { cwd: input.rootPath });
+		if (output !== null) return splitLines(output);
+		if (!canUseGitFallbackSync(input.rootPath, input.kind)) return [];
+	}
+	const output = input.ref ? commandOutputSync("git", [
+		"-C",
+		input.rootPath,
+		"ls-tree",
+		"-r",
+		"-z",
+		"--name-only",
+		input.ref
+	], { cwd: input.rootPath }) : commandOutputSync("git", [
+		"-C",
+		input.rootPath,
+		"ls-files",
+		"-z"
+	], { cwd: input.rootPath });
+	if (output === null) return [];
+	return output.split("\0").filter(Boolean);
+}
+/**
+* Read a blob at a resolved commit through the caller's batch reader.
+* jj conflicted revisions go through `jj file show`: the git tree holds one side only.
+* Null for a missing commit or path, or a non-blob (a directory).
+*/
+async function readFileAtCommit(input) {
+	if (input.reader) return readFileWithReader(input, input.reader);
+	const reader = createBlobBatchReader({
+		rootPath: input.rootPath,
+		kind: input.kind
+	});
+	try {
+		return await readFileWithReader(input, reader);
+	} finally {
+		await reader.close();
+	}
+}
+async function readFileWithReader(input, reader) {
+	if (input.kind === "jj" && await jjCommitIsConflicted(reader, input.commit)) return readJjFileAtCommit(input);
+	const answer = await reader.readObject(input.commit, input.relativePath).catch(() => ({ found: "nothing" }));
+	if (answer.found === "blob") return answer.blob.toString("utf8");
+	if (answer.found === "other" || input.kind !== "jj") return null;
+	return readJjFileAtCommit(input);
+}
+async function readJjFileAtCommit(input) {
+	return commandOutput("jj", [
+		"-R",
+		input.rootPath,
+		"file",
+		"show",
+		"-r",
+		input.commit,
+		"--ignore-working-copy",
+		"--",
+		toJjRootFilePattern(input.relativePath)
+	], {
+		cwd: input.rootPath,
+		maxBuffer: 10485760,
+		trim: false
+	}).catch(() => null);
+}
+/** jj writes this README into a conflicted commit; remembered per (immutable) commit. */
+const JJ_CONFLICT_MARKER = "JJ-CONFLICT-README";
+const jjConflictedCommits = /* @__PURE__ */ new WeakMap();
+async function jjCommitIsConflicted(reader, commit) {
+	let known = jjConflictedCommits.get(reader);
+	if (!known) {
+		known = /* @__PURE__ */ new Map();
+		jjConflictedCommits.set(reader, known);
+	}
+	const answered = known.get(commit);
+	if (answered) return answered;
+	const probe = reader.read(commit, JJ_CONFLICT_MARKER).then((marker) => marker !== null, () => false);
+	known.set(commit, probe);
+	return probe;
+}
+function readFileAtRevisionForKind(input) {
+	return input.kind === "jj" ? readJjFileAtRevisionSync(input) ?? (canUseGitFallbackSync(input.rootPath, input.kind) ? readGitFileAtRevisionSync(input) : null) : readGitFileAtRevisionSync(input) ?? readJjFileAtRevisionSync(input);
+}
+async function diff(input) {
+	const vcs = await knownOrDetectedVcs(input.rootPath, input.kind);
+	if (!vcs) throw new Error(`No Git or jj repository found for ${input.rootPath}.`);
+	return diffForKind({
+		...input,
+		rootPath: vcs.rootPath,
+		kind: vcs.kind
+	});
+}
+/** Use the same summary parser for working files and committed trees. */
+function diffFileSummariesWorkingTree(input) {
+	return withWorkingTreeIndex(input, readGitDiffFileSummaries);
+}
+/** Read one Git patch for the entire checkout, or for the named changed files. */
+function diffWorkingTree(input) {
+	return withWorkingTreeIndex(input, async (options) => {
+		const read = {
+			...options,
+			contextLines: input.contextLines
+		};
+		if (input.paths === void 0) return readGitDiff(read);
+		const requested = new Set(input.paths);
+		const previous = (await readGitDiffFileSummaries(options)).flatMap((change) => change.previousPath && requested.has(change.path) ? [change.previousPath] : []);
+		return readGitDiff({
+			...read,
+			literalPaths: true,
+			paths: [.../* @__PURE__ */ new Set([...previous, ...input.paths])]
+		});
+	});
+}
+/** A private index and object store compare the working tree without staging user files. */
+async function withWorkingTreeIndex(input, read) {
+	const scratch = await fs.promises.mkdtemp(path.join(tmpdir(), "review-git-diff-"));
+	try {
+		const common = await gitCommonDir(input.rootPath);
+		if (!common) throw new Error("Working source requires a Git-backed repository.");
+		const env = {
+			...localGitEnvironment(),
+			GIT_INDEX_FILE: path.join(scratch, "index"),
+			GIT_OBJECT_DIRECTORY: path.join(scratch, "objects"),
+			GIT_ALTERNATE_OBJECT_DIRECTORIES: JSON.stringify(path.join(common, "objects")),
+			GIT_OPTIONAL_LOCKS: "0"
+		};
+		if (input.kind === "jj") {
+			env.GIT_DIR = common;
+			env.GIT_WORK_TREE = input.rootPath;
+		}
+		await fs.promises.mkdir(path.join(scratch, "objects"));
+		const git = (args) => execFileAsync("git", [
+			"-c",
+			"core.splitIndex=false",
+			"-C",
+			input.rootPath,
+			...args
+		], {
+			env,
+			cwd: input.rootPath,
+			maxBuffer: 33554432
+		});
+		if (input.kind === "git") {
+			const index = (await execFileAsync("git", [
+				"-C",
+				input.rootPath,
+				"rev-parse",
+				"--path-format=absolute",
+				"--git-path",
+				"index"
+			], { env: localGitEnvironment() })).stdout.trim();
+			try {
+				const copy = path.join(scratch, "index");
+				await fs.promises.copyFile(index, copy);
+				const { atime, mtime } = await fs.promises.stat(index);
+				await fs.promises.utimes(copy, atime, mtime);
+			} catch (error) {
+				if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) throw error;
+			}
+		} else if (input.headRef) await git(["read-tree", input.headRef]);
+		if (input.kind === "jj") await git([
+			"add",
+			"--intent-to-add",
+			"--all",
+			"--",
+			".",
+			":(exclude).jj"
+		]);
+		await fs.promises.writeFile(path.join(scratch, "empty"), "");
+		const baseRef = input.baseRef ?? (await git([
+			"hash-object",
+			"-w",
+			"-t",
+			"tree",
+			path.join(scratch, "empty")
+		])).stdout.trim();
+		return await read({
+			rootPath: input.rootPath,
+			baseRef,
+			env
+		});
+	} finally {
+		await fs.promises.rm(scratch, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+/** Compare two exact Git trees without merge-base semantics. */
+async function diffTrees(input) {
+	const vcs = await knownOrDetectedVcs(input.rootPath, input.kind);
+	if (!vcs) throw new Error(`No Git or jj repository found for ${input.rootPath}.`);
+	return diffForKind({
+		...input,
+		rootPath: vcs.rootPath,
+		kind: vcs.kind,
+		mergeBase: false
+	});
+}
+async function diffFileSummaries(input) {
+	const vcs = await detectLocalVcs(input.rootPath);
+	if (!vcs) throw new Error(`No Git or jj repository found for ${input.rootPath}.`);
+	return diffFileSummariesForKind({
+		...input,
+		rootPath: vcs.rootPath,
+		kind: vcs.kind
+	});
+}
+/** List commits in base..head order, newest first, with first-parent stats. */
+async function listCommitRange(input) {
+	const vcs = await knownOrDetectedVcs(input.rootPath, input.kind);
+	if (!vcs) throw new Error(`No Git or jj repository found for ${input.rootPath}.`);
+	try {
+		const { stdout } = await execFileAsync("git", [
+			"-C",
+			vcs.rootPath,
+			"log",
+			"--topo-order",
+			"--format=%H%x00%P%x00%an%x00%aI%x00%s%x00",
+			"--numstat",
+			"-z",
+			`${input.baseRef}..${input.headRef}`
+		], {
+			cwd: vcs.rootPath,
+			maxBuffer: 26214400
+		});
+		return parseGitCommitRange(stdout);
+	} catch (error) {
+		if (vcs.kind !== "jj") throw error;
+		return readJjCommitRange(vcs.rootPath, input.baseRef, input.headRef);
+	}
+}
+function parseGitCommitRange(output) {
+	const fields = output.split("\0");
+	const commits = [];
+	let index = 0;
+	while (index < fields.length) {
+		const commit = fields[index++]?.replace(/^\n+/u, "") ?? "";
+		if (!/^[0-9a-f]{40}$/iu.test(commit)) continue;
+		const parentCommit = (fields[index++] ?? "").split(" ")[0] ?? "";
+		const author = fields[index++] ?? "";
+		const authoredAt = fields[index++] ?? "";
+		const subject = fields[index++] ?? "";
+		if (fields[index] === "") index += 1;
+		let fileCount = 0;
+		let additions = 0;
+		let deletions = 0;
+		while (index < fields.length) {
+			const field = fields[index]?.replace(/^\n+/u, "") ?? "";
+			if (/^[0-9a-f]{40}$/iu.test(field)) break;
+			index += 1;
+			if (!field) continue;
+			const [rawAdditions, rawDeletions, filePath] = field.split("	");
+			if (rawDeletions === void 0) continue;
+			fileCount += 1;
+			additions += parseGitNumStatCount(rawAdditions);
+			deletions += parseGitNumStatCount(rawDeletions);
+			if (!filePath) index += 2;
+		}
+		if (!parentCommit || !authoredAt) continue;
+		commits.push({
+			commit,
+			parentCommit,
+			subject,
+			author,
+			authoredAt,
+			fileCount,
+			additions,
+			deletions
+		});
+	}
+	return commits;
+}
+async function readJjCommitRange(rootPath, baseRef, headRef) {
+	const fields = (await commandOutput("jj", [
+		"-R",
+		rootPath,
+		"--no-pager",
+		"log",
+		"--no-graph",
+		"-r",
+		`::${headRef} ~ ::${baseRef}`,
+		"-T",
+		"commit_id ++ \"\\0\" ++ parents.map(|p| p.commit_id()).join(\" \") ++ \"\\0\" ++ author.name() ++ \"\\0\" ++ author.timestamp().format(\"%+\") ++ \"\\0\" ++ description.first_line() ++ \"\\0\"",
+		"--ignore-working-copy"
+	], {
+		cwd: rootPath,
+		maxBuffer: 26214400,
+		trim: false
+	})).split("\0");
+	const metadata = [];
+	for (let index = 0; index + 4 < fields.length; index += 5) {
+		const commit = fields[index]?.trim() ?? "";
+		const parentCommit = (fields[index + 1] ?? "").split(" ")[0] ?? "";
+		if (!commit || !parentCommit) continue;
+		metadata.push({
+			commit,
+			parentCommit,
+			author: fields[index + 2] ?? "",
+			authoredAt: fields[index + 3] ?? "",
+			subject: fields[index + 4] ?? ""
+		});
+	}
+	return Promise.all(metadata.map(async (entry) => {
+		const files = await diffFileSummariesForKind({
+			rootPath,
+			baseRef: entry.parentCommit,
+			headRef: entry.commit,
+			mergeBase: false,
+			kind: "jj"
+		});
+		return {
+			...entry,
+			fileCount: files.length,
+			additions: files.reduce((total, file) => total + file.additions, 0),
+			deletions: files.reduce((total, file) => total + file.deletions, 0)
+		};
+	}));
+}
+/** Summarize changes between two exact Git trees. */
+async function diffFileSummariesTrees(input) {
+	const vcs = await knownOrDetectedVcs(input.rootPath, input.kind);
+	if (!vcs) throw new Error(`No Git or jj repository found for ${input.rootPath}.`);
+	return diffFileSummariesForKind({
+		...input,
+		rootPath: vcs.rootPath,
+		kind: vcs.kind,
+		mergeBase: false
+	});
+}
+async function diffForKind(input) {
+	if (input.kind === "jj") return readJjDiff(input).catch((cause) => {
+		if (!canUseGitFallbackSync(input.rootPath, input.kind)) throw cause;
+		return readGitDiff(input);
+	});
+	return readGitDiff(input).catch(() => readJjDiff(input));
+}
+async function diffFileSummariesForKind(input) {
+	const requestedPaths = normalizeDiffPaths(input.paths);
+	const unfilteredInput = {
+		...input,
+		paths: void 0
+	};
+	let summaries;
+	if (input.kind === "jj") {
+		if (canUseGitFallbackSync(input.rootPath, input.kind)) try {
+			summaries = await readGitDiffFileSummaries(unfilteredInput);
+			return filterDiffFileSummaries(summaries, requestedPaths);
+		} catch {}
+		summaries = parseGitPatchFileSummaries(await readJjDiff(unfilteredInput));
+		return filterDiffFileSummaries(summaries, requestedPaths);
+	}
+	summaries = await readGitDiffFileSummaries(unfilteredInput).catch(async () => parseGitPatchFileSummaries(await readJjDiff(unfilteredInput)));
+	return filterDiffFileSummaries(summaries, requestedPaths);
+}
+async function diffNameStatusForKind(input) {
+	if (input.kind === "jj") return readJjDiffNameStatus(input).catch((cause) => {
+		if (!canUseGitFallbackSync(input.rootPath, input.kind)) throw cause;
+		return readGitDiffNameStatus(input);
+	});
+	return readGitDiffNameStatus(input).catch(() => readJjDiffNameStatus(input));
+}
+async function githubRemoteSlug(rootPath) {
+	return (await resolveRepoContext(rootPath))?.githubSlug ?? null;
+}
+function parseGitRemote(remote) {
+	const value = remote.trim();
+	if (!value) return null;
+	try {
+		const parsed = (0, import_lib.default)(value);
+		const host = parsed.resource.trim().toLowerCase();
+		const owner = parsed.owner.trim();
+		const repo = parsed.name.trim().replace(/\.git$/u, "");
+		const port = parsed.port ? Number(parsed.port) : null;
+		if (!host || !owner || !repo || port !== null && !Number.isInteger(port)) return null;
+		return {
+			protocol: parsed.protocol,
+			host,
+			port,
+			owner,
+			repo,
+			slug: `${owner}/${repo}`
+		};
+	} catch {
+		return null;
+	}
+}
+/**
+* Return an owner/repo slug only for a trusted GitHub host.
+*
+* `git remote get-url` expands Git `url.*.insteadOf` aliases before this
+* function sees the value. OpenSSH `Host` aliases are not expanded by Git, so
+* callers must explicitly list a trusted alias or GitHub Enterprise hostname
+* in `githubHosts`.
+*/
+function parseGitRemoteSlug(remote, options = {}) {
+	const parsed = parseGitRemote(remote);
+	if (!parsed) return null;
+	return new Set(["github.com", ...options.githubHosts ?? []].map((host) => host.toLowerCase())).has(parsed.host) ? parsed.slug : null;
+}
+function parseGitDiffNameStatus(output) {
+	const changedFiles = /* @__PURE__ */ new Set();
+	const deletedFiles = /* @__PURE__ */ new Set();
+	for (const line of output.split(/\r?\n/)) {
+		if (!line.trim()) continue;
+		const [status, firstPath, secondPath] = line.split("	");
+		if (!status || !firstPath) continue;
+		const kind = status[0];
+		if (kind === "D") {
+			deletedFiles.add(firstPath);
+			continue;
+		}
+		if (kind === "R") {
+			deletedFiles.add(firstPath);
+			if (secondPath) changedFiles.add(secondPath);
+			continue;
+		}
+		if (kind === "C") {
+			changedFiles.add(secondPath ?? firstPath);
+			continue;
+		}
+		changedFiles.add(firstPath);
+	}
+	return {
+		changedFiles: [...changedFiles].sort(),
+		deletedFiles: [...deletedFiles].sort()
+	};
+}
+function parseJjDiffSummary(output) {
+	const changedFiles = /* @__PURE__ */ new Set();
+	const deletedFiles = /* @__PURE__ */ new Set();
+	for (const line of output.split(/\r?\n/)) {
+		if (!line.trim()) continue;
+		const status = line[0];
+		const file = line.slice(2).trim();
+		if (!file) continue;
+		if (status === "D") deletedFiles.add(file);
+		else changedFiles.add(file);
+	}
+	return {
+		changedFiles: [...changedFiles].sort(),
+		deletedFiles: [...deletedFiles].sort()
+	};
+}
+function toNameStatusEntries(summary) {
+	return [...summary.changedFiles.map((path) => ({
+		path,
+		status: "modified"
+	})), ...summary.deletedFiles.map((path) => ({
+		path,
+		status: "deleted"
+	}))].sort((left, right) => left.path.localeCompare(right.path));
+}
+async function readGitDiffNameStatus(input) {
+	const refRange = input.mergeBase === false ? [input.baseRef, input.headRef] : [`${input.baseRef}...${input.headRef}`];
+	return parseGitDiffNameStatus(await commandOutput("git", [
+		"-C",
+		input.rootPath,
+		"diff",
+		"--name-status",
+		"--diff-filter=ACDMRTUXB",
+		...refRange,
+		"--"
+	], {
+		cwd: input.rootPath,
+		maxBuffer: 26214400
+	}));
+}
+async function readJjDiffNameStatus(input) {
+	return parseJjDiffSummary(await commandOutput("jj", [
+		"-R",
+		input.rootPath,
+		"diff",
+		"--summary",
+		"--from",
+		input.baseRef,
+		"--to",
+		input.headRef,
+		"--ignore-working-copy"
+	], {
+		cwd: input.rootPath,
+		maxBuffer: 26214400
+	}));
+}
+function toJjRootFilePattern(filePath) {
+	return `root-file:${JSON.stringify(filePath).replace(/\\(.)/g, (escape, char) => char === "b" ? "\\u0008" : char === "f" ? "\\u000c" : escape)}`;
+}
+async function defaultBranchCandidates(rootPath) {
+	return uniqueStrings([
+		await commandOutput("git", [
+			"-C",
+			rootPath,
+			"symbolic-ref",
+			"--quiet",
+			"--short",
+			"refs/remotes/origin/HEAD"
+		], { cwd: rootPath }).catch(() => null),
+		"origin/main",
+		"origin/master",
+		"main",
+		"master"
+	]);
+}
+async function resolveRevisionCommitByPreference(rootPath, revision, preferred) {
+	const primary = preferred === "jj" ? resolveJjRevisionCommit : resolveGitRevisionCommit;
+	const secondary = preferred === "jj" ? resolveGitRevisionCommit : resolveJjRevisionCommit;
+	return await primary(rootPath, revision).catch(() => null) ?? (canUseGitFallbackSync(rootPath, preferred) ? await secondary(rootPath, revision).catch(() => null) : null);
+}
+async function mergeBaseByPreference(rootPath, baseRef, headRef, preferred) {
+	const primary = preferred === "jj" ? resolveJjMergeBase : resolveGitMergeBase;
+	const secondary = preferred === "jj" ? resolveGitMergeBase : resolveJjMergeBase;
+	return await primary(rootPath, baseRef, headRef).catch(() => null) ?? (canUseGitFallbackSync(rootPath, preferred) ? await secondary(rootPath, baseRef, headRef).catch(() => null) : null);
+}
+async function resolveGitRevisionCommit(rootPath, revision) {
+	return commandOutput("git", [
+		"-C",
+		rootPath,
+		"rev-parse",
+		"--verify",
+		`${revision}^{commit}`
+	]);
+}
+function resolveGitRevisionCommitSync(rootPath, revision) {
+	return commandOutputSync("git", [
+		"-C",
+		rootPath,
+		"rev-parse",
+		"--verify",
+		`${revision}^{commit}`
+	]);
+}
+async function resolveJjRevisionCommit(rootPath, revision) {
+	return oneResolvedCommit(await commandOutput("jj", [
+		"-R",
+		rootPath,
+		"log",
+		"--no-graph",
+		"-r",
+		revision,
+		"-T",
+		"commit_id ++ \"\\n\"",
+		"--ignore-working-copy"
+	], { cwd: rootPath }), revision);
+}
+function resolveJjRevisionCommitSync(rootPath, revision) {
+	const output = commandOutputSync("jj", [
+		"-R",
+		rootPath,
+		"log",
+		"--no-graph",
+		"-r",
+		revision,
+		"-T",
+		"commit_id ++ \"\\n\"",
+		"--ignore-working-copy"
+	], { cwd: rootPath });
+	return output ? oneResolvedCommit(output, revision) : null;
+}
+function oneResolvedCommit(output, revision) {
+	const commits = output.split("\n").filter(Boolean);
+	if (commits.length !== 1 || !/^[0-9a-f]{40}$/.test(commits[0])) throw new Error(`Revision ${revision} does not resolve to one Git commit.`);
+	return commits[0];
+}
+async function resolveGitMergeBase(rootPath, baseRef, headRef) {
+	return commandOutput("git", [
+		"-C",
+		rootPath,
+		"merge-base",
+		baseRef,
+		headRef
+	]);
+}
+async function resolveJjMergeBase(rootPath, baseRef, headRef) {
+	return splitLines(await commandOutput("jj", [
+		"-R",
+		rootPath,
+		"log",
+		"--no-graph",
+		"-r",
+		`heads(::${baseRef} & ::${headRef})`,
+		"-T",
+		"commit_id ++ \"\n\"",
+		"--ignore-working-copy"
+	], { cwd: rootPath }))[0] ?? null;
+}
+function readGitFileAtRevisionSync(input) {
+	const commit = resolveGitRevisionCommitSync(input.rootPath, input.ref);
+	if (!commit) return null;
+	const source = commandOutputSync("git", [
+		"-C",
+		input.rootPath,
+		"show",
+		`${commit}:${input.relativePath}`
+	], {
+		maxBuffer: 10485760,
+		trim: false
+	});
+	return source === null ? null : {
+		commit,
+		source
+	};
+}
+function readJjFileAtRevisionSync(input) {
+	const commit = resolveJjRevisionCommitSync(input.rootPath, input.ref);
+	if (!commit) return null;
+	const source = commandOutputSync("jj", [
+		"-R",
+		input.rootPath,
+		"file",
+		"show",
+		"-r",
+		input.ref,
+		"--ignore-working-copy",
+		"--",
+		toJjRootFilePattern(input.relativePath)
+	], {
+		cwd: input.rootPath,
+		maxBuffer: 10485760,
+		trim: false
+	});
+	return source === null ? null : {
+		commit,
+		source
+	};
+}
+async function readGitDiff(input) {
+	const paths = input.literalPaths ? input.paths ?? [] : normalizeDiffPaths(input.paths);
+	const diffRefs = input.headRef ? input.mergeBase === false ? [input.baseRef, input.headRef] : [`${input.baseRef}...${input.headRef}`] : [input.baseRef];
+	const { stdout } = await execFileAsync("git", [
+		...input.literalPaths ? ["--literal-pathspecs"] : [],
+		"-C",
+		input.rootPath,
+		"diff",
+		"--no-ext-diff",
+		"--no-textconv",
+		"--no-color",
+		"-M",
+		...input.contextLines !== void 0 ? [`--unified=${input.contextLines}`] : [],
+		...input.nameOnly ? ["--name-only"] : [],
+		...diffRefs,
+		"--",
+		...paths
+	], {
+		env: input.env,
+		cwd: input.rootPath,
+		maxBuffer: 26214400
+	});
+	return stdout;
+}
+async function readGitDiffFileSummaries(input) {
+	const paths = normalizeDiffPaths(input.paths);
+	const diffRefs = input.headRef ? input.mergeBase === false ? [input.baseRef, input.headRef] : [`${input.baseRef}...${input.headRef}`] : [input.baseRef];
+	const { stdout } = await execFileAsync("git", [
+		"-C",
+		input.rootPath,
+		"diff",
+		"--no-ext-diff",
+		"--no-textconv",
+		"--no-color",
+		"-M",
+		"-z",
+		"--raw",
+		"--numstat",
+		...diffRefs,
+		"--",
+		...paths
+	], {
+		env: input.env,
+		cwd: input.rootPath,
+		maxBuffer: 26214400
+	});
+	return parseGitRawNumStatSummaries(stdout);
+}
+async function readJjDiff(input) {
+	const paths = input.literalPaths ? input.paths ?? [] : normalizeDiffPaths(input.paths);
+	const { stdout } = await execFileAsync("jj", [
+		"-R",
+		input.rootPath,
+		"--color",
+		"never",
+		"--no-pager",
+		"diff",
+		...input.nameOnly ? ["--name-only"] : ["--git"],
+		...input.contextLines !== void 0 ? [`--context=${input.contextLines}`] : [],
+		"--from",
+		input.baseRef,
+		...input.headRef ? ["--to", input.headRef] : [],
+		"--ignore-working-copy",
+		...input.literalPaths ? paths.map(toJjRootFilePattern) : paths
+	], {
+		cwd: input.rootPath,
+		maxBuffer: 26214400
+	});
+	return stdout;
+}
+/** Parse `git diff -z --raw --numstat`: raw records (status + paths) first, then counts keyed by current path. */
+function parseGitRawNumStatSummaries(output) {
+	const fields = output.split("\0");
+	const files = [];
+	const counts = /* @__PURE__ */ new Map();
+	let index = 0;
+	while (index < fields.length) {
+		const record = fields[index];
+		if (record === void 0 || !record.startsWith(":")) break;
+		index += 1;
+		const kind = record.slice(record.lastIndexOf(" ") + 1)[0];
+		if (kind === "R" || kind === "C") {
+			const source = fields[index++];
+			const path = fields[index++];
+			if (!source || !path) continue;
+			files.push(kind === "R" ? {
+				path,
+				previousPath: source,
+				status: "renamed"
+			} : {
+				path,
+				status: "added"
+			});
+			continue;
+		}
+		const path = fields[index++];
+		if (!path) continue;
+		files.push({
+			path,
+			status: kind === "A" ? "added" : kind === "D" ? "deleted" : "modified"
+		});
+	}
+	while (index < fields.length) {
+		const record = fields[index++];
+		if (!record) continue;
+		const additionsEnd = record.indexOf("	");
+		const deletionsEnd = record.indexOf("	", additionsEnd + 1);
+		if (additionsEnd < 0 || deletionsEnd < 0) continue;
+		const rawAdditions = record.slice(0, additionsEnd);
+		const rawDeletions = record.slice(additionsEnd + 1, deletionsEnd);
+		let path = record.slice(deletionsEnd + 1);
+		if (!path) {
+			index += 1;
+			path = fields[index++] ?? "";
+		}
+		if (!path) continue;
+		counts.set(path, rawAdditions === "-" && rawDeletions === "-" ? {
+			additions: 0,
+			deletions: 0,
+			binary: true
+		} : {
+			additions: parseGitNumStatCount(rawAdditions),
+			deletions: parseGitNumStatCount(rawDeletions)
+		});
+	}
+	if (files.length === 0 && counts.size > 0) throw new Error("git diff returned its counts before its raw records.");
+	return files.map((file) => ({
+		...file,
+		...counts.get(file.path) ?? {
+			additions: 0,
+			deletions: 0
+		}
+	}));
+}
+function parseGitNumStatCount(value) {
+	const count = Number(value);
+	return Number.isSafeInteger(count) && count >= 0 ? count : 0;
+}
+/** One entry per file section of a Git-format patch, in patch order. */
+function splitGitPatchFiles(patch) {
+	return splitGitDiffSections(patch).flatMap((section) => {
+		const file = parseGitDiffSectionSummary(section);
+		return file ? [{
+			file,
+			patch: section
+		}] : [];
+	});
+}
+function parseGitPatchFileSummaries(output) {
+	return splitGitPatchFiles(output).map((entry) => entry.file);
+}
+function filterDiffFileSummaries(summaries, paths) {
+	if (paths.length === 0) return summaries;
+	const requested = new Set(paths);
+	return summaries.filter((file) => requested.has(file.path) || file.previousPath !== void 0 && requested.has(file.previousPath));
+}
+function splitGitDiffSections(diff) {
+	const sections = [];
+	let current = null;
+	for (const line of diff.split(/\r?\n/)) if (line.startsWith("diff --git ")) {
+		if (current) sections.push(current.join("\n"));
+		current = [line];
+	} else current?.push(line);
+	if (current) sections.push(current.join("\n"));
+	return sections.filter((section) => section.trim().length > 0);
+}
+function parseGitDiffSectionSummary(section) {
+	const lines = section.split(/\r?\n/);
+	const headerPaths = parseDiffGitHeaderPaths(lines[0] ?? "");
+	let oldPath = headerPaths?.oldPath ?? null;
+	let newPath = headerPaths?.newPath ?? null;
+	let renameFrom;
+	let renameTo;
+	let additions = 0;
+	let deletions = 0;
+	let binary = false;
+	let inHunk = false;
+	for (const line of lines) {
+		if (line.startsWith("@@")) {
+			inHunk = true;
+			continue;
+		}
+		if (inHunk) {
+			if (line.startsWith("+")) additions += 1;
+			else if (line.startsWith("-")) deletions += 1;
+			continue;
+		}
+		if (line.startsWith("Binary files ") || line === "GIT binary patch") binary = true;
+		const parsedOldPath = parseGitFileLine(line, "--- ");
+		const parsedNewPath = parseGitFileLine(line, "+++ ");
+		if (parsedOldPath !== void 0) oldPath = parsedOldPath;
+		if (parsedNewPath !== void 0) newPath = parsedNewPath;
+		if (line.startsWith("rename from ")) renameFrom = unquoteGitPath(line.slice(12).trim());
+		if (line.startsWith("rename to ")) renameTo = unquoteGitPath(line.slice(10).trim());
+	}
+	const status = section.includes("\nnew file mode ") ? "added" : section.includes("\ndeleted file mode ") ? "deleted" : section.includes("\nrename from ") && section.includes("\nrename to ") ? "renamed" : "modified";
+	const filePath = status === "deleted" ? oldPath : renameTo ? renameTo : newPath ?? oldPath;
+	if (!filePath) return null;
+	const summary = {
+		path: filePath,
+		previousPath: status === "renamed" ? renameFrom ?? oldPath ?? void 0 : void 0,
+		status,
+		additions,
+		deletions
+	};
+	if (binary) summary.binary = true;
+	return summary;
+}
+function parseDiffGitHeaderPaths(line) {
+	if (!line.startsWith("diff --git ")) return null;
+	const tokens = line.slice(11).match(/"([^"\\]|\\.)*"|\S+/g);
+	if (!tokens || tokens.length < 2) return null;
+	return {
+		oldPath: stripDiffPathPrefix(unquoteGitPath(tokens[0])),
+		newPath: stripDiffPathPrefix(unquoteGitPath(tokens[1]))
+	};
+}
+function parseGitFileLine(line, prefix) {
+	if (!line.startsWith(prefix)) return void 0;
+	const raw = unquoteGitPath(line.slice(prefix.length).trim());
+	if (raw === "/dev/null") return null;
+	return stripDiffPathPrefix(raw);
+}
+function stripDiffPathPrefix(value) {
+	if (value.startsWith("a/") || value.startsWith("b/")) return value.slice(2);
+	return value;
+}
+function unquoteGitPath(value) {
+	if (!value.startsWith(`"`)) return value;
+	try {
+		return JSON.parse(value);
+	} catch {
+		return value.slice(1, value.endsWith(`"`) ? -1 : void 0);
+	}
+}
+function normalizeDiffPaths(paths) {
+	return [...new Set((paths ?? []).map((path) => path.trim()).filter((path) => path.length > 0 && !path.startsWith("-")))].sort();
+}
+function splitLines(output) {
+	return output.split(/\r?\n/).filter((line) => line.length > 0);
+}
+function uniqueStrings(values) {
+	return [...new Set(values.filter((value) => Boolean(value)))];
+}
+async function canUseGitFallback(rootPath, preferred) {
+	if (preferred !== "jj") return true;
+	const gitRoot = await commandOutput("git", [
+		"-C",
+		rootPath,
+		"rev-parse",
+		"--show-toplevel"
+	], { cwd: rootPath }).catch(() => null);
+	return gitRoot !== null && canonicalPath(gitRoot) === canonicalPath(rootPath);
+}
+function canUseGitFallbackSync(rootPath, preferred) {
+	if (preferred !== "jj") return true;
+	const gitRoot = commandOutputSync("git", [
+		"-C",
+		rootPath,
+		"rev-parse",
+		"--show-toplevel"
+	], { cwd: rootPath });
+	return gitRoot !== null && canonicalPath(gitRoot) === canonicalPath(rootPath);
+}
+function isInsideDirectory(filePath, directoryPath) {
+	const relative = path.relative(canonicalPath(directoryPath), canonicalPath(filePath));
+	return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function canonicalPath(filePath) {
+	try {
+		return fs.realpathSync.native(filePath);
+	} catch {
+		return path.resolve(filePath);
+	}
+}
+async function commandOutput(command, args, options = {}) {
+	return runCommandOutput(command, args, options);
+}
+function commandOutputSync(command, args, options = {}) {
+	return runCommandOutputSync(command, args, options);
+}
+function runCommandOutput(command, args, options) {
+	return execFileAsync(command, args, {
+		cwd: options.cwd,
+		env: commandEnvironment(command, args),
+		maxBuffer: options.maxBuffer
+	}).then(({ stdout }) => options.trim === false ? stdout : stdout.trim());
+}
+function runCommandOutputSync(command, args, options) {
+	try {
+		const output = execFileSyncObserved(command, args, {
+			cwd: options.cwd,
+			encoding: "utf8",
+			env: commandEnvironment(command, args),
+			maxBuffer: options.maxBuffer,
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		});
+		return options.trim === false ? output : output.trim();
+	} catch {
+		return null;
+	}
+}
+function commandEnvironment(command, args) {
+	if (command !== "git" || args[0] !== "-C" && args[0] !== "--git-dir") return;
+	return localGitEnvironment();
+}
+/** Drop per-repository git env vars that would redirect an explicit object store. */
+function localGitEnvironment() {
+	const env = { ...process.env };
+	for (const key of LOCAL_GIT_ENV_KEYS) delete env[key];
+	return env;
+}
+//#endregion
+//#region ../../node_modules/graceful-fs/polyfills.js
+var require_polyfills = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var constants$1 = __require("constants");
+	var origCwd = process.cwd;
+	var cwd = null;
+	var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform;
+	process.cwd = function() {
+		if (!cwd) cwd = origCwd.call(process);
+		return cwd;
+	};
+	try {
+		process.cwd();
+	} catch (er) {}
+	if (typeof process.chdir === "function") {
+		var chdir = process.chdir;
+		process.chdir = function(d) {
+			cwd = null;
+			chdir.call(process, d);
+		};
+		if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir);
+	}
+	module.exports = patch;
+	function patch(fs) {
+		if (constants$1.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) patchLchmod(fs);
+		if (!fs.lutimes) patchLutimes(fs);
+		fs.chown = chownFix(fs.chown);
+		fs.fchown = chownFix(fs.fchown);
+		fs.lchown = chownFix(fs.lchown);
+		fs.chmod = chmodFix(fs.chmod);
+		fs.fchmod = chmodFix(fs.fchmod);
+		fs.lchmod = chmodFix(fs.lchmod);
+		fs.chownSync = chownFixSync(fs.chownSync);
+		fs.fchownSync = chownFixSync(fs.fchownSync);
+		fs.lchownSync = chownFixSync(fs.lchownSync);
+		fs.chmodSync = chmodFixSync(fs.chmodSync);
+		fs.fchmodSync = chmodFixSync(fs.fchmodSync);
+		fs.lchmodSync = chmodFixSync(fs.lchmodSync);
+		fs.stat = statFix(fs.stat);
+		fs.fstat = statFix(fs.fstat);
+		fs.lstat = statFix(fs.lstat);
+		fs.statSync = statFixSync(fs.statSync);
+		fs.fstatSync = statFixSync(fs.fstatSync);
+		fs.lstatSync = statFixSync(fs.lstatSync);
+		if (fs.chmod && !fs.lchmod) {
+			fs.lchmod = function(path, mode, cb) {
+				if (cb) process.nextTick(cb);
+			};
+			fs.lchmodSync = function() {};
+		}
+		if (fs.chown && !fs.lchown) {
+			fs.lchown = function(path, uid, gid, cb) {
+				if (cb) process.nextTick(cb);
+			};
+			fs.lchownSync = function() {};
+		}
+		if (platform === "win32") fs.rename = typeof fs.rename !== "function" ? fs.rename : (function(fs$rename) {
+			function rename(from, to, cb) {
+				var start = Date.now();
+				var backoff = 0;
+				fs$rename(from, to, function CB(er) {
+					if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
+						setTimeout(function() {
+							fs.stat(to, function(stater, st) {
+								if (stater && stater.code === "ENOENT") fs$rename(from, to, CB);
+								else cb(er);
+							});
+						}, backoff);
+						if (backoff < 100) backoff += 10;
+						return;
+					}
+					if (cb) cb(er);
+				});
+			}
+			if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
+			return rename;
+		})(fs.rename);
+		fs.read = typeof fs.read !== "function" ? fs.read : (function(fs$read) {
+			function read(fd, buffer, offset, length, position, callback_) {
+				var callback;
+				if (callback_ && typeof callback_ === "function") {
+					var eagCounter = 0;
+					callback = function(er, _, __) {
+						if (er && er.code === "EAGAIN" && eagCounter < 10) {
+							eagCounter++;
+							return fs$read.call(fs, fd, buffer, offset, length, position, callback);
+						}
+						callback_.apply(this, arguments);
+					};
+				}
+				return fs$read.call(fs, fd, buffer, offset, length, position, callback);
+			}
+			if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
+			return read;
+		})(fs.read);
+		fs.readSync = typeof fs.readSync !== "function" ? fs.readSync : (function(fs$readSync) {
+			return function(fd, buffer, offset, length, position) {
+				var eagCounter = 0;
+				while (true) try {
+					return fs$readSync.call(fs, fd, buffer, offset, length, position);
+				} catch (er) {
+					if (er.code === "EAGAIN" && eagCounter < 10) {
+						eagCounter++;
+						continue;
+					}
+					throw er;
+				}
+			};
+		})(fs.readSync);
+		function patchLchmod(fs) {
+			fs.lchmod = function(path, mode, callback) {
+				fs.open(path, constants$1.O_WRONLY | constants$1.O_SYMLINK, mode, function(err, fd) {
+					if (err) {
+						if (callback) callback(err);
+						return;
+					}
+					fs.fchmod(fd, mode, function(err) {
+						fs.close(fd, function(err2) {
+							if (callback) callback(err || err2);
+						});
+					});
+				});
+			};
+			fs.lchmodSync = function(path, mode) {
+				var fd = fs.openSync(path, constants$1.O_WRONLY | constants$1.O_SYMLINK, mode);
+				var threw = true;
+				var ret;
+				try {
+					ret = fs.fchmodSync(fd, mode);
+					threw = false;
+				} finally {
+					if (threw) try {
+						fs.closeSync(fd);
+					} catch (er) {}
+					else fs.closeSync(fd);
+				}
+				return ret;
+			};
+		}
+		function patchLutimes(fs) {
+			if (constants$1.hasOwnProperty("O_SYMLINK") && fs.futimes) {
+				fs.lutimes = function(path, at, mt, cb) {
+					fs.open(path, constants$1.O_SYMLINK, function(er, fd) {
+						if (er) {
+							if (cb) cb(er);
+							return;
+						}
+						fs.futimes(fd, at, mt, function(er) {
+							fs.close(fd, function(er2) {
+								if (cb) cb(er || er2);
+							});
+						});
+					});
+				};
+				fs.lutimesSync = function(path, at, mt) {
+					var fd = fs.openSync(path, constants$1.O_SYMLINK);
+					var ret;
+					var threw = true;
+					try {
+						ret = fs.futimesSync(fd, at, mt);
+						threw = false;
+					} finally {
+						if (threw) try {
+							fs.closeSync(fd);
+						} catch (er) {}
+						else fs.closeSync(fd);
+					}
+					return ret;
+				};
+			} else if (fs.futimes) {
+				fs.lutimes = function(_a, _b, _c, cb) {
+					if (cb) process.nextTick(cb);
+				};
+				fs.lutimesSync = function() {};
+			}
+		}
+		function chmodFix(orig) {
+			if (!orig) return orig;
+			return function(target, mode, cb) {
+				return orig.call(fs, target, mode, function(er) {
+					if (chownErOk(er)) er = null;
+					if (cb) cb.apply(this, arguments);
+				});
+			};
+		}
+		function chmodFixSync(orig) {
+			if (!orig) return orig;
+			return function(target, mode) {
+				try {
+					return orig.call(fs, target, mode);
+				} catch (er) {
+					if (!chownErOk(er)) throw er;
+				}
+			};
+		}
+		function chownFix(orig) {
+			if (!orig) return orig;
+			return function(target, uid, gid, cb) {
+				return orig.call(fs, target, uid, gid, function(er) {
+					if (chownErOk(er)) er = null;
+					if (cb) cb.apply(this, arguments);
+				});
+			};
+		}
+		function chownFixSync(orig) {
+			if (!orig) return orig;
+			return function(target, uid, gid) {
+				try {
+					return orig.call(fs, target, uid, gid);
+				} catch (er) {
+					if (!chownErOk(er)) throw er;
+				}
+			};
+		}
+		function statFix(orig) {
+			if (!orig) return orig;
+			return function(target, options, cb) {
+				if (typeof options === "function") {
+					cb = options;
+					options = null;
+				}
+				function callback(er, stats) {
+					if (stats) {
+						if (stats.uid < 0) stats.uid += 4294967296;
+						if (stats.gid < 0) stats.gid += 4294967296;
+					}
+					if (cb) cb.apply(this, arguments);
+				}
+				return options ? orig.call(fs, target, options, callback) : orig.call(fs, target, callback);
+			};
+		}
+		function statFixSync(orig) {
+			if (!orig) return orig;
+			return function(target, options) {
+				var stats = options ? orig.call(fs, target, options) : orig.call(fs, target);
+				if (stats) {
+					if (stats.uid < 0) stats.uid += 4294967296;
+					if (stats.gid < 0) stats.gid += 4294967296;
+				}
+				return stats;
+			};
+		}
+		function chownErOk(er) {
+			if (!er) return true;
+			if (er.code === "ENOSYS") return true;
+			if (!process.getuid || process.getuid() !== 0) {
+				if (er.code === "EINVAL" || er.code === "EPERM") return true;
+			}
+			return false;
+		}
+	}
+}));
+//#endregion
+//#region ../../node_modules/graceful-fs/legacy-streams.js
+var require_legacy_streams = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Stream = __require("stream").Stream;
+	module.exports = legacy;
+	function legacy(fs) {
+		return {
+			ReadStream,
+			WriteStream
+		};
+		function ReadStream(path, options) {
+			if (!(this instanceof ReadStream)) return new ReadStream(path, options);
+			Stream.call(this);
+			var self = this;
+			this.path = path;
+			this.fd = null;
+			this.readable = true;
+			this.paused = false;
+			this.flags = "r";
+			this.mode = 438;
+			this.bufferSize = 65536;
+			options = options || {};
+			var keys = Object.keys(options);
+			for (var index = 0, length = keys.length; index < length; index++) {
+				var key = keys[index];
+				this[key] = options[key];
+			}
+			if (this.encoding) this.setEncoding(this.encoding);
+			if (this.start !== void 0) {
+				if ("number" !== typeof this.start) throw TypeError("start must be a Number");
+				if (this.end === void 0) this.end = Infinity;
+				else if ("number" !== typeof this.end) throw TypeError("end must be a Number");
+				if (this.start > this.end) throw new Error("start must be <= end");
+				this.pos = this.start;
+			}
+			if (this.fd !== null) {
+				process.nextTick(function() {
+					self._read();
+				});
+				return;
+			}
+			fs.open(this.path, this.flags, this.mode, function(err, fd) {
+				if (err) {
+					self.emit("error", err);
+					self.readable = false;
+					return;
+				}
+				self.fd = fd;
+				self.emit("open", fd);
+				self._read();
+			});
+		}
+		function WriteStream(path, options) {
+			if (!(this instanceof WriteStream)) return new WriteStream(path, options);
+			Stream.call(this);
+			this.path = path;
+			this.fd = null;
+			this.writable = true;
+			this.flags = "w";
+			this.encoding = "binary";
+			this.mode = 438;
+			this.bytesWritten = 0;
+			options = options || {};
+			var keys = Object.keys(options);
+			for (var index = 0, length = keys.length; index < length; index++) {
+				var key = keys[index];
+				this[key] = options[key];
+			}
+			if (this.start !== void 0) {
+				if ("number" !== typeof this.start) throw TypeError("start must be a Number");
+				if (this.start < 0) throw new Error("start must be >= zero");
+				this.pos = this.start;
+			}
+			this.busy = false;
+			this._queue = [];
+			if (this.fd === null) {
+				this._open = fs.open;
+				this._queue.push([
+					this._open,
+					this.path,
+					this.flags,
+					this.mode,
+					void 0
+				]);
+				this.flush();
+			}
+		}
+	}
+}));
+//#endregion
+//#region ../../node_modules/graceful-fs/clone.js
+var require_clone = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = clone;
+	var getPrototypeOf = Object.getPrototypeOf || function(obj) {
+		return obj.__proto__;
+	};
+	function clone(obj) {
+		if (obj === null || typeof obj !== "object") return obj;
+		if (obj instanceof Object) var copy = { __proto__: getPrototypeOf(obj) };
+		else var copy = Object.create(null);
+		Object.getOwnPropertyNames(obj).forEach(function(key) {
+			Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key));
+		});
+		return copy;
+	}
+}));
+//#endregion
+//#region ../../node_modules/graceful-fs/graceful-fs.js
+var require_graceful_fs = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var fs$1 = __require("fs");
+	var polyfills = require_polyfills();
+	var legacy = require_legacy_streams();
+	var clone = require_clone();
+	var util = __require("util");
+	/* istanbul ignore next - node 0.x polyfill */
+	var gracefulQueue;
+	var previousSymbol;
+	/* istanbul ignore else - node 0.x polyfill */
+	if (typeof Symbol === "function" && typeof Symbol.for === "function") {
+		gracefulQueue = Symbol.for("graceful-fs.queue");
+		previousSymbol = Symbol.for("graceful-fs.previous");
+	} else {
+		gracefulQueue = "___graceful-fs.queue";
+		previousSymbol = "___graceful-fs.previous";
+	}
+	function noop() {}
+	function publishQueue(context, queue) {
+		Object.defineProperty(context, gracefulQueue, { get: function() {
+			return queue;
+		} });
+	}
+	var debug = noop;
+	if (util.debuglog) debug = util.debuglog("gfs4");
+	else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) debug = function() {
+		var m = util.format.apply(util, arguments);
+		m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
+		console.error(m);
+	};
+	if (!fs$1[gracefulQueue]) {
+		publishQueue(fs$1, global[gracefulQueue] || []);
+		fs$1.close = (function(fs$close) {
+			function close(fd, cb) {
+				return fs$close.call(fs$1, fd, function(err) {
+					if (!err) resetQueue();
+					if (typeof cb === "function") cb.apply(this, arguments);
+				});
+			}
+			Object.defineProperty(close, previousSymbol, { value: fs$close });
+			return close;
+		})(fs$1.close);
+		fs$1.closeSync = (function(fs$closeSync) {
+			function closeSync(fd) {
+				fs$closeSync.apply(fs$1, arguments);
+				resetQueue();
+			}
+			Object.defineProperty(closeSync, previousSymbol, { value: fs$closeSync });
+			return closeSync;
+		})(fs$1.closeSync);
+		if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) process.on("exit", function() {
+			debug(fs$1[gracefulQueue]);
+			__require("assert").equal(fs$1[gracefulQueue].length, 0);
+		});
+	}
+	if (!global[gracefulQueue]) publishQueue(global, fs$1[gracefulQueue]);
+	module.exports = patch(clone(fs$1));
+	if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs$1.__patched) {
+		module.exports = patch(fs$1);
+		fs$1.__patched = true;
+	}
+	function patch(fs) {
+		polyfills(fs);
+		fs.gracefulify = patch;
+		fs.createReadStream = createReadStream;
+		fs.createWriteStream = createWriteStream;
+		var fs$readFile = fs.readFile;
+		fs.readFile = readFile;
+		function readFile(path, options, cb) {
+			if (typeof options === "function") cb = options, options = null;
+			return go$readFile(path, options, cb);
+			function go$readFile(path, options, cb, startTime) {
+				return fs$readFile(path, options, function(err) {
+					if (err && (err.code === "EMFILE" || err.code === "ENFILE")) enqueue([
+						go$readFile,
+						[
+							path,
+							options,
+							cb
+						],
+						err,
+						startTime || Date.now(),
+						Date.now()
+					]);
+					else if (typeof cb === "function") cb.apply(this, arguments);
+				});
+			}
+		}
+		var fs$writeFile = fs.writeFile;
+		fs.writeFile = writeFile;
+		function writeFile(path, data, options, cb) {
+			if (typeof options === "function") cb = options, options = null;
+			return go$writeFile(path, data, options, cb);
+			function go$writeFile(path, data, options, cb, startTime) {
+				return fs$writeFile(path, data, options, function(err) {
+					if (err && (err.code === "EMFILE" || err.code === "ENFILE")) enqueue([
+						go$writeFile,
+						[
+							path,
+							data,
+							options,
+							cb
+						],
+						err,
+						startTime || Date.now(),
+						Date.now()
+					]);
+					else if (typeof cb === "function") cb.apply(this, arguments);
+				});
+			}
+		}
+		var fs$appendFile = fs.appendFile;
+		if (fs$appendFile) fs.appendFile = appendFile;
+		function appendFile(path, data, options, cb) {
+			if (typeof options === "function") cb = options, options = null;
+			return go$appendFile(path, data, options, cb);
+			function go$appendFile(path, data, options, cb, startTime) {
+				return fs$appendFile(path, data, options, function(err) {
+					if (err && (err.code === "EMFILE" || err.code === "ENFILE")) enqueue([
+						go$appendFile,
+						[
+							path,
+							data,
+							options,
+							cb
+						],
+						err,
+						startTime || Date.now(),
+						Date.now()
+					]);
+					else if (typeof cb === "function") cb.apply(this, arguments);
+				});
+			}
+		}
+		var fs$copyFile = fs.copyFile;
+		if (fs$copyFile) fs.copyFile = copyFile;
+		function copyFile(src, dest, flags, cb) {
+			if (typeof flags === "function") {
+				cb = flags;
+				flags = 0;
+			}
+			return go$copyFile(src, dest, flags, cb);
+			function go$copyFile(src, dest, flags, cb, startTime) {
+				return fs$copyFile(src, dest, flags, function(err) {
+					if (err && (err.code === "EMFILE" || err.code === "ENFILE")) enqueue([
+						go$copyFile,
+						[
+							src,
+							dest,
+							flags,
+							cb
+						],
+						err,
+						startTime || Date.now(),
+						Date.now()
+					]);
+					else if (typeof cb === "function") cb.apply(this, arguments);
+				});
+			}
+		}
+		var fs$readdir = fs.readdir;
+		fs.readdir = readdir;
+		var noReaddirOptionVersions = /^v[0-5]\./;
+		function readdir(path, options, cb) {
+			if (typeof options === "function") cb = options, options = null;
+			var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir(path, options, cb, startTime) {
+				return fs$readdir(path, fs$readdirCallback(path, options, cb, startTime));
+			} : function go$readdir(path, options, cb, startTime) {
+				return fs$readdir(path, options, fs$readdirCallback(path, options, cb, startTime));
+			};
+			return go$readdir(path, options, cb);
+			function fs$readdirCallback(path, options, cb, startTime) {
+				return function(err, files) {
+					if (err && (err.code === "EMFILE" || err.code === "ENFILE")) enqueue([
+						go$readdir,
+						[
+							path,
+							options,
+							cb
+						],
+						err,
+						startTime || Date.now(),
+						Date.now()
+					]);
+					else {
+						if (files && files.sort) files.sort();
+						if (typeof cb === "function") cb.call(this, err, files);
+					}
+				};
+			}
+		}
+		if (process.version.substr(0, 4) === "v0.8") {
+			var legStreams = legacy(fs);
+			ReadStream = legStreams.ReadStream;
+			WriteStream = legStreams.WriteStream;
+		}
+		var fs$ReadStream = fs.ReadStream;
+		if (fs$ReadStream) {
+			ReadStream.prototype = Object.create(fs$ReadStream.prototype);
+			ReadStream.prototype.open = ReadStream$open;
+		}
+		var fs$WriteStream = fs.WriteStream;
+		if (fs$WriteStream) {
+			WriteStream.prototype = Object.create(fs$WriteStream.prototype);
+			WriteStream.prototype.open = WriteStream$open;
+		}
+		Object.defineProperty(fs, "ReadStream", {
+			get: function() {
+				return ReadStream;
+			},
+			set: function(val) {
+				ReadStream = val;
+			},
+			enumerable: true,
+			configurable: true
+		});
+		Object.defineProperty(fs, "WriteStream", {
+			get: function() {
+				return WriteStream;
+			},
+			set: function(val) {
+				WriteStream = val;
+			},
+			enumerable: true,
+			configurable: true
+		});
+		var FileReadStream = ReadStream;
+		Object.defineProperty(fs, "FileReadStream", {
+			get: function() {
+				return FileReadStream;
+			},
+			set: function(val) {
+				FileReadStream = val;
+			},
+			enumerable: true,
+			configurable: true
+		});
+		var FileWriteStream = WriteStream;
+		Object.defineProperty(fs, "FileWriteStream", {
+			get: function() {
+				return FileWriteStream;
+			},
+			set: function(val) {
+				FileWriteStream = val;
+			},
+			enumerable: true,
+			configurable: true
+		});
+		function ReadStream(path, options) {
+			if (this instanceof ReadStream) return fs$ReadStream.apply(this, arguments), this;
+			else return ReadStream.apply(Object.create(ReadStream.prototype), arguments);
+		}
+		function ReadStream$open() {
+			var that = this;
+			open(that.path, that.flags, that.mode, function(err, fd) {
+				if (err) {
+					if (that.autoClose) that.destroy();
+					that.emit("error", err);
+				} else {
+					that.fd = fd;
+					that.emit("open", fd);
+					that.read();
+				}
+			});
+		}
+		function WriteStream(path, options) {
+			if (this instanceof WriteStream) return fs$WriteStream.apply(this, arguments), this;
+			else return WriteStream.apply(Object.create(WriteStream.prototype), arguments);
+		}
+		function WriteStream$open() {
+			var that = this;
+			open(that.path, that.flags, that.mode, function(err, fd) {
+				if (err) {
+					that.destroy();
+					that.emit("error", err);
+				} else {
+					that.fd = fd;
+					that.emit("open", fd);
+				}
+			});
+		}
+		function createReadStream(path, options) {
+			return new fs.ReadStream(path, options);
+		}
+		function createWriteStream(path, options) {
+			return new fs.WriteStream(path, options);
+		}
+		var fs$open = fs.open;
+		fs.open = open;
+		function open(path, flags, mode, cb) {
+			if (typeof mode === "function") cb = mode, mode = null;
+			return go$open(path, flags, mode, cb);
+			function go$open(path, flags, mode, cb, startTime) {
+				return fs$open(path, flags, mode, function(err, fd) {
+					if (err && (err.code === "EMFILE" || err.code === "ENFILE")) enqueue([
+						go$open,
+						[
+							path,
+							flags,
+							mode,
+							cb
+						],
+						err,
+						startTime || Date.now(),
+						Date.now()
+					]);
+					else if (typeof cb === "function") cb.apply(this, arguments);
+				});
+			}
+		}
+		return fs;
+	}
+	function enqueue(elem) {
+		debug("ENQUEUE", elem[0].name, elem[1]);
+		fs$1[gracefulQueue].push(elem);
+		retry();
+	}
+	var retryTimer;
+	function resetQueue() {
+		var now = Date.now();
+		for (var i = 0; i < fs$1[gracefulQueue].length; ++i) if (fs$1[gracefulQueue][i].length > 2) {
+			fs$1[gracefulQueue][i][3] = now;
+			fs$1[gracefulQueue][i][4] = now;
+		}
+		retry();
+	}
+	function retry() {
+		clearTimeout(retryTimer);
+		retryTimer = void 0;
+		if (fs$1[gracefulQueue].length === 0) return;
+		var elem = fs$1[gracefulQueue].shift();
+		var fn = elem[0];
+		var args = elem[1];
+		var err = elem[2];
+		var startTime = elem[3];
+		var lastTime = elem[4];
+		if (startTime === void 0) {
+			debug("RETRY", fn.name, args);
+			fn.apply(null, args);
+		} else if (Date.now() - startTime >= 6e4) {
+			debug("TIMEOUT", fn.name, args);
+			var cb = args.pop();
+			if (typeof cb === "function") cb.call(null, err);
+		} else {
+			var sinceAttempt = Date.now() - lastTime;
+			var sinceStart = Math.max(lastTime - startTime, 1);
+			if (sinceAttempt >= Math.min(sinceStart * 1.2, 100)) {
+				debug("RETRY", fn.name, args);
+				fn.apply(null, args.concat([startTime]));
+			} else fs$1[gracefulQueue].push(elem);
+		}
+		if (retryTimer === void 0) retryTimer = setTimeout(retry, 0);
+	}
+}));
+//#endregion
+//#region ../../node_modules/retry/lib/retry_operation.js
+var require_retry_operation = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function RetryOperation(timeouts, options) {
+		if (typeof options === "boolean") options = { forever: options };
+		this._originalTimeouts = JSON.parse(JSON.stringify(timeouts));
+		this._timeouts = timeouts;
+		this._options = options || {};
+		this._maxRetryTime = options && options.maxRetryTime || Infinity;
+		this._fn = null;
+		this._errors = [];
+		this._attempts = 1;
+		this._operationTimeout = null;
+		this._operationTimeoutCb = null;
+		this._timeout = null;
+		this._operationStart = null;
+		if (this._options.forever) this._cachedTimeouts = this._timeouts.slice(0);
+	}
+	module.exports = RetryOperation;
+	RetryOperation.prototype.reset = function() {
+		this._attempts = 1;
+		this._timeouts = this._originalTimeouts;
+	};
+	RetryOperation.prototype.stop = function() {
+		if (this._timeout) clearTimeout(this._timeout);
+		this._timeouts = [];
+		this._cachedTimeouts = null;
+	};
+	RetryOperation.prototype.retry = function(err) {
+		if (this._timeout) clearTimeout(this._timeout);
+		if (!err) return false;
+		var currentTime = (/* @__PURE__ */ new Date()).getTime();
+		if (err && currentTime - this._operationStart >= this._maxRetryTime) {
+			this._errors.unshift(/* @__PURE__ */ new Error("RetryOperation timeout occurred"));
+			return false;
+		}
+		this._errors.push(err);
+		var timeout = this._timeouts.shift();
+		if (timeout === void 0) {
+			if (this._cachedTimeouts) {
+				this._errors.splice(this._errors.length - 1, this._errors.length);
+				this._timeouts = this._cachedTimeouts.slice(0);
+				timeout = this._timeouts.shift();
+			} else return false;
+		}
+		var self = this;
+		var timer = setTimeout(function() {
+			self._attempts++;
+			if (self._operationTimeoutCb) {
+				self._timeout = setTimeout(function() {
+					self._operationTimeoutCb(self._attempts);
+				}, self._operationTimeout);
+				if (self._options.unref) self._timeout.unref();
+			}
+			self._fn(self._attempts);
+		}, timeout);
+		if (this._options.unref) timer.unref();
+		return true;
+	};
+	RetryOperation.prototype.attempt = function(fn, timeoutOps) {
+		this._fn = fn;
+		if (timeoutOps) {
+			if (timeoutOps.timeout) this._operationTimeout = timeoutOps.timeout;
+			if (timeoutOps.cb) this._operationTimeoutCb = timeoutOps.cb;
+		}
+		var self = this;
+		if (this._operationTimeoutCb) this._timeout = setTimeout(function() {
+			self._operationTimeoutCb();
+		}, self._operationTimeout);
+		this._operationStart = (/* @__PURE__ */ new Date()).getTime();
+		this._fn(this._attempts);
+	};
+	RetryOperation.prototype.try = function(fn) {
+		console.log("Using RetryOperation.try() is deprecated");
+		this.attempt(fn);
+	};
+	RetryOperation.prototype.start = function(fn) {
+		console.log("Using RetryOperation.start() is deprecated");
+		this.attempt(fn);
+	};
+	RetryOperation.prototype.start = RetryOperation.prototype.try;
+	RetryOperation.prototype.errors = function() {
+		return this._errors;
+	};
+	RetryOperation.prototype.attempts = function() {
+		return this._attempts;
+	};
+	RetryOperation.prototype.mainError = function() {
+		if (this._errors.length === 0) return null;
+		var counts = {};
+		var mainError = null;
+		var mainErrorCount = 0;
+		for (var i = 0; i < this._errors.length; i++) {
+			var error = this._errors[i];
+			var message = error.message;
+			var count = (counts[message] || 0) + 1;
+			counts[message] = count;
+			if (count >= mainErrorCount) {
+				mainError = error;
+				mainErrorCount = count;
+			}
+		}
+		return mainError;
+	};
+}));
+//#endregion
+//#region ../../node_modules/retry/lib/retry.js
+var require_retry$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var RetryOperation = require_retry_operation();
+	exports.operation = function(options) {
+		return new RetryOperation(exports.timeouts(options), {
+			forever: options && options.forever,
+			unref: options && options.unref,
+			maxRetryTime: options && options.maxRetryTime
+		});
+	};
+	exports.timeouts = function(options) {
+		if (options instanceof Array) return [].concat(options);
+		var opts = {
+			retries: 10,
+			factor: 2,
+			minTimeout: 1e3,
+			maxTimeout: Infinity,
+			randomize: false
+		};
+		for (var key in options) opts[key] = options[key];
+		if (opts.minTimeout > opts.maxTimeout) throw new Error("minTimeout is greater than maxTimeout");
+		var timeouts = [];
+		for (var i = 0; i < opts.retries; i++) timeouts.push(this.createTimeout(i, opts));
+		if (options && options.forever && !timeouts.length) timeouts.push(this.createTimeout(i, opts));
+		timeouts.sort(function(a, b) {
+			return a - b;
+		});
+		return timeouts;
+	};
+	exports.createTimeout = function(attempt, opts) {
+		var random = opts.randomize ? Math.random() + 1 : 1;
+		var timeout = Math.round(random * opts.minTimeout * Math.pow(opts.factor, attempt));
+		timeout = Math.min(timeout, opts.maxTimeout);
+		return timeout;
+	};
+	exports.wrap = function(obj, options, methods) {
+		if (options instanceof Array) {
+			methods = options;
+			options = null;
+		}
+		if (!methods) {
+			methods = [];
+			for (var key in obj) if (typeof obj[key] === "function") methods.push(key);
+		}
+		for (var i = 0; i < methods.length; i++) {
+			var method = methods[i];
+			var original = obj[method];
+			obj[method] = function retryWrapper(original) {
+				var op = exports.operation(options);
+				var args = Array.prototype.slice.call(arguments, 1);
+				var callback = args.pop();
+				args.push(function(err) {
+					if (op.retry(err)) return;
+					if (err) arguments[0] = op.mainError();
+					callback.apply(this, arguments);
+				});
+				op.attempt(function() {
+					original.apply(obj, args);
+				});
+			}.bind(obj, original);
+			obj[method].options = options;
+		}
+	};
+}));
+//#endregion
+//#region ../../node_modules/retry/index.js
+var require_retry = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = require_retry$1();
+}));
+//#endregion
+//#region ../../node_modules/signal-exit/signals.js
+var require_signals = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = [
+		"SIGABRT",
+		"SIGALRM",
+		"SIGHUP",
+		"SIGINT",
+		"SIGTERM"
+	];
+	if (process.platform !== "win32") module.exports.push("SIGVTALRM", "SIGXCPU", "SIGXFSZ", "SIGUSR2", "SIGTRAP", "SIGSYS", "SIGQUIT", "SIGIOT");
+	if (process.platform === "linux") module.exports.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT", "SIGUNUSED");
+}));
+//#endregion
+//#region ../../node_modules/signal-exit/index.js
+var require_signal_exit = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var process = global.process;
+	const processOk = function(process) {
+		return process && typeof process === "object" && typeof process.removeListener === "function" && typeof process.emit === "function" && typeof process.reallyExit === "function" && typeof process.listeners === "function" && typeof process.kill === "function" && typeof process.pid === "number" && typeof process.on === "function";
+	};
+	/* istanbul ignore if */
+	if (!processOk(process)) module.exports = function() {
+		return function() {};
+	};
+	else {
+		var assert = __require("assert");
+		var signals = require_signals();
+		var isWin = /^win/i.test(process.platform);
+		var EE = __require("events");
+		/* istanbul ignore if */
+		if (typeof EE !== "function") EE = EE.EventEmitter;
+		var emitter;
+		if (process.__signal_exit_emitter__) emitter = process.__signal_exit_emitter__;
+		else {
+			emitter = process.__signal_exit_emitter__ = new EE();
+			emitter.count = 0;
+			emitter.emitted = {};
+		}
+		if (!emitter.infinite) {
+			emitter.setMaxListeners(Infinity);
+			emitter.infinite = true;
+		}
+		module.exports = function(cb, opts) {
+			/* istanbul ignore if */
+			if (!processOk(global.process)) return function() {};
+			assert.equal(typeof cb, "function", "a callback must be provided for exit handler");
+			if (loaded === false) load();
+			var ev = "exit";
+			if (opts && opts.alwaysLast) ev = "afterexit";
+			var remove = function() {
+				emitter.removeListener(ev, cb);
+				if (emitter.listeners("exit").length === 0 && emitter.listeners("afterexit").length === 0) unload();
+			};
+			emitter.on(ev, cb);
+			return remove;
+		};
+		var unload = function unload() {
+			if (!loaded || !processOk(global.process)) return;
+			loaded = false;
+			signals.forEach(function(sig) {
+				try {
+					process.removeListener(sig, sigListeners[sig]);
+				} catch (er) {}
+			});
+			process.emit = originalProcessEmit;
+			process.reallyExit = originalProcessReallyExit;
+			emitter.count -= 1;
+		};
+		module.exports.unload = unload;
+		var emit = function emit(event, code, signal) {
+			/* istanbul ignore if */
+			if (emitter.emitted[event]) return;
+			emitter.emitted[event] = true;
+			emitter.emit(event, code, signal);
+		};
+		var sigListeners = {};
+		signals.forEach(function(sig) {
+			sigListeners[sig] = function listener() {
+				/* istanbul ignore if */
+				if (!processOk(global.process)) return;
+				if (process.listeners(sig).length === emitter.count) {
+					unload();
+					emit("exit", null, sig);
+					/* istanbul ignore next */
+					emit("afterexit", null, sig);
+					/* istanbul ignore next */
+					if (isWin && sig === "SIGHUP") sig = "SIGINT";
+					/* istanbul ignore next */
+					process.kill(process.pid, sig);
+				}
+			};
+		});
+		module.exports.signals = function() {
+			return signals;
+		};
+		var loaded = false;
+		var load = function load() {
+			if (loaded || !processOk(global.process)) return;
+			loaded = true;
+			emitter.count += 1;
+			signals = signals.filter(function(sig) {
+				try {
+					process.on(sig, sigListeners[sig]);
+					return true;
+				} catch (er) {
+					return false;
+				}
+			});
+			process.emit = processEmit;
+			process.reallyExit = processReallyExit;
+		};
+		module.exports.load = load;
+		var originalProcessReallyExit = process.reallyExit;
+		var processReallyExit = function processReallyExit(code) {
+			/* istanbul ignore if */
+			if (!processOk(global.process)) return;
+			process.exitCode = code || /* istanbul ignore next */ 0;
+			emit("exit", process.exitCode, null);
+			/* istanbul ignore next */
+			emit("afterexit", process.exitCode, null);
+			/* istanbul ignore next */
+			originalProcessReallyExit.call(process, process.exitCode);
+		};
+		var originalProcessEmit = process.emit;
+		var processEmit = function processEmit(ev, arg) {
+			if (ev === "exit" && processOk(global.process)) {
+				/* istanbul ignore else */
+				if (arg !== void 0) process.exitCode = arg;
+				var ret = originalProcessEmit.apply(this, arguments);
+				/* istanbul ignore next */
+				emit("exit", process.exitCode, null);
+				/* istanbul ignore next */
+				emit("afterexit", process.exitCode, null);
+				/* istanbul ignore next */
+				return ret;
+			} else return originalProcessEmit.apply(this, arguments);
+		};
+	}
+}));
+//#endregion
+//#region ../../node_modules/proper-lockfile/lib/mtime-precision.js
+var require_mtime_precision = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const cacheSymbol = Symbol();
+	function probe(file, fs, callback) {
+		const cachedPrecision = fs[cacheSymbol];
+		if (cachedPrecision) return fs.stat(file, (err, stat) => {
+			/* istanbul ignore if */
+			if (err) return callback(err);
+			callback(null, stat.mtime, cachedPrecision);
+		});
+		const mtime = /* @__PURE__ */ new Date(Math.ceil(Date.now() / 1e3) * 1e3 + 5);
+		fs.utimes(file, mtime, mtime, (err) => {
+			/* istanbul ignore if */
+			if (err) return callback(err);
+			fs.stat(file, (err, stat) => {
+				/* istanbul ignore if */
+				if (err) return callback(err);
+				const precision = stat.mtime.getTime() % 1e3 === 0 ? "s" : "ms";
+				Object.defineProperty(fs, cacheSymbol, { value: precision });
+				callback(null, stat.mtime, precision);
+			});
+		});
+	}
+	function getMtime(precision) {
+		let now = Date.now();
+		if (precision === "s") now = Math.ceil(now / 1e3) * 1e3;
+		return new Date(now);
+	}
+	module.exports.probe = probe;
+	module.exports.getMtime = getMtime;
+}));
+//#endregion
+//#region ../../node_modules/proper-lockfile/lib/lockfile.js
+var require_lockfile = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const path$1 = __require("path");
+	const fs = require_graceful_fs();
+	const retry = require_retry();
+	const onExit = require_signal_exit();
+	const mtimePrecision = require_mtime_precision();
+	const locks = {};
+	function getLockFile(file, options) {
+		return options.lockfilePath || `${file}.lock`;
+	}
+	function resolveCanonicalPath(file, options, callback) {
+		if (!options.realpath) return callback(null, path$1.resolve(file));
+		options.fs.realpath(file, callback);
+	}
+	function acquireLock(file, options, callback) {
+		const lockfilePath = getLockFile(file, options);
+		options.fs.mkdir(lockfilePath, (err) => {
+			if (!err) return mtimePrecision.probe(lockfilePath, options.fs, (err, mtime, mtimePrecision) => {
+				/* istanbul ignore if */
+				if (err) {
+					options.fs.rmdir(lockfilePath, () => {});
+					return callback(err);
+				}
+				callback(null, mtime, mtimePrecision);
+			});
+			if (err.code !== "EEXIST") return callback(err);
+			if (options.stale <= 0) return callback(Object.assign(/* @__PURE__ */ new Error("Lock file is already being held"), {
+				code: "ELOCKED",
+				file
+			}));
+			options.fs.stat(lockfilePath, (err, stat) => {
+				if (err) {
+					if (err.code === "ENOENT") return acquireLock(file, {
+						...options,
+						stale: 0
+					}, callback);
+					return callback(err);
+				}
+				if (!isLockStale(stat, options)) return callback(Object.assign(/* @__PURE__ */ new Error("Lock file is already being held"), {
+					code: "ELOCKED",
+					file
+				}));
+				removeLock(file, options, (err) => {
+					if (err) return callback(err);
+					acquireLock(file, {
+						...options,
+						stale: 0
+					}, callback);
+				});
+			});
+		});
+	}
+	function isLockStale(stat, options) {
+		return stat.mtime.getTime() < Date.now() - options.stale;
+	}
+	function removeLock(file, options, callback) {
+		options.fs.rmdir(getLockFile(file, options), (err) => {
+			if (err && err.code !== "ENOENT") return callback(err);
+			callback();
+		});
+	}
+	function updateLock(file, options) {
+		const lock = locks[file];
+		/* istanbul ignore if */
+		if (lock.updateTimeout) return;
+		lock.updateDelay = lock.updateDelay || options.update;
+		lock.updateTimeout = setTimeout(() => {
+			lock.updateTimeout = null;
+			options.fs.stat(lock.lockfilePath, (err, stat) => {
+				const isOverThreshold = lock.lastUpdate + options.stale < Date.now();
+				if (err) {
+					if (err.code === "ENOENT" || isOverThreshold) return setLockAsCompromised(file, lock, Object.assign(err, { code: "ECOMPROMISED" }));
+					lock.updateDelay = 1e3;
+					return updateLock(file, options);
+				}
+				if (!(lock.mtime.getTime() === stat.mtime.getTime())) return setLockAsCompromised(file, lock, Object.assign(/* @__PURE__ */ new Error("Unable to update lock within the stale threshold"), { code: "ECOMPROMISED" }));
+				const mtime = mtimePrecision.getMtime(lock.mtimePrecision);
+				options.fs.utimes(lock.lockfilePath, mtime, mtime, (err) => {
+					const isOverThreshold = lock.lastUpdate + options.stale < Date.now();
+					if (lock.released) return;
+					if (err) {
+						if (err.code === "ENOENT" || isOverThreshold) return setLockAsCompromised(file, lock, Object.assign(err, { code: "ECOMPROMISED" }));
+						lock.updateDelay = 1e3;
+						return updateLock(file, options);
+					}
+					lock.mtime = mtime;
+					lock.lastUpdate = Date.now();
+					lock.updateDelay = null;
+					updateLock(file, options);
+				});
+			});
+		}, lock.updateDelay);
+		/* istanbul ignore else */
+		if (lock.updateTimeout.unref) lock.updateTimeout.unref();
+	}
+	function setLockAsCompromised(file, lock, err) {
+		lock.released = true;
+		/* istanbul ignore if */
+		if (lock.updateTimeout) clearTimeout(lock.updateTimeout);
+		if (locks[file] === lock) delete locks[file];
+		lock.options.onCompromised(err);
+	}
+	function lock(file, options, callback) {
+		/* istanbul ignore next */
+		options = {
+			stale: 1e4,
+			update: null,
+			realpath: true,
+			retries: 0,
+			fs,
+			onCompromised: (err) => {
+				throw err;
+			},
+			...options
+		};
+		options.retries = options.retries || 0;
+		options.retries = typeof options.retries === "number" ? { retries: options.retries } : options.retries;
+		options.stale = Math.max(options.stale || 0, 2e3);
+		options.update = options.update == null ? options.stale / 2 : options.update || 0;
+		options.update = Math.max(Math.min(options.update, options.stale / 2), 1e3);
+		resolveCanonicalPath(file, options, (err, file) => {
+			if (err) return callback(err);
+			const operation = retry.operation(options.retries);
+			operation.attempt(() => {
+				acquireLock(file, options, (err, mtime, mtimePrecision) => {
+					if (operation.retry(err)) return;
+					if (err) return callback(operation.mainError());
+					const lock = locks[file] = {
+						lockfilePath: getLockFile(file, options),
+						mtime,
+						mtimePrecision,
+						options,
+						lastUpdate: Date.now()
+					};
+					updateLock(file, options);
+					callback(null, (releasedCallback) => {
+						if (lock.released) return releasedCallback && releasedCallback(Object.assign(/* @__PURE__ */ new Error("Lock is already released"), { code: "ERELEASED" }));
+						unlock(file, {
+							...options,
+							realpath: false
+						}, releasedCallback);
+					});
+				});
+			});
+		});
+	}
+	function unlock(file, options, callback) {
+		options = {
+			fs,
+			realpath: true,
+			...options
+		};
+		resolveCanonicalPath(file, options, (err, file) => {
+			if (err) return callback(err);
+			const lock = locks[file];
+			if (!lock) return callback(Object.assign(/* @__PURE__ */ new Error("Lock is not acquired/owned by you"), { code: "ENOTACQUIRED" }));
+			lock.updateTimeout && clearTimeout(lock.updateTimeout);
+			lock.released = true;
+			delete locks[file];
+			removeLock(file, options, callback);
+		});
+	}
+	function check(file, options, callback) {
+		options = {
+			stale: 1e4,
+			realpath: true,
+			fs,
+			...options
+		};
+		options.stale = Math.max(options.stale || 0, 2e3);
+		resolveCanonicalPath(file, options, (err, file) => {
+			if (err) return callback(err);
+			options.fs.stat(getLockFile(file, options), (err, stat) => {
+				if (err) return err.code === "ENOENT" ? callback(null, false) : callback(err);
+				return callback(null, !isLockStale(stat, options));
+			});
+		});
+	}
+	function getLocks() {
+		return locks;
+	}
+	/* istanbul ignore next */
+	onExit(() => {
+		for (const file in locks) {
+			const options = locks[file].options;
+			try {
+				options.fs.rmdirSync(getLockFile(file, options));
+			} catch (e) {}
+		}
+	});
+	module.exports.lock = lock;
+	module.exports.unlock = unlock;
+	module.exports.check = check;
+	module.exports.getLocks = getLocks;
+}));
+//#endregion
+//#region ../../node_modules/proper-lockfile/lib/adapter.js
+var require_adapter = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs = require_graceful_fs();
+	function createSyncFs(fs) {
+		const methods = [
+			"mkdir",
+			"realpath",
+			"stat",
+			"rmdir",
+			"utimes"
+		];
+		const newFs = { ...fs };
+		methods.forEach((method) => {
+			newFs[method] = (...args) => {
+				const callback = args.pop();
+				let ret;
+				try {
+					ret = fs[`${method}Sync`](...args);
+				} catch (err) {
+					return callback(err);
+				}
+				callback(null, ret);
+			};
+		});
+		return newFs;
+	}
+	function toPromise(method) {
+		return (...args) => new Promise((resolve, reject) => {
+			args.push((err, result) => {
+				if (err) reject(err);
+				else resolve(result);
+			});
+			method(...args);
+		});
+	}
+	function toSync(method) {
+		return (...args) => {
+			let err;
+			let result;
+			args.push((_err, _result) => {
+				err = _err;
+				result = _result;
+			});
+			method(...args);
+			if (err) throw err;
+			return result;
+		};
+	}
+	function toSyncOptions(options) {
+		options = { ...options };
+		options.fs = createSyncFs(options.fs || fs);
+		if (typeof options.retries === "number" && options.retries > 0 || options.retries && typeof options.retries.retries === "number" && options.retries.retries > 0) throw Object.assign(/* @__PURE__ */ new Error("Cannot use retries with the sync api"), { code: "ESYNC" });
+		return options;
+	}
+	module.exports = {
+		toPromise,
+		toSync,
+		toSyncOptions
+	};
+}));
+(/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const lockfile = require_lockfile();
+	const { toPromise, toSync, toSyncOptions } = require_adapter();
+	async function lock(file, options) {
+		const release = await toPromise(lockfile.lock)(file, options);
+		return toPromise(release);
+	}
+	function lockSync(file, options) {
+		const release = toSync(lockfile.lock)(file, toSyncOptions(options));
+		return toSync(release);
+	}
+	function unlock(file, options) {
+		return toPromise(lockfile.unlock)(file, options);
+	}
+	function unlockSync(file, options) {
+		return toSync(lockfile.unlock)(file, toSyncOptions(options));
+	}
+	function check(file, options) {
+		return toPromise(lockfile.check)(file, options);
+	}
+	function checkSync(file, options) {
+		return toSync(lockfile.check)(file, toSyncOptions(options));
+	}
+	module.exports = lock;
+	module.exports.lock = lock;
+	module.exports.unlock = unlock;
+	module.exports.lockSync = lockSync;
+	module.exports.unlockSync = unlockSync;
+	module.exports.check = check;
+	module.exports.checkSync = checkSync;
+})))();
+//#endregion
+export { __commonJSMin as C, setLocalVcsCommandObserver as S, __toESM as T, readFileAtCommit as _, diffFileSummaries as a, resolveRevision as b, diffTrees as c, gitAt as d, gitCommonDir as f, parseGitRemote as g, listTrackedFilesAtCommit as h, diff as i, diffWorkingTree as l, listCommitRange as m, createBlobBatchReader as n, diffFileSummariesTrees as o, jjRevisionIsConflicted as p, detectLocalVcs as r, diffFileSummariesWorkingTree as s, LocalVcsToolsMissingError as t, git as u, resolveRepoContext as v, __require as w, splitGitPatchFiles as x, resolveRepoContextSync as y };