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

package/dist/index.js

@@ -0,0 +1,3563 @@
+import { a as gitHubRepositoryFromOrigin, i as createGitHubPullRequests, o as ProjectSourceComparison, r as PullRequestError, s as ProjectSourceReview, t as createScratchBlocksDiffRenderer } from "./scratch-block-diff-renderer-xS8OYsRl.js";
+import { n as init_objectSpread2, r as __commonJSMin, t as _objectSpread2$1 } from "./objectSpread2-Dkd68nJH.js";
+import { n as GitPanelError, r as createReadOnlyFs, t as openRepository } from "./repository-BQkADJmK.js";
+import * as m from "react";
+import React, { createContext, memo, useCallback, useContext, useEffect, useMemo, useRef, useState } from "react";
+import { render, unmountComponentAtNode } from "react-dom";
+// builtin:esm-external-require-react
+var require_builtin_esm_external_require_react = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	init_objectSpread2();
+	module.exports = Object.prototype.hasOwnProperty.call(m, "module.exports") ? m["module.exports"] : _objectSpread2$1({}, m);
+}));
+// node_modules/react/cjs/react-jsx-runtime.production.min.js
+/** @license React v16.14.0
+* react-jsx-runtime.production.min.js
+*
+* Copyright (c) Facebook, Inc. and its affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+var require_react_jsx_runtime_production_min = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var f = require_builtin_esm_external_require_react();
+	var g = 60103;
+	exports.Fragment = 60107;
+	if ("function" === typeof Symbol && Symbol.for) {
+		var h = Symbol.for;
+		g = h("react.element");
+		exports.Fragment = h("react.fragment");
+	}
+	var m = f.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner;
+	var n = Object.prototype.hasOwnProperty;
+	var p = {
+		key: !0,
+		ref: !0,
+		__self: !0,
+		__source: !0
+	};
+	function q(c, a, k) {
+		var b, d = {}, e = null, l = null;
+		void 0 !== k && (e = "" + k);
+		void 0 !== a.key && (e = "" + a.key);
+		void 0 !== a.ref && (l = a.ref);
+		for (b in a) n.call(a, b) && !p.hasOwnProperty(b) && (d[b] = a[b]);
+		if (c && c.defaultProps) for (b in a = c.defaultProps, a) void 0 === d[b] && (d[b] = a[b]);
+		return {
+			$$typeof: g,
+			type: c,
+			key: e,
+			ref: l,
+			props: d,
+			_owner: m.current
+		};
+	}
+	exports.jsx = q;
+	exports.jsxs = q;
+}));
+// node_modules/react/cjs/react-jsx-runtime.development.js
+/** @license React v16.14.0
+* react-jsx-runtime.development.js
+*
+* Copyright (c) Facebook, Inc. and its affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+var require_react_jsx_runtime_development = /* @__PURE__ */ __commonJSMin(((exports) => {
+	if (process.env.NODE_ENV !== "production") (function() {
+		"use strict";
+		var React = require_builtin_esm_external_require_react();
+		var REACT_ELEMENT_TYPE = 60103;
+		var REACT_PORTAL_TYPE = 60106;
+		exports.Fragment = 60107;
+		var REACT_STRICT_MODE_TYPE = 60108;
+		var REACT_PROFILER_TYPE = 60114;
+		var REACT_PROVIDER_TYPE = 60109;
+		var REACT_CONTEXT_TYPE = 60110;
+		var REACT_FORWARD_REF_TYPE = 60112;
+		var REACT_SUSPENSE_TYPE = 60113;
+		var REACT_SUSPENSE_LIST_TYPE = 60120;
+		var REACT_MEMO_TYPE = 60115;
+		var REACT_LAZY_TYPE = 60116;
+		var REACT_BLOCK_TYPE = 60121;
+		var REACT_SERVER_BLOCK_TYPE = 60122;
+		var REACT_FUNDAMENTAL_TYPE = 60117;
+		var REACT_DEBUG_TRACING_MODE_TYPE = 60129;
+		var REACT_LEGACY_HIDDEN_TYPE = 60131;
+		if (typeof Symbol === "function" && Symbol.for) {
+			var symbolFor = Symbol.for;
+			REACT_ELEMENT_TYPE = symbolFor("react.element");
+			REACT_PORTAL_TYPE = symbolFor("react.portal");
+			exports.Fragment = symbolFor("react.fragment");
+			REACT_STRICT_MODE_TYPE = symbolFor("react.strict_mode");
+			REACT_PROFILER_TYPE = symbolFor("react.profiler");
+			REACT_PROVIDER_TYPE = symbolFor("react.provider");
+			REACT_CONTEXT_TYPE = symbolFor("react.context");
+			REACT_FORWARD_REF_TYPE = symbolFor("react.forward_ref");
+			REACT_SUSPENSE_TYPE = symbolFor("react.suspense");
+			REACT_SUSPENSE_LIST_TYPE = symbolFor("react.suspense_list");
+			REACT_MEMO_TYPE = symbolFor("react.memo");
+			REACT_LAZY_TYPE = symbolFor("react.lazy");
+			REACT_BLOCK_TYPE = symbolFor("react.block");
+			REACT_SERVER_BLOCK_TYPE = symbolFor("react.server.block");
+			REACT_FUNDAMENTAL_TYPE = symbolFor("react.fundamental");
+			symbolFor("react.scope");
+			symbolFor("react.opaque.id");
+			REACT_DEBUG_TRACING_MODE_TYPE = symbolFor("react.debug_trace_mode");
+			symbolFor("react.offscreen");
+			REACT_LEGACY_HIDDEN_TYPE = symbolFor("react.legacy_hidden");
+		}
+		var MAYBE_ITERATOR_SYMBOL = typeof Symbol === "function" && Symbol.iterator;
+		var FAUX_ITERATOR_SYMBOL = "@@iterator";
+		function getIteratorFn(maybeIterable) {
+			if (maybeIterable === null || typeof maybeIterable !== "object") return null;
+			var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+			if (typeof maybeIterator === "function") return maybeIterator;
+			return null;
+		}
+		var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+		function error(format) {
+			for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) args[_key2 - 1] = arguments[_key2];
+			printWarning("error", format, args);
+		}
+		function printWarning(level, format, args) {
+			var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+			var stack = "";
+			if (currentlyValidatingElement) {
+				var name = getComponentName(currentlyValidatingElement.type);
+				var owner = currentlyValidatingElement._owner;
+				stack += describeComponentFrame(name, currentlyValidatingElement._source, owner && getComponentName(owner.type));
+			}
+			stack += ReactDebugCurrentFrame.getStackAddendum();
+			if (stack !== "") {
+				format += "%s";
+				args = args.concat([stack]);
+			}
+			var argsWithFormat = args.map(function(item) {
+				return "" + item;
+			});
+			argsWithFormat.unshift("Warning: " + format);
+			Function.prototype.apply.call(console[level], console, argsWithFormat);
+		}
+		var enableScopeAPI = false;
+		function isValidElementType(type) {
+			if (typeof type === "string" || typeof type === "function") return true;
+			if (type === exports.Fragment || type === REACT_PROFILER_TYPE || type === REACT_DEBUG_TRACING_MODE_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || type === REACT_LEGACY_HIDDEN_TYPE || enableScopeAPI) return true;
+			if (typeof type === "object" && type !== null) {
+				if (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_BLOCK_TYPE || type[0] === REACT_SERVER_BLOCK_TYPE) return true;
+			}
+			return false;
+		}
+		var BEFORE_SLASH_RE = /^(.*)[\\\/]/;
+		function describeComponentFrame(name, source, ownerName) {
+			var sourceInfo = "";
+			if (source) {
+				var path = source.fileName;
+				var fileName = path.replace(BEFORE_SLASH_RE, "");
+				if (/^index\./.test(fileName)) {
+					var match = path.match(BEFORE_SLASH_RE);
+					if (match) {
+						var pathBeforeSlash = match[1];
+						if (pathBeforeSlash) fileName = pathBeforeSlash.replace(BEFORE_SLASH_RE, "") + "/" + fileName;
+					}
+				}
+				sourceInfo = " (at " + fileName + ":" + source.lineNumber + ")";
+			} else if (ownerName) sourceInfo = " (created by " + ownerName + ")";
+			return "\n    in " + (name || "Unknown") + sourceInfo;
+		}
+		var Resolved = 1;
+		function refineResolvedLazyComponent(lazyComponent) {
+			return lazyComponent._status === Resolved ? lazyComponent._result : null;
+		}
+		function getWrappedName(outerType, innerType, wrapperName) {
+			var functionName = innerType.displayName || innerType.name || "";
+			return outerType.displayName || (functionName !== "" ? wrapperName + "(" + functionName + ")" : wrapperName);
+		}
+		function getComponentName(type) {
+			if (type == null) return null;
+			if (typeof type.tag === "number") error("Received an unexpected object in getComponentName(). This is likely a bug in React. Please file an issue.");
+			if (typeof type === "function") return type.displayName || type.name || null;
+			if (typeof type === "string") return type;
+			switch (type) {
+				case exports.Fragment: return "Fragment";
+				case REACT_PORTAL_TYPE: return "Portal";
+				case REACT_PROFILER_TYPE: return "Profiler";
+				case REACT_STRICT_MODE_TYPE: return "StrictMode";
+				case REACT_SUSPENSE_TYPE: return "Suspense";
+				case REACT_SUSPENSE_LIST_TYPE: return "SuspenseList";
+			}
+			if (typeof type === "object") switch (type.$$typeof) {
+				case REACT_CONTEXT_TYPE: return "Context.Consumer";
+				case REACT_PROVIDER_TYPE: return "Context.Provider";
+				case REACT_FORWARD_REF_TYPE: return getWrappedName(type, type.render, "ForwardRef");
+				case REACT_MEMO_TYPE: return getComponentName(type.type);
+				case REACT_BLOCK_TYPE: return getComponentName(type.render);
+				case REACT_LAZY_TYPE:
+					var resolvedThenable = refineResolvedLazyComponent(type);
+					if (resolvedThenable) return getComponentName(resolvedThenable);
+			}
+			return null;
+		}
+		var loggedTypeFailures = {};
+		ReactSharedInternals.ReactDebugCurrentFrame;
+		var currentlyValidatingElement = null;
+		function setCurrentlyValidatingElement(element) {
+			currentlyValidatingElement = element;
+		}
+		function checkPropTypes(typeSpecs, values, location, componentName, element) {
+			var has = Function.call.bind(Object.prototype.hasOwnProperty);
+			for (var typeSpecName in typeSpecs) if (has(typeSpecs, typeSpecName)) {
+				var error$1 = void 0;
+				try {
+					if (typeof typeSpecs[typeSpecName] !== "function") {
+						var err = Error((componentName || "React class") + ": " + location + " type `" + typeSpecName + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof typeSpecs[typeSpecName] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
+						err.name = "Invariant Violation";
+						throw err;
+					}
+					error$1 = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
+				} catch (ex) {
+					error$1 = ex;
+				}
+				if (error$1 && !(error$1 instanceof Error)) {
+					setCurrentlyValidatingElement(element);
+					error("%s: type specification of %s `%s` is invalid; the type checker function must return `null` or an `Error` but returned a %s. You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).", componentName || "React class", location, typeSpecName, typeof error$1);
+					setCurrentlyValidatingElement(null);
+				}
+				if (error$1 instanceof Error && !(error$1.message in loggedTypeFailures)) {
+					loggedTypeFailures[error$1.message] = true;
+					setCurrentlyValidatingElement(element);
+					error("Failed %s type: %s", location, error$1.message);
+					setCurrentlyValidatingElement(null);
+				}
+			}
+		}
+		var ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner;
+		var hasOwnProperty = Object.prototype.hasOwnProperty;
+		var RESERVED_PROPS = {
+			key: true,
+			ref: true,
+			__self: true,
+			__source: true
+		};
+		var specialPropKeyWarningShown;
+		var specialPropRefWarningShown;
+		var didWarnAboutStringRefs = {};
+		function hasValidRef(config) {
+			if (hasOwnProperty.call(config, "ref")) {
+				var getter = Object.getOwnPropertyDescriptor(config, "ref").get;
+				if (getter && getter.isReactWarning) return false;
+			}
+			return config.ref !== void 0;
+		}
+		function hasValidKey(config) {
+			if (hasOwnProperty.call(config, "key")) {
+				var getter = Object.getOwnPropertyDescriptor(config, "key").get;
+				if (getter && getter.isReactWarning) return false;
+			}
+			return config.key !== void 0;
+		}
+		function warnIfStringRefCannotBeAutoConverted(config, self) {
+			if (typeof config.ref === "string" && ReactCurrentOwner.current && self && ReactCurrentOwner.current.stateNode !== self) {
+				var componentName = getComponentName(ReactCurrentOwner.current.type);
+				if (!didWarnAboutStringRefs[componentName]) {
+					error("Component \"%s\" contains the string ref \"%s\". Support for string refs will be removed in a future major release. This case cannot be automatically converted to an arrow function. We ask you to manually fix this case by using useRef() or createRef() instead. Learn more about using refs safely here: https://reactjs.org/link/strict-mode-string-ref", getComponentName(ReactCurrentOwner.current.type), config.ref);
+					didWarnAboutStringRefs[componentName] = true;
+				}
+			}
+		}
+		function defineKeyPropWarningGetter(props, displayName) {
+			var warnAboutAccessingKey = function() {
+				if (!specialPropKeyWarningShown) {
+					specialPropKeyWarningShown = true;
+					error("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", displayName);
+				}
+			};
+			warnAboutAccessingKey.isReactWarning = true;
+			Object.defineProperty(props, "key", {
+				get: warnAboutAccessingKey,
+				configurable: true
+			});
+		}
+		function defineRefPropWarningGetter(props, displayName) {
+			var warnAboutAccessingRef = function() {
+				if (!specialPropRefWarningShown) {
+					specialPropRefWarningShown = true;
+					error("%s: `ref` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", displayName);
+				}
+			};
+			warnAboutAccessingRef.isReactWarning = true;
+			Object.defineProperty(props, "ref", {
+				get: warnAboutAccessingRef,
+				configurable: true
+			});
+		}
+		/**
+		* Factory method to create a new React element. This no longer adheres to
+		* the class pattern, so do not use new to call it. Also, instanceof check
+		* will not work. Instead test $$typeof field against Symbol.for('react.element') to check
+		* if something is a React Element.
+		*
+		* @param {*} type
+		* @param {*} props
+		* @param {*} key
+		* @param {string|object} ref
+		* @param {*} owner
+		* @param {*} self A *temporary* helper to detect places where `this` is
+		* different from the `owner` when React.createElement is called, so that we
+		* can warn. We want to get rid of owner and replace string `ref`s with arrow
+		* functions, and as long as `this` and owner are the same, there will be no
+		* change in behavior.
+		* @param {*} source An annotation object (added by a transpiler or otherwise)
+		* indicating filename, line number, and/or other information.
+		* @internal
+		*/
+		var ReactElement = function(type, key, ref, self, source, owner, props) {
+			var element = {
+				$$typeof: REACT_ELEMENT_TYPE,
+				type,
+				key,
+				ref,
+				props,
+				_owner: owner
+			};
+			element._store = {};
+			Object.defineProperty(element._store, "validated", {
+				configurable: false,
+				enumerable: false,
+				writable: true,
+				value: false
+			});
+			Object.defineProperty(element, "_self", {
+				configurable: false,
+				enumerable: false,
+				writable: false,
+				value: self
+			});
+			Object.defineProperty(element, "_source", {
+				configurable: false,
+				enumerable: false,
+				writable: false,
+				value: source
+			});
+			if (Object.freeze) {
+				Object.freeze(element.props);
+				Object.freeze(element);
+			}
+			return element;
+		};
+		/**
+		* https://github.com/reactjs/rfcs/pull/107
+		* @param {*} type
+		* @param {object} props
+		* @param {string} key
+		*/
+		function jsxDEV(type, config, maybeKey, source, self) {
+			var propName;
+			var props = {};
+			var key = null;
+			var ref = null;
+			if (maybeKey !== void 0) key = "" + maybeKey;
+			if (hasValidKey(config)) key = "" + config.key;
+			if (hasValidRef(config)) {
+				ref = config.ref;
+				warnIfStringRefCannotBeAutoConverted(config, self);
+			}
+			for (propName in config) if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) props[propName] = config[propName];
+			if (type && type.defaultProps) {
+				var defaultProps = type.defaultProps;
+				for (propName in defaultProps) if (props[propName] === void 0) props[propName] = defaultProps[propName];
+			}
+			if (key || ref) {
+				var displayName = typeof type === "function" ? type.displayName || type.name || "Unknown" : type;
+				if (key) defineKeyPropWarningGetter(props, displayName);
+				if (ref) defineRefPropWarningGetter(props, displayName);
+			}
+			return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
+		}
+		var ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner;
+		ReactSharedInternals.ReactDebugCurrentFrame;
+		function setCurrentlyValidatingElement$1(element) {
+			currentlyValidatingElement = element;
+		}
+		var propTypesMisspellWarningShown = false;
+		/**
+		* Verifies the object is a ReactElement.
+		* See https://reactjs.org/docs/react-api.html#isvalidelement
+		* @param {?object} object
+		* @return {boolean} True if `object` is a ReactElement.
+		* @final
+		*/
+		function isValidElement(object) {
+			return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+		}
+		function getDeclarationErrorAddendum() {
+			if (ReactCurrentOwner$1.current) {
+				var name = getComponentName(ReactCurrentOwner$1.current.type);
+				if (name) return "\n\nCheck the render method of `" + name + "`.";
+			}
+			return "";
+		}
+		function getSourceInfoErrorAddendum(source) {
+			if (source !== void 0) {
+				var fileName = source.fileName.replace(/^.*[\\\/]/, "");
+				var lineNumber = source.lineNumber;
+				return "\n\nCheck your code at " + fileName + ":" + lineNumber + ".";
+			}
+			return "";
+		}
+		/**
+		* Warn if there's no key explicitly set on dynamic arrays of children or
+		* object keys are not valid. This allows us to keep track of children between
+		* updates.
+		*/
+		var ownerHasKeyUseWarning = {};
+		function getCurrentComponentErrorInfo(parentType) {
+			var info = getDeclarationErrorAddendum();
+			if (!info) {
+				var parentName = typeof parentType === "string" ? parentType : parentType.displayName || parentType.name;
+				if (parentName) info = "\n\nCheck the top-level render call using <" + parentName + ">.";
+			}
+			return info;
+		}
+		/**
+		* Warn if the element doesn't have an explicit key assigned to it.
+		* This element is in an array. The array could grow and shrink or be
+		* reordered. All children that haven't already been validated are required to
+		* have a "key" property assigned to it. Error statuses are cached so a warning
+		* will only be shown once.
+		*
+		* @internal
+		* @param {ReactElement} element Element that requires a key.
+		* @param {*} parentType element's parent's type.
+		*/
+		function validateExplicitKey(element, parentType) {
+			if (!element._store || element._store.validated || element.key != null) return;
+			element._store.validated = true;
+			var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);
+			if (ownerHasKeyUseWarning[currentComponentErrorInfo]) return;
+			ownerHasKeyUseWarning[currentComponentErrorInfo] = true;
+			var childOwner = "";
+			if (element && element._owner && element._owner !== ReactCurrentOwner$1.current) childOwner = " It was passed a child from " + getComponentName(element._owner.type) + ".";
+			setCurrentlyValidatingElement$1(element);
+			error("Each child in a list should have a unique \"key\" prop.%s%s See https://reactjs.org/link/warning-keys for more information.", currentComponentErrorInfo, childOwner);
+			setCurrentlyValidatingElement$1(null);
+		}
+		/**
+		* Ensure that every element either is passed in a static location, in an
+		* array with an explicit keys property defined, or in an object literal
+		* with valid key property.
+		*
+		* @internal
+		* @param {ReactNode} node Statically passed child of any type.
+		* @param {*} parentType node's parent's type.
+		*/
+		function validateChildKeys(node, parentType) {
+			if (typeof node !== "object") return;
+			if (Array.isArray(node)) for (var i = 0; i < node.length; i++) {
+				var child = node[i];
+				if (isValidElement(child)) validateExplicitKey(child, parentType);
+			}
+			else if (isValidElement(node)) {
+				if (node._store) node._store.validated = true;
+			} else if (node) {
+				var iteratorFn = getIteratorFn(node);
+				if (typeof iteratorFn === "function") {
+					if (iteratorFn !== node.entries) {
+						var iterator = iteratorFn.call(node);
+						var step;
+						while (!(step = iterator.next()).done) if (isValidElement(step.value)) validateExplicitKey(step.value, parentType);
+					}
+				}
+			}
+		}
+		/**
+		* Given an element, validate that its props follow the propTypes definition,
+		* provided by the type.
+		*
+		* @param {ReactElement} element
+		*/
+		function validatePropTypes(element) {
+			var type = element.type;
+			if (type === null || type === void 0 || typeof type === "string") return;
+			var propTypes;
+			if (typeof type === "function") propTypes = type.propTypes;
+			else if (typeof type === "object" && (type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_MEMO_TYPE)) propTypes = type.propTypes;
+			else return;
+			if (propTypes) {
+				var name = getComponentName(type);
+				checkPropTypes(propTypes, element.props, "prop", name, element);
+			} else if (type.PropTypes !== void 0 && !propTypesMisspellWarningShown) {
+				propTypesMisspellWarningShown = true;
+				error("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", getComponentName(type) || "Unknown");
+			}
+			if (typeof type.getDefaultProps === "function" && !type.getDefaultProps.isReactClassApproved) error("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
+		}
+		/**
+		* Given a fragment, validate that it can only be provided with fragment props
+		* @param {ReactElement} fragment
+		*/
+		function validateFragmentProps(fragment) {
+			var keys = Object.keys(fragment.props);
+			for (var i = 0; i < keys.length; i++) {
+				var key = keys[i];
+				if (key !== "children" && key !== "key") {
+					setCurrentlyValidatingElement$1(fragment);
+					error("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", key);
+					setCurrentlyValidatingElement$1(null);
+					break;
+				}
+			}
+			if (fragment.ref !== null) {
+				setCurrentlyValidatingElement$1(fragment);
+				error("Invalid attribute `ref` supplied to `React.Fragment`.");
+				setCurrentlyValidatingElement$1(null);
+			}
+		}
+		function jsxWithValidation(type, props, key, isStaticChildren, source, self) {
+			var validType = isValidElementType(type);
+			if (!validType) {
+				var info = "";
+				if (type === void 0 || typeof type === "object" && type !== null && Object.keys(type).length === 0) info += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.";
+				var sourceInfo = getSourceInfoErrorAddendum(source);
+				if (sourceInfo) info += sourceInfo;
+				else info += getDeclarationErrorAddendum();
+				var typeString;
+				if (type === null) typeString = "null";
+				else if (Array.isArray(type)) typeString = "array";
+				else if (type !== void 0 && type.$$typeof === REACT_ELEMENT_TYPE) {
+					typeString = "<" + (getComponentName(type.type) || "Unknown") + " />";
+					info = " Did you accidentally export a JSX literal instead of a component?";
+				} else typeString = typeof type;
+				error("React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", typeString, info);
+			}
+			var element = jsxDEV(type, props, key, source, self);
+			if (element == null) return element;
+			if (validType) {
+				var children = props.children;
+				if (children !== void 0) {
+					if (isStaticChildren) {
+						if (Array.isArray(children)) {
+							for (var i = 0; i < children.length; i++) validateChildKeys(children[i], type);
+							if (Object.freeze) Object.freeze(children);
+						} else error("React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead.");
+					} else validateChildKeys(children, type);
+				}
+			}
+			if (type === exports.Fragment) validateFragmentProps(element);
+			else validatePropTypes(element);
+			return element;
+		}
+		function jsxWithValidationStatic(type, props, key) {
+			return jsxWithValidation(type, props, key, true);
+		}
+		function jsxWithValidationDynamic(type, props, key) {
+			return jsxWithValidation(type, props, key, false);
+		}
+		var jsx = jsxWithValidationDynamic;
+		var jsxs = jsxWithValidationStatic;
+		exports.jsx = jsx;
+		exports.jsxs = jsxs;
+	})();
+}));
+// node_modules/react-diff-view/es/index.js
+var import_jsx_runtime = (/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	if (process.env.NODE_ENV === "production") module.exports = require_react_jsx_runtime_production_min();
+	else module.exports = require_react_jsx_runtime_development();
+})))();
+function ownKeys(e, r) {
+	var t = Object.keys(e);
+	if (Object.getOwnPropertySymbols) {
+		var o = Object.getOwnPropertySymbols(e);
+		r && (o = o.filter((function(r) {
+			return Object.getOwnPropertyDescriptor(e, r).enumerable;
+		}))), t.push.apply(t, o);
+	}
+	return t;
+}
+function _objectSpread2(e) {
+	for (var r = 1; r < arguments.length; r++) {
+		var t = null != arguments[r] ? arguments[r] : {};
+		r % 2 ? ownKeys(Object(t), !0).forEach((function(r) {
+			_defineProperty$1(e, r, t[r]);
+		})) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach((function(r) {
+			Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+		}));
+	}
+	return e;
+}
+function _defineProperty$1(obj, key, value) {
+	return (key = function(arg) {
+		var key = function(input, hint) {
+			if ("object" != typeof input || null === input) return input;
+			var prim = input[Symbol.toPrimitive];
+			if (void 0 !== prim) {
+				var res = prim.call(input, hint || "default");
+				if ("object" != typeof res) return res;
+				throw new TypeError("@@toPrimitive must return a primitive value.");
+			}
+			return ("string" === hint ? String : Number)(input);
+		}(arg, "string");
+		return "symbol" == typeof key ? key : String(key);
+	}(key)) in obj ? Object.defineProperty(obj, key, {
+		value,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : obj[key] = value, obj;
+}
+function _objectWithoutProperties(source, excluded) {
+	if (null == source) return {};
+	var key, i, target = function(source, excluded) {
+		if (null == source) return {};
+		var key, i, target = {}, sourceKeys = Object.keys(source);
+		for (i = 0; i < sourceKeys.length; i++) key = sourceKeys[i], excluded.indexOf(key) >= 0 || (target[key] = source[key]);
+		return target;
+	}(source, excluded);
+	if (Object.getOwnPropertySymbols) {
+		var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+		for (i = 0; i < sourceSymbolKeys.length; i++) key = sourceSymbolKeys[i], excluded.indexOf(key) >= 0 || Object.prototype.propertyIsEnumerable.call(source, key) && (target[key] = source[key]);
+	}
+	return target;
+}
+function _slicedToArray(arr, i) {
+	return _arrayWithHoles(arr) || function(r, l) {
+		var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+		if (null != t) {
+			var e, n, i, u, a = [], f = !0, o = !1;
+			try {
+				if (i = (t = t.call(r)).next, 0 === l) {
+					if (Object(t) !== t) return;
+					f = !1;
+				} else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+			} catch (r) {
+				o = !0, n = r;
+			} finally {
+				try {
+					if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
+				} finally {
+					if (o) throw n;
+				}
+			}
+			return a;
+		}
+	}(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+function _toConsumableArray(arr) {
+	return function(arr) {
+		if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+	}(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || function() {
+		throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+	}();
+}
+function _arrayWithHoles(arr) {
+	if (Array.isArray(arr)) return arr;
+}
+function _iterableToArray(iter) {
+	if ("undefined" != typeof Symbol && null != iter[Symbol.iterator] || null != iter["@@iterator"]) return Array.from(iter);
+}
+function _unsupportedIterableToArray(o, minLen) {
+	if (o) {
+		if ("string" == typeof o) return _arrayLikeToArray(o, minLen);
+		var n = Object.prototype.toString.call(o).slice(8, -1);
+		return "Object" === n && o.constructor && (n = o.constructor.name), "Map" === n || "Set" === n ? Array.from(o) : "Arguments" === n || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n) ? _arrayLikeToArray(o, minLen) : void 0;
+	}
+}
+function _arrayLikeToArray(arr, len) {
+	(null == len || len > arr.length) && (len = arr.length);
+	for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+	return arr2;
+}
+function _nonIterableRest() {
+	throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _createForOfIteratorHelper(o, allowArrayLike) {
+	var it = "undefined" != typeof Symbol && o[Symbol.iterator] || o["@@iterator"];
+	if (!it) {
+		if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && "number" == typeof o.length) {
+			it && (o = it);
+			var i = 0, F = function() {};
+			return {
+				s: F,
+				n: function() {
+					return i >= o.length ? { done: !0 } : {
+						done: !1,
+						value: o[i++]
+					};
+				},
+				e: function(e) {
+					throw e;
+				},
+				f: F
+			};
+		}
+		throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+	}
+	var err, normalCompletion = !0, didErr = !1;
+	return {
+		s: function() {
+			it = it.call(o);
+		},
+		n: function() {
+			var step = it.next();
+			return normalCompletion = step.done, step;
+		},
+		e: function(e) {
+			didErr = !0, err = e;
+		},
+		f: function() {
+			try {
+				normalCompletion || null == it.return || it.return();
+			} finally {
+				if (didErr) throw err;
+			}
+		}
+	};
+}
+var commonjsGlobal = "undefined" != typeof globalThis ? globalThis : "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof self ? self : {};
+function createCommonjsModule(fn, module) {
+	return fn(module = { exports: {} }, module.exports), module.exports;
+}
+var classnames = createCommonjsModule((function(module) {
+	/*!
+	Copyright (c) 2018 Jed Watson.
+	Licensed under the MIT License (MIT), see
+	http://jedwatson.github.io/classnames
+	*/
+	(function() {
+		var hasOwn = {}.hasOwnProperty;
+		function classNames() {
+			for (var classes = [], i = 0; i < arguments.length; i++) {
+				var arg = arguments[i];
+				if (arg) {
+					var argType = typeof arg;
+					if ("string" === argType || "number" === argType) classes.push(arg);
+					else if (Array.isArray(arg)) {
+						if (arg.length) {
+							var inner = classNames.apply(null, arg);
+							inner && classes.push(inner);
+						}
+					} else if ("object" === argType) {
+						if (arg.toString !== Object.prototype.toString && !arg.toString.toString().includes("[native code]")) {
+							classes.push(arg.toString());
+							continue;
+						}
+						for (var key in arg) hasOwn.call(arg, key) && arg[key] && classes.push(key);
+					}
+				}
+			}
+			return classes.join(" ");
+		}
+		module.exports ? (classNames.default = classNames, module.exports = classNames) : window.classNames = classNames;
+	})();
+}));
+var DEFAULT_CONTEXT_VALUE = {
+	hunkClassName: "",
+	lineClassName: "",
+	gutterClassName: "",
+	codeClassName: "",
+	monotonous: !1,
+	gutterType: "default",
+	viewType: "split",
+	widgets: {},
+	hideGutter: !1,
+	selectedChanges: [],
+	generateAnchorID: function() {},
+	generateLineClassName: function() {},
+	renderGutter: function(_ref) {
+		var renderDefault = _ref.renderDefault;
+		return (0, _ref.wrapInAnchor)(renderDefault());
+	},
+	codeEvents: {},
+	gutterEvents: {}
+};
+var ContextType = createContext(DEFAULT_CONTEXT_VALUE);
+var Provider = ContextType.Provider;
+var useDiffSettings = function() {
+	return useContext(ContextType);
+};
+var gitdiffParser = createCommonjsModule((function(module, exports) {
+	(function(root) {
+		function parsePathFromFirstLine(line) {
+			var filesStr = line.slice(11), oldPath = null, newPath = null;
+			switch (filesStr.indexOf("\"")) {
+				case -1:
+					oldPath = (segs = filesStr.split(" "))[0].slice(2), newPath = segs[1].slice(2);
+					break;
+				case 0:
+					var nextQuoteIndex = filesStr.indexOf("\"", 2);
+					oldPath = filesStr.slice(3, nextQuoteIndex);
+					var newQuoteIndex = filesStr.indexOf("\"", nextQuoteIndex + 1);
+					newPath = newQuoteIndex < 0 ? filesStr.slice(nextQuoteIndex + 4) : filesStr.slice(newQuoteIndex + 3, -1);
+					break;
+				default:
+					var segs;
+					oldPath = (segs = filesStr.split(" "))[0].slice(2), newPath = segs[1].slice(3, -1);
+			}
+			return {
+				oldPath,
+				newPath
+			};
+		}
+		module.exports = { parse: function(source) {
+			for (var currentInfo, currentHunk, changeOldLine, changeNewLine, paths, infos = [], stat = 2, lines = source.split("\n"), linesLen = lines.length, i = 0; i < linesLen;) {
+				var line = lines[i];
+				if (0 === line.indexOf("diff --git")) {
+					currentInfo = {
+						hunks: [],
+						oldEndingNewLine: !0,
+						newEndingNewLine: !0,
+						oldPath: (paths = parsePathFromFirstLine(line)).oldPath,
+						newPath: paths.newPath
+					}, infos.push(currentInfo);
+					var simiLine, currentInfoType = null;
+					simiLoop: for (; simiLine = lines[++i];) {
+						var spaceIndex = simiLine.indexOf(" "), infoType = spaceIndex > -1 ? simiLine.slice(0, spaceIndex) : infoType;
+						switch (infoType) {
+							case "diff":
+								i--;
+								break simiLoop;
+							case "deleted":
+							case "new":
+								var leftStr = simiLine.slice(spaceIndex + 1);
+								0 === leftStr.indexOf("file mode") && (currentInfo["new" === infoType ? "newMode" : "oldMode"] = leftStr.slice(10));
+								break;
+							case "similarity":
+								currentInfo.similarity = parseInt(simiLine.split(" ")[2], 10);
+								break;
+							case "index":
+								var segs = simiLine.slice(spaceIndex + 1).split(" "), revs = segs[0].split("..");
+								currentInfo.oldRevision = revs[0], currentInfo.newRevision = revs[1], segs[1] && (currentInfo.oldMode = currentInfo.newMode = segs[1]);
+								break;
+							case "copy":
+							case "rename":
+								var infoStr = simiLine.slice(spaceIndex + 1);
+								0 === infoStr.indexOf("from") ? currentInfo.oldPath = infoStr.slice(5) : currentInfo.newPath = infoStr.slice(3), currentInfoType = infoType;
+								break;
+							case "---":
+								var oldPath = simiLine.slice(spaceIndex + 1), newPath = lines[++i].slice(4);
+								"/dev/null" === oldPath ? (newPath = newPath.slice(2), currentInfoType = "add") : "/dev/null" === newPath ? (oldPath = oldPath.slice(2), currentInfoType = "delete") : (currentInfoType = "modify", oldPath = oldPath.slice(2), newPath = newPath.slice(2)), oldPath && (currentInfo.oldPath = oldPath), newPath && (currentInfo.newPath = newPath), stat = 5;
+								break simiLoop;
+						}
+					}
+					currentInfo.type = currentInfoType || "modify";
+				} else if (0 === line.indexOf("Binary")) currentInfo.isBinary = !0, currentInfo.type = line.indexOf("/dev/null and") >= 0 ? "add" : line.indexOf("and /dev/null") >= 0 ? "delete" : "modify", stat = 2, currentInfo = null;
+				else if (5 === stat) if (0 === line.indexOf("@@")) {
+					var match = /^@@\s+-([0-9]+)(,([0-9]+))?\s+\+([0-9]+)(,([0-9]+))?/.exec(line);
+					currentHunk = {
+						content: line,
+						oldStart: match[1] - 0,
+						newStart: match[4] - 0,
+						oldLines: match[3] - 0 || 1,
+						newLines: match[6] - 0 || 1,
+						changes: []
+					}, currentInfo.hunks.push(currentHunk), changeOldLine = currentHunk.oldStart, changeNewLine = currentHunk.newStart;
+				} else {
+					var typeChar = line.slice(0, 1), change = { content: line.slice(1) };
+					switch (typeChar) {
+						case "+":
+							change.type = "insert", change.isInsert = !0, change.lineNumber = changeNewLine, changeNewLine++;
+							break;
+						case "-":
+							change.type = "delete", change.isDelete = !0, change.lineNumber = changeOldLine, changeOldLine++;
+							break;
+						case " ":
+							change.type = "normal", change.isNormal = !0, change.oldLineNumber = changeOldLine, change.newLineNumber = changeNewLine, changeOldLine++, changeNewLine++;
+							break;
+						case "\\":
+							var lastChange = currentHunk.changes[currentHunk.changes.length - 1];
+							lastChange.isDelete || (currentInfo.newEndingNewLine = !1), lastChange.isInsert || (currentInfo.oldEndingNewLine = !1);
+					}
+					change.type && currentHunk.changes.push(change);
+				}
+				i++;
+			}
+			return infos;
+		} };
+	})();
+}));
+function isInsert(change) {
+	return "insert" === change.type;
+}
+function isDelete(change) {
+	return "delete" === change.type;
+}
+function isNormal(change) {
+	return "normal" === change.type;
+}
+function mapHunk(hunk, options) {
+	var changes = "zip" === options.nearbySequences ? function(changes) {
+		return _slicedToArray(changes.reduce((function(_ref, current, i) {
+			var _ref2 = _slicedToArray(_ref, 3), result = _ref2[0], last = _ref2[1], lastDeletionIndex = _ref2[2];
+			return last ? isInsert(current) && lastDeletionIndex >= 0 ? (result.splice(lastDeletionIndex + 1, 0, current), [
+				result,
+				current,
+				lastDeletionIndex + 2
+			]) : (result.push(current), [
+				result,
+				current,
+				isDelete(current) && isDelete(last) ? lastDeletionIndex : i
+			]) : (result.push(current), [
+				result,
+				current,
+				isDelete(current) ? i : -1
+			]);
+		}), [
+			[],
+			null,
+			-1
+		]), 1)[0];
+	}(hunk.changes) : hunk.changes;
+	return _objectSpread2(_objectSpread2({}, hunk), {}, {
+		isPlain: !1,
+		changes
+	});
+}
+function parseDiff(text) {
+	var options = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : {}, diffText = function(text) {
+		if (text.startsWith("diff --git")) return text;
+		var indexOfFirstLineBreak = text.indexOf("\n"), indexOfSecondLineBreak = text.indexOf("\n", indexOfFirstLineBreak + 1), firstLine = text.slice(0, indexOfFirstLineBreak), secondLine = text.slice(indexOfFirstLineBreak + 1, indexOfSecondLineBreak), oldPath = firstLine.split(" ").slice(1, -3).join(" "), newPath = secondLine.split(" ").slice(1, -3).join(" ");
+		return [
+			"diff --git a/".concat(oldPath, " b/").concat(newPath),
+			"index 1111111..2222222 100644",
+			"--- a/".concat(oldPath),
+			"+++ b/".concat(newPath),
+			text.slice(indexOfSecondLineBreak + 1)
+		].join("\n");
+	}(text.trimStart());
+	return gitdiffParser.parse(diffText).map((function(file) {
+		return function(file, options) {
+			var hunks = file.hunks.map((function(hunk) {
+				return mapHunk(hunk, options);
+			}));
+			return _objectSpread2(_objectSpread2({}, file), {}, { hunks });
+		}(file, options);
+	}));
+}
+function first(array) {
+	return array[0];
+}
+function last$1(array) {
+	return array[array.length - 1];
+}
+function sideToProperty(side) {
+	return ["".concat(side, "Start"), "".concat(side, "Lines")];
+}
+function computeLineNumberFactory(side) {
+	return "old" === side ? function(change) {
+		return isInsert(change) ? -1 : isNormal(change) ? change.oldLineNumber : change.lineNumber;
+	} : function(change) {
+		return isDelete(change) ? -1 : isNormal(change) ? change.newLineNumber : change.lineNumber;
+	};
+}
+function isInHunkFactory(startProperty, linesProperty) {
+	return function(hunk, lineNumber) {
+		var start = hunk[startProperty], end = start + hunk[linesProperty];
+		return lineNumber >= start && lineNumber < end;
+	};
+}
+function isBetweenHunksFactory(startProperty, linesProperty) {
+	return function(previousHunk, nextHunk, lineNumber) {
+		var start = previousHunk[startProperty] + previousHunk[linesProperty], end = nextHunk[startProperty];
+		return lineNumber >= start && lineNumber < end;
+	};
+}
+function findChangeByLineNumberFactory(side) {
+	var computeLineNumber = computeLineNumberFactory(side), findContainerHunk = function(side) {
+		var _sideToProperty2 = _slicedToArray(sideToProperty(side), 2), isInHunk = isInHunkFactory(_sideToProperty2[0], _sideToProperty2[1]);
+		return function(hunks, lineNumber) {
+			return hunks.find((function(hunk) {
+				return isInHunk(hunk, lineNumber);
+			}));
+		};
+	}(side);
+	return function(hunks, lineNumber) {
+		var containerHunk = findContainerHunk(hunks, lineNumber);
+		if (containerHunk) return containerHunk.changes.find((function(change) {
+			return computeLineNumber(change) === lineNumber;
+		}));
+	};
+}
+function getCorrespondingLineNumberFactory(baseSide) {
+	var anotherSide = "old" === baseSide ? "new" : "old", _sideToProperty4 = _slicedToArray(sideToProperty(baseSide), 2), baseStart = _sideToProperty4[0], baseLines = _sideToProperty4[1], _sideToProperty6 = _slicedToArray(sideToProperty(anotherSide), 2), correspondingStart = _sideToProperty6[0], correspondingLines = _sideToProperty6[1], baseLineNumber = computeLineNumberFactory(baseSide), correspondingLineNumber = computeLineNumberFactory(anotherSide), isInHunk = isInHunkFactory(baseStart, baseLines), isBetweenHunks = isBetweenHunksFactory(baseStart, baseLines);
+	return function(hunks, lineNumber) {
+		var firstHunk = first(hunks);
+		if (lineNumber < firstHunk[baseStart]) {
+			var spanFromStart = firstHunk[baseStart] - lineNumber;
+			return firstHunk[correspondingStart] - spanFromStart;
+		}
+		var lastHunk = last$1(hunks);
+		if (lastHunk[baseStart] + lastHunk[baseLines] <= lineNumber) {
+			var spanFromEnd = lineNumber - lastHunk[baseStart] - lastHunk[baseLines];
+			return lastHunk[correspondingStart] + lastHunk[correspondingLines] + spanFromEnd;
+		}
+		for (var i = 0; i < hunks.length; i++) {
+			var currentHunk = hunks[i], nextHunk = hunks[i + 1];
+			if (isInHunk(currentHunk, lineNumber)) {
+				var changeIndex = currentHunk.changes.findIndex((function(change) {
+					return baseLineNumber(change) === lineNumber;
+				})), change = currentHunk.changes[changeIndex];
+				if (isNormal(change)) return correspondingLineNumber(change);
+				var possibleCorrespondingChangeIndex = isDelete(change) ? changeIndex + 1 : changeIndex - 1, possibleCorrespondingChange = currentHunk.changes[possibleCorrespondingChangeIndex];
+				if (!possibleCorrespondingChange) return -1;
+				var negativeChangeType = isInsert(change) ? "delete" : "insert";
+				return possibleCorrespondingChange.type === negativeChangeType ? correspondingLineNumber(possibleCorrespondingChange) : -1;
+			}
+			if (isBetweenHunks(currentHunk, nextHunk, lineNumber)) {
+				var _spanFromEnd = lineNumber - currentHunk[baseStart] - currentHunk[baseLines];
+				return currentHunk[correspondingStart] + currentHunk[correspondingLines] + _spanFromEnd;
+			}
+		}
+		throw new Error("Unexpected line position ".concat(lineNumber));
+	};
+}
+var _listCacheClear = function() {
+	this.__data__ = [], this.size = 0;
+};
+var eq_1 = function(value, other) {
+	return value === other || value != value && other != other;
+};
+var _assocIndexOf = function(array, key) {
+	for (var length = array.length; length--;) if (eq_1(array[length][0], key)) return length;
+	return -1;
+};
+var splice = Array.prototype.splice;
+var _listCacheDelete = function(key) {
+	var data = this.__data__, index = _assocIndexOf(data, key);
+	return !(index < 0) && (index == data.length - 1 ? data.pop() : splice.call(data, index, 1), --this.size, !0);
+};
+var _listCacheGet = function(key) {
+	var data = this.__data__, index = _assocIndexOf(data, key);
+	return index < 0 ? void 0 : data[index][1];
+};
+var _listCacheHas = function(key) {
+	return _assocIndexOf(this.__data__, key) > -1;
+};
+var _listCacheSet = function(key, value) {
+	var data = this.__data__, index = _assocIndexOf(data, key);
+	return index < 0 ? (++this.size, data.push([key, value])) : data[index][1] = value, this;
+};
+function ListCache(entries) {
+	var index = -1, length = null == entries ? 0 : entries.length;
+	for (this.clear(); ++index < length;) {
+		var entry = entries[index];
+		this.set(entry[0], entry[1]);
+	}
+}
+ListCache.prototype.clear = _listCacheClear, ListCache.prototype.delete = _listCacheDelete, ListCache.prototype.get = _listCacheGet, ListCache.prototype.has = _listCacheHas, ListCache.prototype.set = _listCacheSet;
+var _ListCache = ListCache;
+var _stackClear = function() {
+	this.__data__ = new _ListCache(), this.size = 0;
+};
+var _stackDelete = function(key) {
+	var data = this.__data__, result = data.delete(key);
+	return this.size = data.size, result;
+};
+var _stackGet = function(key) {
+	return this.__data__.get(key);
+};
+var _stackHas = function(key) {
+	return this.__data__.has(key);
+};
+var _freeGlobal = "object" == typeof commonjsGlobal && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
+var freeSelf = "object" == typeof self && self && self.Object === Object && self;
+var _root = _freeGlobal || freeSelf || Function("return this")();
+var _Symbol = _root.Symbol;
+var objectProto$d = Object.prototype;
+var hasOwnProperty$a = objectProto$d.hasOwnProperty;
+var nativeObjectToString$1 = objectProto$d.toString;
+var symToStringTag$1 = _Symbol ? _Symbol.toStringTag : void 0;
+var _getRawTag = function(value) {
+	var isOwn = hasOwnProperty$a.call(value, symToStringTag$1), tag = value[symToStringTag$1];
+	try {
+		value[symToStringTag$1] = void 0;
+		var unmasked = !0;
+	} catch (e) {}
+	var result = nativeObjectToString$1.call(value);
+	return unmasked && (isOwn ? value[symToStringTag$1] = tag : delete value[symToStringTag$1]), result;
+};
+var nativeObjectToString = Object.prototype.toString;
+var _objectToString = function(value) {
+	return nativeObjectToString.call(value);
+};
+var symToStringTag = _Symbol ? _Symbol.toStringTag : void 0;
+var _baseGetTag = function(value) {
+	return null == value ? void 0 === value ? "[object Undefined]" : "[object Null]" : symToStringTag && symToStringTag in Object(value) ? _getRawTag(value) : _objectToString(value);
+};
+var isObject_1 = function(value) {
+	var type = typeof value;
+	return null != value && ("object" == type || "function" == type);
+};
+var isFunction_1 = function(value) {
+	if (!isObject_1(value)) return !1;
+	var tag = _baseGetTag(value);
+	return "[object Function]" == tag || "[object GeneratorFunction]" == tag || "[object AsyncFunction]" == tag || "[object Proxy]" == tag;
+};
+var _coreJsData = _root["__core-js_shared__"];
+var maskSrcKey = function() {
+	var uid = /[^.]+$/.exec(_coreJsData && _coreJsData.keys && _coreJsData.keys.IE_PROTO || "");
+	return uid ? "Symbol(src)_1." + uid : "";
+}();
+var _isMasked = function(func) {
+	return !!maskSrcKey && maskSrcKey in func;
+};
+var funcToString$1 = Function.prototype.toString;
+var _toSource = function(func) {
+	if (null != func) {
+		try {
+			return funcToString$1.call(func);
+		} catch (e) {}
+		try {
+			return func + "";
+		} catch (e) {}
+	}
+	return "";
+};
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+var funcProto = Function.prototype;
+var objectProto$b = Object.prototype;
+var funcToString = funcProto.toString;
+var hasOwnProperty$9 = objectProto$b.hasOwnProperty;
+var reIsNative = RegExp("^" + funcToString.call(hasOwnProperty$9).replace(/[\\^$.*+?()[\]{}|]/g, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$");
+var _baseIsNative = function(value) {
+	return !(!isObject_1(value) || _isMasked(value)) && (isFunction_1(value) ? reIsNative : reIsHostCtor).test(_toSource(value));
+};
+var _getValue = function(object, key) {
+	return null == object ? void 0 : object[key];
+};
+var _getNative = function(object, key) {
+	var value = _getValue(object, key);
+	return _baseIsNative(value) ? value : void 0;
+};
+var _Map = _getNative(_root, "Map");
+var _nativeCreate = _getNative(Object, "create");
+var _hashClear = function() {
+	this.__data__ = _nativeCreate ? _nativeCreate(null) : {}, this.size = 0;
+};
+var _hashDelete = function(key) {
+	var result = this.has(key) && delete this.__data__[key];
+	return this.size -= result ? 1 : 0, result;
+};
+var hasOwnProperty$8 = Object.prototype.hasOwnProperty;
+var _hashGet = function(key) {
+	var data = this.__data__;
+	if (_nativeCreate) {
+		var result = data[key];
+		return "__lodash_hash_undefined__" === result ? void 0 : result;
+	}
+	return hasOwnProperty$8.call(data, key) ? data[key] : void 0;
+};
+var hasOwnProperty$7 = Object.prototype.hasOwnProperty;
+var _hashHas = function(key) {
+	var data = this.__data__;
+	return _nativeCreate ? void 0 !== data[key] : hasOwnProperty$7.call(data, key);
+};
+var _hashSet = function(key, value) {
+	var data = this.__data__;
+	return this.size += this.has(key) ? 0 : 1, data[key] = _nativeCreate && void 0 === value ? "__lodash_hash_undefined__" : value, this;
+};
+function Hash(entries) {
+	var index = -1, length = null == entries ? 0 : entries.length;
+	for (this.clear(); ++index < length;) {
+		var entry = entries[index];
+		this.set(entry[0], entry[1]);
+	}
+}
+Hash.prototype.clear = _hashClear, Hash.prototype.delete = _hashDelete, Hash.prototype.get = _hashGet, Hash.prototype.has = _hashHas, Hash.prototype.set = _hashSet;
+var _Hash = Hash;
+var _mapCacheClear = function() {
+	this.size = 0, this.__data__ = {
+		hash: new _Hash(),
+		map: new (_Map || _ListCache)(),
+		string: new _Hash()
+	};
+};
+var _isKeyable = function(value) {
+	var type = typeof value;
+	return "string" == type || "number" == type || "symbol" == type || "boolean" == type ? "__proto__" !== value : null === value;
+};
+var _getMapData = function(map, key) {
+	var data = map.__data__;
+	return _isKeyable(key) ? data["string" == typeof key ? "string" : "hash"] : data.map;
+};
+var _mapCacheDelete = function(key) {
+	var result = _getMapData(this, key).delete(key);
+	return this.size -= result ? 1 : 0, result;
+};
+var _mapCacheGet = function(key) {
+	return _getMapData(this, key).get(key);
+};
+var _mapCacheHas = function(key) {
+	return _getMapData(this, key).has(key);
+};
+var _mapCacheSet = function(key, value) {
+	var data = _getMapData(this, key), size = data.size;
+	return data.set(key, value), this.size += data.size == size ? 0 : 1, this;
+};
+function MapCache(entries) {
+	var index = -1, length = null == entries ? 0 : entries.length;
+	for (this.clear(); ++index < length;) {
+		var entry = entries[index];
+		this.set(entry[0], entry[1]);
+	}
+}
+MapCache.prototype.clear = _mapCacheClear, MapCache.prototype.delete = _mapCacheDelete, MapCache.prototype.get = _mapCacheGet, MapCache.prototype.has = _mapCacheHas, MapCache.prototype.set = _mapCacheSet;
+var _MapCache = MapCache;
+var _stackSet = function(key, value) {
+	var data = this.__data__;
+	if (data instanceof _ListCache) {
+		var pairs = data.__data__;
+		if (!_Map || pairs.length < 199) return pairs.push([key, value]), this.size = ++data.size, this;
+		data = this.__data__ = new _MapCache(pairs);
+	}
+	return data.set(key, value), this.size = data.size, this;
+};
+function Stack(entries) {
+	var data = this.__data__ = new _ListCache(entries);
+	this.size = data.size;
+}
+Stack.prototype.clear = _stackClear, Stack.prototype.delete = _stackDelete, Stack.prototype.get = _stackGet, Stack.prototype.has = _stackHas, Stack.prototype.set = _stackSet;
+var _Stack = Stack;
+var _setCacheAdd = function(value) {
+	return this.__data__.set(value, "__lodash_hash_undefined__"), this;
+};
+var _setCacheHas = function(value) {
+	return this.__data__.has(value);
+};
+function SetCache(values) {
+	var index = -1, length = null == values ? 0 : values.length;
+	for (this.__data__ = new _MapCache(); ++index < length;) this.add(values[index]);
+}
+SetCache.prototype.add = SetCache.prototype.push = _setCacheAdd, SetCache.prototype.has = _setCacheHas;
+var _SetCache = SetCache;
+var _arraySome = function(array, predicate) {
+	for (var index = -1, length = null == array ? 0 : array.length; ++index < length;) if (predicate(array[index], index, array)) return !0;
+	return !1;
+};
+var _cacheHas = function(cache, key) {
+	return cache.has(key);
+};
+var _equalArrays = function(array, other, bitmask, customizer, equalFunc, stack) {
+	var isPartial = 1 & bitmask, arrLength = array.length, othLength = other.length;
+	if (arrLength != othLength && !(isPartial && othLength > arrLength)) return !1;
+	var arrStacked = stack.get(array), othStacked = stack.get(other);
+	if (arrStacked && othStacked) return arrStacked == other && othStacked == array;
+	var index = -1, result = !0, seen = 2 & bitmask ? new _SetCache() : void 0;
+	for (stack.set(array, other), stack.set(other, array); ++index < arrLength;) {
+		var arrValue = array[index], othValue = other[index];
+		if (customizer) var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);
+		if (void 0 !== compared) {
+			if (compared) continue;
+			result = !1;
+			break;
+		}
+		if (seen) {
+			if (!_arraySome(other, (function(othValue, othIndex) {
+				if (!_cacheHas(seen, othIndex) && (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) return seen.push(othIndex);
+			}))) {
+				result = !1;
+				break;
+			}
+		} else if (arrValue !== othValue && !equalFunc(arrValue, othValue, bitmask, customizer, stack)) {
+			result = !1;
+			break;
+		}
+	}
+	return stack.delete(array), stack.delete(other), result;
+};
+var _Uint8Array = _root.Uint8Array;
+var _mapToArray = function(map) {
+	var index = -1, result = Array(map.size);
+	return map.forEach((function(value, key) {
+		result[++index] = [key, value];
+	})), result;
+};
+var _setToArray = function(set) {
+	var index = -1, result = Array(set.size);
+	return set.forEach((function(value) {
+		result[++index] = value;
+	})), result;
+};
+var symbolProto$1 = _Symbol ? _Symbol.prototype : void 0;
+var symbolValueOf = symbolProto$1 ? symbolProto$1.valueOf : void 0;
+var _equalByTag = function(object, other, tag, bitmask, customizer, equalFunc, stack) {
+	switch (tag) {
+		case "[object DataView]":
+			if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) return !1;
+			object = object.buffer, other = other.buffer;
+		case "[object ArrayBuffer]": return !(object.byteLength != other.byteLength || !equalFunc(new _Uint8Array(object), new _Uint8Array(other)));
+		case "[object Boolean]":
+		case "[object Date]":
+		case "[object Number]": return eq_1(+object, +other);
+		case "[object Error]": return object.name == other.name && object.message == other.message;
+		case "[object RegExp]":
+		case "[object String]": return object == other + "";
+		case "[object Map]": var convert = _mapToArray;
+		case "[object Set]":
+			var isPartial = 1 & bitmask;
+			if (convert || (convert = _setToArray), object.size != other.size && !isPartial) return !1;
+			var stacked = stack.get(object);
+			if (stacked) return stacked == other;
+			bitmask |= 2, stack.set(object, other);
+			var result = _equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
+			return stack.delete(object), result;
+		case "[object Symbol]": if (symbolValueOf) return symbolValueOf.call(object) == symbolValueOf.call(other);
+	}
+	return !1;
+};
+var _arrayPush = function(array, values) {
+	for (var index = -1, length = values.length, offset = array.length; ++index < length;) array[offset + index] = values[index];
+	return array;
+};
+var isArray_1 = Array.isArray;
+var _baseGetAllKeys = function(object, keysFunc, symbolsFunc) {
+	var result = keysFunc(object);
+	return isArray_1(object) ? result : _arrayPush(result, symbolsFunc(object));
+};
+var _arrayFilter = function(array, predicate) {
+	for (var index = -1, length = null == array ? 0 : array.length, resIndex = 0, result = []; ++index < length;) {
+		var value = array[index];
+		predicate(value, index, array) && (result[resIndex++] = value);
+	}
+	return result;
+};
+var stubArray_1 = function() {
+	return [];
+};
+var propertyIsEnumerable$1 = Object.prototype.propertyIsEnumerable;
+var nativeGetSymbols = Object.getOwnPropertySymbols;
+var _getSymbols = nativeGetSymbols ? function(object) {
+	return null == object ? [] : (object = Object(object), _arrayFilter(nativeGetSymbols(object), (function(symbol) {
+		return propertyIsEnumerable$1.call(object, symbol);
+	})));
+} : stubArray_1;
+var _baseTimes = function(n, iteratee) {
+	for (var index = -1, result = Array(n); ++index < n;) result[index] = iteratee(index);
+	return result;
+};
+var isObjectLike_1 = function(value) {
+	return null != value && "object" == typeof value;
+};
+var _baseIsArguments = function(value) {
+	return isObjectLike_1(value) && "[object Arguments]" == _baseGetTag(value);
+};
+var objectProto$7 = Object.prototype;
+var hasOwnProperty$6 = objectProto$7.hasOwnProperty;
+var propertyIsEnumerable = objectProto$7.propertyIsEnumerable;
+var isArguments_1 = _baseIsArguments(function() {
+	return arguments;
+}()) ? _baseIsArguments : function(value) {
+	return isObjectLike_1(value) && hasOwnProperty$6.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
+};
+var stubFalse_1 = function() {
+	return !1;
+};
+var isBuffer_1 = createCommonjsModule((function(module, exports) {
+	var freeExports = exports && !exports.nodeType && exports, freeModule = freeExports && module && !module.nodeType && module, Buffer = freeModule && freeModule.exports === freeExports ? _root.Buffer : void 0;
+	module.exports = (Buffer ? Buffer.isBuffer : void 0) || stubFalse_1;
+}));
+var reIsUint = /^(?:0|[1-9]\d*)$/;
+var _isIndex = function(value, length) {
+	var type = typeof value;
+	return !!(length = null == length ? 9007199254740991 : length) && ("number" == type || "symbol" != type && reIsUint.test(value)) && value > -1 && value % 1 == 0 && value < length;
+};
+var isLength_1 = function(value) {
+	return "number" == typeof value && value > -1 && value % 1 == 0 && value <= 9007199254740991;
+};
+var typedArrayTags = {};
+typedArrayTags["[object Float32Array]"] = typedArrayTags["[object Float64Array]"] = typedArrayTags["[object Int8Array]"] = typedArrayTags["[object Int16Array]"] = typedArrayTags["[object Int32Array]"] = typedArrayTags["[object Uint8Array]"] = typedArrayTags["[object Uint8ClampedArray]"] = typedArrayTags["[object Uint16Array]"] = typedArrayTags["[object Uint32Array]"] = !0, typedArrayTags["[object Arguments]"] = typedArrayTags["[object Array]"] = typedArrayTags["[object ArrayBuffer]"] = typedArrayTags["[object Boolean]"] = typedArrayTags["[object DataView]"] = typedArrayTags["[object Date]"] = typedArrayTags["[object Error]"] = typedArrayTags["[object Function]"] = typedArrayTags["[object Map]"] = typedArrayTags["[object Number]"] = typedArrayTags["[object Object]"] = typedArrayTags["[object RegExp]"] = typedArrayTags["[object Set]"] = typedArrayTags["[object String]"] = typedArrayTags["[object WeakMap]"] = !1;
+var _baseIsTypedArray = function(value) {
+	return isObjectLike_1(value) && isLength_1(value.length) && !!typedArrayTags[_baseGetTag(value)];
+};
+var _baseUnary = function(func) {
+	return function(value) {
+		return func(value);
+	};
+};
+var _nodeUtil = createCommonjsModule((function(module, exports) {
+	var freeExports = exports && !exports.nodeType && exports, freeModule = freeExports && module && !module.nodeType && module, freeProcess = freeModule && freeModule.exports === freeExports && _freeGlobal.process;
+	module.exports = function() {
+		try {
+			return freeModule && freeModule.require && freeModule.require("util").types || freeProcess && freeProcess.binding && freeProcess.binding("util");
+		} catch (e) {}
+	}();
+}));
+var nodeIsTypedArray = _nodeUtil && _nodeUtil.isTypedArray;
+var isTypedArray_1 = nodeIsTypedArray ? _baseUnary(nodeIsTypedArray) : _baseIsTypedArray;
+var hasOwnProperty$5 = Object.prototype.hasOwnProperty;
+var _arrayLikeKeys = function(value, inherited) {
+	var isArr = isArray_1(value), isArg = !isArr && isArguments_1(value), isBuff = !isArr && !isArg && isBuffer_1(value), isType = !isArr && !isArg && !isBuff && isTypedArray_1(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? _baseTimes(value.length, String) : [], length = result.length;
+	for (var key in value) !inherited && !hasOwnProperty$5.call(value, key) || skipIndexes && ("length" == key || isBuff && ("offset" == key || "parent" == key) || isType && ("buffer" == key || "byteLength" == key || "byteOffset" == key) || _isIndex(key, length)) || result.push(key);
+	return result;
+};
+var objectProto$5 = Object.prototype;
+var _isPrototype = function(value) {
+	var Ctor = value && value.constructor;
+	return value === ("function" == typeof Ctor && Ctor.prototype || objectProto$5);
+};
+var _nativeKeys = function(func, transform) {
+	return function(arg) {
+		return func(transform(arg));
+	};
+}(Object.keys, Object);
+var hasOwnProperty$4 = Object.prototype.hasOwnProperty;
+var _baseKeys = function(object) {
+	if (!_isPrototype(object)) return _nativeKeys(object);
+	var result = [];
+	for (var key in Object(object)) hasOwnProperty$4.call(object, key) && "constructor" != key && result.push(key);
+	return result;
+};
+var isArrayLike_1 = function(value) {
+	return null != value && isLength_1(value.length) && !isFunction_1(value);
+};
+var keys_1 = function(object) {
+	return isArrayLike_1(object) ? _arrayLikeKeys(object) : _baseKeys(object);
+};
+var _getAllKeys = function(object) {
+	return _baseGetAllKeys(object, keys_1, _getSymbols);
+};
+var hasOwnProperty$3 = Object.prototype.hasOwnProperty;
+var _equalObjects = function(object, other, bitmask, customizer, equalFunc, stack) {
+	var isPartial = 1 & bitmask, objProps = _getAllKeys(object), objLength = objProps.length;
+	if (objLength != _getAllKeys(other).length && !isPartial) return !1;
+	for (var index = objLength; index--;) {
+		var key = objProps[index];
+		if (!(isPartial ? key in other : hasOwnProperty$3.call(other, key))) return !1;
+	}
+	var objStacked = stack.get(object), othStacked = stack.get(other);
+	if (objStacked && othStacked) return objStacked == other && othStacked == object;
+	var result = !0;
+	stack.set(object, other), stack.set(other, object);
+	for (var skipCtor = isPartial; ++index < objLength;) {
+		var objValue = object[key = objProps[index]], othValue = other[key];
+		if (customizer) var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
+		if (!(void 0 === compared ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
+			result = !1;
+			break;
+		}
+		skipCtor || (skipCtor = "constructor" == key);
+	}
+	if (result && !skipCtor) {
+		var objCtor = object.constructor, othCtor = other.constructor;
+		objCtor == othCtor || !("constructor" in object) || !("constructor" in other) || "function" == typeof objCtor && objCtor instanceof objCtor && "function" == typeof othCtor && othCtor instanceof othCtor || (result = !1);
+	}
+	return stack.delete(object), stack.delete(other), result;
+};
+var _DataView = _getNative(_root, "DataView");
+var _Promise = _getNative(_root, "Promise");
+var _Set = _getNative(_root, "Set");
+var _WeakMap = _getNative(_root, "WeakMap");
+var dataViewCtorString = _toSource(_DataView);
+var mapCtorString = _toSource(_Map);
+var promiseCtorString = _toSource(_Promise);
+var setCtorString = _toSource(_Set);
+var weakMapCtorString = _toSource(_WeakMap);
+var getTag = _baseGetTag;
+(_DataView && "[object DataView]" != getTag(new _DataView(/* @__PURE__ */ new ArrayBuffer(1))) || _Map && "[object Map]" != getTag(new _Map()) || _Promise && "[object Promise]" != getTag(_Promise.resolve()) || _Set && "[object Set]" != getTag(new _Set()) || _WeakMap && "[object WeakMap]" != getTag(new _WeakMap())) && (getTag = function(value) {
+	var result = _baseGetTag(value), Ctor = "[object Object]" == result ? value.constructor : void 0, ctorString = Ctor ? _toSource(Ctor) : "";
+	if (ctorString) switch (ctorString) {
+		case dataViewCtorString: return "[object DataView]";
+		case mapCtorString: return "[object Map]";
+		case promiseCtorString: return "[object Promise]";
+		case setCtorString: return "[object Set]";
+		case weakMapCtorString: return "[object WeakMap]";
+	}
+	return result;
+});
+var _getTag = getTag;
+var objectTag = "[object Object]";
+var hasOwnProperty$2 = Object.prototype.hasOwnProperty;
+var _baseIsEqualDeep = function(object, other, bitmask, customizer, equalFunc, stack) {
+	var objIsArr = isArray_1(object), othIsArr = isArray_1(other), objTag = objIsArr ? "[object Array]" : _getTag(object), othTag = othIsArr ? "[object Array]" : _getTag(other), objIsObj = (objTag = "[object Arguments]" == objTag ? objectTag : objTag) == objectTag, othIsObj = (othTag = "[object Arguments]" == othTag ? objectTag : othTag) == objectTag, isSameTag = objTag == othTag;
+	if (isSameTag && isBuffer_1(object)) {
+		if (!isBuffer_1(other)) return !1;
+		objIsArr = !0, objIsObj = !1;
+	}
+	if (isSameTag && !objIsObj) return stack || (stack = new _Stack()), objIsArr || isTypedArray_1(object) ? _equalArrays(object, other, bitmask, customizer, equalFunc, stack) : _equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
+	if (!(1 & bitmask)) {
+		var objIsWrapped = objIsObj && hasOwnProperty$2.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty$2.call(other, "__wrapped__");
+		if (objIsWrapped || othIsWrapped) {
+			var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;
+			return stack || (stack = new _Stack()), equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
+		}
+	}
+	return !!isSameTag && (stack || (stack = new _Stack()), _equalObjects(object, other, bitmask, customizer, equalFunc, stack));
+};
+var _baseIsEqual = function baseIsEqual(value, other, bitmask, customizer, stack) {
+	return value === other || (null == value || null == other || !isObjectLike_1(value) && !isObjectLike_1(other) ? value != value && other != other : _baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack));
+};
+var _baseIsMatch = function(object, source, matchData, customizer) {
+	var index = matchData.length, length = index, noCustomizer = !customizer;
+	if (null == object) return !length;
+	for (object = Object(object); index--;) {
+		var data = matchData[index];
+		if (noCustomizer && data[2] ? data[1] !== object[data[0]] : !(data[0] in object)) return !1;
+	}
+	for (; ++index < length;) {
+		var key = (data = matchData[index])[0], objValue = object[key], srcValue = data[1];
+		if (noCustomizer && data[2]) {
+			if (void 0 === objValue && !(key in object)) return !1;
+		} else {
+			var stack = new _Stack();
+			if (customizer) var result = customizer(objValue, srcValue, key, object, source, stack);
+			if (!(void 0 === result ? _baseIsEqual(srcValue, objValue, 3, customizer, stack) : result)) return !1;
+		}
+	}
+	return !0;
+};
+var _isStrictComparable = function(value) {
+	return value == value && !isObject_1(value);
+};
+var _getMatchData = function(object) {
+	for (var result = keys_1(object), length = result.length; length--;) {
+		var key = result[length], value = object[key];
+		result[length] = [
+			key,
+			value,
+			_isStrictComparable(value)
+		];
+	}
+	return result;
+};
+var _matchesStrictComparable = function(key, srcValue) {
+	return function(object) {
+		return null != object && object[key] === srcValue && (void 0 !== srcValue || key in Object(object));
+	};
+};
+var _baseMatches = function(source) {
+	var matchData = _getMatchData(source);
+	return 1 == matchData.length && matchData[0][2] ? _matchesStrictComparable(matchData[0][0], matchData[0][1]) : function(object) {
+		return object === source || _baseIsMatch(object, source, matchData);
+	};
+};
+var isSymbol_1 = function(value) {
+	return "symbol" == typeof value || isObjectLike_1(value) && "[object Symbol]" == _baseGetTag(value);
+};
+var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
+var reIsPlainProp = /^\w*$/;
+var _isKey = function(value, object) {
+	if (isArray_1(value)) return !1;
+	var type = typeof value;
+	return !("number" != type && "symbol" != type && "boolean" != type && null != value && !isSymbol_1(value)) || reIsPlainProp.test(value) || !reIsDeepProp.test(value) || null != object && value in Object(object);
+};
+function memoize(func, resolver) {
+	if ("function" != typeof func || null != resolver && "function" != typeof resolver) throw new TypeError("Expected a function");
+	var memoized = function() {
+		var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
+		if (cache.has(key)) return cache.get(key);
+		var result = func.apply(this, args);
+		return memoized.cache = cache.set(key, result) || cache, result;
+	};
+	return memoized.cache = new (memoize.Cache || _MapCache)(), memoized;
+}
+memoize.Cache = _MapCache;
+var memoize_1 = memoize;
+var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+var reEscapeChar = /\\(\\)?/g;
+var _stringToPath = function(func) {
+	var result = memoize_1(func, (function(key) {
+		return 500 === cache.size && cache.clear(), key;
+	})), cache = result.cache;
+	return result;
+}((function(string) {
+	var result = [];
+	return 46 === string.charCodeAt(0) && result.push(""), string.replace(rePropName, (function(match, number, quote, subString) {
+		result.push(quote ? subString.replace(reEscapeChar, "$1") : number || match);
+	})), result;
+}));
+var _arrayMap = function(array, iteratee) {
+	for (var index = -1, length = null == array ? 0 : array.length, result = Array(length); ++index < length;) result[index] = iteratee(array[index], index, array);
+	return result;
+};
+var symbolProto = _Symbol ? _Symbol.prototype : void 0;
+var symbolToString = symbolProto ? symbolProto.toString : void 0;
+var _baseToString = function baseToString(value) {
+	if ("string" == typeof value) return value;
+	if (isArray_1(value)) return _arrayMap(value, baseToString) + "";
+	if (isSymbol_1(value)) return symbolToString ? symbolToString.call(value) : "";
+	var result = value + "";
+	return "0" == result && 1 / value == -Infinity ? "-0" : result;
+};
+var toString_1 = function(value) {
+	return null == value ? "" : _baseToString(value);
+};
+var _castPath = function(value, object) {
+	return isArray_1(value) ? value : _isKey(value, object) ? [value] : _stringToPath(toString_1(value));
+};
+var _toKey = function(value) {
+	if ("string" == typeof value || isSymbol_1(value)) return value;
+	var result = value + "";
+	return "0" == result && 1 / value == -Infinity ? "-0" : result;
+};
+var _baseGet = function(object, path) {
+	for (var index = 0, length = (path = _castPath(path, object)).length; null != object && index < length;) object = object[_toKey(path[index++])];
+	return index && index == length ? object : void 0;
+};
+var get_1 = function(object, path, defaultValue) {
+	var result = null == object ? void 0 : _baseGet(object, path);
+	return void 0 === result ? defaultValue : result;
+};
+var _baseHasIn = function(object, key) {
+	return null != object && key in Object(object);
+};
+var _hasPath = function(object, path, hasFunc) {
+	for (var index = -1, length = (path = _castPath(path, object)).length, result = !1; ++index < length;) {
+		var key = _toKey(path[index]);
+		if (!(result = null != object && hasFunc(object, key))) break;
+		object = object[key];
+	}
+	return result || ++index != length ? result : !!(length = null == object ? 0 : object.length) && isLength_1(length) && _isIndex(key, length) && (isArray_1(object) || isArguments_1(object));
+};
+var hasIn_1 = function(object, path) {
+	return null != object && _hasPath(object, path, _baseHasIn);
+};
+var _baseMatchesProperty = function(path, srcValue) {
+	return _isKey(path) && _isStrictComparable(srcValue) ? _matchesStrictComparable(_toKey(path), srcValue) : function(object) {
+		var objValue = get_1(object, path);
+		return void 0 === objValue && objValue === srcValue ? hasIn_1(object, path) : _baseIsEqual(srcValue, objValue, 3);
+	};
+};
+var identity_1 = function(value) {
+	return value;
+};
+var _baseProperty = function(key) {
+	return function(object) {
+		return null == object ? void 0 : object[key];
+	};
+};
+var _basePropertyDeep = function(path) {
+	return function(object) {
+		return _baseGet(object, path);
+	};
+};
+var property_1 = function(path) {
+	return _isKey(path) ? _baseProperty(_toKey(path)) : _basePropertyDeep(path);
+};
+var _baseIteratee = function(value) {
+	return "function" == typeof value ? value : null == value ? identity_1 : "object" == typeof value ? isArray_1(value) ? _baseMatchesProperty(value[0], value[1]) : _baseMatches(value) : property_1(value);
+};
+function getChangeKey(change) {
+	if (!change) throw new Error("change is not provided");
+	if (isNormal(change)) return "N".concat(change.oldLineNumber);
+	var prefix = isInsert(change) ? "I" : "D";
+	return "".concat(prefix).concat(change.lineNumber);
+}
+getCorrespondingLineNumberFactory("old");
+var computeOldLineNumber = computeLineNumberFactory("old");
+var computeNewLineNumber = computeLineNumberFactory("new");
+findChangeByLineNumberFactory("old");
+findChangeByLineNumberFactory("new");
+getCorrespondingLineNumberFactory("new");
+getCorrespondingLineNumberFactory("old");
+var _defineProperty = function() {
+	try {
+		var func = _getNative(Object, "defineProperty");
+		return func({}, "", {}), func;
+	} catch (e) {}
+}();
+var _baseAssignValue = function(object, key, value) {
+	"__proto__" == key && _defineProperty ? _defineProperty(object, key, {
+		configurable: !0,
+		enumerable: !0,
+		value,
+		writable: !0
+	}) : object[key] = value;
+};
+var _createBaseFor = function(fromRight) {
+	return function(object, iteratee, keysFunc) {
+		for (var index = -1, iterable = Object(object), props = keysFunc(object), length = props.length; length--;) {
+			var key = props[fromRight ? length : ++index];
+			if (!1 === iteratee(iterable[key], key, iterable)) break;
+		}
+		return object;
+	};
+};
+var _baseFor = _createBaseFor();
+var _baseForOwn = function(object, iteratee) {
+	return object && _baseFor(object, iteratee, keys_1);
+};
+var mapValues_1 = function(object, iteratee) {
+	var result = {};
+	return iteratee = _baseIteratee(iteratee), _baseForOwn(object, (function(value, key, object) {
+		_baseAssignValue(result, key, iteratee(value, key, object));
+	})), result;
+};
+var _excluded$7 = [
+	"changeKey",
+	"text",
+	"tokens",
+	"renderToken"
+];
+var defaultRenderToken = function defaultRenderToken(_ref, i) {
+	var type = _ref.type, value = _ref.value, markType = _ref.markType, properties = _ref.properties, className = _ref.className, children = _ref.children, renderWithClassName = function(className) {
+		return (0, import_jsx_runtime.jsx)("span", {
+			className,
+			children: value || children && children.map(defaultRenderToken)
+		}, i);
+	};
+	switch (type) {
+		case "text": return value;
+		case "mark": return renderWithClassName("diff-code-mark diff-code-mark-".concat(markType));
+		case "edit": return renderWithClassName("diff-code-edit");
+		default:
+			var legacyClassName = properties && properties.className;
+			return renderWithClassName(classnames(className || legacyClassName));
+	}
+};
+function isEmptyToken(tokens) {
+	if (!Array.isArray(tokens)) return !0;
+	if (tokens.length > 1) return !1;
+	if (1 === tokens.length) {
+		var token = _slicedToArray(tokens, 1)[0];
+		return "text" === token.type && !token.value;
+	}
+	return !0;
+}
+function CodeCell(props) {
+	var changeKey = props.changeKey, text = props.text, tokens = props.tokens, renderToken = props.renderToken, attributes = _objectWithoutProperties(props, _excluded$7), actualRenderToken = renderToken ? function(token, i) {
+		return renderToken(token, defaultRenderToken, i);
+	} : defaultRenderToken;
+	return (0, import_jsx_runtime.jsx)("td", _objectSpread2(_objectSpread2({}, attributes), {}, {
+		"data-change-key": changeKey,
+		children: tokens ? isEmptyToken(tokens) ? " " : tokens.map(actualRenderToken) : text || " "
+	}));
+}
+var CodeCell$1 = memo(CodeCell);
+function renderDefaultBy(change, side) {
+	return function() {
+		var lineNumber = "old" === side ? computeOldLineNumber(change) : computeNewLineNumber(change);
+		return -1 === lineNumber ? void 0 : lineNumber;
+	};
+}
+function wrapInAnchorBy(gutterAnchor, anchorTarget) {
+	return function(element) {
+		return gutterAnchor && element ? (0, import_jsx_runtime.jsx)("a", {
+			href: anchorTarget ? "#" + anchorTarget : void 0,
+			children: element
+		}) : element;
+	};
+}
+function composeCallback(own, custom) {
+	return custom ? function(e) {
+		own(), custom(e);
+	} : own;
+}
+function useBoundCallbacks(callbacks, arg, hoverOn, hoverOff) {
+	return useMemo((function() {
+		var output = mapValues_1(callbacks, (function(fn) {
+			return function(e) {
+				return fn && fn(arg, e);
+			};
+		}));
+		return output.onMouseEnter = composeCallback(hoverOn, output.onMouseEnter), output.onMouseLeave = composeCallback(hoverOff, output.onMouseLeave), output;
+	}), [
+		callbacks,
+		hoverOn,
+		hoverOff,
+		arg
+	]);
+}
+function renderGutterCell(className, change, changeKey, side, gutterAnchor, anchorTarget, events, inHoverState, renderGutter) {
+	var gutterOptions = {
+		change,
+		side,
+		inHoverState,
+		renderDefault: renderDefaultBy(change, side),
+		wrapInAnchor: wrapInAnchorBy(gutterAnchor, anchorTarget)
+	};
+	return (0, import_jsx_runtime.jsx)("td", _objectSpread2(_objectSpread2({ className }, events), {}, {
+		"data-change-key": changeKey,
+		children: renderGutter(gutterOptions)
+	}));
+}
+function UnifiedChange(props) {
+	var _useState2, value, setValue, change = props.change, selected = props.selected, tokens = props.tokens, className = props.className, generateLineClassName = props.generateLineClassName, gutterClassName = props.gutterClassName, codeClassName = props.codeClassName, gutterEvents = props.gutterEvents, codeEvents = props.codeEvents, hideGutter = props.hideGutter, gutterAnchor = props.gutterAnchor, generateAnchorID = props.generateAnchorID, renderToken = props.renderToken, renderGutter = props.renderGutter, type = change.type, content = change.content, changeKey = getChangeKey(change), _useBoolean2 = _slicedToArray((_useState2 = _slicedToArray(useState(!1), 2), value = _useState2[0], setValue = _useState2[1], [
+		value,
+		useCallback((function() {
+			return setValue(!0);
+		}), []),
+		useCallback((function() {
+			return setValue(!1);
+		}), [])
+	]), 3), hover = _useBoolean2[0], hoverOn = _useBoolean2[1], hoverOff = _useBoolean2[2], eventArg = useMemo((function() {
+		return { change };
+	}), [change]), boundGutterEvents = useBoundCallbacks(gutterEvents, eventArg, hoverOn, hoverOff), boundCodeEvents = useBoundCallbacks(codeEvents, eventArg, hoverOn, hoverOff), anchorID = generateAnchorID(change), lineClassName = generateLineClassName({
+		changes: [change],
+		defaultGenerate: function() {
+			return className;
+		}
+	}), gutterClassNameValue = classnames("diff-gutter", "diff-gutter-".concat(type), gutterClassName, { "diff-gutter-selected": selected }), codeClassNameValue = classnames("diff-code", "diff-code-".concat(type), codeClassName, { "diff-code-selected": selected });
+	return (0, import_jsx_runtime.jsxs)("tr", {
+		id: anchorID,
+		className: classnames("diff-line", lineClassName),
+		children: [
+			!hideGutter && renderGutterCell(gutterClassNameValue, change, changeKey, "old", gutterAnchor, anchorID, boundGutterEvents, hover, renderGutter),
+			!hideGutter && renderGutterCell(gutterClassNameValue, change, changeKey, "new", gutterAnchor, anchorID, boundGutterEvents, hover, renderGutter),
+			(0, import_jsx_runtime.jsx)(CodeCell$1, _objectSpread2({
+				className: codeClassNameValue,
+				changeKey,
+				text: content,
+				tokens,
+				renderToken
+			}, boundCodeEvents))
+		]
+	});
+}
+var UnifiedChange$1 = memo(UnifiedChange);
+function UnifiedWidget(_ref) {
+	var hideGutter = _ref.hideGutter, element = _ref.element;
+	return (0, import_jsx_runtime.jsx)("tr", {
+		className: "diff-widget",
+		children: (0, import_jsx_runtime.jsx)("td", {
+			colSpan: hideGutter ? 1 : 3,
+			className: "diff-widget-content",
+			children: element
+		})
+	});
+}
+var _excluded$6 = [
+	"hideGutter",
+	"selectedChanges",
+	"tokens",
+	"lineClassName"
+];
+var _excluded2$2 = [
+	"hunk",
+	"widgets",
+	"className"
+];
+function UnifiedHunk(props) {
+	var hunk = props.hunk, widgets = props.widgets, className = props.className, childrenProps = _objectWithoutProperties(props, _excluded2$2), elements = function(changes, widgets) {
+		return changes.reduce((function(elements, change) {
+			var key = getChangeKey(change);
+			elements.push([
+				"change",
+				key,
+				change
+			]);
+			var widget = widgets[key];
+			return widget && elements.push([
+				"widget",
+				key,
+				widget
+			]), elements;
+		}), []);
+	}(hunk.changes, widgets);
+	return (0, import_jsx_runtime.jsx)("tbody", {
+		className: classnames("diff-hunk", className),
+		children: elements.map((function(element) {
+			return function(_ref, props) {
+				var _ref2 = _slicedToArray(_ref, 3), type = _ref2[0], key = _ref2[1], value = _ref2[2], hideGutter = props.hideGutter, selectedChanges = props.selectedChanges, tokens = props.tokens, lineClassName = props.lineClassName, changeProps = _objectWithoutProperties(props, _excluded$6);
+				if ("change" === type) {
+					var side = isDelete(value) ? "old" : "new", lineNumber = isDelete(value) ? computeOldLineNumber(value) : computeNewLineNumber(value), tokensOfLine = tokens ? tokens[side][lineNumber - 1] : null;
+					return (0, import_jsx_runtime.jsx)(UnifiedChange$1, _objectSpread2({
+						className: lineClassName,
+						change: value,
+						hideGutter,
+						selected: selectedChanges.includes(key),
+						tokens: tokensOfLine
+					}, changeProps), "change".concat(key));
+				}
+				return "widget" === type ? (0, import_jsx_runtime.jsx)(UnifiedWidget, {
+					hideGutter,
+					element: value
+				}, "widget".concat(key)) : null;
+			}(element, childrenProps);
+		}))
+	});
+}
+var SIDE_OLD = 0;
+function useCallbackOnSide(side, setHover, change, customCallbacks) {
+	var markHover = useCallback((function() {
+		return setHover(side);
+	}), [side, setHover]), unmarkHover = useCallback((function() {
+		return setHover("");
+	}), [setHover]);
+	return useMemo((function() {
+		var callbacks = mapValues_1(customCallbacks, (function(fn) {
+			return function(e) {
+				return fn && fn({
+					side,
+					change
+				}, e);
+			};
+		}));
+		return callbacks.onMouseEnter = composeCallback(markHover, callbacks.onMouseEnter), callbacks.onMouseLeave = composeCallback(unmarkHover, callbacks.onMouseLeave), callbacks;
+	}), [
+		change,
+		customCallbacks,
+		markHover,
+		side,
+		unmarkHover
+	]);
+}
+function renderCells(args) {
+	var change = args.change, side = args.side, selected = args.selected, tokens = args.tokens, gutterClassName = args.gutterClassName, codeClassName = args.codeClassName, gutterEvents = args.gutterEvents, codeEvents = args.codeEvents, anchorID = args.anchorID, gutterAnchor = args.gutterAnchor, gutterAnchorTarget = args.gutterAnchorTarget, hideGutter = args.hideGutter, hover = args.hover, renderToken = args.renderToken, renderGutter = args.renderGutter;
+	if (!change) {
+		var _gutterClassNameValue = classnames("diff-gutter", "diff-gutter-omit", gutterClassName), _codeClassNameValue = classnames("diff-code", "diff-code-omit", codeClassName);
+		return [!hideGutter && (0, import_jsx_runtime.jsx)("td", { className: _gutterClassNameValue }, "gutter"), (0, import_jsx_runtime.jsx)("td", { className: _codeClassNameValue }, "code")];
+	}
+	var type = change.type, content = change.content, changeKey = getChangeKey(change), sideName = side === SIDE_OLD ? "old" : "new", gutterProps = _objectSpread2({
+		id: anchorID || void 0,
+		className: classnames("diff-gutter", "diff-gutter-".concat(type), _defineProperty$1({ "diff-gutter-selected": selected }, "diff-line-hover-" + sideName, hover), gutterClassName),
+		children: renderGutter({
+			change,
+			side: sideName,
+			inHoverState: hover,
+			renderDefault: renderDefaultBy(change, sideName),
+			wrapInAnchor: wrapInAnchorBy(gutterAnchor, gutterAnchorTarget)
+		})
+	}, gutterEvents), codeClassNameValue = classnames("diff-code", "diff-code-".concat(type), _defineProperty$1({ "diff-code-selected": selected }, "diff-line-hover-" + sideName, hover), codeClassName);
+	return [!hideGutter && (0, import_jsx_runtime.jsx)("td", _objectSpread2(_objectSpread2({}, gutterProps), {}, { "data-change-key": changeKey }), "gutter"), (0, import_jsx_runtime.jsx)(CodeCell$1, _objectSpread2({
+		className: codeClassNameValue,
+		changeKey,
+		text: content,
+		tokens,
+		renderToken
+	}, codeEvents), "code")];
+}
+function SplitChange(props) {
+	var className = props.className, oldChange = props.oldChange, newChange = props.newChange, oldSelected = props.oldSelected, newSelected = props.newSelected, oldTokens = props.oldTokens, newTokens = props.newTokens, monotonous = props.monotonous, gutterClassName = props.gutterClassName, codeClassName = props.codeClassName, gutterEvents = props.gutterEvents, codeEvents = props.codeEvents, hideGutter = props.hideGutter, generateAnchorID = props.generateAnchorID, generateLineClassName = props.generateLineClassName, gutterAnchor = props.gutterAnchor, renderToken = props.renderToken, renderGutter = props.renderGutter, _useState2 = _slicedToArray(useState(""), 2), hover = _useState2[0], setHover = _useState2[1], oldGutterEvents = useCallbackOnSide("old", setHover, oldChange, gutterEvents), newGutterEvents = useCallbackOnSide("new", setHover, newChange, gutterEvents), oldCodeEvents = useCallbackOnSide("old", setHover, oldChange, codeEvents), newCodeEvents = useCallbackOnSide("new", setHover, newChange, codeEvents), oldAnchorID = oldChange && generateAnchorID(oldChange), newAnchorID = newChange && generateAnchorID(newChange), lineClassName = generateLineClassName({
+		changes: [oldChange, newChange],
+		defaultGenerate: function() {
+			return className;
+		}
+	}), commons = {
+		monotonous,
+		hideGutter,
+		gutterClassName,
+		codeClassName,
+		gutterEvents,
+		codeEvents,
+		renderToken,
+		renderGutter
+	}, oldArgs = _objectSpread2(_objectSpread2({}, commons), {}, {
+		change: oldChange,
+		side: SIDE_OLD,
+		selected: oldSelected,
+		tokens: oldTokens,
+		gutterEvents: oldGutterEvents,
+		codeEvents: oldCodeEvents,
+		anchorID: oldAnchorID,
+		gutterAnchor,
+		gutterAnchorTarget: oldAnchorID,
+		hover: "old" === hover
+	}), newArgs = _objectSpread2(_objectSpread2({}, commons), {}, {
+		change: newChange,
+		side: 1,
+		selected: newSelected,
+		tokens: newTokens,
+		gutterEvents: newGutterEvents,
+		codeEvents: newCodeEvents,
+		anchorID: oldChange === newChange ? null : newAnchorID,
+		gutterAnchor,
+		gutterAnchorTarget: oldChange === newChange ? oldAnchorID : newAnchorID,
+		hover: "new" === hover
+	});
+	if (monotonous) return (0, import_jsx_runtime.jsx)("tr", {
+		className: classnames("diff-line", lineClassName),
+		children: renderCells(oldChange ? oldArgs : newArgs)
+	});
+	return (0, import_jsx_runtime.jsxs)("tr", {
+		className: classnames("diff-line", function(oldChange, newChange) {
+			return oldChange && !newChange ? "diff-line-old-only" : !oldChange && newChange ? "diff-line-new-only" : oldChange === newChange ? "diff-line-normal" : "diff-line-compare";
+		}(oldChange, newChange), lineClassName),
+		children: [renderCells(oldArgs), renderCells(newArgs)]
+	});
+}
+var SplitChange$1 = memo(SplitChange);
+function SplitWidget(_ref) {
+	var hideGutter = _ref.hideGutter, oldElement = _ref.oldElement, newElement = _ref.newElement;
+	return _ref.monotonous ? (0, import_jsx_runtime.jsx)("tr", {
+		className: "diff-widget",
+		children: (0, import_jsx_runtime.jsx)("td", {
+			colSpan: hideGutter ? 1 : 2,
+			className: "diff-widget-content",
+			children: oldElement || newElement
+		})
+	}) : oldElement === newElement ? (0, import_jsx_runtime.jsx)("tr", {
+		className: "diff-widget",
+		children: (0, import_jsx_runtime.jsx)("td", {
+			colSpan: hideGutter ? 2 : 4,
+			className: "diff-widget-content",
+			children: oldElement
+		})
+	}) : (0, import_jsx_runtime.jsxs)("tr", {
+		className: "diff-widget",
+		children: [(0, import_jsx_runtime.jsx)("td", {
+			colSpan: hideGutter ? 1 : 2,
+			className: "diff-widget-content",
+			children: oldElement
+		}), (0, import_jsx_runtime.jsx)("td", {
+			colSpan: hideGutter ? 1 : 2,
+			className: "diff-widget-content",
+			children: newElement
+		})]
+	});
+}
+var _excluded$5 = [
+	"selectedChanges",
+	"monotonous",
+	"hideGutter",
+	"tokens",
+	"lineClassName"
+];
+var _excluded2$1 = [
+	"hunk",
+	"widgets",
+	"className"
+];
+function keyForPair(x, y) {
+	return (x ? getChangeKey(x) : "00") + (y ? getChangeKey(y) : "00");
+}
+function SplitHunk(props) {
+	var hunk = props.hunk, widgets = props.widgets, className = props.className, childrenProps = _objectWithoutProperties(props, _excluded2$1), elements = function(changes, widgets) {
+		for (var findWidget = function(change) {
+			if (!change) return null;
+			return widgets[getChangeKey(change)] || null;
+		}, elements = [], i = 0; i < changes.length; i++) {
+			var current = changes[i];
+			if (isNormal(current)) elements.push([
+				"change",
+				keyForPair(current, current),
+				current,
+				current
+			]);
+			else if (isDelete(current)) {
+				var next = changes[i + 1];
+				next && isInsert(next) ? (i += 1, elements.push([
+					"change",
+					keyForPair(current, next),
+					current,
+					next
+				])) : elements.push([
+					"change",
+					keyForPair(current, null),
+					current,
+					null
+				]);
+			} else elements.push([
+				"change",
+				keyForPair(null, current),
+				null,
+				current
+			]);
+			var rowChanges = elements[elements.length - 1], oldWidget = findWidget(rowChanges[2]), newWidget = findWidget(rowChanges[3]);
+			if (oldWidget || newWidget) {
+				var key = rowChanges[1];
+				elements.push([
+					"widget",
+					key,
+					oldWidget,
+					newWidget
+				]);
+			}
+		}
+		return elements;
+	}(hunk.changes, widgets);
+	return (0, import_jsx_runtime.jsx)("tbody", {
+		className: classnames("diff-hunk", className),
+		children: elements.map((function(item) {
+			return function(_ref, props) {
+				var _ref2 = _slicedToArray(_ref, 4), type = _ref2[0], key = _ref2[1], oldValue = _ref2[2], newValue = _ref2[3], selectedChanges = props.selectedChanges, monotonous = props.monotonous, hideGutter = props.hideGutter, tokens = props.tokens, lineClassName = props.lineClassName, changeProps = _objectWithoutProperties(props, _excluded$5);
+				if ("change" === type) {
+					var oldSelected = !!oldValue && selectedChanges.includes(getChangeKey(oldValue)), newSelected = !!newValue && selectedChanges.includes(getChangeKey(newValue)), oldTokens = oldValue && tokens ? tokens.old[computeOldLineNumber(oldValue) - 1] : null, newTokens = newValue && tokens ? tokens.new[computeNewLineNumber(newValue) - 1] : null;
+					return (0, import_jsx_runtime.jsx)(SplitChange$1, _objectSpread2({
+						className: lineClassName,
+						oldChange: oldValue,
+						newChange: newValue,
+						monotonous,
+						hideGutter,
+						oldSelected,
+						newSelected,
+						oldTokens,
+						newTokens
+					}, changeProps), "change".concat(key));
+				}
+				return "widget" === type ? (0, import_jsx_runtime.jsx)(SplitWidget, {
+					monotonous,
+					hideGutter,
+					oldElement: oldValue,
+					newElement: newValue
+				}, "widget".concat(key)) : null;
+			}(item, childrenProps);
+		}))
+	});
+}
+var _excluded$4 = ["gutterType", "hunkClassName"];
+function Hunk(_ref) {
+	var hunk = _ref.hunk, _useDiffSettings = useDiffSettings(), gutterType = _useDiffSettings.gutterType, hunkClassName = _useDiffSettings.hunkClassName, context = _objectWithoutProperties(_useDiffSettings, _excluded$4), hideGutter = "none" === gutterType, gutterAnchor = "anchor" === gutterType, RenderingHunk = "unified" === context.viewType ? UnifiedHunk : SplitHunk;
+	return (0, import_jsx_runtime.jsx)(RenderingHunk, _objectSpread2(_objectSpread2({}, context), {}, {
+		hunk,
+		hideGutter,
+		gutterAnchor,
+		className: hunkClassName
+	}));
+}
+function noop() {}
+function setUserSelectStyle(element, selectable) {
+	var value = selectable ? "auto" : "none";
+	element instanceof HTMLElement && element.style.userSelect !== value && (element.style.userSelect = value);
+}
+function defaultRenderChildren(hunks) {
+	return hunks.map((function(hunk) {
+		return (0, import_jsx_runtime.jsx)(Hunk, { hunk }, function(hunk) {
+			return "-".concat(hunk.oldStart, ",").concat(hunk.oldLines, " +").concat(hunk.newStart, ",").concat(hunk.newLines);
+		}(hunk));
+	}));
+}
+function Diff(props) {
+	var diffType = props.diffType, hunks = props.hunks, optimizeSelection = props.optimizeSelection, className = props.className, _props$hunkClassName = props.hunkClassName, hunkClassName = void 0 === _props$hunkClassName ? DEFAULT_CONTEXT_VALUE.hunkClassName : _props$hunkClassName, _props$lineClassName = props.lineClassName, lineClassName = void 0 === _props$lineClassName ? DEFAULT_CONTEXT_VALUE.lineClassName : _props$lineClassName, _props$generateLineCl = props.generateLineClassName, generateLineClassName = void 0 === _props$generateLineCl ? DEFAULT_CONTEXT_VALUE.generateLineClassName : _props$generateLineCl, _props$gutterClassNam = props.gutterClassName, gutterClassName = void 0 === _props$gutterClassNam ? DEFAULT_CONTEXT_VALUE.gutterClassName : _props$gutterClassNam, _props$codeClassName = props.codeClassName, codeClassName = void 0 === _props$codeClassName ? DEFAULT_CONTEXT_VALUE.codeClassName : _props$codeClassName, _props$gutterType = props.gutterType, gutterType = void 0 === _props$gutterType ? DEFAULT_CONTEXT_VALUE.gutterType : _props$gutterType, _props$viewType = props.viewType, viewType = void 0 === _props$viewType ? DEFAULT_CONTEXT_VALUE.viewType : _props$viewType, _props$gutterEvents = props.gutterEvents, gutterEvents = void 0 === _props$gutterEvents ? DEFAULT_CONTEXT_VALUE.gutterEvents : _props$gutterEvents, _props$codeEvents = props.codeEvents, codeEvents = void 0 === _props$codeEvents ? DEFAULT_CONTEXT_VALUE.codeEvents : _props$codeEvents, _props$generateAnchor = props.generateAnchorID, generateAnchorID = void 0 === _props$generateAnchor ? DEFAULT_CONTEXT_VALUE.generateAnchorID : _props$generateAnchor, _props$selectedChange = props.selectedChanges, selectedChanges = void 0 === _props$selectedChange ? DEFAULT_CONTEXT_VALUE.selectedChanges : _props$selectedChange, _props$widgets = props.widgets, widgets = void 0 === _props$widgets ? DEFAULT_CONTEXT_VALUE.widgets : _props$widgets, _props$renderGutter = props.renderGutter, renderGutter = void 0 === _props$renderGutter ? DEFAULT_CONTEXT_VALUE.renderGutter : _props$renderGutter, tokens = props.tokens, renderToken = props.renderToken, _props$children = props.children, children = void 0 === _props$children ? defaultRenderChildren : _props$children, root = useRef(null), enableColumnSelection = useCallback((function(_ref) {
+		var target = _ref.target;
+		if (0 === _ref.button) {
+			var closestCell = function(target, className) {
+				for (var current = target; current && current !== document.documentElement && !current.classList.contains(className);) current = current.parentElement;
+				return current === document.documentElement ? null : current;
+			}(target, "diff-code");
+			if (closestCell && closestCell.parentElement) {
+				var selection = window.getSelection();
+				selection && selection.removeAllRanges();
+				var index = _toConsumableArray(closestCell.parentElement.children).indexOf(closestCell);
+				if (1 === index || 3 === index) {
+					var _step, _iterator = _createForOfIteratorHelper(root.current ? root.current.querySelectorAll(".diff-line") : []);
+					try {
+						for (_iterator.s(); !(_step = _iterator.n()).done;) {
+							var cells = _step.value.children;
+							setUserSelectStyle(cells[1], 1 === index), setUserSelectStyle(cells[3], 3 === index);
+						}
+					} catch (err) {
+						_iterator.e(err);
+					} finally {
+						_iterator.f();
+					}
+				}
+			}
+		}
+	}), []), hideGutter = "none" === gutterType, monotonous = "add" === diffType || "delete" === diffType, onTableMouseDown = "split" === viewType && !monotonous && optimizeSelection ? enableColumnSelection : noop, cols = useMemo((function() {
+		return (0, import_jsx_runtime.jsxs)("colgroup", "unified" === viewType ? { children: [
+			!hideGutter && (0, import_jsx_runtime.jsx)("col", { className: "diff-gutter-col" }),
+			!hideGutter && (0, import_jsx_runtime.jsx)("col", { className: "diff-gutter-col" }),
+			(0, import_jsx_runtime.jsx)("col", {})
+		] } : monotonous ? { children: [!hideGutter && (0, import_jsx_runtime.jsx)("col", { className: "diff-gutter-col" }), (0, import_jsx_runtime.jsx)("col", {})] } : { children: [
+			!hideGutter && (0, import_jsx_runtime.jsx)("col", { className: "diff-gutter-col" }),
+			(0, import_jsx_runtime.jsx)("col", {}),
+			!hideGutter && (0, import_jsx_runtime.jsx)("col", { className: "diff-gutter-col" }),
+			(0, import_jsx_runtime.jsx)("col", {})
+		] });
+	}), [
+		viewType,
+		monotonous,
+		hideGutter
+	]), settingsContextValue = useMemo((function() {
+		return {
+			hunkClassName,
+			lineClassName,
+			generateLineClassName,
+			gutterClassName,
+			codeClassName,
+			monotonous,
+			hideGutter,
+			viewType,
+			gutterType,
+			codeEvents,
+			gutterEvents,
+			generateAnchorID,
+			selectedChanges,
+			widgets,
+			renderGutter,
+			tokens,
+			renderToken
+		};
+	}), [
+		codeClassName,
+		codeEvents,
+		generateAnchorID,
+		gutterClassName,
+		gutterEvents,
+		gutterType,
+		hideGutter,
+		hunkClassName,
+		lineClassName,
+		generateLineClassName,
+		monotonous,
+		renderGutter,
+		renderToken,
+		selectedChanges,
+		tokens,
+		viewType,
+		widgets
+	]);
+	return (0, import_jsx_runtime.jsx)(Provider, {
+		value: settingsContextValue,
+		children: (0, import_jsx_runtime.jsxs)("table", {
+			ref: root,
+			className: classnames("diff", "diff-".concat(viewType), className),
+			onMouseDown: onTableMouseDown,
+			children: [cols, children(hunks)]
+		})
+	});
+}
+var index = memo(Diff);
+if ("production" !== process.env.NODE_ENV) var printWarning = function(format, args) {
+	var len = arguments.length;
+	args = new Array(len > 1 ? len - 1 : 0);
+	for (var key = 1; key < len; key++) args[key - 1] = arguments[key];
+	var argIndex = 0, message = "Warning: " + format.replace(/%s/g, (function() {
+		return args[argIndex++];
+	}));
+	"undefined" != typeof console && console.error(message);
+	try {
+		throw new Error(message);
+	} catch (x) {}
+};
+_Symbol && _Symbol.isConcatSpreadable;
+var diffMatchPatch = createCommonjsModule((function(module) {
+	var diff_match_patch = function() {
+		this.Diff_Timeout = 1, this.Diff_EditCost = 4, this.Match_Threshold = .5, this.Match_Distance = 1e3, this.Patch_DeleteThreshold = .5, this.Patch_Margin = 4, this.Match_MaxBits = 32;
+	};
+	diff_match_patch.Diff = function(op, text) {
+		return [op, text];
+	}, diff_match_patch.prototype.diff_main = function(text1, text2, opt_checklines, opt_deadline) {
+		void 0 === opt_deadline && (opt_deadline = this.Diff_Timeout <= 0 ? Number.MAX_VALUE : (/* @__PURE__ */ new Date()).getTime() + 1e3 * this.Diff_Timeout);
+		var deadline = opt_deadline;
+		if (null == text1 || null == text2) throw new Error("Null input. (diff_main)");
+		if (text1 == text2) return text1 ? [new diff_match_patch.Diff(0, text1)] : [];
+		void 0 === opt_checklines && (opt_checklines = !0);
+		var checklines = opt_checklines, commonlength = this.diff_commonPrefix(text1, text2), commonprefix = text1.substring(0, commonlength);
+		text1 = text1.substring(commonlength), text2 = text2.substring(commonlength), commonlength = this.diff_commonSuffix(text1, text2);
+		var commonsuffix = text1.substring(text1.length - commonlength);
+		text1 = text1.substring(0, text1.length - commonlength), text2 = text2.substring(0, text2.length - commonlength);
+		var diffs = this.diff_compute_(text1, text2, checklines, deadline);
+		return commonprefix && diffs.unshift(new diff_match_patch.Diff(0, commonprefix)), commonsuffix && diffs.push(new diff_match_patch.Diff(0, commonsuffix)), this.diff_cleanupMerge(diffs), diffs;
+	}, diff_match_patch.prototype.diff_compute_ = function(text1, text2, checklines, deadline) {
+		var diffs;
+		if (!text1) return [new diff_match_patch.Diff(1, text2)];
+		if (!text2) return [new diff_match_patch.Diff(-1, text1)];
+		var longtext = text1.length > text2.length ? text1 : text2, shorttext = text1.length > text2.length ? text2 : text1, i = longtext.indexOf(shorttext);
+		if (-1 != i) return diffs = [
+			new diff_match_patch.Diff(1, longtext.substring(0, i)),
+			new diff_match_patch.Diff(0, shorttext),
+			new diff_match_patch.Diff(1, longtext.substring(i + shorttext.length))
+		], text1.length > text2.length && (diffs[0][0] = diffs[2][0] = -1), diffs;
+		if (1 == shorttext.length) return [new diff_match_patch.Diff(-1, text1), new diff_match_patch.Diff(1, text2)];
+		var hm = this.diff_halfMatch_(text1, text2);
+		if (hm) {
+			var text1_a = hm[0], text1_b = hm[1], text2_a = hm[2], text2_b = hm[3], mid_common = hm[4], diffs_a = this.diff_main(text1_a, text2_a, checklines, deadline), diffs_b = this.diff_main(text1_b, text2_b, checklines, deadline);
+			return diffs_a.concat([new diff_match_patch.Diff(0, mid_common)], diffs_b);
+		}
+		return checklines && text1.length > 100 && text2.length > 100 ? this.diff_lineMode_(text1, text2, deadline) : this.diff_bisect_(text1, text2, deadline);
+	}, diff_match_patch.prototype.diff_lineMode_ = function(text1, text2, deadline) {
+		var a = this.diff_linesToChars_(text1, text2);
+		text1 = a.chars1, text2 = a.chars2;
+		var linearray = a.lineArray, diffs = this.diff_main(text1, text2, !1, deadline);
+		this.diff_charsToLines_(diffs, linearray), this.diff_cleanupSemantic(diffs), diffs.push(new diff_match_patch.Diff(0, ""));
+		for (var pointer = 0, count_delete = 0, count_insert = 0, text_delete = "", text_insert = ""; pointer < diffs.length;) {
+			switch (diffs[pointer][0]) {
+				case 1:
+					count_insert++, text_insert += diffs[pointer][1];
+					break;
+				case -1:
+					count_delete++, text_delete += diffs[pointer][1];
+					break;
+				case 0:
+					if (count_delete >= 1 && count_insert >= 1) {
+						diffs.splice(pointer - count_delete - count_insert, count_delete + count_insert), pointer = pointer - count_delete - count_insert;
+						for (var subDiff = this.diff_main(text_delete, text_insert, !1, deadline), j = subDiff.length - 1; j >= 0; j--) diffs.splice(pointer, 0, subDiff[j]);
+						pointer += subDiff.length;
+					}
+					count_insert = 0, count_delete = 0, text_delete = "", text_insert = "";
+			}
+			pointer++;
+		}
+		return diffs.pop(), diffs;
+	}, diff_match_patch.prototype.diff_bisect_ = function(text1, text2, deadline) {
+		for (var text1_length = text1.length, text2_length = text2.length, max_d = Math.ceil((text1_length + text2_length) / 2), v_offset = max_d, v_length = 2 * max_d, v1 = new Array(v_length), v2 = new Array(v_length), x = 0; x < v_length; x++) v1[x] = -1, v2[x] = -1;
+		v1[v_offset + 1] = 0, v2[v_offset + 1] = 0;
+		for (var delta = text1_length - text2_length, front = delta % 2 != 0, k1start = 0, k1end = 0, k2start = 0, k2end = 0, d = 0; d < max_d && !((/* @__PURE__ */ new Date()).getTime() > deadline); d++) {
+			for (var k1 = -d + k1start; k1 <= d - k1end; k1 += 2) {
+				for (var k1_offset = v_offset + k1, y1 = (x1 = k1 == -d || k1 != d && v1[k1_offset - 1] < v1[k1_offset + 1] ? v1[k1_offset + 1] : v1[k1_offset - 1] + 1) - k1; x1 < text1_length && y1 < text2_length && text1.charAt(x1) == text2.charAt(y1);) x1++, y1++;
+				if (v1[k1_offset] = x1, x1 > text1_length) k1end += 2;
+				else if (y1 > text2_length) k1start += 2;
+				else if (front) {
+					if ((k2_offset = v_offset + delta - k1) >= 0 && k2_offset < v_length && -1 != v2[k2_offset]) {
+						if (x1 >= (x2 = text1_length - v2[k2_offset])) return this.diff_bisectSplit_(text1, text2, x1, y1, deadline);
+					}
+				}
+			}
+			for (var k2 = -d + k2start; k2 <= d - k2end; k2 += 2) {
+				for (var x2, k2_offset = v_offset + k2, y2 = (x2 = k2 == -d || k2 != d && v2[k2_offset - 1] < v2[k2_offset + 1] ? v2[k2_offset + 1] : v2[k2_offset - 1] + 1) - k2; x2 < text1_length && y2 < text2_length && text1.charAt(text1_length - x2 - 1) == text2.charAt(text2_length - y2 - 1);) x2++, y2++;
+				if (v2[k2_offset] = x2, x2 > text1_length) k2end += 2;
+				else if (y2 > text2_length) k2start += 2;
+				else if (!front) {
+					if ((k1_offset = v_offset + delta - k2) >= 0 && k1_offset < v_length && -1 != v1[k1_offset]) {
+						var x1;
+						y1 = v_offset + (x1 = v1[k1_offset]) - k1_offset;
+						if (x1 >= (x2 = text1_length - x2)) return this.diff_bisectSplit_(text1, text2, x1, y1, deadline);
+					}
+				}
+			}
+		}
+		return [new diff_match_patch.Diff(-1, text1), new diff_match_patch.Diff(1, text2)];
+	}, diff_match_patch.prototype.diff_bisectSplit_ = function(text1, text2, x, y, deadline) {
+		var text1a = text1.substring(0, x), text2a = text2.substring(0, y), text1b = text1.substring(x), text2b = text2.substring(y), diffs = this.diff_main(text1a, text2a, !1, deadline), diffsb = this.diff_main(text1b, text2b, !1, deadline);
+		return diffs.concat(diffsb);
+	}, diff_match_patch.prototype.diff_linesToChars_ = function(text1, text2) {
+		var lineArray = [], lineHash = {};
+		function diff_linesToCharsMunge_(text) {
+			for (var chars = "", lineStart = 0, lineEnd = -1, lineArrayLength = lineArray.length; lineEnd < text.length - 1;) {
+				-1 == (lineEnd = text.indexOf("\n", lineStart)) && (lineEnd = text.length - 1);
+				var line = text.substring(lineStart, lineEnd + 1);
+				(lineHash.hasOwnProperty ? lineHash.hasOwnProperty(line) : void 0 !== lineHash[line]) ? chars += String.fromCharCode(lineHash[line]) : (lineArrayLength == maxLines && (line = text.substring(lineStart), lineEnd = text.length), chars += String.fromCharCode(lineArrayLength), lineHash[line] = lineArrayLength, lineArray[lineArrayLength++] = line), lineStart = lineEnd + 1;
+			}
+			return chars;
+		}
+		lineArray[0] = "";
+		var maxLines = 4e4, chars1 = diff_linesToCharsMunge_(text1);
+		return maxLines = 65535, {
+			chars1,
+			chars2: diff_linesToCharsMunge_(text2),
+			lineArray
+		};
+	}, diff_match_patch.prototype.diff_charsToLines_ = function(diffs, lineArray) {
+		for (var i = 0; i < diffs.length; i++) {
+			for (var chars = diffs[i][1], text = [], j = 0; j < chars.length; j++) text[j] = lineArray[chars.charCodeAt(j)];
+			diffs[i][1] = text.join("");
+		}
+	}, diff_match_patch.prototype.diff_commonPrefix = function(text1, text2) {
+		if (!text1 || !text2 || text1.charAt(0) != text2.charAt(0)) return 0;
+		for (var pointermin = 0, pointermax = Math.min(text1.length, text2.length), pointermid = pointermax, pointerstart = 0; pointermin < pointermid;) text1.substring(pointerstart, pointermid) == text2.substring(pointerstart, pointermid) ? pointerstart = pointermin = pointermid : pointermax = pointermid, pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);
+		return pointermid;
+	}, diff_match_patch.prototype.diff_commonSuffix = function(text1, text2) {
+		if (!text1 || !text2 || text1.charAt(text1.length - 1) != text2.charAt(text2.length - 1)) return 0;
+		for (var pointermin = 0, pointermax = Math.min(text1.length, text2.length), pointermid = pointermax, pointerend = 0; pointermin < pointermid;) text1.substring(text1.length - pointermid, text1.length - pointerend) == text2.substring(text2.length - pointermid, text2.length - pointerend) ? pointerend = pointermin = pointermid : pointermax = pointermid, pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);
+		return pointermid;
+	}, diff_match_patch.prototype.diff_commonOverlap_ = function(text1, text2) {
+		var text1_length = text1.length, text2_length = text2.length;
+		if (0 == text1_length || 0 == text2_length) return 0;
+		text1_length > text2_length ? text1 = text1.substring(text1_length - text2_length) : text1_length < text2_length && (text2 = text2.substring(0, text1_length));
+		var text_length = Math.min(text1_length, text2_length);
+		if (text1 == text2) return text_length;
+		for (var best = 0, length = 1;;) {
+			var pattern = text1.substring(text_length - length), found = text2.indexOf(pattern);
+			if (-1 == found) return best;
+			length += found, 0 != found && text1.substring(text_length - length) != text2.substring(0, length) || (best = length, length++);
+		}
+	}, diff_match_patch.prototype.diff_halfMatch_ = function(text1, text2) {
+		if (this.Diff_Timeout <= 0) return null;
+		var longtext = text1.length > text2.length ? text1 : text2, shorttext = text1.length > text2.length ? text2 : text1;
+		if (longtext.length < 4 || 2 * shorttext.length < longtext.length) return null;
+		var dmp = this;
+		function diff_halfMatchI_(longtext, shorttext, i) {
+			for (var best_longtext_a, best_longtext_b, best_shorttext_a, best_shorttext_b, seed = longtext.substring(i, i + Math.floor(longtext.length / 4)), j = -1, best_common = ""; -1 != (j = shorttext.indexOf(seed, j + 1));) {
+				var prefixLength = dmp.diff_commonPrefix(longtext.substring(i), shorttext.substring(j)), suffixLength = dmp.diff_commonSuffix(longtext.substring(0, i), shorttext.substring(0, j));
+				best_common.length < suffixLength + prefixLength && (best_common = shorttext.substring(j - suffixLength, j) + shorttext.substring(j, j + prefixLength), best_longtext_a = longtext.substring(0, i - suffixLength), best_longtext_b = longtext.substring(i + prefixLength), best_shorttext_a = shorttext.substring(0, j - suffixLength), best_shorttext_b = shorttext.substring(j + prefixLength));
+			}
+			return 2 * best_common.length >= longtext.length ? [
+				best_longtext_a,
+				best_longtext_b,
+				best_shorttext_a,
+				best_shorttext_b,
+				best_common
+			] : null;
+		}
+		var hm, text1_a, text1_b, text2_a, text2_b, hm1 = diff_halfMatchI_(longtext, shorttext, Math.ceil(longtext.length / 4)), hm2 = diff_halfMatchI_(longtext, shorttext, Math.ceil(longtext.length / 2));
+		return hm1 || hm2 ? (hm = hm2 ? hm1 && hm1[4].length > hm2[4].length ? hm1 : hm2 : hm1, text1.length > text2.length ? (text1_a = hm[0], text1_b = hm[1], text2_a = hm[2], text2_b = hm[3]) : (text2_a = hm[0], text2_b = hm[1], text1_a = hm[2], text1_b = hm[3]), [
+			text1_a,
+			text1_b,
+			text2_a,
+			text2_b,
+			hm[4]
+		]) : null;
+	}, diff_match_patch.prototype.diff_cleanupSemantic = function(diffs) {
+		for (var changes = !1, equalities = [], equalitiesLength = 0, lastEquality = null, pointer = 0, length_insertions1 = 0, length_deletions1 = 0, length_insertions2 = 0, length_deletions2 = 0; pointer < diffs.length;) 0 == diffs[pointer][0] ? (equalities[equalitiesLength++] = pointer, length_insertions1 = length_insertions2, length_deletions1 = length_deletions2, length_insertions2 = 0, length_deletions2 = 0, lastEquality = diffs[pointer][1]) : (1 == diffs[pointer][0] ? length_insertions2 += diffs[pointer][1].length : length_deletions2 += diffs[pointer][1].length, lastEquality && lastEquality.length <= Math.max(length_insertions1, length_deletions1) && lastEquality.length <= Math.max(length_insertions2, length_deletions2) && (diffs.splice(equalities[equalitiesLength - 1], 0, new diff_match_patch.Diff(-1, lastEquality)), diffs[equalities[equalitiesLength - 1] + 1][0] = 1, equalitiesLength--, pointer = --equalitiesLength > 0 ? equalities[equalitiesLength - 1] : -1, length_insertions1 = 0, length_deletions1 = 0, length_insertions2 = 0, length_deletions2 = 0, lastEquality = null, changes = !0)), pointer++;
+		for (changes && this.diff_cleanupMerge(diffs), this.diff_cleanupSemanticLossless(diffs), pointer = 1; pointer < diffs.length;) {
+			if (-1 == diffs[pointer - 1][0] && 1 == diffs[pointer][0]) {
+				var deletion = diffs[pointer - 1][1], insertion = diffs[pointer][1], overlap_length1 = this.diff_commonOverlap_(deletion, insertion), overlap_length2 = this.diff_commonOverlap_(insertion, deletion);
+				overlap_length1 >= overlap_length2 ? (overlap_length1 >= deletion.length / 2 || overlap_length1 >= insertion.length / 2) && (diffs.splice(pointer, 0, new diff_match_patch.Diff(0, insertion.substring(0, overlap_length1))), diffs[pointer - 1][1] = deletion.substring(0, deletion.length - overlap_length1), diffs[pointer + 1][1] = insertion.substring(overlap_length1), pointer++) : (overlap_length2 >= deletion.length / 2 || overlap_length2 >= insertion.length / 2) && (diffs.splice(pointer, 0, new diff_match_patch.Diff(0, deletion.substring(0, overlap_length2))), diffs[pointer - 1][0] = 1, diffs[pointer - 1][1] = insertion.substring(0, insertion.length - overlap_length2), diffs[pointer + 1][0] = -1, diffs[pointer + 1][1] = deletion.substring(overlap_length2), pointer++), pointer++;
+			}
+			pointer++;
+		}
+	}, diff_match_patch.prototype.diff_cleanupSemanticLossless = function(diffs) {
+		function diff_cleanupSemanticScore_(one, two) {
+			if (!one || !two) return 6;
+			var char1 = one.charAt(one.length - 1), char2 = two.charAt(0), nonAlphaNumeric1 = char1.match(diff_match_patch.nonAlphaNumericRegex_), nonAlphaNumeric2 = char2.match(diff_match_patch.nonAlphaNumericRegex_), whitespace1 = nonAlphaNumeric1 && char1.match(diff_match_patch.whitespaceRegex_), whitespace2 = nonAlphaNumeric2 && char2.match(diff_match_patch.whitespaceRegex_), lineBreak1 = whitespace1 && char1.match(diff_match_patch.linebreakRegex_), lineBreak2 = whitespace2 && char2.match(diff_match_patch.linebreakRegex_), blankLine1 = lineBreak1 && one.match(diff_match_patch.blanklineEndRegex_), blankLine2 = lineBreak2 && two.match(diff_match_patch.blanklineStartRegex_);
+			return blankLine1 || blankLine2 ? 5 : lineBreak1 || lineBreak2 ? 4 : nonAlphaNumeric1 && !whitespace1 && whitespace2 ? 3 : whitespace1 || whitespace2 ? 2 : nonAlphaNumeric1 || nonAlphaNumeric2 ? 1 : 0;
+		}
+		for (var pointer = 1; pointer < diffs.length - 1;) {
+			if (0 == diffs[pointer - 1][0] && 0 == diffs[pointer + 1][0]) {
+				var equality1 = diffs[pointer - 1][1], edit = diffs[pointer][1], equality2 = diffs[pointer + 1][1], commonOffset = this.diff_commonSuffix(equality1, edit);
+				if (commonOffset) {
+					var commonString = edit.substring(edit.length - commonOffset);
+					equality1 = equality1.substring(0, equality1.length - commonOffset), edit = commonString + edit.substring(0, edit.length - commonOffset), equality2 = commonString + equality2;
+				}
+				for (var bestEquality1 = equality1, bestEdit = edit, bestEquality2 = equality2, bestScore = diff_cleanupSemanticScore_(equality1, edit) + diff_cleanupSemanticScore_(edit, equality2); edit.charAt(0) === equality2.charAt(0);) {
+					equality1 += edit.charAt(0), edit = edit.substring(1) + equality2.charAt(0), equality2 = equality2.substring(1);
+					var score = diff_cleanupSemanticScore_(equality1, edit) + diff_cleanupSemanticScore_(edit, equality2);
+					score >= bestScore && (bestScore = score, bestEquality1 = equality1, bestEdit = edit, bestEquality2 = equality2);
+				}
+				diffs[pointer - 1][1] != bestEquality1 && (bestEquality1 ? diffs[pointer - 1][1] = bestEquality1 : (diffs.splice(pointer - 1, 1), pointer--), diffs[pointer][1] = bestEdit, bestEquality2 ? diffs[pointer + 1][1] = bestEquality2 : (diffs.splice(pointer + 1, 1), pointer--));
+			}
+			pointer++;
+		}
+	}, diff_match_patch.nonAlphaNumericRegex_ = /[^a-zA-Z0-9]/, diff_match_patch.whitespaceRegex_ = /\s/, diff_match_patch.linebreakRegex_ = /[\r\n]/, diff_match_patch.blanklineEndRegex_ = /\n\r?\n$/, diff_match_patch.blanklineStartRegex_ = /^\r?\n\r?\n/, diff_match_patch.prototype.diff_cleanupEfficiency = function(diffs) {
+		for (var changes = !1, equalities = [], equalitiesLength = 0, lastEquality = null, pointer = 0, pre_ins = !1, pre_del = !1, post_ins = !1, post_del = !1; pointer < diffs.length;) 0 == diffs[pointer][0] ? (diffs[pointer][1].length < this.Diff_EditCost && (post_ins || post_del) ? (equalities[equalitiesLength++] = pointer, pre_ins = post_ins, pre_del = post_del, lastEquality = diffs[pointer][1]) : (equalitiesLength = 0, lastEquality = null), post_ins = post_del = !1) : (-1 == diffs[pointer][0] ? post_del = !0 : post_ins = !0, lastEquality && (pre_ins && pre_del && post_ins && post_del || lastEquality.length < this.Diff_EditCost / 2 && pre_ins + pre_del + post_ins + post_del == 3) && (diffs.splice(equalities[equalitiesLength - 1], 0, new diff_match_patch.Diff(-1, lastEquality)), diffs[equalities[equalitiesLength - 1] + 1][0] = 1, equalitiesLength--, lastEquality = null, pre_ins && pre_del ? (post_ins = post_del = !0, equalitiesLength = 0) : (pointer = --equalitiesLength > 0 ? equalities[equalitiesLength - 1] : -1, post_ins = post_del = !1), changes = !0)), pointer++;
+		changes && this.diff_cleanupMerge(diffs);
+	}, diff_match_patch.prototype.diff_cleanupMerge = function(diffs) {
+		diffs.push(new diff_match_patch.Diff(0, ""));
+		for (var commonlength, pointer = 0, count_delete = 0, count_insert = 0, text_delete = "", text_insert = ""; pointer < diffs.length;) switch (diffs[pointer][0]) {
+			case 1:
+				count_insert++, text_insert += diffs[pointer][1], pointer++;
+				break;
+			case -1:
+				count_delete++, text_delete += diffs[pointer][1], pointer++;
+				break;
+			case 0: count_delete + count_insert > 1 ? (0 !== count_delete && 0 !== count_insert && (0 !== (commonlength = this.diff_commonPrefix(text_insert, text_delete)) && (pointer - count_delete - count_insert > 0 && 0 == diffs[pointer - count_delete - count_insert - 1][0] ? diffs[pointer - count_delete - count_insert - 1][1] += text_insert.substring(0, commonlength) : (diffs.splice(0, 0, new diff_match_patch.Diff(0, text_insert.substring(0, commonlength))), pointer++), text_insert = text_insert.substring(commonlength), text_delete = text_delete.substring(commonlength)), 0 !== (commonlength = this.diff_commonSuffix(text_insert, text_delete)) && (diffs[pointer][1] = text_insert.substring(text_insert.length - commonlength) + diffs[pointer][1], text_insert = text_insert.substring(0, text_insert.length - commonlength), text_delete = text_delete.substring(0, text_delete.length - commonlength))), pointer -= count_delete + count_insert, diffs.splice(pointer, count_delete + count_insert), text_delete.length && (diffs.splice(pointer, 0, new diff_match_patch.Diff(-1, text_delete)), pointer++), text_insert.length && (diffs.splice(pointer, 0, new diff_match_patch.Diff(1, text_insert)), pointer++), pointer++) : 0 !== pointer && 0 == diffs[pointer - 1][0] ? (diffs[pointer - 1][1] += diffs[pointer][1], diffs.splice(pointer, 1)) : pointer++, count_insert = 0, count_delete = 0, text_delete = "", text_insert = "";
+		}
+		"" === diffs[diffs.length - 1][1] && diffs.pop();
+		var changes = !1;
+		for (pointer = 1; pointer < diffs.length - 1;) 0 == diffs[pointer - 1][0] && 0 == diffs[pointer + 1][0] && (diffs[pointer][1].substring(diffs[pointer][1].length - diffs[pointer - 1][1].length) == diffs[pointer - 1][1] ? (diffs[pointer][1] = diffs[pointer - 1][1] + diffs[pointer][1].substring(0, diffs[pointer][1].length - diffs[pointer - 1][1].length), diffs[pointer + 1][1] = diffs[pointer - 1][1] + diffs[pointer + 1][1], diffs.splice(pointer - 1, 1), changes = !0) : diffs[pointer][1].substring(0, diffs[pointer + 1][1].length) == diffs[pointer + 1][1] && (diffs[pointer - 1][1] += diffs[pointer + 1][1], diffs[pointer][1] = diffs[pointer][1].substring(diffs[pointer + 1][1].length) + diffs[pointer + 1][1], diffs.splice(pointer + 1, 1), changes = !0)), pointer++;
+		changes && this.diff_cleanupMerge(diffs);
+	}, diff_match_patch.prototype.diff_xIndex = function(diffs, loc) {
+		var x, chars1 = 0, chars2 = 0, last_chars1 = 0, last_chars2 = 0;
+		for (x = 0; x < diffs.length && (1 !== diffs[x][0] && (chars1 += diffs[x][1].length), -1 !== diffs[x][0] && (chars2 += diffs[x][1].length), !(chars1 > loc)); x++) last_chars1 = chars1, last_chars2 = chars2;
+		return diffs.length != x && -1 === diffs[x][0] ? last_chars2 : last_chars2 + (loc - last_chars1);
+	}, diff_match_patch.prototype.diff_prettyHtml = function(diffs) {
+		for (var html = [], pattern_amp = /&/g, pattern_lt = /</g, pattern_gt = />/g, pattern_para = /\n/g, x = 0; x < diffs.length; x++) {
+			var op = diffs[x][0], text = diffs[x][1].replace(pattern_amp, "&amp;").replace(pattern_lt, "&lt;").replace(pattern_gt, "&gt;").replace(pattern_para, "&para;<br>");
+			switch (op) {
+				case 1:
+					html[x] = "<ins style=\"background:#e6ffe6;\">" + text + "</ins>";
+					break;
+				case -1:
+					html[x] = "<del style=\"background:#ffe6e6;\">" + text + "</del>";
+					break;
+				case 0: html[x] = "<span>" + text + "</span>";
+			}
+		}
+		return html.join("");
+	}, diff_match_patch.prototype.diff_text1 = function(diffs) {
+		for (var text = [], x = 0; x < diffs.length; x++) 1 !== diffs[x][0] && (text[x] = diffs[x][1]);
+		return text.join("");
+	}, diff_match_patch.prototype.diff_text2 = function(diffs) {
+		for (var text = [], x = 0; x < diffs.length; x++) -1 !== diffs[x][0] && (text[x] = diffs[x][1]);
+		return text.join("");
+	}, diff_match_patch.prototype.diff_levenshtein = function(diffs) {
+		for (var levenshtein = 0, insertions = 0, deletions = 0, x = 0; x < diffs.length; x++) {
+			var op = diffs[x][0], data = diffs[x][1];
+			switch (op) {
+				case 1:
+					insertions += data.length;
+					break;
+				case -1:
+					deletions += data.length;
+					break;
+				case 0: levenshtein += Math.max(insertions, deletions), insertions = 0, deletions = 0;
+			}
+		}
+		return levenshtein += Math.max(insertions, deletions);
+	}, diff_match_patch.prototype.diff_toDelta = function(diffs) {
+		for (var text = [], x = 0; x < diffs.length; x++) switch (diffs[x][0]) {
+			case 1:
+				text[x] = "+" + encodeURI(diffs[x][1]);
+				break;
+			case -1:
+				text[x] = "-" + diffs[x][1].length;
+				break;
+			case 0: text[x] = "=" + diffs[x][1].length;
+		}
+		return text.join("	").replace(/%20/g, " ");
+	}, diff_match_patch.prototype.diff_fromDelta = function(text1, delta) {
+		for (var diffs = [], diffsLength = 0, pointer = 0, tokens = delta.split(/\t/g), x = 0; x < tokens.length; x++) {
+			var param = tokens[x].substring(1);
+			switch (tokens[x].charAt(0)) {
+				case "+":
+					try {
+						diffs[diffsLength++] = new diff_match_patch.Diff(1, decodeURI(param));
+					} catch (ex) {
+						throw new Error("Illegal escape in diff_fromDelta: " + param);
+					}
+					break;
+				case "-":
+				case "=":
+					var n = parseInt(param, 10);
+					if (isNaN(n) || n < 0) throw new Error("Invalid number in diff_fromDelta: " + param);
+					var text = text1.substring(pointer, pointer += n);
+					"=" == tokens[x].charAt(0) ? diffs[diffsLength++] = new diff_match_patch.Diff(0, text) : diffs[diffsLength++] = new diff_match_patch.Diff(-1, text);
+					break;
+				default: if (tokens[x]) throw new Error("Invalid diff operation in diff_fromDelta: " + tokens[x]);
+			}
+		}
+		if (pointer != text1.length) throw new Error("Delta length (" + pointer + ") does not equal source text length (" + text1.length + ").");
+		return diffs;
+	}, diff_match_patch.prototype.match_main = function(text, pattern, loc) {
+		if (null == text || null == pattern || null == loc) throw new Error("Null input. (match_main)");
+		return loc = Math.max(0, Math.min(loc, text.length)), text == pattern ? 0 : text.length ? text.substring(loc, loc + pattern.length) == pattern ? loc : this.match_bitap_(text, pattern, loc) : -1;
+	}, diff_match_patch.prototype.match_bitap_ = function(text, pattern, loc) {
+		if (pattern.length > this.Match_MaxBits) throw new Error("Pattern too long for this browser.");
+		var s = this.match_alphabet_(pattern), dmp = this;
+		function match_bitapScore_(e, x) {
+			var accuracy = e / pattern.length, proximity = Math.abs(loc - x);
+			return dmp.Match_Distance ? accuracy + proximity / dmp.Match_Distance : proximity ? 1 : accuracy;
+		}
+		var score_threshold = this.Match_Threshold, best_loc = text.indexOf(pattern, loc);
+		-1 != best_loc && (score_threshold = Math.min(match_bitapScore_(0, best_loc), score_threshold), -1 != (best_loc = text.lastIndexOf(pattern, loc + pattern.length)) && (score_threshold = Math.min(match_bitapScore_(0, best_loc), score_threshold)));
+		var bin_min, bin_mid, matchmask = 1 << pattern.length - 1;
+		best_loc = -1;
+		for (var last_rd, bin_max = pattern.length + text.length, d = 0; d < pattern.length; d++) {
+			for (bin_min = 0, bin_mid = bin_max; bin_min < bin_mid;) match_bitapScore_(d, loc + bin_mid) <= score_threshold ? bin_min = bin_mid : bin_max = bin_mid, bin_mid = Math.floor((bin_max - bin_min) / 2 + bin_min);
+			bin_max = bin_mid;
+			var start = Math.max(1, loc - bin_mid + 1), finish = Math.min(loc + bin_mid, text.length) + pattern.length, rd = Array(finish + 2);
+			rd[finish + 1] = (1 << d) - 1;
+			for (var j = finish; j >= start; j--) {
+				var charMatch = s[text.charAt(j - 1)];
+				if (rd[j] = 0 === d ? (rd[j + 1] << 1 | 1) & charMatch : (rd[j + 1] << 1 | 1) & charMatch | (last_rd[j + 1] | last_rd[j]) << 1 | 1 | last_rd[j + 1], rd[j] & matchmask) {
+					var score = match_bitapScore_(d, j - 1);
+					if (score <= score_threshold) {
+						if (score_threshold = score, !((best_loc = j - 1) > loc)) break;
+						start = Math.max(1, 2 * loc - best_loc);
+					}
+				}
+			}
+			if (match_bitapScore_(d + 1, loc) > score_threshold) break;
+			last_rd = rd;
+		}
+		return best_loc;
+	}, diff_match_patch.prototype.match_alphabet_ = function(pattern) {
+		for (var s = {}, i = 0; i < pattern.length; i++) s[pattern.charAt(i)] = 0;
+		for (i = 0; i < pattern.length; i++) s[pattern.charAt(i)] |= 1 << pattern.length - i - 1;
+		return s;
+	}, diff_match_patch.prototype.patch_addContext_ = function(patch, text) {
+		if (0 != text.length) {
+			if (null === patch.start2) throw Error("patch not initialized");
+			for (var pattern = text.substring(patch.start2, patch.start2 + patch.length1), padding = 0; text.indexOf(pattern) != text.lastIndexOf(pattern) && pattern.length < this.Match_MaxBits - this.Patch_Margin - this.Patch_Margin;) padding += this.Patch_Margin, pattern = text.substring(patch.start2 - padding, patch.start2 + patch.length1 + padding);
+			padding += this.Patch_Margin;
+			var prefix = text.substring(patch.start2 - padding, patch.start2);
+			prefix && patch.diffs.unshift(new diff_match_patch.Diff(0, prefix));
+			var suffix = text.substring(patch.start2 + patch.length1, patch.start2 + patch.length1 + padding);
+			suffix && patch.diffs.push(new diff_match_patch.Diff(0, suffix)), patch.start1 -= prefix.length, patch.start2 -= prefix.length, patch.length1 += prefix.length + suffix.length, patch.length2 += prefix.length + suffix.length;
+		}
+	}, diff_match_patch.prototype.patch_make = function(a, opt_b, opt_c) {
+		var text1, diffs;
+		if ("string" == typeof a && "string" == typeof opt_b && void 0 === opt_c) text1 = a, (diffs = this.diff_main(text1, opt_b, !0)).length > 2 && (this.diff_cleanupSemantic(diffs), this.diff_cleanupEfficiency(diffs));
+		else if (a && "object" == typeof a && void 0 === opt_b && void 0 === opt_c) diffs = a, text1 = this.diff_text1(diffs);
+		else if ("string" == typeof a && opt_b && "object" == typeof opt_b && void 0 === opt_c) text1 = a, diffs = opt_b;
+		else {
+			if ("string" != typeof a || "string" != typeof opt_b || !opt_c || "object" != typeof opt_c) throw new Error("Unknown call format to patch_make.");
+			text1 = a, diffs = opt_c;
+		}
+		if (0 === diffs.length) return [];
+		for (var patches = [], patch = new diff_match_patch.patch_obj(), patchDiffLength = 0, char_count1 = 0, char_count2 = 0, prepatch_text = text1, postpatch_text = text1, x = 0; x < diffs.length; x++) {
+			var diff_type = diffs[x][0], diff_text = diffs[x][1];
+			switch (patchDiffLength || 0 === diff_type || (patch.start1 = char_count1, patch.start2 = char_count2), diff_type) {
+				case 1:
+					patch.diffs[patchDiffLength++] = diffs[x], patch.length2 += diff_text.length, postpatch_text = postpatch_text.substring(0, char_count2) + diff_text + postpatch_text.substring(char_count2);
+					break;
+				case -1:
+					patch.length1 += diff_text.length, patch.diffs[patchDiffLength++] = diffs[x], postpatch_text = postpatch_text.substring(0, char_count2) + postpatch_text.substring(char_count2 + diff_text.length);
+					break;
+				case 0: diff_text.length <= 2 * this.Patch_Margin && patchDiffLength && diffs.length != x + 1 ? (patch.diffs[patchDiffLength++] = diffs[x], patch.length1 += diff_text.length, patch.length2 += diff_text.length) : diff_text.length >= 2 * this.Patch_Margin && patchDiffLength && (this.patch_addContext_(patch, prepatch_text), patches.push(patch), patch = new diff_match_patch.patch_obj(), patchDiffLength = 0, prepatch_text = postpatch_text, char_count1 = char_count2);
+			}
+			1 !== diff_type && (char_count1 += diff_text.length), -1 !== diff_type && (char_count2 += diff_text.length);
+		}
+		return patchDiffLength && (this.patch_addContext_(patch, prepatch_text), patches.push(patch)), patches;
+	}, diff_match_patch.prototype.patch_deepCopy = function(patches) {
+		for (var patchesCopy = [], x = 0; x < patches.length; x++) {
+			var patch = patches[x], patchCopy = new diff_match_patch.patch_obj();
+			patchCopy.diffs = [];
+			for (var y = 0; y < patch.diffs.length; y++) patchCopy.diffs[y] = new diff_match_patch.Diff(patch.diffs[y][0], patch.diffs[y][1]);
+			patchCopy.start1 = patch.start1, patchCopy.start2 = patch.start2, patchCopy.length1 = patch.length1, patchCopy.length2 = patch.length2, patchesCopy[x] = patchCopy;
+		}
+		return patchesCopy;
+	}, diff_match_patch.prototype.patch_apply = function(patches, text) {
+		if (0 == patches.length) return [text, []];
+		patches = this.patch_deepCopy(patches);
+		var nullPadding = this.patch_addPadding(patches);
+		text = nullPadding + text + nullPadding, this.patch_splitMax(patches);
+		for (var delta = 0, results = [], x = 0; x < patches.length; x++) {
+			var start_loc, text2, expected_loc = patches[x].start2 + delta, text1 = this.diff_text1(patches[x].diffs), end_loc = -1;
+			if (text1.length > this.Match_MaxBits ? -1 != (start_loc = this.match_main(text, text1.substring(0, this.Match_MaxBits), expected_loc)) && (-1 == (end_loc = this.match_main(text, text1.substring(text1.length - this.Match_MaxBits), expected_loc + text1.length - this.Match_MaxBits)) || start_loc >= end_loc) && (start_loc = -1) : start_loc = this.match_main(text, text1, expected_loc), -1 == start_loc) results[x] = !1, delta -= patches[x].length2 - patches[x].length1;
+			else if (results[x] = !0, delta = start_loc - expected_loc, text1 == (text2 = -1 == end_loc ? text.substring(start_loc, start_loc + text1.length) : text.substring(start_loc, end_loc + this.Match_MaxBits))) text = text.substring(0, start_loc) + this.diff_text2(patches[x].diffs) + text.substring(start_loc + text1.length);
+			else {
+				var diffs = this.diff_main(text1, text2, !1);
+				if (text1.length > this.Match_MaxBits && this.diff_levenshtein(diffs) / text1.length > this.Patch_DeleteThreshold) results[x] = !1;
+				else {
+					this.diff_cleanupSemanticLossless(diffs);
+					for (var index2, index1 = 0, y = 0; y < patches[x].diffs.length; y++) {
+						var mod = patches[x].diffs[y];
+						0 !== mod[0] && (index2 = this.diff_xIndex(diffs, index1)), 1 === mod[0] ? text = text.substring(0, start_loc + index2) + mod[1] + text.substring(start_loc + index2) : -1 === mod[0] && (text = text.substring(0, start_loc + index2) + text.substring(start_loc + this.diff_xIndex(diffs, index1 + mod[1].length))), -1 !== mod[0] && (index1 += mod[1].length);
+					}
+				}
+			}
+		}
+		return [text = text.substring(nullPadding.length, text.length - nullPadding.length), results];
+	}, diff_match_patch.prototype.patch_addPadding = function(patches) {
+		for (var paddingLength = this.Patch_Margin, nullPadding = "", x = 1; x <= paddingLength; x++) nullPadding += String.fromCharCode(x);
+		for (x = 0; x < patches.length; x++) patches[x].start1 += paddingLength, patches[x].start2 += paddingLength;
+		var patch = patches[0], diffs = patch.diffs;
+		if (0 == diffs.length || 0 != diffs[0][0]) diffs.unshift(new diff_match_patch.Diff(0, nullPadding)), patch.start1 -= paddingLength, patch.start2 -= paddingLength, patch.length1 += paddingLength, patch.length2 += paddingLength;
+		else if (paddingLength > diffs[0][1].length) {
+			var extraLength = paddingLength - diffs[0][1].length;
+			diffs[0][1] = nullPadding.substring(diffs[0][1].length) + diffs[0][1], patch.start1 -= extraLength, patch.start2 -= extraLength, patch.length1 += extraLength, patch.length2 += extraLength;
+		}
+		if (0 == (diffs = (patch = patches[patches.length - 1]).diffs).length || 0 != diffs[diffs.length - 1][0]) diffs.push(new diff_match_patch.Diff(0, nullPadding)), patch.length1 += paddingLength, patch.length2 += paddingLength;
+		else if (paddingLength > diffs[diffs.length - 1][1].length) {
+			extraLength = paddingLength - diffs[diffs.length - 1][1].length;
+			diffs[diffs.length - 1][1] += nullPadding.substring(0, extraLength), patch.length1 += extraLength, patch.length2 += extraLength;
+		}
+		return nullPadding;
+	}, diff_match_patch.prototype.patch_splitMax = function(patches) {
+		for (var patch_size = this.Match_MaxBits, x = 0; x < patches.length; x++) if (!(patches[x].length1 <= patch_size)) {
+			var bigpatch = patches[x];
+			patches.splice(x--, 1);
+			for (var start1 = bigpatch.start1, start2 = bigpatch.start2, precontext = ""; 0 !== bigpatch.diffs.length;) {
+				var patch = new diff_match_patch.patch_obj(), empty = !0;
+				for (patch.start1 = start1 - precontext.length, patch.start2 = start2 - precontext.length, "" !== precontext && (patch.length1 = patch.length2 = precontext.length, patch.diffs.push(new diff_match_patch.Diff(0, precontext))); 0 !== bigpatch.diffs.length && patch.length1 < patch_size - this.Patch_Margin;) {
+					var diff_type = bigpatch.diffs[0][0], diff_text = bigpatch.diffs[0][1];
+					1 === diff_type ? (patch.length2 += diff_text.length, start2 += diff_text.length, patch.diffs.push(bigpatch.diffs.shift()), empty = !1) : -1 === diff_type && 1 == patch.diffs.length && 0 == patch.diffs[0][0] && diff_text.length > 2 * patch_size ? (patch.length1 += diff_text.length, start1 += diff_text.length, empty = !1, patch.diffs.push(new diff_match_patch.Diff(diff_type, diff_text)), bigpatch.diffs.shift()) : (diff_text = diff_text.substring(0, patch_size - patch.length1 - this.Patch_Margin), patch.length1 += diff_text.length, start1 += diff_text.length, 0 === diff_type ? (patch.length2 += diff_text.length, start2 += diff_text.length) : empty = !1, patch.diffs.push(new diff_match_patch.Diff(diff_type, diff_text)), diff_text == bigpatch.diffs[0][1] ? bigpatch.diffs.shift() : bigpatch.diffs[0][1] = bigpatch.diffs[0][1].substring(diff_text.length));
+				}
+				precontext = (precontext = this.diff_text2(patch.diffs)).substring(precontext.length - this.Patch_Margin);
+				var postcontext = this.diff_text1(bigpatch.diffs).substring(0, this.Patch_Margin);
+				"" !== postcontext && (patch.length1 += postcontext.length, patch.length2 += postcontext.length, 0 !== patch.diffs.length && 0 === patch.diffs[patch.diffs.length - 1][0] ? patch.diffs[patch.diffs.length - 1][1] += postcontext : patch.diffs.push(new diff_match_patch.Diff(0, postcontext))), empty || patches.splice(++x, 0, patch);
+			}
+		}
+	}, diff_match_patch.prototype.patch_toText = function(patches) {
+		for (var text = [], x = 0; x < patches.length; x++) text[x] = patches[x];
+		return text.join("");
+	}, diff_match_patch.prototype.patch_fromText = function(textline) {
+		var patches = [];
+		if (!textline) return patches;
+		for (var text = textline.split("\n"), textPointer = 0, patchHeader = /^@@ -(\d+),?(\d*) \+(\d+),?(\d*) @@$/; textPointer < text.length;) {
+			var m = text[textPointer].match(patchHeader);
+			if (!m) throw new Error("Invalid patch string: " + text[textPointer]);
+			var patch = new diff_match_patch.patch_obj();
+			for (patches.push(patch), patch.start1 = parseInt(m[1], 10), "" === m[2] ? (patch.start1--, patch.length1 = 1) : "0" == m[2] ? patch.length1 = 0 : (patch.start1--, patch.length1 = parseInt(m[2], 10)), patch.start2 = parseInt(m[3], 10), "" === m[4] ? (patch.start2--, patch.length2 = 1) : "0" == m[4] ? patch.length2 = 0 : (patch.start2--, patch.length2 = parseInt(m[4], 10)), textPointer++; textPointer < text.length;) {
+				var sign = text[textPointer].charAt(0);
+				try {
+					var line = decodeURI(text[textPointer].substring(1));
+				} catch (ex) {
+					throw new Error("Illegal escape in patch_fromText: " + line);
+				}
+				if ("-" == sign) patch.diffs.push(new diff_match_patch.Diff(-1, line));
+				else if ("+" == sign) patch.diffs.push(new diff_match_patch.Diff(1, line));
+				else if (" " == sign) patch.diffs.push(new diff_match_patch.Diff(0, line));
+				else {
+					if ("@" == sign) break;
+					if ("" !== sign) throw new Error("Invalid patch mode \"" + sign + "\" in: " + line);
+				}
+				textPointer++;
+			}
+		}
+		return patches;
+	}, (diff_match_patch.patch_obj = function() {
+		this.diffs = [], this.start1 = null, this.start2 = null, this.length1 = 0, this.length2 = 0;
+	}).prototype.toString = function() {
+		for (var op, text = ["@@ -" + (0 === this.length1 ? this.start1 + ",0" : 1 == this.length1 ? this.start1 + 1 : this.start1 + 1 + "," + this.length1) + " +" + (0 === this.length2 ? this.start2 + ",0" : 1 == this.length2 ? this.start2 + 1 : this.start2 + 1 + "," + this.length2) + " @@\n"], x = 0; x < this.diffs.length; x++) {
+			switch (this.diffs[x][0]) {
+				case 1:
+					op = "+";
+					break;
+				case -1:
+					op = "-";
+					break;
+				case 0: op = " ";
+			}
+			text[x + 1] = op + encodeURI(this.diffs[x][1]) + "\n";
+		}
+		return text.join("").replace(/%20/g, " ");
+	}, module.exports = diff_match_patch, module.exports.diff_match_patch = diff_match_patch, module.exports.DIFF_DELETE = -1, module.exports.DIFF_INSERT = 1, module.exports.DIFF_EQUAL = 0;
+}));
+diffMatchPatch.DIFF_EQUAL;
+diffMatchPatch.DIFF_DELETE;
+diffMatchPatch.DIFF_INSERT;
+// src/file-diff-view.tsx
+var en$2 = {
+	view: "Show changes as",
+	blocks: "Blocks",
+	text: "Text"
+};
+var ja$2 = {
+	view: "変更の表示",
+	blocks: "ブロック",
+	text: "テキスト"
+};
+/** Project sources are the files the panel opens as projects. */
+var isProjectSource = (path) => path.split("/").pop() === "project.source.json";
+/**
+* Shows one changed file. Project sources are compared as blocks by default, with their text diff one switch away.
+*/
+function FileDiffView({ change, diff, labels, locale, renderBlock, loadAsset }) {
+	var _change$oldMode, _change$newMode;
+	const [view, setView] = useState("blocks");
+	const names = locale.startsWith("ja") ? ja$2 : en$2;
+	const parsed = (diff === null || diff === void 0 ? void 0 : diff.patch) ? parseDiff(diff.patch)[0] : null;
+	const text = /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement("p", null, labels.mode, " · ", ((_change$oldMode = change.oldMode) === null || _change$oldMode === void 0 ? void 0 : _change$oldMode.toString(8)) || "—", " → ", ((_change$newMode = change.newMode) === null || _change$newMode === void 0 ? void 0 : _change$newMode.toString(8)) || "—"), diff && /* @__PURE__ */ React.createElement("p", null, diff.beforeSize, " → ", diff.afterSize, " ", labels.bytes), (diff === null || diff === void 0 ? void 0 : diff.binary) && /* @__PURE__ */ React.createElement("p", null, labels.binary), (diff === null || diff === void 0 ? void 0 : diff.tooLarge) && /* @__PURE__ */ React.createElement("p", null, labels.large), parsed && /* @__PURE__ */ React.createElement(index, {
+		viewType: "unified",
+		diffType: parsed.type,
+		hunks: parsed.hunks
+	}, (hunks) => hunks.map((hunk) => /* @__PURE__ */ React.createElement(Hunk, {
+		key: hunk.content,
+		hunk
+	}))), diff && !diff.binary && !diff.tooLarge && !(parsed === null || parsed === void 0 ? void 0 : parsed.hunks.length) && /* @__PURE__ */ React.createElement("p", null, labels.unchanged));
+	const sources = renderBlock && (diff === null || diff === void 0 ? void 0 : diff.text) && isProjectSource(change.path) ? diff.text : null;
+	return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement("h3", null, change.path), sources && /* @__PURE__ */ React.createElement("div", {
+		className: "twgit-view-switch",
+		role: "group",
+		"aria-label": names.view
+	}, ["blocks", "text"].map((mode) => /* @__PURE__ */ React.createElement("button", {
+		key: mode,
+		type: "button",
+		"aria-pressed": view === mode,
+		"data-git-view": mode,
+		onClick: () => setView(mode)
+	}, names[mode]))), sources && view === "blocks" ? /* @__PURE__ */ React.createElement(ProjectSourceComparison, {
+		renderBlock,
+		locale,
+		fallback: text,
+		loadAsset,
+		before: change.before === null ? null : sources.before,
+		after: change.after === null ? null : sources.after
+	}) : text);
+}
+// src/messages.ts
+var messages = {
+	en: {
+		pullRequests: "Pull requests",
+		localChanges: "Local changes",
+		title: "Local Git",
+		menu: "Local Git…",
+		close: "Close",
+		choose: "Choose Repository…",
+		refresh: "Refresh",
+		empty: "Choose an existing Git repository to inspect its files and history.",
+		repository: "Repository",
+		project: "Project folder",
+		none: "No project selected",
+		root: "Repository root",
+		open: "Open This Project",
+		reload: "Reload Project",
+		up: "Parent folder",
+		browse: "Choose a project inside this repository",
+		replace: "Replace the open project and discard its unsaved changes?",
+		dirty: "The Editor has unsaved changes.",
+		saved: "The Editor has no unsaved changes.",
+		staged: "Staged",
+		unstaged: "Unstaged",
+		untracked: "Untracked",
+		commit: "Commit changes",
+		history: "History",
+		worktree: "Working tree",
+		clean: "No changes in the selected folder.",
+		branches: "Local branches",
+		unborn: "No commits yet",
+		detached: "Detached HEAD",
+		select: "Select a file to view its diff.",
+		binary: "Binary asset",
+		large: "Text preview exceeds its display limit.",
+		bytes: "bytes",
+		mode: "Git file mode",
+		permissions: "Working-tree executable permission changes are unavailable in the browser.",
+		unchanged: "The text is unchanged.",
+		loading: "Reading repository…",
+		invalid: "Choose a repository with a .git directory, and a project inside that repository.",
+		changed: "Files or Git state changed while reading. Refresh to read the current state.",
+		outdated: "The repository changed outside the Editor. Refresh to read the current state.",
+		unsupported: "This repository contains an entry the browser cannot represent.",
+		pullUnsafe: "Stop the project and clear unsaved or local Git changes before pulling.",
+		diverged: "Pull requires a fast-forward. Your local branch and files are intact.",
+		session: "Reconnect GitHub for this repository and requested permission.",
+		pushUnknown: "The push result is unknown. Fetch and check the remote branch before retrying.",
+		pushRefresh: "The push succeeded. Fetch to refresh the local tracking branch.",
+		rollbackFailed: "Git could not restore all local changes. Check the working tree and Git status.",
+		remoteFailed: "The Git operation failed. Check the selected connection and retry.",
+		remoteDone: "Git operation completed.",
+		pulledProject: "Pull completed. Use Reload Project to open the updated files.",
+		confirmPush: "Push the current branch to its GitHub origin?",
+		failed: "Could not read the repository. Check folder access and refresh."
+	},
+	ja: {
+		pullRequests: "プルリクエスト",
+		localChanges: "ローカルの変更",
+		title: "ローカル Git",
+		menu: "ローカル Git…",
+		close: "閉じる",
+		choose: "リポジトリを選択…",
+		refresh: "再取得",
+		empty: "既存の Git リポジトリを選び、ファイルの状態と履歴を確認できます。",
+		repository: "リポジトリ",
+		project: "作品フォルダ",
+		none: "作品は未選択",
+		root: "リポジトリルート",
+		open: "この作品を開く",
+		reload: "作品を再読込",
+		up: "上のフォルダ",
+		browse: "リポジトリ内の作品を選択",
+		replace: "未保存の変更を破棄して、別の作品を開きますか？",
+		dirty: "Editor に未保存の変更があります。",
+		saved: "Editor に未保存の変更はありません。",
+		staged: "ステージ済み",
+		unstaged: "未ステージ",
+		untracked: "未追跡",
+		commit: "コミットの変更",
+		history: "履歴",
+		worktree: "作業ツリー",
+		clean: "対象フォルダに変更はありません。",
+		branches: "ローカルブランチ",
+		unborn: "コミットはまだありません",
+		detached: "ブランチ未選択の HEAD",
+		select: "ファイルを選ぶと差分を表示します。",
+		binary: "バイナリアセット",
+		large: "テキスト差分の表示上限を超えています。",
+		bytes: "バイト",
+		mode: "Git のファイルモード",
+		permissions: "作業ツリーの実行権限の変更はブラウザーから確認できません。",
+		unchanged: "テキストに変更はありません。",
+		loading: "リポジトリを読込中…",
+		invalid: ".git ディレクトリを持つリポジトリと、その配下の作品を選んでください。",
+		changed: "読込中にファイルまたは Git の状態が変わりました。再取得してください。",
+		outdated: "Editor の外でリポジトリが変更されました。再取得すると最新の状態を読み込みます。",
+		unsupported: "ブラウザーで扱えない種類の Git エントリーがあります。",
+		pullUnsafe: "pull の前に実行を止め、未保存編集とローカルの Git 変更を解消してください。",
+		diverged: "fast-forward できません。ローカルブランチとファイルは保持されています。",
+		session: "このリポジトリと操作に必要な権限で GitHub に接続してください。",
+		pushUnknown: "push の結果が不明です。再試行する前に fetch でリモートブランチを確認してください。",
+		pushRefresh: "push は成功しました。fetch でローカルの追跡ブランチを更新してください。",
+		rollbackFailed: "Git がローカルの変更をすべて復元できませんでした。作業ツリーと Git の状態を確認してください。",
+		remoteFailed: "Git 操作に失敗しました。選択中の接続を確認して再試行してください。",
+		remoteDone: "Git 操作が完了しました。",
+		pulledProject: "pull が完了しました。「作品を再読込」で更新済みのファイルを開けます。",
+		confirmPush: "現在のブランチを GitHub の origin に push しますか？",
+		failed: "リポジトリを読み込めませんでした。フォルダへのアクセスを確認し、再取得してください。"
+	}
+};
+var labelsFor = (locale) => locale.startsWith("ja") ? messages.ja : messages.en;
+// src/connection-settings.tsx
+var en$1 = {
+	title: "GitHub connection",
+	mode: "Connection mode",
+	select: "Choose a connection",
+	desktop: "Desktop local",
+	cloudflare: "Cloudflare",
+	proxy: "Proxy",
+	account: "Account",
+	"disconnected": "Disconnected",
+	"connecting": "Waiting for GitHub",
+	"connected": "Connected",
+	"reauth-required": "Sign in again",
+	connect: "Connect to GitHub",
+	open: "Open GitHub authorization",
+	check: "Check connection",
+	disconnect: "Disconnect",
+	noRemote: "Choose a repository with a GitHub HTTPS origin.",
+	unavailable: "No GitHub connection is configured.",
+	changed: "Switching disconnects the current session.",
+	error: "GitHub connection failed. Retry using the selected connection.",
+	invalid: "The selected repository needs a GitHub HTTPS origin.",
+	allowPush: "Authorize push",
+	fetch: "Fetch",
+	pull: "Pull (fast-forward only)",
+	push: "Push"
+};
+var ja$1 = {
+	title: "GitHub 接続",
+	mode: "接続方式",
+	select: "接続方式を選択",
+	desktop: "Desktop ローカル",
+	cloudflare: "Cloudflare",
+	proxy: "プロキシ",
+	account: "アカウント",
+	"disconnected": "未接続",
+	"connecting": "GitHub の認証待ち",
+	"connected": "接続済み",
+	"reauth-required": "再認証が必要",
+	connect: "GitHub に接続",
+	open: "GitHub の認証を開く",
+	check: "接続を確認",
+	disconnect: "切断",
+	noRemote: "GitHub の HTTPS リモート origin があるリポジトリを選択してください。",
+	unavailable: "GitHub 接続先が設定されていません。",
+	changed: "方式を切り替えると現在のセッションを切断します。",
+	error: "GitHub 接続に失敗しました。選択中の方式で再試行してください。",
+	invalid: "選択したリポジトリには GitHub の HTTPS リモート origin が必要です。",
+	allowPush: "push を許可する",
+	fetch: "Fetch",
+	pull: "Pull（fast-forward のみ）",
+	push: "Push"
+};
+function ConnectionSettings({ settings, locale, readOrigin, runOperation }) {
+	const labels = locale.startsWith("ja") ? ja$1 : en$1;
+	const [, update] = useState(0);
+	const [busy, setBusy] = useState(false);
+	const [allowPush, setAllowPush] = useState(false);
+	const [error, setError] = useState(null);
+	const active = useRef(true);
+	useEffect(() => {
+		active.current = true;
+		return () => {
+			active.current = false;
+		};
+	}, []);
+	const run = async (action) => {
+		if (busy) return;
+		setBusy(true);
+		setError(null);
+		try {
+			await action();
+		} catch (failure) {
+			if (active.current) setError(failure.message === "INVALID_REMOTE" ? "invalid" : "error");
+		} finally {
+			if (active.current) {
+				setBusy(false);
+				update((value) => value + 1);
+			}
+		}
+	};
+	const { mode, state, proxyOrigin, authorization, write } = settings.getView();
+	const connect = () => run(async () => {
+		const remote = await (readOrigin === null || readOrigin === void 0 ? void 0 : readOrigin());
+		if (!remote) throw new Error("INVALID_REMOTE");
+		await settings.connect(remote, allowPush);
+	});
+	return /* @__PURE__ */ React.createElement("details", { className: "twgit-connection" }, /* @__PURE__ */ React.createElement("summary", null, labels.title), !settings.modes.length ? /* @__PURE__ */ React.createElement("p", null, labels.unavailable) : /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement("label", null, labels.mode, " ", /* @__PURE__ */ React.createElement("select", {
+		value: mode !== null && mode !== void 0 ? mode : "",
+		disabled: busy,
+		onChange: (event) => {
+			const choice = event.currentTarget.value;
+			run(() => settings.select(choice));
+		}
+	}, /* @__PURE__ */ React.createElement("option", {
+		value: "",
+		disabled: true
+	}, labels.select), settings.modes.map((choice) => /* @__PURE__ */ React.createElement("option", {
+		key: choice,
+		value: choice
+	}, labels[choice])))), /* @__PURE__ */ React.createElement("p", null, labels.changed), /* @__PURE__ */ React.createElement("p", {
+		"data-git-connection-state": "",
+		role: "status"
+	}, labels[state.status]), proxyOrigin && /* @__PURE__ */ React.createElement("p", null, labels.proxy, " · ", /* @__PURE__ */ React.createElement("code", null, proxyOrigin)), state.account && /* @__PURE__ */ React.createElement("p", null, labels.account, " · ", state.account.login), !readOrigin && /* @__PURE__ */ React.createElement("p", null, labels.noRemote), mode && /* @__PURE__ */ React.createElement(React.Fragment, null, runOperation && /* @__PURE__ */ React.createElement("label", null, /* @__PURE__ */ React.createElement("input", {
+		type: "checkbox",
+		checked: allowPush,
+		disabled: busy || state.status === "connecting" || state.status === "connected",
+		onChange: (event) => setAllowPush(event.currentTarget.checked)
+	}), " ", labels.allowPush), /* @__PURE__ */ React.createElement("button", {
+		disabled: busy || !readOrigin || state.status === "connecting" || state.status === "connected",
+		onClick: connect
+	}, labels.connect), authorization && /* @__PURE__ */ React.createElement("p", null, authorization.userCode && /* @__PURE__ */ React.createElement("code", null, authorization.userCode, " "), /* @__PURE__ */ React.createElement("a", {
+		href: authorization.url,
+		target: "_blank",
+		rel: "noopener noreferrer"
+	}, labels.open)), state.status !== "disconnected" && /* @__PURE__ */ React.createElement("button", {
+		disabled: busy,
+		onClick: () => void run(settings.refresh)
+	}, labels.check), /* @__PURE__ */ React.createElement("button", {
+		disabled: busy,
+		onClick: () => void run(settings.disconnect)
+	}, labels.disconnect), runOperation && state.status === "connected" && [
+		"fetch",
+		"pull",
+		"push"
+	].map((operation) => /* @__PURE__ */ React.createElement("button", {
+		key: operation,
+		disabled: busy || !readOrigin || operation === "push" && !write,
+		onClick: () => void run(() => runOperation(operation))
+	}, labels[operation]))), error && /* @__PURE__ */ React.createElement("p", {
+		className: "twgit-error",
+		role: "alert"
+	}, labels[error])));
+}
+// src/pull-request-panel.tsx
+var en = {
+	title: "Pull requests",
+	number: "Pull request number",
+	openNumber: "Open pull request",
+	open: "Open",
+	closed: "Closed",
+	merged: "Merged",
+	draft: "Draft",
+	prev: "Previous page",
+	next: "Next page",
+	empty: "No pull requests on this page.",
+	loading: "Reading GitHub…",
+	select: "Select a pull request to review its changes.",
+	onGitHub: "Open on GitHub",
+	noOrigin: "Choose a repository whose origin is on GitHub.",
+	unavailable: "GitHub could not read this repository or pull request. The panel supports public repositories.",
+	rateLimit: "The public GitHub API rate limit was reached. Try again after the limit resets.",
+	failed: "Could not read GitHub. Try again.",
+	changed: "The pull request changed while it was being read. Open it again.",
+	tooManyFiles: "GitHub only returns the first 3,000 changed files. This pull request exceeds that limit."
+};
+var ja = {
+	title: "プルリクエスト",
+	number: "プルリクエスト番号",
+	openNumber: "PR を開く",
+	open: "オープン",
+	closed: "クローズ済み",
+	merged: "マージ済み",
+	draft: "ドラフト",
+	prev: "前のページ",
+	next: "次のページ",
+	empty: "このページにプルリクエストはありません。",
+	loading: "GitHub から取得中…",
+	select: "プルリクエストを選ぶと差分内容を確認できます。",
+	onGitHub: "GitHub で開く",
+	noOrigin: "GitHub のリポジトリを origin に設定した作業フォルダを選んでください。",
+	unavailable: "GitHub のリポジトリまたは PR を取得できません。公開リポジトリに対応しています。",
+	rateLimit: "公開 GitHub API の利用上限に達しました。上限の解除後に再試行してください。",
+	failed: "GitHub から取得できませんでした。再試行してください。",
+	changed: "取得中にプルリクエストが更新されました。もう一度開いてください。",
+	tooManyFiles: "変更ファイルが GitHub API の取得上限である 3,000 件を超えています。"
+};
+function errorMessage(error, labels) {
+	return error instanceof PullRequestError ? labels[error.code] : labels.failed;
+}
+function PullRequests({ name, labels, locale, renderBlock }) {
+	const client = useMemo(() => createGitHubPullRequests(name), [name]);
+	const [page, setPage] = useState(1);
+	const [listing, setListing] = useState();
+	const [input, setInput] = useState("");
+	const [selection, setSelection] = useState();
+	const [loaded, setLoaded] = useState();
+	const list = (listing === null || listing === void 0 ? void 0 : listing.page) === page ? listing.result : void 0;
+	const detail = (loaded === null || loaded === void 0 ? void 0 : loaded.selection) === selection ? loaded === null || loaded === void 0 ? void 0 : loaded.result : void 0;
+	useEffect(() => {
+		const controller = new AbortController();
+		setListing(void 0);
+		client.list(page, controller.signal).then((data) => {
+			if (!controller.signal.aborted) setListing({
+				page,
+				result: { data }
+			});
+		}, (error) => {
+			if (!controller.signal.aborted) setListing({
+				page,
+				result: { error: errorMessage(error, labels) }
+			});
+		});
+		return () => controller.abort();
+	}, [
+		client,
+		page,
+		labels
+	]);
+	useEffect(() => {
+		if (!selection) return;
+		const controller = new AbortController();
+		client.load(selection.number, controller.signal).then((data) => {
+			if (!controller.signal.aborted) setLoaded({
+				selection,
+				result: { data }
+			});
+		}, (error) => {
+			if (!controller.signal.aborted) setLoaded({
+				selection,
+				result: { error: errorMessage(error, labels) }
+			});
+		});
+		return () => controller.abort();
+	}, [
+		client,
+		selection,
+		labels
+	]);
+	const choose = (number) => {
+		if (!Number.isSafeInteger(number) || number < 1) return;
+		setSelection({ number });
+		setInput(String(number));
+	};
+	const pr = detail === null || detail === void 0 ? void 0 : detail.data;
+	return /* @__PURE__ */ React.createElement("div", { className: "twgit-content" }, /* @__PURE__ */ React.createElement("aside", null, /* @__PURE__ */ React.createElement("h3", null, labels.title), /* @__PURE__ */ React.createElement("p", null, name), /* @__PURE__ */ React.createElement("form", {
+		className: "twgit-pr-number",
+		onSubmit: (event) => {
+			event.preventDefault();
+			choose(Number(input));
+		}
+	}, /* @__PURE__ */ React.createElement("label", null, labels.number, /* @__PURE__ */ React.createElement("input", {
+		type: "number",
+		required: true,
+		min: 1,
+		max: Number.MAX_SAFE_INTEGER,
+		value: input,
+		onChange: (event) => setInput(event.currentTarget.value)
+	})), /* @__PURE__ */ React.createElement("button", { type: "submit" }, labels.openNumber)), !list && /* @__PURE__ */ React.createElement("p", { role: "status" }, labels.loading), (list === null || list === void 0 ? void 0 : list.error) && /* @__PURE__ */ React.createElement("p", { role: "alert" }, list.error), (list === null || list === void 0 ? void 0 : list.data) && /* @__PURE__ */ React.createElement(React.Fragment, null, !list.data.items.length && /* @__PURE__ */ React.createElement("p", null, labels.empty), /* @__PURE__ */ React.createElement("ul", null, list.data.items.map((item) => /* @__PURE__ */ React.createElement("li", { key: item.number }, /* @__PURE__ */ React.createElement("button", {
+		className: "twgit-file",
+		type: "button",
+		"aria-pressed": (selection === null || selection === void 0 ? void 0 : selection.number) === item.number,
+		onClick: () => choose(item.number)
+	}, "#", item.number, " ", item.title)))), /* @__PURE__ */ React.createElement("div", { className: "twgit-pr-paging" }, /* @__PURE__ */ React.createElement("button", {
+		type: "button",
+		disabled: page === 1,
+		onClick: () => setPage(page - 1)
+	}, labels.prev), /* @__PURE__ */ React.createElement("button", {
+		type: "button",
+		disabled: !list.data.more,
+		onClick: () => setPage(page + 1)
+	}, labels.next)))), /* @__PURE__ */ React.createElement("main", { className: "twgit-diff" }, !selection && /* @__PURE__ */ React.createElement("p", null, labels.select), selection && !detail && /* @__PURE__ */ React.createElement("p", { role: "status" }, labels.loading), (detail === null || detail === void 0 ? void 0 : detail.error) && /* @__PURE__ */ React.createElement("p", { role: "alert" }, detail.error), pr && /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement("p", { className: "twgit-pr-revision" }, /* @__PURE__ */ React.createElement("strong", null, "#", pr.number, " · ", labels[pr.state]), pr.author && /* @__PURE__ */ React.createElement("span", null, pr.author), /* @__PURE__ */ React.createElement("code", { title: pr.head.sha }, pr.head.ref, " → ", pr.base.ref), /* @__PURE__ */ React.createElement("a", {
+		href: pr.url,
+		target: "_blank",
+		rel: "noreferrer"
+	}, labels.onGitHub)), /* @__PURE__ */ React.createElement(ProjectSourceReview, {
+		title: pr.title,
+		description: pr.description,
+		files: pr.files,
+		renderBlock,
+		locale
+	}))));
+}
+function PullRequestReviewPanel({ repository, locale, renderBlock }) {
+	const labels = locale.startsWith("ja") ? ja : en;
+	const [origin, setOrigin] = useState();
+	useEffect(() => {
+		let active = true;
+		repository.readOrigin().then((value) => {
+			if (active) setOrigin({
+				repository,
+				name: gitHubRepositoryFromOrigin(value)
+			});
+		}, () => {
+			if (active) setOrigin({
+				repository,
+				name: null,
+				failed: true
+			});
+		});
+		return () => {
+			active = false;
+		};
+	}, [repository]);
+	if ((origin === null || origin === void 0 ? void 0 : origin.repository) !== repository) return /* @__PURE__ */ React.createElement("p", {
+		role: "status",
+		className: "twgit-context"
+	}, labels.loading);
+	if (!origin.name) return /* @__PURE__ */ React.createElement("p", {
+		className: "twgit-context",
+		role: "status"
+	}, origin.failed ? labels.failed : labels.noOrigin);
+	return /* @__PURE__ */ React.createElement(PullRequests, {
+		key: origin.name,
+		name: origin.name,
+		labels,
+		locale,
+		renderBlock
+	});
+}
+// src/index.tsx
+init_objectSpread2();
+var initial = {
+	repository: null,
+	snapshot: null,
+	project: null,
+	browser: null,
+	changes: [],
+	selected: null,
+	diff: null,
+	commit: null,
+	error: null,
+	busy: false
+};
+var controllers = /* @__PURE__ */ new WeakMap();
+var watchInterval = 2e3;
+function GitPanel({ document, host, controller }) {
+	var _state$repository, _state$snapshot, _state$snapshot2, _state$snapshot3, _state$snapshot4, _state$snapshot5;
+	const [visible, setVisible] = useState(false);
+	const [review, setReview] = useState(false);
+	const [locale, setLocale] = useState(document.documentElement.lang || "en");
+	const [dirty, setDirty] = useState(host.isProjectDirty());
+	const [state, setState] = useState(initial);
+	const current = useRef(state);
+	current.current = state;
+	const epoch = useRef(0);
+	const running = useRef(false);
+	const refreshPending = useRef(false);
+	const remoteRequest = useRef();
+	const alive = useRef(true);
+	const opening = useRef(false);
+	const dialog = useRef(null);
+	const reviewing = useRef(review);
+	reviewing.current = review;
+	const handled = useRef(null);
+	const labels = labelsFor(locale);
+	const background = useRef(null);
+	const run = async (operation, automatic = false) => {
+		if (running.current && !automatic && background.current) await background.current;
+		if (running.current || !alive.current) return;
+		let settle = () => {};
+		if (automatic) background.current = new Promise((resolve) => {
+			settle = resolve;
+		});
+		running.current = true;
+		const ticket = ++epoch.current;
+		setState((previous) => automatic ? _objectSpread2$1(_objectSpread2$1({}, previous), {}, { busy: true }) : _objectSpread2$1(_objectSpread2$1({}, previous), {}, {
+			busy: true,
+			error: null,
+			notice: void 0
+		}));
+		try {
+			const update = await operation();
+			if (epoch.current === ticket) setState((previous) => _objectSpread2$1(_objectSpread2$1(_objectSpread2$1({}, previous), update), {}, { busy: false }));
+		} catch (error) {
+			if (epoch.current !== ticket) return;
+			const code = error instanceof GitPanelError ? error.code : "failed";
+			const message = labels[code] || labels.failed;
+			setState((previous) => _objectSpread2$1(_objectSpread2$1({}, previous), {}, {
+				error: automatic && previous.error ? previous.error : message,
+				busy: false,
+				diff: null
+			}));
+		} finally {
+			running.current = false;
+			if (automatic) {
+				background.current = null;
+				settle();
+			}
+			if (refreshPending.current) {
+				refreshPending.current = false;
+				queueMicrotask(() => void controller.refresh());
+			}
+		}
+	};
+	controller.open = (language) => {
+		setLocale(language);
+		setVisible(true);
+	};
+	controller.refresh = async (automatic = false) => {
+		if (!alive.current || !current.current.repository) return;
+		if (running.current) {
+			if (!automatic) refreshPending.current = true;
+			return;
+		}
+		await run(async () => {
+			const { repository, project } = current.current;
+			const snapshot = await repository.read(project !== null && project !== void 0 ? project : "");
+			return {
+				snapshot,
+				changes: snapshot.changes,
+				selected: null,
+				diff: null,
+				commit: null
+			};
+		}, automatic);
+	};
+	useEffect(() => {
+		var _host$subscribe;
+		alive.current = true;
+		const unsubscribe = (_host$subscribe = host.subscribe) === null || _host$subscribe === void 0 ? void 0 : _host$subscribe.call(host, (event) => {
+			setDirty(host.isProjectDirty());
+			if (event === "loaded" && !opening.current) {
+				epoch.current++;
+				setState((previous) => _objectSpread2$1(_objectSpread2$1({}, previous), {}, {
+					project: null,
+					snapshot: null,
+					changes: [],
+					selected: null,
+					diff: null,
+					commit: null,
+					busy: false
+				}));
+				queueMicrotask(() => void controller.refresh());
+			}
+		});
+		return () => {
+			var _remoteRequest$curren;
+			alive.current = false;
+			epoch.current++;
+			(_remoteRequest$curren = remoteRequest.current) === null || _remoteRequest$curren === void 0 || _remoteRequest$curren.abort();
+			unsubscribe === null || unsubscribe === void 0 || unsubscribe();
+		};
+	}, [host]);
+	useEffect(() => {
+		const repository = state.repository;
+		if (!visible || !repository) return;
+		const view = document.defaultView;
+		let stopped = false;
+		let checking = false;
+		const check = async () => {
+			const { snapshot } = current.current;
+			if (stopped || checking || running.current || document.visibilityState === "hidden" || !snapshot || current.current.repository !== repository) return;
+			checking = true;
+			try {
+				const probe = await repository.probe(snapshot.scope);
+				if (stopped || probe === "locked" || probe === snapshot.probe || probe === handled.current || current.current.snapshot !== snapshot) return;
+				handled.current = probe;
+				const { selected, commit } = current.current;
+				if (selected || commit || reviewing.current) setState((previous) => previous.snapshot === snapshot ? _objectSpread2$1(_objectSpread2$1({}, previous), {}, { notice: labelsFor(locale).outdated }) : previous);
+				else await controller.refresh(true);
+			} catch (_unused) {} finally {
+				checking = false;
+			}
+		};
+		let soon;
+		const schedule = () => {
+			view.clearTimeout(soon);
+			soon = view.setTimeout(() => void check(), 300);
+		};
+		const interval = view.setInterval(() => void check(), watchInterval);
+		const onFocus = () => void check();
+		view.addEventListener("focus", onFocus);
+		document.addEventListener("visibilitychange", onFocus);
+		let observer = null;
+		try {
+			if (view.FileSystemObserver) {
+				observer = new view.FileSystemObserver(schedule);
+				observer.observe(repository.root, { recursive: true }).catch(() => {});
+			}
+		} catch (_unused2) {
+			observer = null;
+		}
+		check();
+		return () => {
+			stopped = true;
+			view.clearInterval(interval);
+			view.clearTimeout(soon);
+			view.removeEventListener("focus", onFocus);
+			document.removeEventListener("visibilitychange", onFocus);
+			observer === null || observer === void 0 || observer.disconnect();
+		};
+	}, [
+		visible,
+		state.repository,
+		locale
+	]);
+	useEffect(() => {
+		var _dialog$current;
+		if (!visible) return;
+		const previous = document.activeElement;
+		(_dialog$current = dialog.current) === null || _dialog$current === void 0 || _dialog$current.focus();
+		return () => {
+			if (previous === null || previous === void 0 ? void 0 : previous.isConnected) previous.focus();
+		};
+	}, [visible]);
+	const chooseRoot = async () => {
+		const view = document.defaultView;
+		await run(async () => {
+			var _host$connectionSetti;
+			let root;
+			try {
+				root = await view.showDirectoryPicker({
+					id: "turbowarp-plus-git-root",
+					mode: "readwrite"
+				});
+			} catch (error) {
+				if (error.name === "AbortError") return {};
+				throw error;
+			}
+			const repository = await openRepository(root);
+			const snapshot = await repository.read();
+			const browser = await repository.browse();
+			await ((_host$connectionSetti = host.connectionSettings) === null || _host$connectionSetti === void 0 ? void 0 : _host$connectionSetti.disconnect());
+			setReview(false);
+			return _objectSpread2$1(_objectSpread2$1({}, initial), {}, {
+				repository,
+				snapshot,
+				browser,
+				changes: snapshot.changes
+			});
+		});
+	};
+	const browse = (path) => run(async () => ({ browser: await state.repository.browse(path) }));
+	const openProject = (path) => run(async () => {
+		const directory = await state.repository.openProject(path);
+		opening.current = true;
+		try {
+			if (await host.openProject(directory, () => document.defaultView.confirm(labels.replace)) === "cancelled") return {};
+		} finally {
+			opening.current = false;
+		}
+		if (!alive.current) return {};
+		setDirty(host.isProjectDirty());
+		setState((previous) => _objectSpread2$1(_objectSpread2$1({}, previous), {}, {
+			project: path,
+			snapshot: null,
+			changes: [],
+			selected: null,
+			diff: null,
+			commit: null
+		}));
+		const snapshot = await state.repository.read(path);
+		return {
+			project: path,
+			snapshot,
+			changes: snapshot.changes,
+			selected: null,
+			diff: null,
+			commit: null
+		};
+	});
+	const selectFile = (selected) => run(async () => ({
+		selected,
+		diff: await state.repository.readDiff(state.snapshot, selected)
+	}));
+	const selectCommit = (commit) => run(async () => ({
+		commit,
+		changes: await state.repository.historyChanges(state.snapshot, commit),
+		selected: null,
+		diff: null
+	}));
+	const remoteOperation = async (operation) => {
+		var _host$connectionSetti2, _document$defaultView;
+		const repository = current.current.repository;
+		const getSession = (_host$connectionSetti2 = host.connectionSettings) === null || _host$connectionSetti2 === void 0 ? void 0 : _host$connectionSetti2.getSession;
+		if (!repository || !getSession) return;
+		if (operation === "push" && !((_document$defaultView = document.defaultView) === null || _document$defaultView === void 0 ? void 0 : _document$defaultView.confirm(labels.confirmPush))) return;
+		await run(async () => {
+			var _current$current$proj;
+			const ticket = epoch.current;
+			const request = new AbortController();
+			remoteRequest.current = request;
+			try {
+				await repository.remoteOperation(operation, getSession, () => {
+					var _host$isProjectRunnin;
+					if (epoch.current !== ticket) throw new GitPanelError("changed");
+					if (operation === "pull" && (host.isProjectDirty() || ((_host$isProjectRunnin = host.isProjectRunning) === null || _host$isProjectRunnin === void 0 ? void 0 : _host$isProjectRunnin.call(host)))) throw new GitPanelError("pullUnsafe");
+				}, request.signal);
+			} finally {
+				remoteRequest.current = void 0;
+			}
+			const snapshot = await repository.read((_current$current$proj = current.current.project) !== null && _current$current$proj !== void 0 ? _current$current$proj : "");
+			return {
+				snapshot,
+				changes: snapshot.changes,
+				selected: null,
+				diff: null,
+				commit: null,
+				notice: operation === "pull" && current.current.project !== null ? labels.pulledProject : labels.remoteDone
+			};
+		});
+	};
+	const focusTrap = (event) => {
+		if (event.key === "Escape") {
+			event.stopPropagation();
+			setVisible(false);
+			return;
+		}
+		if (event.key !== "Tab") return;
+		const items = [...event.currentTarget.querySelectorAll("button:not(:disabled), input:not(:disabled), select:not(:disabled), a[href], summary, [tabindex=\"0\"]")].filter((item) => item.getClientRects().length > 0);
+		const first = items[0], last = items[items.length - 1];
+		if (event.shiftKey && (document.activeElement === first || document.activeElement === event.currentTarget)) {
+			event.preventDefault();
+			last === null || last === void 0 || last.focus();
+		} else if (!event.shiftKey && document.activeElement === last) {
+			event.preventDefault();
+			first === null || first === void 0 || first.focus();
+		}
+	};
+	const loadAsset = useMemo(() => state.repository && state.snapshot && state.selected ? state.repository.assetLoader(state.snapshot, state.selected) : void 0, [
+		state.repository,
+		state.snapshot,
+		state.selected
+	]);
+	if (!visible) return null;
+	const groups = state.commit ? ["commit"] : [
+		"staged",
+		"unstaged",
+		"untracked"
+	];
+	return /* @__PURE__ */ React.createElement("div", { className: "twgit-backdrop" }, /* @__PURE__ */ React.createElement("div", {
+		className: "twgit-panel",
+		ref: dialog,
+		tabIndex: -1,
+		role: "dialog",
+		"aria-modal": "true",
+		"aria-label": labels.title,
+		onKeyDown: focusTrap
+	}, /* @__PURE__ */ React.createElement("header", null, /* @__PURE__ */ React.createElement("h2", null, labels.title), /* @__PURE__ */ React.createElement("button", {
+		onClick: chooseRoot,
+		disabled: state.busy
+	}, labels.choose), !review && /* @__PURE__ */ React.createElement("button", {
+		onClick: () => void controller.refresh(),
+		disabled: !state.repository || state.busy
+	}, labels.refresh), !review && state.project !== null && /* @__PURE__ */ React.createElement("button", {
+		disabled: state.busy,
+		onClick: () => void openProject(state.project)
+	}, labels.reload), state.repository && host.renderReviewBlock && /* @__PURE__ */ React.createElement("button", {
+		type: "button",
+		disabled: state.busy,
+		onClick: () => setReview(!review)
+	}, review ? labels.localChanges : labels.pullRequests), /* @__PURE__ */ React.createElement("button", { onClick: () => setVisible(false) }, labels.close)), /* @__PURE__ */ React.createElement("div", { className: "twgit-context" }, /* @__PURE__ */ React.createElement("span", null, labels.repository, " · ", ((_state$repository = state.repository) === null || _state$repository === void 0 ? void 0 : _state$repository.root.name) || "—"), /* @__PURE__ */ React.createElement("span", null, labels.project, " · ", state.project === null ? labels.none : state.project || labels.root), /* @__PURE__ */ React.createElement("strong", null, ((_state$snapshot = state.snapshot) === null || _state$snapshot === void 0 ? void 0 : _state$snapshot.branch) || (((_state$snapshot2 = state.snapshot) === null || _state$snapshot2 === void 0 ? void 0 : _state$snapshot2.head) ? labels.detached : labels.unborn)), /* @__PURE__ */ React.createElement("code", null, (_state$snapshot3 = state.snapshot) === null || _state$snapshot3 === void 0 || (_state$snapshot3 = _state$snapshot3.head) === null || _state$snapshot3 === void 0 ? void 0 : _state$snapshot3.slice(0, 12)), /* @__PURE__ */ React.createElement("span", { "data-git-dirty": "" }, dirty ? labels.dirty : labels.saved)), !review && host.connectionSettings && /* @__PURE__ */ React.createElement(ConnectionSettings, {
+		settings: host.connectionSettings,
+		locale,
+		runOperation: host.connectionSettings.getSession ? remoteOperation : void 0,
+		readOrigin: state.repository && !state.busy ? async () => {
+			const ticket = epoch.current;
+			const remote = await state.repository.readOrigin();
+			return epoch.current === ticket ? remote : void 0;
+		} : void 0
+	}), state.error && /* @__PURE__ */ React.createElement("p", {
+		className: "twgit-error",
+		role: "alert"
+	}, state.error), state.notice && /* @__PURE__ */ React.createElement("p", {
+		className: "twgit-context",
+		role: "status"
+	}, state.notice), state.busy && /* @__PURE__ */ React.createElement("p", { role: "status" }, labels.loading), !state.repository && /* @__PURE__ */ React.createElement("p", null, labels.empty), review && state.repository && host.renderReviewBlock && /* @__PURE__ */ React.createElement(PullRequestReviewPanel, {
+		repository: state.repository,
+		locale,
+		renderBlock: host.renderReviewBlock
+	}), !review && state.repository && /* @__PURE__ */ React.createElement("div", { className: "twgit-content" }, /* @__PURE__ */ React.createElement("aside", null, state.browser && /* @__PURE__ */ React.createElement("details", null, /* @__PURE__ */ React.createElement("summary", null, labels.browse), /* @__PURE__ */ React.createElement("p", null, /* @__PURE__ */ React.createElement("code", null, state.browser.path || "/")), /* @__PURE__ */ React.createElement("button", {
+		disabled: state.busy || !state.browser.path,
+		onClick: () => void browse(state.browser.path.split("/").slice(0, -1).join("/"))
+	}, labels.up), /* @__PURE__ */ React.createElement("button", {
+		"data-git-open-project": "",
+		disabled: state.busy || !state.browser.isProject,
+		onClick: () => void openProject(state.browser.path)
+	}, labels.open), /* @__PURE__ */ React.createElement("ul", null, state.browser.children.map((name) => /* @__PURE__ */ React.createElement("li", { key: name }, /* @__PURE__ */ React.createElement("button", {
+		disabled: state.busy,
+		onClick: () => void browse([state.browser.path, name].filter(Boolean).join("/"))
+	}, name, "/"))))), /* @__PURE__ */ React.createElement("h3", null, /* @__PURE__ */ React.createElement("button", {
+		disabled: state.busy,
+		onClick: () => void controller.refresh()
+	}, labels.worktree)), groups.map((group) => /* @__PURE__ */ React.createElement("section", { key: group }, /* @__PURE__ */ React.createElement("h3", null, labels[group], " · ", state.changes.filter((change) => change.group === group).length), /* @__PURE__ */ React.createElement("ul", null, state.changes.filter((change) => change.group === group).map((change) => /* @__PURE__ */ React.createElement("li", { key: change.path }, /* @__PURE__ */ React.createElement("button", {
+		className: "twgit-file",
+		"data-git-group": group,
+		disabled: state.busy,
+		"aria-pressed": state.selected === change,
+		onClick: () => void selectFile(change)
+	}, /* @__PURE__ */ React.createElement("span", null, !change.after ? "D" : !change.before ? "A" : "M"), " ", change.path)))))), !state.changes.length && /* @__PURE__ */ React.createElement("p", null, labels.clean), /* @__PURE__ */ React.createElement("details", null, /* @__PURE__ */ React.createElement("summary", null, labels.branches), /* @__PURE__ */ React.createElement("ul", null, (_state$snapshot4 = state.snapshot) === null || _state$snapshot4 === void 0 ? void 0 : _state$snapshot4.branches.map((branch) => /* @__PURE__ */ React.createElement("li", { key: branch }, branch)))), /* @__PURE__ */ React.createElement("h3", null, labels.history), /* @__PURE__ */ React.createElement("ol", { className: "twgit-history" }, (_state$snapshot5 = state.snapshot) === null || _state$snapshot5 === void 0 ? void 0 : _state$snapshot5.commits.map((commit) => /* @__PURE__ */ React.createElement("li", { key: commit.oid }, /* @__PURE__ */ React.createElement("button", {
+		disabled: state.busy,
+		"aria-pressed": state.commit === commit.oid,
+		title: commit.oid,
+		onClick: () => void selectCommit(commit.oid)
+	}, commit.message.split("\n")[0]), /* @__PURE__ */ React.createElement("small", null, /* @__PURE__ */ React.createElement("code", null, commit.oid.slice(0, 8)), " · ", commit.author, " · ", (/* @__PURE__ */ new Date(commit.timestamp * 1e3)).toLocaleString(locale)))))), /* @__PURE__ */ React.createElement("main", { className: "twgit-diff" }, state.selected ? /* @__PURE__ */ React.createElement(FileDiffView, {
+		change: state.selected,
+		diff: state.diff,
+		labels,
+		locale,
+		renderBlock: host.renderReviewBlock,
+		loadAsset
+	}) : /* @__PURE__ */ React.createElement("p", null, labels.select))), /* @__PURE__ */ React.createElement("footer", null, labels.permissions)));
+}
+function mountGitPanel({ vm, document, host }) {
+	var _document$defaultView2;
+	if (!((_document$defaultView2 = document.defaultView) === null || _document$defaultView2 === void 0 ? void 0 : _document$defaultView2.showDirectoryPicker)) return null;
+	const root = document.createElement("div");
+	document.body.append(root);
+	const controller = {
+		open() {},
+		async refresh() {}
+	};
+	controllers.set(vm, controller);
+	render(/* @__PURE__ */ React.createElement(GitPanel, {
+		document,
+		host,
+		controller
+	}), root);
+	return {
+		refresh: () => controller.refresh(),
+		dispose() {
+			var _host$connectionSetti3;
+			if (controllers.get(vm) === controller) controllers.delete(vm);
+			(_host$connectionSetti3 = host.connectionSettings) === null || _host$connectionSetti3 === void 0 || _host$connectionSetti3.disconnect().catch(() => {});
+			unmountComponentAtNode(root);
+			root.remove();
+		}
+	};
+}
+function renderGitMenu(createElement, { vm, locale = "en", MenuItem, MenuSection, onRequestClose }) {
+	const controller = controllers.get(vm);
+	if (!controller) return null;
+	return createElement(MenuSection, null, createElement(MenuItem, {
+		command: "local-git",
+		onClick() {
+			onRequestClose();
+			controller.open(locale);
+		}
+	}, labelsFor(locale).menu));
+}
+export { GitPanelError, createReadOnlyFs, createScratchBlocksDiffRenderer, mountGitPanel, openRepository, renderGitMenu };